Merge pull request #249 from pcc/xgetinputfocus
[mono.git] / mcs / class / Managed.Windows.Forms / System.Windows.Forms / XplatUIX11.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) 2004-2006 Novell, Inc.
21 //
22 // Authors:
23 //      Peter Bartok    pbartok@novell.com
24 //
25 //
26
27 // NOTE:
28 //      This driver understands the following environment variables: (Set the var to enable feature)
29 //
30 //      MONO_XEXCEPTIONS        = throw an exception when a X11 error is encountered;
31 //                                by default a message is displayed but execution continues
32 //
33 //      MONO_XSYNC              = perform all X11 commands synchronous; this is slower but
34 //                                helps in debugging errors
35 //
36
37 // NOT COMPLETE
38
39 // define to log Window handles and relationships to stdout
40 #undef DriverDebug
41
42 // Extra detailed debug
43 #undef DriverDebugExtra
44 #undef DriverDebugParent
45 #undef DriverDebugCreate
46 #undef DriverDebugDestroy
47 #undef DriverDebugThreads
48 #undef DriverDebugXEmbed
49
50 //#define TRACE
51 //#define DEBUG
52
53 using System;
54 using System.ComponentModel;
55 using System.Collections;
56 using System.Diagnostics;
57 using System.Drawing;
58 using System.Drawing.Drawing2D;
59 using System.Drawing.Imaging;
60 using System.IO;
61 using System.Net;
62 using System.Net.Sockets;
63 using System.Reflection;
64 using System.Runtime.InteropServices;
65 using System.Runtime.Serialization;
66 using System.Runtime.Serialization.Formatters.Binary;
67 using System.Text;
68 using System.Threading;
69
70 // Only do the poll when building with mono for now
71 #if __MonoCS__
72 using Mono.Unix.Native;
73 #endif
74
75 /// X11 Version
76 namespace System.Windows.Forms {
77         internal class XplatUIX11 : XplatUIDriver {
78                 #region Local Variables
79                 // General
80                 static volatile XplatUIX11      Instance;
81                 static int              RefCount;
82                 static object           XlibLock;               // Our locking object
83                 static bool             themes_enabled;
84
85                 // General X11
86                 static IntPtr           DisplayHandle;          // X11 handle to display
87                 static int              ScreenNo;               // Screen number used
88                 static IntPtr           DefaultColormap;        // Colormap for screen
89                 static IntPtr           CustomVisual;           // Visual for window creation
90                 static IntPtr           CustomColormap;         // Colormap for window creation
91                 static IntPtr           RootWindow;             // Handle of the root window for the screen/display
92                 static IntPtr           FosterParent;           // Container to hold child windows until their parent exists
93                 static XErrorHandler    ErrorHandler;           // Error handler delegate
94                 static bool             ErrorExceptions;        // Throw exceptions on X errors
95                 int                     render_major_opcode;
96                 int                     render_first_event;
97                 int                     render_first_error;
98
99                 // Clipboard
100                 static IntPtr           ClipMagic;
101                 static ClipboardData    Clipboard;              // Our clipboard
102
103                 // Communication
104                 static IntPtr           PostAtom;               // PostMessage atom
105                 static IntPtr           AsyncAtom;              // Support for async messages
106
107                 // Message Loop
108                 static Hashtable        MessageQueues;          // Holds our thread-specific XEventQueues
109                 static ArrayList        unattached_timer_list; // holds timers that are enabled but not attached to a window.
110                 #if __MonoCS__                                          //
111                 static Pollfd[]         pollfds;                // For watching the X11 socket
112                 static bool wake_waiting;
113                 static object wake_waiting_lock = new object ();
114                 #endif                                                  //
115                 static X11Keyboard      Keyboard;               //
116                 static X11Dnd           Dnd;
117                 static Socket           listen;                 //
118                 static Socket           wake;                   //
119                 static Socket           wake_receive;           //
120                 static byte[]           network_buffer;         //
121                 static bool             detectable_key_auto_repeat;
122
123                 // Focus tracking
124                 static IntPtr           ActiveWindow;           // Handle of the active window
125                 static IntPtr           FocusWindow;            // Handle of the window with keyboard focus (if any)
126
127                 // Modality support
128                 static Stack            ModalWindows;           // Stack of our modal windows
129
130                 // Systray
131                 static IntPtr           SystrayMgrWindow;       // Handle of the Systray Manager window
132
133                 // Cursors
134                 static IntPtr           LastCursorWindow;       // The last window we set the cursor on
135                 static IntPtr           LastCursorHandle;       // The handle that was last set on LastCursorWindow
136                 static IntPtr           OverrideCursorHandle;   // The cursor that is set to override any other cursors
137
138                 // Caret
139                 static CaretStruct      Caret;                  //
140
141                 // Last window containing the pointer
142                 static IntPtr           LastPointerWindow;      // The last window containing the pointer
143
144                 // Our atoms
145                 static IntPtr WM_PROTOCOLS;
146                 static IntPtr WM_DELETE_WINDOW;
147                 static IntPtr WM_TAKE_FOCUS;
148                 //static IntPtr _NET_SUPPORTED;
149                 //static IntPtr _NET_CLIENT_LIST;
150                 //static IntPtr _NET_NUMBER_OF_DESKTOPS;
151                 static IntPtr _NET_DESKTOP_GEOMETRY;
152                 //static IntPtr _NET_DESKTOP_VIEWPORT;
153                 static IntPtr _NET_CURRENT_DESKTOP;
154                 //static IntPtr _NET_DESKTOP_NAMES;
155                 static IntPtr _NET_ACTIVE_WINDOW;
156                 static IntPtr _NET_WORKAREA;
157                 //static IntPtr _NET_SUPPORTING_WM_CHECK;
158                 //static IntPtr _NET_VIRTUAL_ROOTS;
159                 //static IntPtr _NET_DESKTOP_LAYOUT;
160                 //static IntPtr _NET_SHOWING_DESKTOP;
161                 //static IntPtr _NET_CLOSE_WINDOW;
162                 //static IntPtr _NET_MOVERESIZE_WINDOW;
163                 static IntPtr _NET_WM_MOVERESIZE;
164                 //static IntPtr _NET_RESTACK_WINDOW;
165                 //static IntPtr _NET_REQUEST_FRAME_EXTENTS;
166                 static IntPtr _NET_WM_NAME;
167                 //static IntPtr _NET_WM_VISIBLE_NAME;
168                 //static IntPtr _NET_WM_ICON_NAME;
169                 //static IntPtr _NET_WM_VISIBLE_ICON_NAME;
170                 //static IntPtr _NET_WM_DESKTOP;
171                 static IntPtr _NET_WM_WINDOW_TYPE;
172                 static IntPtr _NET_WM_STATE;
173                 //static IntPtr _NET_WM_ALLOWED_ACTIONS;
174                 //static IntPtr _NET_WM_STRUT;
175                 //static IntPtr _NET_WM_STRUT_PARTIAL;
176                 //static IntPtr _NET_WM_ICON_GEOMETRY;
177                 static IntPtr _NET_WM_ICON;
178                 //static IntPtr _NET_WM_PID;
179                 //static IntPtr _NET_WM_HANDLED_ICONS;
180                 static IntPtr _NET_WM_USER_TIME;
181                 static IntPtr _NET_FRAME_EXTENTS;
182                 //static IntPtr _NET_WM_PING;
183                 //static IntPtr _NET_WM_SYNC_REQUEST;
184                 static IntPtr _NET_SYSTEM_TRAY_S;
185                 //static IntPtr _NET_SYSTEM_TRAY_ORIENTATION;
186                 static IntPtr _NET_SYSTEM_TRAY_OPCODE;
187                 static IntPtr _NET_WM_STATE_MAXIMIZED_HORZ;
188                 static IntPtr _NET_WM_STATE_MAXIMIZED_VERT;
189                 static IntPtr _XEMBED;
190                 static IntPtr _XEMBED_INFO;
191                 static IntPtr _MOTIF_WM_HINTS;
192                 static IntPtr _NET_WM_STATE_SKIP_TASKBAR;
193                 static IntPtr _NET_WM_STATE_ABOVE;
194                 static IntPtr _NET_WM_STATE_MODAL;
195                 static IntPtr _NET_WM_STATE_HIDDEN;
196                 static IntPtr _NET_WM_CONTEXT_HELP;
197                 static IntPtr _NET_WM_WINDOW_OPACITY;
198                 //static IntPtr _NET_WM_WINDOW_TYPE_DESKTOP;
199                 //static IntPtr _NET_WM_WINDOW_TYPE_DOCK;
200                 //static IntPtr _NET_WM_WINDOW_TYPE_TOOLBAR;
201                 //static IntPtr _NET_WM_WINDOW_TYPE_MENU;
202                 static IntPtr _NET_WM_WINDOW_TYPE_UTILITY;
203                 //static IntPtr _NET_WM_WINDOW_TYPE_SPLASH;
204                 // static IntPtr _NET_WM_WINDOW_TYPE_DIALOG;
205                 static IntPtr _NET_WM_WINDOW_TYPE_NORMAL;
206                 static IntPtr CLIPBOARD;
207                 static IntPtr PRIMARY;
208                 //static IntPtr DIB;
209                 static IntPtr OEMTEXT;
210                 static IntPtr UTF8_STRING;
211                 static IntPtr UTF16_STRING;
212                 static IntPtr RICHTEXTFORMAT;
213                 static IntPtr TARGETS;
214
215                 // mouse hover message generation
216                 static HoverStruct      HoverState;             //
217
218                 // double click message generation
219                 static ClickStruct      ClickPending;           //
220
221                 // Support for mouse grab
222                 static GrabStruct       Grab;                   //
223
224                 // State
225                 Point           mouse_position;         // Last position of mouse, in screen coords
226                 internal static MouseButtons    MouseState;             // Last state of mouse buttons
227                 internal static bool in_doevents;
228                 // 'Constants'
229                 static int              DoubleClickInterval;    // msec; max interval between clicks to count as double click
230
231                 const EventMask SelectInputMask = (EventMask.ButtonPressMask | 
232                                                    EventMask.ButtonReleaseMask | 
233                                                    EventMask.KeyPressMask | 
234                                                    EventMask.KeyReleaseMask | 
235                                                    EventMask.EnterWindowMask | 
236                                                    EventMask.LeaveWindowMask |
237                                                    EventMask.ExposureMask |
238                                                    EventMask.FocusChangeMask |
239                                                    EventMask.PointerMotionMask | 
240                                                    EventMask.PointerMotionHintMask | 
241                                                    EventMask.SubstructureNotifyMask);
242
243                 static readonly object lockobj = new object ();
244
245                 // messages WaitForHwndMwssage is waiting on
246                 static Hashtable        messageHold;
247
248                 #endregion      // Local Variables
249                 #region Constructors
250                 XplatUIX11()
251                 {
252                         // Handle singleton stuff first
253                         RefCount = 0;
254                         in_doevents = false;
255
256                         // Now regular initialization
257                         XlibLock = new object ();
258                         X11Keyboard.XlibLock = XlibLock;
259                         MessageQueues = Hashtable.Synchronized (new Hashtable(7));
260                         unattached_timer_list = ArrayList.Synchronized (new ArrayList (3));
261                         messageHold = Hashtable.Synchronized (new Hashtable(3));
262                         Clipboard = new ClipboardData ();
263                         XInitThreads();
264
265                         ErrorExceptions = false;
266
267                         // X11 Initialization
268                         SetDisplay(XOpenDisplay(IntPtr.Zero));
269                         X11DesktopColors.Initialize();
270
271                         
272                         // Disable keyboard autorepeat
273                         try {
274                                 XkbSetDetectableAutoRepeat (DisplayHandle, true,  IntPtr.Zero);
275                                 detectable_key_auto_repeat = true;
276                         } catch {
277                                 Console.Error.WriteLine ("Could not disable keyboard auto repeat, will attempt to disable manually.");
278                                 detectable_key_auto_repeat = false;
279                         }
280
281                         // Handle any upcoming errors; we re-set it here, X11DesktopColor stuff might have stolen it (gtk does)
282                         ErrorHandler = new XErrorHandler(HandleError);
283                         XSetErrorHandler(ErrorHandler);
284                 }
285
286                 ~XplatUIX11() {
287                         // Remove our display handle from S.D
288                         Graphics.FromHdcInternal (IntPtr.Zero);
289                 }
290
291                 #endregion      // Constructors
292
293                 #region Singleton Specific Code
294                 public static XplatUIX11 GetInstance() {
295                         lock (lockobj) {
296                                 if (Instance == null) {
297                                         Instance=new XplatUIX11();
298                                 }
299                                 RefCount++;
300                         }
301                         return Instance;
302                 }
303
304                 public int Reference {
305                         get {
306                                 return RefCount;
307                         }
308                 }
309                 #endregion
310
311                 #region Internal Properties
312                 internal static IntPtr Display {
313                         get {
314                                 return DisplayHandle;
315                         }
316
317                         set {
318                                 XplatUIX11.GetInstance().SetDisplay(value);
319                         }
320                 }
321
322                 internal static int Screen {
323                         get {
324                                 return ScreenNo;
325                         }
326
327                         set {
328                                 ScreenNo = value;
329                         }
330                 }
331
332                 internal static IntPtr RootWindowHandle {
333                         get {
334                                 return RootWindow;
335                         }
336
337                         set {
338                                 RootWindow = value;
339                         }
340                 }
341
342                 internal static IntPtr Visual {
343                         get {
344                                 return CustomVisual;
345                         }
346
347                         set {
348                                 CustomVisual = value;
349                         }
350                 }
351
352                 internal static IntPtr ColorMap {
353                         get {
354                                 return CustomColormap;
355                         }
356
357                         set {
358                                 CustomColormap = value;
359                         }
360                 }
361
362 #if DEBUG_shana
363                 internal static IntPtr DefaultColorMap {
364                         get {
365                                 return DefaultColormap;
366                         }
367                 }
368 #endif
369                 #endregion
370
371                 #region XExceptionClass
372                 internal class XException : ApplicationException {
373                         IntPtr          Display;
374                         IntPtr          ResourceID;
375                         IntPtr          Serial;
376                         XRequest        RequestCode;
377                         byte            ErrorCode;
378                         byte            MinorCode;
379
380                         public XException(IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) {
381                                 this.Display = Display;
382                                 this.ResourceID = ResourceID;
383                                 this.Serial = Serial;
384                                 this.RequestCode = RequestCode;
385                                 this.ErrorCode = ErrorCode;
386                                 this.MinorCode = MinorCode;
387                         }
388
389                         public override string Message {
390                                 get {
391                                         return GetMessage(Display, ResourceID, Serial, ErrorCode, RequestCode, MinorCode);
392                                 }
393                         }
394
395                         public static string GetMessage(IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) {
396                                 StringBuilder   sb;
397                                 string          x_error_text;
398                                 string          error;
399                                 string          hwnd_text;
400                                 string          control_text;
401                                 Hwnd            hwnd;
402                                 Control         c;
403
404                                 sb = new StringBuilder(160);
405                                 XGetErrorText(Display, ErrorCode, sb, sb.Capacity);
406                                 x_error_text = sb.ToString();
407                                 hwnd = Hwnd.ObjectFromHandle(ResourceID);
408                                 if (hwnd != null) {
409                                         hwnd_text = hwnd.ToString();
410                                         c = Control.FromHandle(hwnd.Handle);
411                                         if (c != null) {
412                                                 control_text = c.ToString();
413                                         } else {
414                                                 control_text = String.Format("<handle {0:X} non-existant>", hwnd.Handle.ToInt32());
415                                         }
416                                 } else {
417                                         hwnd_text = "<null>";
418                                         control_text = "<null>";
419                                 }
420
421
422                                 error = String.Format("\n  Error: {0}\n  Request:     {1:D} ({2})\n  Resource ID: 0x{3:X}\n  Serial:      {4}\n  Hwnd:        {5}\n  Control:     {6}", x_error_text, RequestCode, MinorCode, ResourceID.ToInt32(), Serial, hwnd_text, control_text);
423                                 return error;
424                         }
425                 }
426                 #endregion      // XExceptionClass
427
428                 #region Internal Methods
429                 internal void SetDisplay(IntPtr display_handle)
430                 {
431                         if (display_handle != IntPtr.Zero) {
432                                 Hwnd    hwnd;
433
434                                 if ((DisplayHandle != IntPtr.Zero) && (FosterParent != IntPtr.Zero)) {
435                                         hwnd = Hwnd.ObjectFromHandle(FosterParent);
436                                         XDestroyWindow(DisplayHandle, FosterParent);
437                                         hwnd.Dispose();
438                                 }
439
440                                 if (DisplayHandle != IntPtr.Zero) {
441                                         XCloseDisplay(DisplayHandle);
442                                 }
443
444                                 DisplayHandle=display_handle;
445
446                                 // We need to tell System.Drawing our DisplayHandle. FromHdcInternal has
447                                 // been hacked to do this for us.
448                                 Graphics.FromHdcInternal (DisplayHandle);
449
450                                 // query for the render extension so
451                                 // we can ignore the spurious
452                                 // BadPicture errors that are
453                                 // generated by cairo/render.
454                                 XQueryExtension (DisplayHandle, "RENDER",
455                                                  ref render_major_opcode, ref render_first_event, ref render_first_error);
456
457                                 // Debugging support
458                                 if (Environment.GetEnvironmentVariable ("MONO_XSYNC") != null) {
459                                         XSynchronize(DisplayHandle, true);
460                                 }
461
462                                 if (Environment.GetEnvironmentVariable ("MONO_XEXCEPTIONS") != null) {
463                                         ErrorExceptions = true;
464                                 }
465
466                                 // Generic X11 setup
467                                 ScreenNo = XDefaultScreen(DisplayHandle);
468                                 RootWindow = XRootWindow(DisplayHandle, ScreenNo);
469                                 DefaultColormap = XDefaultColormap(DisplayHandle, ScreenNo);
470
471                                 // Create the foster parent
472                                 // it is important that border_width is kept in synch with the other XCreateWindow calls
473                                 FosterParent=XCreateSimpleWindow(DisplayHandle, RootWindow, 0, 0, 1, 1, 0, UIntPtr.Zero, UIntPtr.Zero);
474                                 if (FosterParent==IntPtr.Zero) {
475                                         Console.WriteLine("XplatUIX11 Constructor failed to create FosterParent");
476                                 }
477
478                                 DebugHelper.WriteLine ("FosterParent created 0x{0:x}", FosterParent.ToInt32());
479
480                                 hwnd = new Hwnd();
481                                 hwnd.Queue = ThreadQueue(Thread.CurrentThread);
482                                 hwnd.WholeWindow = FosterParent;
483                                 hwnd.ClientWindow = FosterParent;
484
485                                 // Create a HWND for RootWIndow as well, so our queue doesn't eat the events
486                                 hwnd = new Hwnd();
487                                 hwnd.Queue = ThreadQueue(Thread.CurrentThread);
488                                 hwnd.whole_window = RootWindow;
489                                 hwnd.ClientWindow = RootWindow;
490
491                                 // For sleeping on the X11 socket
492                                 listen = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
493                                 IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, 0);
494                                 listen.Bind(ep);
495                                 listen.Listen(1);
496
497                                 // To wake up when a timer is ready
498                                 network_buffer = new byte[10];
499
500                                 wake = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
501                                 wake.Connect(listen.LocalEndPoint);
502
503                                 // Make this non-blocking, so it doesn't
504                                 // deadlock if too many wakes are sent
505                                 // before the wake_receive end is polled
506                                 wake.Blocking = false;
507
508                                 wake_receive = listen.Accept();
509
510                                 #if __MonoCS__
511                                 pollfds = new Pollfd [2];
512                                 pollfds [0] = new Pollfd ();
513                                 pollfds [0].fd = XConnectionNumber (DisplayHandle);
514                                 pollfds [0].events = PollEvents.POLLIN;
515
516                                 pollfds [1] = new Pollfd ();
517                                 pollfds [1].fd = wake_receive.Handle.ToInt32 ();
518                                 pollfds [1].events = PollEvents.POLLIN;
519                                 #endif
520
521                                 Keyboard = new X11Keyboard(DisplayHandle, FosterParent);
522                                 Dnd = new X11Dnd (DisplayHandle, Keyboard);
523
524                                 DoubleClickInterval = 500;
525
526                                 HoverState.Interval = 500;
527                                 HoverState.Timer = new Timer();
528                                 HoverState.Timer.Enabled = false;
529                                 HoverState.Timer.Interval = HoverState.Interval;
530                                 HoverState.Timer.Tick += new EventHandler(MouseHover);
531                                 HoverState.Size = new Size(4, 4);
532                                 HoverState.X = -1;
533                                 HoverState.Y = -1;
534
535                                 ActiveWindow = IntPtr.Zero;
536                                 FocusWindow = IntPtr.Zero;
537                                 ModalWindows = new Stack(3);
538
539                                 MouseState = MouseButtons.None;
540                                 mouse_position = new Point(0, 0);
541
542                                 Caret.Timer = new Timer();
543                                 Caret.Timer.Interval = 500;             // FIXME - where should this number come from?
544                                 Caret.Timer.Tick += new EventHandler(CaretCallback);
545
546                                 SetupAtoms();
547
548                                 // Grab atom changes off the root window to catch certain WM events
549                                 XSelectInput(DisplayHandle, RootWindow, new IntPtr ((int) (EventMask.PropertyChangeMask | Keyboard.KeyEventMask)));
550
551                                 // Handle any upcoming errors
552                                 ErrorHandler = new XErrorHandler(HandleError);
553                                 XSetErrorHandler(ErrorHandler);
554                         } else {
555                                 throw new ArgumentNullException("Display", "Could not open display (X-Server required. Check you DISPLAY environment variable)");
556                         }
557                 }
558                 #endregion      // Internal Methods
559
560                 #region Methods
561                 [Conditional ("DriverDebug")]
562                 static void DriverDebug (string format, params object [] args)
563                 {
564                         Console.WriteLine (String.Format (format, args));
565                 }
566                 
567                 int unixtime() {
568                         TimeSpan t = (DateTime.UtcNow - new DateTime(1970, 1, 1));
569
570                         return (int) t.TotalSeconds;
571                 }
572
573                 static void SetupAtoms() {
574                         // make sure this array stays in sync with the statements below
575                         string [] atom_names = new string[] {
576                                 "WM_PROTOCOLS",
577                                 "WM_DELETE_WINDOW",
578                                 "WM_TAKE_FOCUS",
579                                 //"_NET_SUPPORTED",
580                                 //"_NET_CLIENT_LIST",
581                                 //"_NET_NUMBER_OF_DESKTOPS",
582                                 "_NET_DESKTOP_GEOMETRY",
583                                 //"_NET_DESKTOP_VIEWPORT",
584                                 "_NET_CURRENT_DESKTOP",
585                                 //"_NET_DESKTOP_NAMES",
586                                 "_NET_ACTIVE_WINDOW",
587                                 "_NET_WORKAREA",
588                                 //"_NET_SUPPORTING_WM_CHECK",
589                                 //"_NET_VIRTUAL_ROOTS",
590                                 //"_NET_DESKTOP_LAYOUT",
591                                 //"_NET_SHOWING_DESKTOP",
592                                 //"_NET_CLOSE_WINDOW",
593                                 //"_NET_MOVERESIZE_WINDOW",
594                                 "_NET_WM_MOVERESIZE",
595                                 //"_NET_RESTACK_WINDOW",
596                                 //"_NET_REQUEST_FRAME_EXTENTS",
597                                 "_NET_WM_NAME",
598                                 //"_NET_WM_VISIBLE_NAME",
599                                 //"_NET_WM_ICON_NAME",
600                                 //"_NET_WM_VISIBLE_ICON_NAME",
601                                 //"_NET_WM_DESKTOP",
602                                 "_NET_WM_WINDOW_TYPE",
603                                 "_NET_WM_STATE",
604                                 //"_NET_WM_ALLOWED_ACTIONS",
605                                 //"_NET_WM_STRUT",
606                                 //"_NET_WM_STRUT_PARTIAL",
607                                 //"_NET_WM_ICON_GEOMETRY",
608                                 "_NET_WM_ICON",
609                                 //"_NET_WM_PID",
610                                 //"_NET_WM_HANDLED_ICONS",
611                                 "_NET_WM_USER_TIME",
612                                 "_NET_FRAME_EXTENTS",
613                                 //"_NET_WM_PING",
614                                 //"_NET_WM_SYNC_REQUEST",
615                                 "_NET_SYSTEM_TRAY_OPCODE",
616                                 //"_NET_SYSTEM_TRAY_ORIENTATION",
617                                 "_NET_WM_STATE_MAXIMIZED_HORZ",
618                                 "_NET_WM_STATE_MAXIMIZED_VERT",
619                                 "_NET_WM_STATE_HIDDEN",
620                                 "_XEMBED",
621                                 "_XEMBED_INFO",
622                                 "_MOTIF_WM_HINTS",
623                                 "_NET_WM_STATE_SKIP_TASKBAR",
624                                 "_NET_WM_STATE_ABOVE",
625                                 "_NET_WM_STATE_MODAL",
626                                 "_NET_WM_CONTEXT_HELP",
627                                 "_NET_WM_WINDOW_OPACITY",
628                                 //"_NET_WM_WINDOW_TYPE_DESKTOP",
629                                 //"_NET_WM_WINDOW_TYPE_DOCK",
630                                 //"_NET_WM_WINDOW_TYPE_TOOLBAR",
631                                 //"_NET_WM_WINDOW_TYPE_MENU",
632                                 "_NET_WM_WINDOW_TYPE_UTILITY",
633                                 // "_NET_WM_WINDOW_TYPE_DIALOG",
634                                 //"_NET_WM_WINDOW_TYPE_SPLASH",
635                                 "_NET_WM_WINDOW_TYPE_NORMAL",
636                                 "CLIPBOARD",
637                                 "PRIMARY",
638                                 "COMPOUND_TEXT",
639                                 "UTF8_STRING",
640                                 "UTF16_STRING",
641                                 "RICHTEXTFORMAT",
642                                 "TARGETS",
643                                 "_SWF_AsyncAtom",
644                                 "_SWF_PostMessageAtom",
645                                 "_SWF_HoverAtom" };
646
647                         IntPtr[] atoms = new IntPtr [atom_names.Length];;
648
649                         XInternAtoms (DisplayHandle, atom_names, atom_names.Length, false, atoms);
650
651                         int off = 0;
652                         WM_PROTOCOLS = atoms [off++];
653                         WM_DELETE_WINDOW = atoms [off++];
654                         WM_TAKE_FOCUS = atoms [off++];
655                         //_NET_SUPPORTED = atoms [off++];
656                         //_NET_CLIENT_LIST = atoms [off++];
657                         //_NET_NUMBER_OF_DESKTOPS = atoms [off++];
658                         _NET_DESKTOP_GEOMETRY = atoms [off++];
659                         //_NET_DESKTOP_VIEWPORT = atoms [off++];
660                         _NET_CURRENT_DESKTOP = atoms [off++];
661                         //_NET_DESKTOP_NAMES = atoms [off++];
662                         _NET_ACTIVE_WINDOW = atoms [off++];
663                         _NET_WORKAREA = atoms [off++];
664                         //_NET_SUPPORTING_WM_CHECK = atoms [off++];
665                         //_NET_VIRTUAL_ROOTS = atoms [off++];
666                         //_NET_DESKTOP_LAYOUT = atoms [off++];
667                         //_NET_SHOWING_DESKTOP = atoms [off++];
668                         //_NET_CLOSE_WINDOW = atoms [off++];
669                         //_NET_MOVERESIZE_WINDOW = atoms [off++];
670                         _NET_WM_MOVERESIZE = atoms [off++];
671                         //_NET_RESTACK_WINDOW = atoms [off++];
672                         //_NET_REQUEST_FRAME_EXTENTS = atoms [off++];
673                         _NET_WM_NAME = atoms [off++];
674                         //_NET_WM_VISIBLE_NAME = atoms [off++];
675                         //_NET_WM_ICON_NAME = atoms [off++];
676                         //_NET_WM_VISIBLE_ICON_NAME = atoms [off++];
677                         //_NET_WM_DESKTOP = atoms [off++];
678                         _NET_WM_WINDOW_TYPE = atoms [off++];
679                         _NET_WM_STATE = atoms [off++];
680                         //_NET_WM_ALLOWED_ACTIONS = atoms [off++];
681                         //_NET_WM_STRUT = atoms [off++];
682                         //_NET_WM_STRUT_PARTIAL = atoms [off++];
683                         //_NET_WM_ICON_GEOMETRY = atoms [off++];
684                         _NET_WM_ICON = atoms [off++];
685                         //_NET_WM_PID = atoms [off++];
686                         //_NET_WM_HANDLED_ICONS = atoms [off++];
687                         _NET_WM_USER_TIME = atoms [off++];
688                         _NET_FRAME_EXTENTS = atoms [off++];
689                         //_NET_WM_PING = atoms [off++];
690                         //_NET_WM_SYNC_REQUEST = atoms [off++];
691                         _NET_SYSTEM_TRAY_OPCODE = atoms [off++];
692                         //_NET_SYSTEM_TRAY_ORIENTATION = atoms [off++];
693                         _NET_WM_STATE_MAXIMIZED_HORZ = atoms [off++];
694                         _NET_WM_STATE_MAXIMIZED_VERT = atoms [off++];
695                         _NET_WM_STATE_HIDDEN = atoms [off++];
696                         _XEMBED = atoms [off++];
697                         _XEMBED_INFO = atoms [off++];
698                         _MOTIF_WM_HINTS = atoms [off++];
699                         _NET_WM_STATE_SKIP_TASKBAR = atoms [off++];
700                         _NET_WM_STATE_ABOVE = atoms [off++];
701                         _NET_WM_STATE_MODAL = atoms [off++];
702                         _NET_WM_CONTEXT_HELP = atoms [off++];
703                         _NET_WM_WINDOW_OPACITY = atoms [off++];
704                         //_NET_WM_WINDOW_TYPE_DESKTOP = atoms [off++];
705                         //_NET_WM_WINDOW_TYPE_DOCK = atoms [off++];
706                         //_NET_WM_WINDOW_TYPE_TOOLBAR = atoms [off++];
707                         //_NET_WM_WINDOW_TYPE_MENU = atoms [off++];
708                         _NET_WM_WINDOW_TYPE_UTILITY = atoms [off++];
709                         // _NET_WM_WINDOW_TYPE_DIALOG = atoms [off++];
710                         //_NET_WM_WINDOW_TYPE_SPLASH = atoms [off++];
711                         _NET_WM_WINDOW_TYPE_NORMAL = atoms [off++];
712                         CLIPBOARD = atoms [off++];
713                         PRIMARY = atoms [off++];
714                         OEMTEXT = atoms [off++];
715                         UTF8_STRING = atoms [off++];
716                         UTF16_STRING = atoms [off++];
717                         RICHTEXTFORMAT = atoms [off++];
718                         TARGETS = atoms [off++];
719                         AsyncAtom = atoms [off++];
720                         PostAtom = atoms [off++];
721                         HoverState.Atom = atoms [off++];
722
723                         //DIB = (IntPtr)Atom.XA_PIXMAP;
724                         _NET_SYSTEM_TRAY_S = XInternAtom (DisplayHandle, "_NET_SYSTEM_TRAY_S" + ScreenNo.ToString(), false);
725                 }
726
727                 void GetSystrayManagerWindow() {
728                         XGrabServer(DisplayHandle);
729                         SystrayMgrWindow = XGetSelectionOwner(DisplayHandle, _NET_SYSTEM_TRAY_S);
730                         XUngrabServer(DisplayHandle);
731                         XFlush(DisplayHandle);
732                 }
733
734                 void SendNetWMMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) {
735                         SendNetWMMessage (window, message_type, l0, l1, l2, IntPtr.Zero);
736                 }
737
738                 void SendNetWMMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2, IntPtr l3) {
739                         XEvent  xev;
740
741                         xev = new XEvent();
742                         xev.ClientMessageEvent.type = XEventName.ClientMessage;
743                         xev.ClientMessageEvent.send_event = true;
744                         xev.ClientMessageEvent.window = window;
745                         xev.ClientMessageEvent.message_type = message_type;
746                         xev.ClientMessageEvent.format = 32;
747                         xev.ClientMessageEvent.ptr1 = l0;
748                         xev.ClientMessageEvent.ptr2 = l1;
749                         xev.ClientMessageEvent.ptr3 = l2;
750                         xev.ClientMessageEvent.ptr4 = l3;
751                         XSendEvent(DisplayHandle, RootWindow, false, new IntPtr ((int) (EventMask.SubstructureRedirectMask | EventMask.SubstructureNotifyMask)), ref xev);
752                 }
753
754                 void SendNetClientMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) {
755                         XEvent  xev;
756
757                         xev = new XEvent();
758                         xev.ClientMessageEvent.type = XEventName.ClientMessage;
759                         xev.ClientMessageEvent.send_event = true;
760                         xev.ClientMessageEvent.window = window;
761                         xev.ClientMessageEvent.message_type = message_type;
762                         xev.ClientMessageEvent.format = 32;
763                         xev.ClientMessageEvent.ptr1 = l0;
764                         xev.ClientMessageEvent.ptr2 = l1;
765                         xev.ClientMessageEvent.ptr3 = l2;
766                         XSendEvent(DisplayHandle, window, false, new IntPtr ((int)EventMask.NoEventMask), ref xev);
767                 }
768
769                 // For WM_LBUTTONDOWN, WM_MBUTTONDOWN, WM_RBUTTONDOWN, WM_XBUTTONDOWN
770                 //     WM_CREATE and WM_DESTROY causes
771                 void SendParentNotify(IntPtr child, Msg cause, int x, int y)
772                 {       
773                         Hwnd hwnd;
774                         
775                         if (child == IntPtr.Zero) {
776                                 return;
777                         }
778                         
779                         hwnd = Hwnd.GetObjectFromWindow (child);
780                         
781                         if (hwnd == null) {
782                                 return;
783                         }
784                         
785                         if (hwnd.Handle == IntPtr.Zero) {
786                                 return;
787                         }
788                         
789                         if (ExStyleSet ((int) hwnd.initial_ex_style, WindowExStyles.WS_EX_NOPARENTNOTIFY)) {
790                                 return;
791                         }
792                         
793                         if (hwnd.Parent == null) {
794                                 return;
795                         }
796                         
797                         if (hwnd.Parent.Handle == IntPtr.Zero) {
798                                 return;
799                         }
800
801                         if (cause == Msg.WM_CREATE || cause == Msg.WM_DESTROY) {
802                                 SendMessage(hwnd.Parent.Handle, Msg.WM_PARENTNOTIFY, Control.MakeParam((int)cause, 0), child);
803                         } else {
804                                 SendMessage(hwnd.Parent.Handle, Msg.WM_PARENTNOTIFY, Control.MakeParam((int)cause, 0), Control.MakeParam(x, y));
805                         }
806                         
807                         SendParentNotify (hwnd.Parent.Handle, cause, x, y);
808                 }
809                 
810                 bool StyleSet (int s, WindowStyles ws)
811                 {
812                         return (s & (int)ws) == (int)ws;
813                 }
814
815                 bool ExStyleSet (int ex, WindowExStyles exws)
816                 {
817                         return (ex & (int)exws) == (int)exws;
818                 }
819
820                 internal static Rectangle TranslateClientRectangleToXClientRectangle (Hwnd hwnd)
821                 {
822                         return TranslateClientRectangleToXClientRectangle (hwnd, Control.FromHandle (hwnd.Handle));
823                 }
824                 
825                 internal static Rectangle TranslateClientRectangleToXClientRectangle (Hwnd hwnd, Control ctrl)
826                 {
827                         /* 
828                          * If this is a form with no window manager, X is handling all the border and caption painting
829                          * so remove that from the area (since the area we set of the window here is the part of the window 
830                          * we're painting in only)
831                          */
832                         Rectangle rect = hwnd.ClientRect;
833                         Form form = ctrl as Form;
834                         CreateParams cp = null;
835
836                         if (form != null)
837                                 cp = form.GetCreateParams ();
838
839                         if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) {
840                                 Hwnd.Borders borders = Hwnd.GetBorders (cp, null);
841                                 Rectangle xrect = rect;
842
843                                 xrect.Y -= borders.top;
844                                 xrect.X -= borders.left;
845                                 xrect.Width += borders.left + borders.right;
846                                 xrect.Height += borders.top + borders.bottom;
847
848                                 rect = xrect;
849                         }
850                         
851                         if (rect.Width < 1 || rect.Height < 1) {
852                                 rect.Width = 1;
853                                 rect.Height = 1;
854                                 rect.X = -5;
855                                 rect.Y = -5;
856                         }
857                         
858                         return rect;
859                 }
860
861                 internal static Size TranslateWindowSizeToXWindowSize (CreateParams cp)
862                 {
863                         return TranslateWindowSizeToXWindowSize (cp, new Size (cp.Width, cp.Height));
864                 }
865
866                 internal static Size TranslateWindowSizeToXWindowSize (CreateParams cp, Size size)
867                 {
868                         /* 
869                          * If this is a form with no window manager, X is handling all the border and caption painting
870                          * so remove that from the area (since the area we set of the window here is the part of the window 
871                          * we're painting in only)
872                          */
873                         Form form = cp.control as Form;
874                         if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) {
875                                 Hwnd.Borders borders = Hwnd.GetBorders (cp, null);
876                                 Size xrect = size;
877
878                                 xrect.Width -= borders.left + borders.right;
879                                 xrect.Height -= borders.top + borders.bottom;
880
881                                 size = xrect;
882                         }
883                         if (size.Height == 0)
884                                 size.Height = 1;
885                         if (size.Width == 0)
886                                 size.Width = 1;
887                         return size;
888                 }
889
890                 internal static Size TranslateXWindowSizeToWindowSize (CreateParams cp, int xWidth, int xHeight)
891                 {
892                         /* 
893                          * If this is a form with no window manager, X is handling all the border and caption painting
894                          * so remove that from the area (since the area we set of the window here is the part of the window 
895                          * we're painting in only)
896                          */
897                         Size rect = new Size (xWidth, xHeight);
898                         Form form = cp.control as Form;
899                         if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) {
900                                 Hwnd.Borders borders = Hwnd.GetBorders (cp, null);
901                                 Size xrect = rect;
902
903                                 xrect.Width += borders.left + borders.right;
904                                 xrect.Height += borders.top + borders.bottom;
905
906                                 rect = xrect;
907                         }
908                         return rect;
909                 }
910                 
911                 internal static Point GetTopLevelWindowLocation (Hwnd hwnd)
912                 {
913                         IntPtr dummy; 
914                         int x, y;
915                         Hwnd.Borders frame;
916
917                         XTranslateCoordinates (DisplayHandle, hwnd.whole_window, RootWindow, 0, 0, out x, out y, out dummy);
918                         frame = FrameExtents (hwnd.whole_window);
919
920                         x -= frame.left;
921                         y -= frame.top;
922                         
923                         return new Point (x, y);
924                 }
925                 
926                 void DeriveStyles(int Style, int ExStyle, out FormBorderStyle border_style, out bool border_static, out TitleStyle title_style, out int caption_height, out int tool_caption_height) {
927
928                         caption_height = 0;
929                         tool_caption_height = 19;
930                         border_static = false;
931
932                         if (StyleSet (Style, WindowStyles.WS_CHILD)) {
933                                 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) {
934                                         border_style = FormBorderStyle.Fixed3D;
935                                 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) {
936                                         border_style = FormBorderStyle.Fixed3D;
937                                         border_static = true;
938                                 } else if (!StyleSet (Style, WindowStyles.WS_BORDER)) {
939                                         border_style = FormBorderStyle.None;
940                                 } else {
941                                         border_style = FormBorderStyle.FixedSingle;
942                                 }
943                                 title_style = TitleStyle.None;
944                                 
945                                 if (StyleSet (Style, WindowStyles.WS_CAPTION)) {
946                                         caption_height = 19;
947                                         if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
948                                                 title_style = TitleStyle.Tool;
949                                         } else {
950                                                 title_style = TitleStyle.Normal;
951                                         }
952                                 }
953
954                                 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_MDICHILD)) {
955                                         caption_height = 19;
956
957                                         if (StyleSet (Style, WindowStyles.WS_OVERLAPPEDWINDOW) ||
958                                             ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
959                                                 border_style = (FormBorderStyle) 0xFFFF;
960                                         } else {
961                                                 border_style = FormBorderStyle.None;
962                                         }
963                                 }
964
965                         } else {
966                                 title_style = TitleStyle.None;
967                                 if (StyleSet (Style, WindowStyles.WS_CAPTION)) {
968                                         if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
969                                                 title_style = TitleStyle.Tool;
970                                         } else {
971                                                 title_style = TitleStyle.Normal;
972                                         }
973                                 }
974
975                                 border_style = FormBorderStyle.None;
976
977                                 if (StyleSet (Style, WindowStyles.WS_THICKFRAME)) {
978                                         if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
979                                                 border_style = FormBorderStyle.SizableToolWindow;
980                                         } else {
981                                                 border_style = FormBorderStyle.Sizable;
982                                         }
983                                 } else {
984                                         if (StyleSet (Style, WindowStyles.WS_CAPTION)) {
985                                                 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) {
986                                                         border_style = FormBorderStyle.Fixed3D;
987                                                 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) {
988                                                         border_style = FormBorderStyle.Fixed3D;
989                                                         border_static = true;
990                                                 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) {
991                                                         border_style = FormBorderStyle.FixedDialog;
992                                                 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
993                                                         border_style = FormBorderStyle.FixedToolWindow;
994                                                 } else if (StyleSet (Style, WindowStyles.WS_BORDER)) {
995                                                         border_style = FormBorderStyle.FixedSingle;
996                                                 }
997                                         } else {
998                                                 if (StyleSet (Style, WindowStyles.WS_BORDER)) {
999                                                         border_style = FormBorderStyle.FixedSingle;
1000                                                 }
1001                                         }
1002                                 }
1003                         }
1004                 }
1005
1006                 void SetHwndStyles(Hwnd hwnd, CreateParams cp) {
1007                         DeriveStyles(cp.Style, cp.ExStyle, out hwnd.border_style, out hwnd.border_static, out hwnd.title_style, out hwnd.caption_height, out hwnd.tool_caption_height);
1008                 }
1009
1010                 void SetWMStyles(Hwnd hwnd, CreateParams cp) {
1011                         MotifWmHints            mwmHints;
1012                         MotifFunctions          functions;
1013                         MotifDecorations        decorations;
1014                         int[]                   atoms;
1015                         int                     atom_count;
1016                         Rectangle               client_rect;
1017                         Form                    form;
1018                         IntPtr                  window_type;
1019                         bool                    hide_from_taskbar;
1020                         IntPtr                  transient_for_parent;
1021                         
1022                         // Windows we manage ourselves don't need WM window styles.
1023                         if (cp.HasWindowManager && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) {
1024                                 return;
1025                         }
1026
1027                         atoms = new int[8];
1028                         mwmHints = new MotifWmHints();
1029                         functions = 0;
1030                         decorations = 0;
1031                         window_type = _NET_WM_WINDOW_TYPE_NORMAL;
1032                         transient_for_parent = IntPtr.Zero;
1033
1034                         mwmHints.flags = (IntPtr)(MotifFlags.Functions | MotifFlags.Decorations);
1035                         mwmHints.functions = (IntPtr)0;
1036                         mwmHints.decorations = (IntPtr)0;
1037
1038                         form = cp.control as Form;
1039
1040                         if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
1041                                 /* tool windows get no window manager
1042                                    decorations.
1043                                 */
1044
1045                                 /* just because the window doesn't get any decorations doesn't
1046                                    mean we should disable the functions.  for instance, without
1047                                    MotifFunctions.Maximize, changing the windowstate to Maximized
1048                                    is ignored by metacity. */
1049                                 functions |= MotifFunctions.Move | MotifFunctions.Resize | MotifFunctions.Minimize | MotifFunctions.Maximize;
1050                         } else if (form != null && form.FormBorderStyle == FormBorderStyle.None) {
1051                                 /* allow borderless window to be maximized */
1052                                 functions |= MotifFunctions.All | MotifFunctions.Resize;
1053                         } else {
1054                                 if (StyleSet (cp.Style, WindowStyles.WS_CAPTION)) {
1055                                         functions |= MotifFunctions.Move;
1056                                         decorations |= MotifDecorations.Title | MotifDecorations.Menu;
1057                                 }
1058
1059                                 if (StyleSet (cp.Style, WindowStyles.WS_THICKFRAME)) {
1060                                         functions |= MotifFunctions.Move | MotifFunctions.Resize;
1061                                         decorations |= MotifDecorations.Border | MotifDecorations.ResizeH;
1062                                 }
1063
1064                                 if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZEBOX)) {
1065                                         functions |= MotifFunctions.Minimize;
1066                                         decorations |= MotifDecorations.Minimize;
1067                                 }
1068
1069                                 if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZEBOX)) {
1070                                         functions |= MotifFunctions.Maximize;
1071                                         decorations |= MotifDecorations.Maximize;
1072                                 }
1073
1074                                 if (StyleSet (cp.Style, WindowStyles.WS_SIZEBOX)) {
1075                                         functions |= MotifFunctions.Resize;
1076                                         decorations |= MotifDecorations.ResizeH;
1077                                 }
1078
1079                                 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) {
1080                                         decorations |= MotifDecorations.Border;
1081                                 }
1082
1083                                 if (StyleSet (cp.Style, WindowStyles.WS_BORDER)) {
1084                                         decorations |= MotifDecorations.Border;
1085                                 }
1086                         
1087                                 if (StyleSet (cp.Style, WindowStyles.WS_DLGFRAME)) {
1088                                         decorations |= MotifDecorations.Border;
1089                                 }
1090
1091                                 if (StyleSet (cp.Style, WindowStyles.WS_SYSMENU)) {
1092                                         functions |= MotifFunctions.Close;
1093                                 }
1094                                 else {
1095                                         functions &= ~(MotifFunctions.Maximize | MotifFunctions.Minimize | MotifFunctions.Close);
1096                                         decorations &= ~(MotifDecorations.Menu | MotifDecorations.Maximize | MotifDecorations.Minimize);
1097                                         if (cp.Caption == "") {
1098                                                 functions &= ~MotifFunctions.Move;
1099                                                 decorations &= ~(MotifDecorations.Title | MotifDecorations.ResizeH);
1100                                         }
1101                                 }
1102                         }
1103
1104                         if ((functions & MotifFunctions.Resize) == 0) {
1105                                 hwnd.fixed_size = true;
1106                                 Rectangle fixed_rectangle = new Rectangle (cp.X, cp.Y, cp.Width, cp.Height);
1107                                 SetWindowMinMax(hwnd.Handle, fixed_rectangle, fixed_rectangle.Size, fixed_rectangle.Size, cp);
1108                         } else {
1109                                 hwnd.fixed_size = false;
1110                         }
1111
1112                         mwmHints.functions = (IntPtr)functions;
1113                         mwmHints.decorations = (IntPtr)decorations;
1114
1115                         DriverDebug ("SetWMStyles ({0}, {1}) functions = {2}, decorations = {3}", hwnd, cp, functions, decorations);
1116
1117                         if (cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) {
1118                                 // needed! map toolwindows to _NET_WM_WINDOW_TYPE_UTILITY to make newer metacity versions happy
1119                                 // and get those windows in front of their parents
1120                                 window_type = _NET_WM_WINDOW_TYPE_UTILITY;
1121                         } else {
1122                                 window_type = _NET_WM_WINDOW_TYPE_NORMAL;
1123                         }
1124                         
1125                         if (!cp.IsSet (WindowExStyles.WS_EX_APPWINDOW)) {
1126                                 hide_from_taskbar = true;
1127                         } else if (cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW) &&  form != null && form.Parent != null && !form.ShowInTaskbar) {
1128                                 hide_from_taskbar = true;
1129                         } else {
1130                                 hide_from_taskbar = false;
1131                         }
1132
1133                         if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
1134                                 if (form != null && !hwnd.reparented) {
1135                                         if (form.Owner != null && form.Owner.Handle != IntPtr.Zero) {
1136                                                 Hwnd owner_hwnd = Hwnd.ObjectFromHandle (form.Owner.Handle);
1137                                                 if (owner_hwnd != null)
1138                                                         transient_for_parent = owner_hwnd.whole_window;
1139                                         }
1140                                 }
1141                         } 
1142                         if (StyleSet (cp.Style, WindowStyles.WS_POPUP) && (hwnd.parent != null) && (hwnd.parent.whole_window != IntPtr.Zero)) {
1143                                 transient_for_parent = hwnd.parent.whole_window;
1144                         }
1145                         
1146                         FormWindowState current_state = GetWindowState (hwnd.Handle);
1147                         if (current_state == (FormWindowState)(-1))
1148                                 current_state = FormWindowState.Normal;
1149
1150                         client_rect = TranslateClientRectangleToXClientRectangle (hwnd);
1151
1152                         lock (XlibLock) {
1153                                 atom_count = 0;
1154
1155                                 atoms [0] = window_type.ToInt32 ();
1156                                 XChangeProperty (DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
1157
1158                                 XChangeProperty(DisplayHandle, hwnd.whole_window, _MOTIF_WM_HINTS, _MOTIF_WM_HINTS, 32, PropertyMode.Replace, ref mwmHints, 5);
1159
1160                                 if (transient_for_parent != IntPtr.Zero) {
1161                                         XSetTransientForHint (DisplayHandle, hwnd.whole_window, transient_for_parent);
1162                                 }
1163
1164                                 MoveResizeWindow(DisplayHandle, hwnd.client_window, client_rect.X, client_rect.Y, client_rect.Width, client_rect.Height);
1165
1166                                 if (hide_from_taskbar) {
1167                                         /* this line keeps the window from showing up in gnome's taskbar */
1168                                         atoms[atom_count++] = _NET_WM_STATE_SKIP_TASKBAR.ToInt32();
1169                                 }
1170                                 /* we need to add these atoms in the
1171                                  * event we're maximized, since we're
1172                                  * replacing the existing
1173                                  * _NET_WM_STATE here.  If we don't
1174                                  * add them, future calls to
1175                                  * GetWindowState will return Normal
1176                                  * for a window which is maximized. */
1177                                 if (current_state == FormWindowState.Maximized) {
1178                                         atoms[atom_count++] = _NET_WM_STATE_MAXIMIZED_HORZ.ToInt32();
1179                                         atoms[atom_count++] = _NET_WM_STATE_MAXIMIZED_VERT.ToInt32();
1180                                 }
1181                                 
1182                                 if (form != null && form.Modal) {
1183                                         atoms[atom_count++] = _NET_WM_STATE_MODAL.ToInt32 ();
1184                                 }
1185                                 
1186                                 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, atom_count);
1187
1188                                 atom_count = 0;
1189                                 IntPtr[] atom_ptrs = new IntPtr[2];
1190                                 atom_ptrs[atom_count++] = WM_DELETE_WINDOW;
1191                                 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_CONTEXTHELP)) {
1192                                         atom_ptrs[atom_count++] = _NET_WM_CONTEXT_HELP;
1193                                 }
1194
1195                                 XSetWMProtocols(DisplayHandle, hwnd.whole_window, atom_ptrs, atom_count);
1196                         }
1197                 }
1198
1199                 void SetIcon(Hwnd hwnd, Icon icon)
1200                 {
1201                         if (icon == null) {
1202                                 // XXX
1203
1204                                 // This really needs to do whatever it
1205                                 // takes to remove the window manager
1206                                 // menu, not just delete the ICON
1207                                 // property.  This will cause metacity
1208                                 // to use the "no icon set" icon, and
1209                                 // we'll still have an icon.
1210                                 XDeleteProperty (DisplayHandle, hwnd.whole_window, _NET_WM_ICON);
1211                         }
1212                         else {
1213                                 Bitmap          bitmap;
1214                                 int             size;
1215                                 IntPtr[]        data;
1216                                 int             index;
1217
1218                                 bitmap = icon.ToBitmap();
1219                                 index = 0;
1220                                 size = bitmap.Width * bitmap.Height + 2;
1221                                 data = new IntPtr[size];
1222
1223                                 data[index++] = (IntPtr)bitmap.Width;
1224                                 data[index++] = (IntPtr)bitmap.Height;
1225
1226                                 for (int y = 0; y < bitmap.Height; y++) {
1227                                         for (int x = 0; x < bitmap.Width; x++) {
1228                                                 data[index++] = (IntPtr)bitmap.GetPixel (x, y).ToArgb ();
1229                                         }
1230                                 }
1231
1232                                 XChangeProperty (DisplayHandle, hwnd.whole_window,
1233                                                  _NET_WM_ICON, (IntPtr)Atom.XA_CARDINAL, 32,
1234                                                  PropertyMode.Replace, data, size);
1235                         }
1236                 }
1237
1238                 void WakeupMain () {
1239                         try {
1240                                 wake.Send (new byte [] { 0xFF });
1241                         } catch (SocketException ex) {
1242                                 if (ex.SocketErrorCode != SocketError.WouldBlock) {
1243                                         throw;
1244                                 }
1245                         }
1246                 }
1247
1248                 XEventQueue ThreadQueue(Thread thread) {
1249                         XEventQueue     queue;
1250
1251                         queue = (XEventQueue)MessageQueues[thread];
1252                         if (queue == null) {
1253                                 queue = new XEventQueue(thread);
1254                                 MessageQueues[thread] = queue;
1255                         }
1256
1257                         return queue;
1258                 }
1259
1260                 void TranslatePropertyToClipboard(IntPtr property) {
1261                         IntPtr                  actual_atom;
1262                         int                     actual_format;
1263                         IntPtr                  nitems;
1264                         IntPtr                  bytes_after;
1265                         IntPtr                  prop = IntPtr.Zero;
1266
1267                         Clipboard.Item = null;
1268
1269                         XGetWindowProperty(DisplayHandle, FosterParent, property, IntPtr.Zero, new IntPtr (0x7fffffff), true, (IntPtr)Atom.AnyPropertyType, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
1270
1271                         if ((long)nitems > 0) {
1272                                 if (property == (IntPtr)Atom.XA_STRING) {
1273                                         // Some X managers/apps pass unicode chars as escaped strings, so
1274                                         // we may need to unescape them.
1275                                         Clipboard.Item = UnescapeUnicodeFromAnsi (Marshal.PtrToStringAnsi(prop));
1276                                 } else if (property == (IntPtr)Atom.XA_BITMAP) {
1277                                         // FIXME - convert bitmap to image
1278                                 } else if (property == (IntPtr)Atom.XA_PIXMAP) {
1279                                         // FIXME - convert pixmap to image
1280                                 } else if (property == OEMTEXT) {
1281                                         Clipboard.Item = UnescapeUnicodeFromAnsi (Marshal.PtrToStringAnsi(prop));
1282                                 } else if (property == UTF8_STRING) {
1283                                         byte [] buffer = new byte [(int)nitems];
1284                                         for (int i = 0; i < (int)nitems; i++)
1285                                                 buffer [i] = Marshal.ReadByte (prop, i);
1286                                         Clipboard.Item = Encoding.UTF8.GetString (buffer);
1287                                 } else if (property == UTF16_STRING) {
1288                                         Clipboard.Item = Marshal.PtrToStringUni (prop, Encoding.Unicode.GetMaxCharCount ((int)nitems));
1289                                 } else if (property == RICHTEXTFORMAT)
1290                                         Clipboard.Item = Marshal.PtrToStringAnsi(prop);
1291                                 else if (DataFormats.ContainsFormat (property.ToInt32 ())) {
1292                                         if (DataFormats.GetFormat (property.ToInt32 ()).is_serializable) {
1293                                                 MemoryStream memory_stream = new MemoryStream ((int)nitems);
1294                                                 for (int i = 0; i < (int)nitems; i++)
1295                                                         memory_stream.WriteByte (Marshal.ReadByte (prop, i));
1296
1297                                                 memory_stream.Position = 0;
1298                                                 BinaryFormatter formatter = new BinaryFormatter ();
1299                                                 Clipboard.Item = formatter.Deserialize (memory_stream);
1300                                                 memory_stream.Close ();
1301                                         }
1302                                 }
1303
1304                                 XFree(prop);
1305                         }
1306                 }
1307
1308                 string UnescapeUnicodeFromAnsi (string value)
1309                 {
1310                         if (value == null || value.IndexOf ("\\u") == -1)
1311                                 return value;
1312
1313                         StringBuilder sb = new StringBuilder (value.Length);
1314                         int start, pos;
1315
1316                         start = pos = 0;
1317                         while (start < value.Length) {
1318                                 pos = value.IndexOf ("\\u", start);
1319                                 if (pos == -1)
1320                                         break;
1321
1322                                 sb.Append (value, start, pos - start);
1323                                 pos += 2;
1324                                 start = pos;
1325
1326                                 int length = 0;
1327                                 while (pos < value.Length) {
1328                                         if (!Char.IsLetterOrDigit (value [pos]))
1329                                                 break;
1330                                         length++;
1331                                         pos++;
1332                                 }
1333
1334                                 int res;
1335                                 if (!Int32.TryParse (value.Substring (start, length), System.Globalization.NumberStyles.HexNumber, 
1336                                                         null, out res))
1337                                         return value; // Error, return the unescaped original value.
1338                                 
1339                                 sb.Append ((char)res);
1340                                 start = pos;
1341                         }
1342
1343                         // Append any remaining data.
1344                         if (start < value.Length)
1345                                 sb.Append (value, start, value.Length - start);
1346
1347                         return sb.ToString ();
1348                 }
1349
1350                 void AddExpose (Hwnd hwnd, bool client, int x, int y, int width, int height) {
1351                         // Don't waste time
1352                         if ((hwnd == null) || (x > hwnd.Width) || (y > hwnd.Height) || ((x + width) < 0) || ((y + height) < 0)) {
1353                                 return;
1354                         }
1355
1356                         // Keep the invalid area as small as needed
1357                         if ((x + width) > hwnd.width) {
1358                                 width = hwnd.width - x;
1359                         }
1360
1361                         if ((y + height) > hwnd.height) {
1362                                 height = hwnd.height - y;
1363                         }
1364
1365                         if (client) {
1366                                 hwnd.AddInvalidArea(x, y, width, height);
1367                                 if (!hwnd.expose_pending) {
1368                                         if (!hwnd.nc_expose_pending) {
1369                                                 hwnd.Queue.Paint.Enqueue(hwnd);
1370                                         }
1371                                         hwnd.expose_pending = true;
1372                                 }
1373                         } else {
1374                                 hwnd.AddNcInvalidArea (x, y, width, height);
1375                                 
1376                                 if (!hwnd.nc_expose_pending) {
1377                                         if (!hwnd.expose_pending) {
1378                                                 hwnd.Queue.Paint.Enqueue(hwnd);
1379                                         }
1380                                         hwnd.nc_expose_pending = true;
1381                                 }
1382                         }
1383                 }
1384
1385                 static Hwnd.Borders FrameExtents (IntPtr window)
1386                 {
1387                         IntPtr actual_atom;
1388                         int actual_format;
1389                         IntPtr nitems;
1390                         IntPtr bytes_after;
1391                         IntPtr prop = IntPtr.Zero;
1392                         Hwnd.Borders rect = new Hwnd.Borders ();
1393
1394                         XGetWindowProperty (DisplayHandle, window, _NET_FRAME_EXTENTS, IntPtr.Zero, new IntPtr (16), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
1395                         if (prop != IntPtr.Zero) {
1396                                 if (nitems.ToInt32 () == 4) {
1397                                         rect.left = Marshal.ReadInt32 (prop, 0);
1398                                         rect.right = Marshal.ReadInt32 (prop, IntPtr.Size);
1399                                         rect.top = Marshal.ReadInt32 (prop, 2 * IntPtr.Size);
1400                                         rect.bottom = Marshal.ReadInt32 (prop, 3 * IntPtr.Size);
1401                                 }
1402                                 XFree (prop);
1403                         }
1404                         
1405                         return rect;
1406                 }
1407
1408                 void AddConfigureNotify (XEvent xevent) {
1409                         Hwnd    hwnd;
1410
1411                         hwnd = Hwnd.GetObjectFromWindow(xevent.ConfigureEvent.window);
1412
1413                         // Don't waste time
1414                         if (hwnd == null || hwnd.zombie) {
1415                                 return;
1416                         }
1417                         if ((xevent.ConfigureEvent.window == hwnd.whole_window)/* && (xevent.ConfigureEvent.window == xevent.ConfigureEvent.xevent)*/) {
1418                                 if (hwnd.parent == null) {
1419                                         // The location given by the event is not reliable between different wm's, 
1420                                         // so use an alternative way of getting it.
1421                                         Point location = GetTopLevelWindowLocation (hwnd);
1422                                         hwnd.x = location.X;
1423                                         hwnd.y = location.Y;
1424                                 }
1425
1426                                 // XXX this sucks.  this isn't thread safe
1427                                 Control ctrl = Control.FromHandle (hwnd.Handle);
1428                                 Size TranslatedSize;
1429                                 if (ctrl != null) {
1430                                         TranslatedSize = TranslateXWindowSizeToWindowSize (ctrl.GetCreateParams (), xevent.ConfigureEvent.width, xevent.ConfigureEvent.height);
1431                                 } else {
1432                                         TranslatedSize = new Size (xevent.ConfigureEvent.width, xevent.ConfigureEvent.height);
1433                                 }
1434                                 hwnd.width = TranslatedSize.Width;
1435                                 hwnd.height = TranslatedSize.Height;
1436                                 hwnd.ClientRect = Rectangle.Empty;
1437
1438                                 DriverDebug ("AddConfigureNotify (hwnd.Handle = {1}, final hwnd.rect = {0}, reported rect={2})",
1439                                              new Rectangle (hwnd.x, hwnd.y, hwnd.width, hwnd.height), hwnd.Handle,
1440                                              new Rectangle (xevent.ConfigureEvent.x, xevent.ConfigureEvent.y, xevent.ConfigureEvent.width, xevent.ConfigureEvent.width));
1441                                 lock (hwnd.configure_lock) {
1442                                         if (!hwnd.configure_pending) {
1443                                                 hwnd.Queue.EnqueueLocked (xevent);
1444                                                 hwnd.configure_pending = true;
1445                                         }
1446                                 }
1447                         }
1448                         // We drop configure events for Client windows
1449                 }
1450
1451                 void ShowCaret() {
1452                         if ((Caret.gc == IntPtr.Zero) || Caret.On) {
1453                                 return;
1454                         }
1455                         Caret.On = true;
1456
1457                         lock (XlibLock) {
1458                                 XDrawLine(DisplayHandle, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height);
1459                         }
1460                 }
1461
1462                 void HideCaret() {
1463                         if ((Caret.gc == IntPtr.Zero) || !Caret.On) {
1464                                 return;
1465                         }
1466                         Caret.On = false;
1467
1468                         lock (XlibLock) {
1469                                 XDrawLine(DisplayHandle, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height);
1470                         }
1471                 }
1472
1473                 int NextTimeout (ArrayList timers, DateTime now) {
1474                         int timeout = 0; 
1475
1476                         foreach (Timer timer in timers) {
1477                                 int next = (int) (timer.Expires - now).TotalMilliseconds;
1478                                 if (next < 0) {
1479                                         return 0; // Have a timer that has already expired
1480                                 }
1481
1482                                 if (next < timeout) {
1483                                         timeout = next;
1484                                 }
1485                         }
1486                         if (timeout < Timer.Minimum) {
1487                                 timeout = Timer.Minimum;
1488                         }
1489
1490                         if (timeout > 1000)
1491                                 timeout = 1000;
1492                         return timeout;
1493                 }
1494
1495                 void CheckTimers (ArrayList timers, DateTime now) {
1496                         int count;
1497
1498                         count = timers.Count;
1499
1500                         if (count == 0)
1501                                 return;
1502
1503                         for (int i = 0; i < timers.Count; i++) {
1504                                 Timer timer;
1505
1506                                 timer = (Timer) timers [i];
1507
1508                                 if (timer.Enabled && timer.Expires <= now && !timer.Busy) {
1509                                         // Timer ticks:
1510                                         //  - Before MainForm.OnLoad if DoEvents () is called.
1511                                         //  - After MainForm.OnLoad if not.
1512                                         //
1513                                         if (in_doevents ||
1514                                             (Application.MWFThread.Current.Context != null && 
1515                                              (Application.MWFThread.Current.Context.MainForm == null || 
1516                                               Application.MWFThread.Current.Context.MainForm.IsLoaded))) {
1517                                                 timer.Busy = true;
1518                                                 timer.Update (now);
1519                                                 timer.FireTick ();
1520                                                 timer.Busy = false;
1521                                         }
1522                                 }
1523                         }
1524                 }
1525
1526                 void WaitForHwndMessage (Hwnd hwnd, Msg message) {
1527                         WaitForHwndMessage (hwnd, message, false);
1528
1529                 }
1530
1531                 void WaitForHwndMessage (Hwnd hwnd, Msg message, bool process) {
1532                         MSG msg = new MSG ();
1533                         XEventQueue queue;
1534
1535                         queue = ThreadQueue(Thread.CurrentThread);
1536
1537                         queue.DispatchIdle = false;
1538
1539                         bool done = false;
1540                         string key = hwnd.Handle + ":" + message;
1541                         if (!messageHold.ContainsKey (key))     
1542                                 messageHold.Add (key, 1);
1543                         else
1544                                 messageHold[key] = ((int)messageHold[key]) + 1;
1545                         
1546                                         
1547                         do {
1548
1549                                 DebugHelper.WriteLine  ("Waiting for message " + message + " on hwnd " + String.Format("0x{0:x}", hwnd.Handle.ToInt32 ()));
1550                                 DebugHelper.Indent ();
1551                                 
1552                                 if (PeekMessage(queue, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) {
1553                                         if ((Msg)msg.message == Msg.WM_QUIT) {
1554                                                 PostQuitMessage (0);
1555                                                 done = true;
1556                                         }
1557                                         else {
1558                                                 
1559                                                 DebugHelper.WriteLine  ("PeekMessage got " + msg);
1560                                                 
1561                                                 if (msg.hwnd == hwnd.Handle) {
1562                                                         if ((Msg)msg.message == message) {
1563                                                                 if (process) {
1564                                                                         TranslateMessage (ref msg);
1565                                                                         DispatchMessage (ref msg);
1566                                                                 }
1567                                                                 break;
1568                                                         }
1569                                                         else if ((Msg)msg.message == Msg.WM_DESTROY)
1570                                                                 done = true;
1571                                                 }
1572
1573                                                 TranslateMessage (ref msg);
1574                                                 DispatchMessage (ref msg);
1575                                         }
1576                                 }
1577                                 
1578                                 done = !messageHold.ContainsKey (key) || ((int)messageHold[key] < 1) || done;
1579                         } while (!done);
1580                                                 
1581                         messageHold.Remove (key);
1582
1583                         DebugHelper.Unindent ();
1584                         DebugHelper.WriteLine  ("Finished waiting for " + key);                 
1585
1586                         queue.DispatchIdle = true;
1587
1588                 }
1589
1590                 void MapWindow(Hwnd hwnd, WindowType windows) {
1591                         if (!hwnd.mapped) {
1592                                 Form f = Control.FromHandle(hwnd.Handle) as Form;
1593                                 if (f != null) {
1594                                         if (f.WindowState == FormWindowState.Normal) {
1595                                                 f.waiting_showwindow = true;
1596                                                 SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero);
1597                                         }
1598                                 }
1599
1600                                 // it's possible that our Hwnd is no
1601                                 // longer valid after making that
1602                                 // SendMessage call, so check here.
1603                                 if (hwnd.zombie)
1604                                         return;
1605
1606                                 if ((windows & WindowType.Whole) != 0) {
1607                                         XMapWindow(DisplayHandle, hwnd.whole_window);
1608                                 }
1609                                 if ((windows & WindowType.Client) != 0) {
1610                                         XMapWindow(DisplayHandle, hwnd.client_window);
1611                                 }
1612
1613                                 hwnd.mapped = true;
1614
1615                                 if (f != null) {
1616                                         if (f.waiting_showwindow) {
1617                                                 WaitForHwndMessage (hwnd, Msg.WM_SHOWWINDOW);
1618                                                 CreateParams cp = f.GetCreateParams();
1619                                                 if (!ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_MDICHILD) &&
1620                                                     !StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
1621                                                         WaitForHwndMessage (hwnd, Msg.WM_ACTIVATE, true);
1622                                                 }
1623                                         }
1624                                 }
1625                         }
1626                 }
1627
1628                 void UnmapWindow(Hwnd hwnd, WindowType windows) {
1629                         if (hwnd.mapped) {
1630                                 Form f = null;
1631                                 if (Control.FromHandle(hwnd.Handle) is Form) {
1632                                         f = Control.FromHandle(hwnd.Handle) as Form;
1633                                         if (f.WindowState == FormWindowState.Normal) {
1634                                                 f.waiting_showwindow = true;
1635                                                 SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, IntPtr.Zero, IntPtr.Zero);
1636                                         }
1637                                 }
1638
1639                                 // it's possible that our Hwnd is no
1640                                 // longer valid after making that
1641                                 // SendMessage call, so check here.
1642                                 // FIXME: it is likely wrong, as it has already sent WM_SHOWWINDOW
1643                                 if (hwnd.zombie)
1644                                         return;
1645
1646                                 if ((windows & WindowType.Client) != 0) {
1647                                         XUnmapWindow(DisplayHandle, hwnd.client_window);
1648                                 }
1649                                 if ((windows & WindowType.Whole) != 0) {
1650                                         XUnmapWindow(DisplayHandle, hwnd.whole_window);
1651                                 }
1652
1653                                 hwnd.mapped = false;
1654
1655                                 if (f != null) {
1656                                         if (f.waiting_showwindow) {
1657                                                 WaitForHwndMessage (hwnd, Msg.WM_SHOWWINDOW);
1658                                                 CreateParams cp = f.GetCreateParams();
1659                                                 if (!ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_MDICHILD) &&
1660                                                     !StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
1661                                                         WaitForHwndMessage (hwnd, Msg.WM_ACTIVATE, true);
1662                                                 }
1663                                         }
1664                                 }
1665                         }
1666                 }
1667
1668                 void UpdateMessageQueue (XEventQueue queue) {
1669                         UpdateMessageQueue(queue, true);
1670                 }
1671
1672                 void UpdateMessageQueue (XEventQueue queue, bool allowIdle) {
1673                         DateTime        now;
1674                         int             pending;
1675                         Hwnd            hwnd;
1676
1677                         now = DateTime.UtcNow;
1678
1679                         lock (XlibLock) {
1680                                 pending = XPending (DisplayHandle);
1681                         }
1682
1683                         if (pending == 0 && allowIdle) {
1684                                 if ((queue == null || queue.DispatchIdle) && Idle != null) {
1685                                         Idle (this, EventArgs.Empty);
1686                                 }
1687
1688                                 lock (XlibLock) {
1689                                         pending = XPending (DisplayHandle);
1690                                 }
1691                         }
1692
1693                         if (pending == 0) {
1694                                 int     timeout = 0;
1695
1696                                 if (queue != null) {
1697                                         if (queue.Paint.Count > 0)
1698                                                 return;
1699
1700                                         timeout = NextTimeout (queue.timer_list, now);
1701                                 }
1702
1703                                 if (timeout > 0) {
1704                                         #if __MonoCS__
1705                                         int length = pollfds.Length - 1;
1706                                         lock (wake_waiting_lock) {
1707                                                 if (wake_waiting == false) {
1708                                                         length ++;
1709                                                         wake_waiting = true;
1710                                                 }
1711                                         }
1712
1713                                         Syscall.poll (pollfds, (uint)length, timeout);
1714                                         // Clean out buffer, so we're not busy-looping on the same data
1715                                         if (length == pollfds.Length) {
1716                                                 if (pollfds[1].revents != 0)
1717                                                         wake_receive.Receive(network_buffer, 0, 1, SocketFlags.None);
1718                                                 lock (wake_waiting_lock) {
1719                                                         wake_waiting = false;
1720                                                 }
1721                                         }
1722                                         #endif
1723                                         lock (XlibLock) {
1724                                                 pending = XPending (DisplayHandle);
1725                                         }
1726                                 }
1727                         }
1728
1729                         if (queue != null)
1730                                 CheckTimers (queue.timer_list, now);
1731
1732                         while (true) {
1733                                 XEvent xevent = new XEvent ();
1734
1735                                 lock (XlibLock) {
1736                                         if (XPending (DisplayHandle) == 0)
1737                                                 break;
1738
1739                                         XNextEvent (DisplayHandle, ref xevent);
1740
1741                                         if (xevent.AnyEvent.type == XEventName.KeyPress ||
1742                                             xevent.AnyEvent.type == XEventName.KeyRelease) {
1743                                                 // PreFilter() handles "shift key state updates.
1744                                                 Keyboard.PreFilter (xevent);
1745                                                 if (XFilterEvent (ref xevent, Keyboard.ClientWindow)) {
1746                                                         // probably here we could raise WM_IME_KEYDOWN and
1747                                                         // WM_IME_KEYUP, but I'm not sure it is worthy.
1748                                                         continue;
1749                                                 }
1750                                         }
1751                                         else if (XFilterEvent (ref xevent, IntPtr.Zero))
1752                                                 continue;
1753                                 }
1754
1755                                 hwnd = Hwnd.GetObjectFromWindow(xevent.AnyEvent.window);
1756                                 if (hwnd == null)
1757                                         continue;
1758
1759                                 DebugHelper.WriteLine  ("UpdateMessageQueue got Event: " + xevent.ToString ());
1760
1761                                 switch (xevent.type) {
1762                                 case XEventName.Expose:
1763                                         AddExpose (hwnd, xevent.ExposeEvent.window == hwnd.ClientWindow, xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height);
1764                                         break;
1765
1766                                 case XEventName.SelectionClear: {
1767                                         // Should we do something?
1768                                         break;
1769                                 }
1770
1771                                 case XEventName.SelectionRequest: {
1772                                         if (Dnd.HandleSelectionRequestEvent (ref xevent))
1773                                                 break;
1774                                         XEvent sel_event;
1775
1776                                         sel_event = new XEvent();
1777                                         sel_event.SelectionEvent.type = XEventName.SelectionNotify;
1778                                         sel_event.SelectionEvent.send_event = true;
1779                                         sel_event.SelectionEvent.display = DisplayHandle;
1780                                         sel_event.SelectionEvent.selection = xevent.SelectionRequestEvent.selection;
1781                                         sel_event.SelectionEvent.target = xevent.SelectionRequestEvent.target;
1782                                         sel_event.SelectionEvent.requestor = xevent.SelectionRequestEvent.requestor;
1783                                         sel_event.SelectionEvent.time = xevent.SelectionRequestEvent.time;
1784                                         sel_event.SelectionEvent.property = IntPtr.Zero;
1785
1786                                         IntPtr format_atom = xevent.SelectionRequestEvent.target;
1787
1788                                         // Seems that some apps support asking for supported types
1789                                         if (format_atom == TARGETS) {
1790                                                 int[]   atoms;
1791                                                 int     atom_count;
1792
1793                                                 atoms = new int[5];
1794                                                 atom_count = 0;
1795
1796                                                 if (Clipboard.IsSourceText) {
1797                                                         atoms[atom_count++] = (int)Atom.XA_STRING;
1798                                                         atoms[atom_count++] = (int)OEMTEXT;
1799                                                         atoms[atom_count++] = (int)UTF8_STRING;
1800                                                         atoms[atom_count++] = (int)UTF16_STRING;
1801                                                         atoms[atom_count++] = (int)RICHTEXTFORMAT;
1802                                                 } else if (Clipboard.IsSourceImage) {
1803                                                         atoms[atom_count++] = (int)Atom.XA_PIXMAP;
1804                                                         atoms[atom_count++] = (int)Atom.XA_BITMAP;
1805                                                 } else {
1806                                                         // FIXME - handle other types
1807                                                 }
1808
1809                                                 XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, 
1810                                                                 (IntPtr)xevent.SelectionRequestEvent.target, 32, PropertyMode.Replace, atoms, atom_count);
1811                                                 sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1812                                         } else if (format_atom == (IntPtr)RICHTEXTFORMAT) {
1813                                                 string rtf_text = Clipboard.GetRtfText ();
1814                                                 if (rtf_text != null) {
1815                                                         // The RTF spec mentions that ascii is enough to contain it
1816                                                         Byte [] bytes = Encoding.ASCII.GetBytes (rtf_text);
1817                                                         int buflen = bytes.Length;
1818                                                         IntPtr buffer = Marshal.AllocHGlobal (buflen);
1819
1820                                                         for (int i = 0; i < buflen; i++)
1821                                                                 Marshal.WriteByte (buffer, i, bytes[i]);
1822
1823                                                         XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property,
1824                                                                         (IntPtr)xevent.SelectionRequestEvent.target, 8, PropertyMode.Replace, buffer, buflen);
1825                                                         sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1826                                                         Marshal.FreeHGlobal(buffer);
1827                                                 }
1828                                         } else if (Clipboard.IsSourceText && 
1829                                                    (format_atom == (IntPtr)Atom.XA_STRING 
1830                                                     || format_atom == OEMTEXT
1831                                                     || format_atom == UTF16_STRING
1832                                                     || format_atom == UTF8_STRING)) {
1833                                                 IntPtr  buffer = IntPtr.Zero;
1834                                                 int     buflen;
1835                                                 Encoding encoding = null;
1836
1837                                                 buflen = 0;
1838
1839                                                 // Select an encoding depending on the target
1840                                                 IntPtr target_atom = xevent.SelectionRequestEvent.target;
1841                                                 if (target_atom == (IntPtr)Atom.XA_STRING || target_atom == OEMTEXT)
1842                                                         // FIXME - EOMTEXT should encode into ISO2022
1843                                                         encoding = Encoding.ASCII;
1844                                                 else if (target_atom == UTF16_STRING)
1845                                                         encoding = Encoding.Unicode;
1846                                                 else if (target_atom == UTF8_STRING)
1847                                                         encoding = Encoding.UTF8;
1848
1849                                                 Byte [] bytes;
1850
1851                                                 bytes = encoding.GetBytes (Clipboard.GetPlainText ());
1852                                                 buffer = Marshal.AllocHGlobal (bytes.Length);
1853                                                 buflen = bytes.Length;
1854
1855                                                 for (int i = 0; i < buflen; i++)
1856                                                         Marshal.WriteByte (buffer, i, bytes [i]);
1857
1858                                                 if (buffer != IntPtr.Zero) {
1859                                                         XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, (IntPtr)xevent.SelectionRequestEvent.target, 8, PropertyMode.Replace, buffer, buflen);
1860                                                         sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1861                                                         Marshal.FreeHGlobal(buffer);
1862                                                 }
1863                                         } else if (Clipboard.GetSource (format_atom.ToInt32 ()) != null) { // check if we have an available value of this format
1864                                                 if (DataFormats.GetFormat (format_atom.ToInt32 ()).is_serializable) {
1865                                                         object serializable = Clipboard.GetSource (format_atom.ToInt32 ());
1866
1867                                                         BinaryFormatter formatter = new BinaryFormatter ();
1868                                                         MemoryStream memory_stream = new MemoryStream ();
1869                                                         formatter.Serialize (memory_stream, serializable);
1870
1871                                                         int buflen = (int)memory_stream.Length;
1872                                                         IntPtr buffer = Marshal.AllocHGlobal (buflen);
1873                                                         memory_stream.Position = 0;
1874                                                         for (int i = 0; i < buflen; i++)
1875                                                                 Marshal.WriteByte (buffer, i, (byte)memory_stream.ReadByte ());
1876                                                         memory_stream.Close ();
1877
1878                                                         XChangeProperty (DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, (IntPtr)xevent.SelectionRequestEvent.target,
1879                                                                         8, PropertyMode.Replace, buffer, buflen);
1880                                                         sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1881                                                         Marshal.FreeHGlobal (buffer);
1882                                                 }
1883
1884                                         } else if (Clipboard.IsSourceImage) {
1885                                                 if (xevent.SelectionEvent.target == (IntPtr)Atom.XA_PIXMAP) {
1886                                                         // FIXME - convert image and store as property
1887                                                 } else if (xevent.SelectionEvent.target == (IntPtr)Atom.XA_PIXMAP) {
1888                                                         // FIXME - convert image and store as property
1889                                                 }
1890                                         }
1891
1892                                         XSendEvent(DisplayHandle, xevent.SelectionRequestEvent.requestor, false, new IntPtr ((int)EventMask.NoEventMask), ref sel_event);
1893                                         break;
1894                                 }
1895
1896                                 case XEventName.SelectionNotify: {
1897                                         if (Clipboard.Enumerating) {
1898                                                 Clipboard.Enumerating = false;
1899                                                 if (xevent.SelectionEvent.property != IntPtr.Zero) {
1900                                                         XDeleteProperty(DisplayHandle, FosterParent, (IntPtr)xevent.SelectionEvent.property);
1901                                                         if (!Clipboard.Formats.Contains(xevent.SelectionEvent.property)) {
1902                                                                 Clipboard.Formats.Add(xevent.SelectionEvent.property);
1903                                                                 DriverDebug("Got supported clipboard atom format: {0}", xevent.SelectionEvent.property);
1904                                                         }
1905                                                 }
1906                                         } else if (Clipboard.Retrieving) {
1907                                                 Clipboard.Retrieving = false;
1908                                                 if (xevent.SelectionEvent.property != IntPtr.Zero) {
1909                                                         TranslatePropertyToClipboard(xevent.SelectionEvent.property);
1910                                                 } else {
1911                                                         Clipboard.ClearSources ();
1912                                                         Clipboard.Item = null;
1913                                                 }
1914                                         } else {
1915                                                 Dnd.HandleSelectionNotifyEvent (ref xevent);
1916                                         }
1917                                         break;
1918                                 }
1919
1920                                 case XEventName.KeyRelease:
1921                                         if (!detectable_key_auto_repeat && XPending (DisplayHandle) != 0) {
1922                                                 XEvent nextevent = new XEvent ();
1923
1924                                                 XPeekEvent (DisplayHandle, ref nextevent);
1925
1926                                                 if (nextevent.type == XEventName.KeyPress &&
1927                                                     nextevent.KeyEvent.keycode == xevent.KeyEvent.keycode &&
1928                                                     nextevent.KeyEvent.time == xevent.KeyEvent.time) {
1929                                                         continue;
1930                                                 }
1931                                         }
1932                                         goto case XEventName.KeyPress;
1933                                         
1934                                 case XEventName.MotionNotify: {
1935                                         XEvent peek;
1936
1937                                         /* we can't do motion compression across threads, so just punt if we don't match up */
1938                                         if (Thread.CurrentThread == hwnd.Queue.Thread && hwnd.Queue.Count > 0) {
1939                                                 peek = hwnd.Queue.Peek();
1940                                                 if (peek.AnyEvent.type == XEventName.MotionNotify) {
1941                                                         continue;
1942                                                 }
1943                                         }
1944                                         goto case XEventName.KeyPress;
1945                                 }
1946
1947                                 case XEventName.KeyPress:
1948                                         hwnd.Queue.EnqueueLocked (xevent);
1949                                         /* Process KeyPresses immediately. Otherwise multiple Compose messages as a result of a
1950                                          * single physical keypress are not processed correctly */
1951                                         return;
1952                                 case XEventName.ButtonPress:
1953                                 case XEventName.ButtonRelease:
1954                                 case XEventName.EnterNotify:
1955                                 case XEventName.LeaveNotify:
1956                                 case XEventName.CreateNotify:
1957                                 case XEventName.DestroyNotify:
1958                                 case XEventName.FocusIn:
1959                                 case XEventName.FocusOut:
1960                                 case XEventName.ClientMessage:
1961                                 case XEventName.ReparentNotify:
1962                                 case XEventName.MapNotify:
1963                                 case XEventName.UnmapNotify:
1964                                         hwnd.Queue.EnqueueLocked (xevent);
1965                                         break;
1966
1967                                 case XEventName.ConfigureNotify:
1968                                         AddConfigureNotify(xevent);
1969                                         break;
1970
1971                                 case XEventName.PropertyNotify:
1972                                         DriverDebug ("UpdateMessageQueue (), got Event: {0}", xevent.ToString ());
1973                                         if (xevent.PropertyEvent.atom == _NET_ACTIVE_WINDOW) {
1974                                                 IntPtr  actual_atom;
1975                                                 int     actual_format;
1976                                                 IntPtr  nitems;
1977                                                 IntPtr  bytes_after;
1978                                                 IntPtr  prop = IntPtr.Zero;
1979                                                 IntPtr  prev_active;
1980
1981                                                 prev_active = ActiveWindow;
1982                                                 XGetWindowProperty(DisplayHandle, RootWindow, _NET_ACTIVE_WINDOW, IntPtr.Zero, new IntPtr (1), false, (IntPtr)Atom.XA_WINDOW, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
1983                                                 if (((long)nitems > 0) && (prop != IntPtr.Zero)) {
1984                                                         ActiveWindow = Hwnd.GetHandleFromWindow((IntPtr)Marshal.ReadInt32(prop));                                                       
1985                                                         XFree(prop);
1986
1987                                                         DebugHelper.WriteLine ("PropertyNotify: _NET_ACTIVE_WINDOW: previous = 0x{0:x}, new = 0x{1:x}", prev_active.ToInt32 (), ActiveWindow.ToInt32 ());
1988                                                         
1989                                                         if (prev_active != ActiveWindow) {
1990                                                                 if (prev_active != IntPtr.Zero) {
1991                                                                         PostMessage(prev_active, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero);
1992                                                                 }
1993                                                                 if (ActiveWindow != IntPtr.Zero) {
1994                                                                         PostMessage(ActiveWindow, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_ACTIVE, IntPtr.Zero);
1995                                                                 }
1996                                                         }
1997                                                         if (ModalWindows.Count == 0) {
1998                                                                 break;
1999                                                         } else {
2000                                                                 // Modality Handling
2001                                                                 // 
2002                                                                 // If there is a modal window on the stack and the new active 
2003                                                                 // window is MWF window, but not the modal one and not a non-modal 
2004                                                                 // child of the modal one, switch back to the modal window.
2005                                                                 //
2006                                                                 // To identify if a non-modal form is child of a modal form 
2007                                                                 // we match their ApplicationContexts, which will be the same.
2008                                                                 // This is because each modal form runs the loop with a 
2009                                                                 // new ApplicationContext, which is inherited by the non-modal 
2010                                                                 // forms.
2011
2012                                                                 Form activeForm = Control.FromHandle (ActiveWindow) as Form;
2013                                                                 if (activeForm != null) {
2014                                                                         Form modalForm = Control.FromHandle ((IntPtr)ModalWindows.Peek()) as Form;
2015                                                                         if (ActiveWindow != (IntPtr)ModalWindows.Peek() && 
2016                                                                             (modalForm == null || activeForm.context == modalForm.context)) {
2017                                                                                 Activate((IntPtr)ModalWindows.Peek());
2018                                                                         }
2019                                                                 }
2020                                                                 break;
2021                                                         }
2022                                                 }
2023                                         }
2024                                         else if (xevent.PropertyEvent.atom == _NET_WM_STATE) {
2025                                                 // invalidate our cache - we'll query again the next time someone does GetWindowState.
2026                                                 hwnd.cached_window_state = (FormWindowState)(-1);
2027                                                 PostMessage (hwnd.Handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
2028                                         }
2029                                         break;
2030
2031                                 }
2032                         }
2033                 }
2034
2035                 IntPtr GetMousewParam(int Delta) {
2036                         int     result = 0;
2037
2038                         if ((MouseState & MouseButtons.Left) != 0) {
2039                                 result |= (int)MsgButtons.MK_LBUTTON;
2040                         }
2041
2042                         if ((MouseState & MouseButtons.Middle) != 0) {
2043                                 result |= (int)MsgButtons.MK_MBUTTON;
2044                         }
2045
2046                         if ((MouseState & MouseButtons.Right) != 0) {
2047                                 result |= (int)MsgButtons.MK_RBUTTON;
2048                         }
2049
2050                         Keys mods = ModifierKeys;
2051                         if ((mods & Keys.Control) != 0) {
2052                                 result |= (int)MsgButtons.MK_CONTROL;
2053                         }
2054
2055                         if ((mods & Keys.Shift) != 0) {
2056                                 result |= (int)MsgButtons.MK_SHIFT;
2057                         }
2058
2059                         result |= Delta << 16;
2060
2061                         return (IntPtr)result;
2062                 }
2063                 IntPtr XGetParent(IntPtr handle) {
2064                         IntPtr  Root;
2065                         IntPtr  Parent;
2066                         IntPtr  Children;
2067                         int     ChildCount;
2068
2069                         lock (XlibLock) {
2070                                 XQueryTree(DisplayHandle, handle, out Root, out Parent, out Children, out ChildCount);
2071                         }
2072
2073                         if (Children!=IntPtr.Zero) {
2074                                 lock (XlibLock) {
2075                                         XFree(Children);
2076                                 }
2077                         }
2078                         return Parent;
2079                 }
2080
2081                 int HandleError (IntPtr display, ref XErrorEvent error_event)
2082                 {
2083                         // we need to workaround a problem with the
2084                         // ordering of destruction of Drawables and
2085                         // Pictures that exists between cairo and
2086                         // RENDER on the server.
2087                         if (error_event.request_code == (XRequest)render_major_opcode
2088                             && error_event.minor_code == 7 /* X_RenderFreePicture from render.h */
2089                             && error_event.error_code == render_first_error + 1 /* BadPicture from render.h */) {
2090                                 return 0;
2091                         }
2092
2093                         if (ErrorExceptions) {
2094                                 XUngrabPointer (display, IntPtr.Zero);
2095                                 throw new XException (error_event.display, error_event.resourceid,
2096                                                       error_event.serial, error_event.error_code,
2097                                                       error_event.request_code, error_event.minor_code);
2098                         } else {
2099                                 Console.WriteLine("X11 Error encountered: {0}{1}\n",
2100                                                   XException.GetMessage (error_event.display, error_event.resourceid,
2101                                                                          error_event.serial, error_event.error_code,
2102                                                                          error_event.request_code, error_event.minor_code),
2103                                                   Environment.StackTrace);
2104                         }
2105                         return 0;
2106                 }
2107
2108                 void AccumulateDestroyedHandles (Control c, ArrayList list)
2109                 {
2110                         DebugHelper.Enter ();
2111                         if (c != null) {
2112                                 
2113                                 Control[] controls = c.Controls.GetAllControls ();
2114                                 
2115                                 DebugHelper.WriteLine  ("Checking control:0x{0:x}", c.IsHandleCreated ? c.Handle.ToInt32() : 0);
2116
2117                                 if (c.IsHandleCreated && !c.IsDisposed) {
2118                                         Hwnd hwnd = Hwnd.ObjectFromHandle(c.Handle);
2119
2120                                         DriverDebug (" + adding {0} to the list of zombie windows", XplatUI.Window (hwnd.Handle));
2121                                         DriverDebug (" + parent X window is {0:X}", XGetParent (hwnd.whole_window).ToInt32());
2122
2123                                         list.Add (hwnd);
2124                                         CleanupCachedWindows (hwnd);
2125                                 }
2126
2127                                 for (int  i = 0; i < controls.Length; i ++) {
2128                                         AccumulateDestroyedHandles (controls[i], list);
2129                                 }                                
2130                         }
2131                         DebugHelper.Leave ();
2132                 }
2133
2134                 void CleanupCachedWindows (Hwnd hwnd)
2135                 {
2136                         if (ActiveWindow == hwnd.Handle) {
2137                                 SendMessage(hwnd.client_window, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero);
2138                                 ActiveWindow = IntPtr.Zero;
2139                         }
2140
2141                         if (FocusWindow == hwnd.Handle) {
2142                                 SendMessage(hwnd.client_window, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero);
2143                                 FocusWindow = IntPtr.Zero;
2144                         }
2145
2146                         if (Grab.Hwnd == hwnd.Handle) {
2147                                 Grab.Hwnd = IntPtr.Zero;
2148                                 Grab.Confined = false;
2149                         }
2150
2151                         DestroyCaret (hwnd.Handle);
2152                 }
2153
2154                 void PerformNCCalc(Hwnd hwnd) {
2155                         XplatUIWin32.NCCALCSIZE_PARAMS  ncp;
2156                         IntPtr                          ptr;
2157                         Rectangle                       rect;
2158
2159                         rect = new Rectangle (0, 0, hwnd.Width, hwnd.Height);
2160
2161                         ncp = new XplatUIWin32.NCCALCSIZE_PARAMS();
2162                         ptr = Marshal.AllocHGlobal(Marshal.SizeOf(ncp));
2163
2164                         ncp.rgrc1.left = rect.Left;
2165                         ncp.rgrc1.top = rect.Top;
2166                         ncp.rgrc1.right = rect.Right;
2167                         ncp.rgrc1.bottom = rect.Bottom;
2168
2169                         Marshal.StructureToPtr(ncp, ptr, true);
2170                         NativeWindow.WndProc(hwnd.client_window, Msg.WM_NCCALCSIZE, (IntPtr)1, ptr);
2171                         ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure(ptr, typeof(XplatUIWin32.NCCALCSIZE_PARAMS));
2172                         Marshal.FreeHGlobal(ptr);
2173
2174
2175                         rect = new Rectangle(ncp.rgrc1.left, ncp.rgrc1.top, ncp.rgrc1.right - ncp.rgrc1.left, ncp.rgrc1.bottom - ncp.rgrc1.top);
2176                         hwnd.ClientRect = rect;
2177                 
2178                         rect = TranslateClientRectangleToXClientRectangle (hwnd);
2179
2180                         if (hwnd.visible) {
2181                                 MoveResizeWindow (DisplayHandle, hwnd.client_window, rect.X, rect.Y, rect.Width, rect.Height);
2182                         }
2183
2184                         AddExpose (hwnd, hwnd.WholeWindow == hwnd.ClientWindow, 0, 0, hwnd.Width, hwnd.Height);
2185                 }
2186                 #endregion      // Methods
2187
2188                 #region Callbacks
2189                 void MouseHover(object sender, EventArgs e) {
2190                         XEvent  xevent;
2191                         Hwnd    hwnd;
2192
2193                         HoverState.Timer.Enabled = false;
2194
2195                         if (HoverState.Window != IntPtr.Zero) {
2196                                 hwnd = Hwnd.GetObjectFromWindow(HoverState.Window);
2197                                 if (hwnd != null) {
2198                                         xevent = new XEvent ();
2199
2200                                         xevent.type = XEventName.ClientMessage;
2201                                         xevent.ClientMessageEvent.display = DisplayHandle;
2202                                         xevent.ClientMessageEvent.window = HoverState.Window;
2203                                         xevent.ClientMessageEvent.message_type = HoverState.Atom;
2204                                         xevent.ClientMessageEvent.format = 32;
2205                                         xevent.ClientMessageEvent.ptr1 = (IntPtr) (HoverState.Y << 16 | HoverState.X);
2206
2207                                         hwnd.Queue.EnqueueLocked (xevent);
2208
2209                                         WakeupMain ();
2210                                 }
2211                         }
2212                 }
2213
2214                 void CaretCallback(object sender, EventArgs e) {
2215                         if (Caret.Paused) {
2216                                 return;
2217                         }
2218                         Caret.On = !Caret.On;
2219
2220                         XDrawLine(DisplayHandle, Caret.Hwnd, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height);
2221                 }
2222                 #endregion      // Callbacks
2223
2224                 #region Public Properties
2225
2226                 internal override int CaptionHeight {
2227                         get {
2228                                 return 19;
2229                         }
2230                 }
2231
2232                 internal override  Size CursorSize {
2233                         get {
2234                                 int     x;
2235                                 int     y;
2236
2237                                 if (XQueryBestCursor(DisplayHandle, RootWindow, 32, 32, out x, out y) != 0) {
2238                                         return new Size(x, y);
2239                                 } else {
2240                                         return new Size(16, 16);
2241                                 }
2242                         }
2243                 } 
2244
2245                 internal override  bool DragFullWindows {
2246                         get {
2247                                 return true;
2248                         }
2249                 } 
2250
2251                 internal override  Size DragSize {
2252                         get {
2253                                 return new Size(4, 4);
2254                         }
2255                 }
2256
2257                 internal override  Size FrameBorderSize { 
2258                         get {
2259                                 return new Size (4, 4);
2260                         }
2261                 }
2262
2263                 internal override  Size IconSize {
2264                         get {
2265                                 IntPtr          list;
2266                                 XIconSize       size;
2267                                 int             count;
2268
2269                                 if (XGetIconSizes(DisplayHandle, RootWindow, out list, out count) != 0) {
2270                                         long            current;
2271                                         int             largest;
2272
2273                                         current = (long)list;
2274                                         largest = 0;
2275
2276                                         size = new XIconSize();
2277
2278                                         for (int i = 0; i < count; i++) {
2279                                                 size = (XIconSize)Marshal.PtrToStructure((IntPtr)current, size.GetType());
2280                                                 current += Marshal.SizeOf(size);
2281
2282                                                 // Look for our preferred size
2283                                                 if (size.min_width == 32) {
2284                                                         XFree(list);
2285                                                         return new Size(32, 32);
2286                                                 }
2287
2288                                                 if (size.max_width == 32) {
2289                                                         XFree(list);
2290                                                         return new Size(32, 32);
2291                                                 }
2292
2293                                                 if (size.min_width < 32 && size.max_width > 32) {
2294                                                         int     x;
2295
2296                                                         // check if we can fit one
2297                                                         x = size.min_width;
2298                                                         while (x < size.max_width) {
2299                                                                 x += size.width_inc;
2300                                                                 if (x == 32) {
2301                                                                         XFree(list);
2302                                                                         return new Size(32, 32);
2303                                                                 }
2304                                                         }
2305                                                 }
2306
2307                                                 if (largest < size.max_width) {
2308                                                         largest = size.max_width;
2309                                                 }
2310                                         }
2311
2312                                         // We didn't find a match or we wouldn't be here
2313                                         return new Size(largest, largest);
2314
2315                                 } else {
2316                                         return new Size(32, 32);
2317                                 }
2318                         }
2319                 } 
2320
2321                 internal override int KeyboardSpeed {
2322                         get{
2323                                 //
2324                                 // A lot harder: need to do:
2325                                 // XkbQueryExtension(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58)       = 1
2326                                 // XkbAllocKeyboard(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58)        = 0x080517a8
2327                                 // XkbGetControls(0x08051008, 1, 0x080517a8, 0xbfffdf54, 0xbfffdf58)                   = 0
2328                                 //
2329                                 // And from that we can tell the repetition rate
2330                                 //
2331                                 // Notice, the values must map to:
2332                                 //   [0, 31] which maps to 2.5 to 30 repetitions per second.
2333                                 //
2334                                 return 0;
2335                         }
2336                 }
2337
2338                 internal override int KeyboardDelay {
2339                         get {
2340                                 //
2341                                 // Return values must range from 0 to 4, 0 meaning 250ms,
2342                                 // and 4 meaning 1000 ms.
2343                                 //
2344                                 return 1; // ie, 500 ms
2345                         }
2346                 } 
2347
2348                 internal override  Size MaxWindowTrackSize {
2349                         get {
2350                                 return new Size (WorkingArea.Width, WorkingArea.Height);
2351                         }
2352                 }
2353
2354                 internal override bool MenuAccessKeysUnderlined {
2355                         get {
2356                                 return false;
2357                         }
2358                 }
2359
2360                 internal override  Size MinimizedWindowSpacingSize {
2361                         get {
2362                                 return new Size(1, 1);
2363                         }
2364                 } 
2365
2366                 internal override  Size MinimumWindowSize {
2367                         get {
2368                                 return new Size(110, 22);
2369                         }
2370                 } 
2371
2372                 internal override Size MinimumFixedToolWindowSize {
2373                         get { return new Size (27, 22); }
2374                 }
2375
2376                 internal override Size MinimumSizeableToolWindowSize {
2377                         get { return new Size (37, 22); }
2378                 }
2379
2380                 internal override Size MinimumNoBorderWindowSize {
2381                         get { return new Size (2, 2); }
2382                 }
2383                 
2384                 internal override Keys ModifierKeys {
2385                         get {
2386                                 return Keyboard.ModifierKeys;
2387                         }
2388                 }
2389
2390                 internal override  Size SmallIconSize {
2391                         get {
2392                                 IntPtr          list;
2393                                 XIconSize       size;
2394                                 int             count;
2395
2396                                 if (XGetIconSizes(DisplayHandle, RootWindow, out list, out count) != 0) {
2397                                         long            current;
2398                                         int             smallest;
2399
2400                                         current = (long)list;
2401                                         smallest = 0;
2402
2403                                         size = new XIconSize();
2404
2405                                         for (int i = 0; i < count; i++) {
2406                                                 size = (XIconSize)Marshal.PtrToStructure((IntPtr)current, size.GetType());
2407                                                 current += Marshal.SizeOf(size);
2408
2409                                                 // Look for our preferred size
2410                                                 if (size.min_width == 16) {
2411                                                         XFree(list);
2412                                                         return new Size(16, 16);
2413                                                 }
2414
2415                                                 if (size.max_width == 16) {
2416                                                         XFree(list);
2417                                                         return new Size(16, 16);
2418                                                 }
2419
2420                                                 if (size.min_width < 16 && size.max_width > 16) {
2421                                                         int     x;
2422
2423                                                         // check if we can fit one
2424                                                         x = size.min_width;
2425                                                         while (x < size.max_width) {
2426                                                                 x += size.width_inc;
2427                                                                 if (x == 16) {
2428                                                                         XFree(list);
2429                                                                         return new Size(16, 16);
2430                                                                 }
2431                                                         }
2432                                                 }
2433
2434                                                 if (smallest == 0 || smallest > size.min_width) {
2435                                                         smallest = size.min_width;
2436                                                 }
2437                                         }
2438
2439                                         // We didn't find a match or we wouldn't be here
2440                                         return new Size(smallest, smallest);
2441
2442                                 } else {
2443                                         return new Size(16, 16);
2444                                 }
2445                         }
2446                 } 
2447
2448                 internal override  int MouseButtonCount {
2449                         get {
2450                                 return 3;
2451                         }
2452                 } 
2453
2454                 internal override  bool MouseButtonsSwapped {
2455                         get {
2456                                 return false;   // FIXME - how to detect?
2457                         }
2458                 } 
2459
2460                 internal override Point MousePosition {
2461                         get {
2462                                 return mouse_position;
2463                         }
2464                 }
2465
2466                 internal override Size MouseHoverSize {
2467                         get {
2468                                 return new Size (1, 1);
2469                         }
2470                 }
2471
2472                 internal override int MouseHoverTime {
2473                         get {
2474                                 return HoverState.Interval;
2475                         }
2476                 }
2477
2478
2479
2480                 internal override  bool MouseWheelPresent {
2481                         get {
2482                                 return true;    // FIXME - how to detect?
2483                         }
2484                 } 
2485
2486                 internal override MouseButtons MouseButtons {
2487                         get {
2488                                 return MouseState;
2489                         }
2490                 }
2491
2492                 internal override  Rectangle VirtualScreen {
2493                         get {
2494                                 IntPtr                  actual_atom;
2495                                 int                     actual_format;
2496                                 IntPtr                  nitems;
2497                                 IntPtr                  bytes_after;
2498                                 IntPtr                  prop = IntPtr.Zero;
2499                                 int                     width;
2500                                 int                     height;
2501
2502                                 XGetWindowProperty(DisplayHandle, RootWindow, _NET_DESKTOP_GEOMETRY, IntPtr.Zero, new IntPtr (256), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
2503                                 if ((long)nitems < 2)
2504                                         goto failsafe;
2505
2506                                 width = Marshal.ReadIntPtr(prop, 0).ToInt32();
2507                                 height = Marshal.ReadIntPtr(prop, IntPtr.Size).ToInt32();
2508
2509                                 XFree(prop);
2510
2511                                 return new Rectangle(0, 0, width, height);
2512
2513                         failsafe:
2514                                 XWindowAttributes       attributes=new XWindowAttributes();
2515
2516                                 lock (XlibLock) {
2517                                         XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes);
2518                                 }
2519
2520                                 return new Rectangle(0, 0, attributes.width, attributes.height);
2521                         }
2522                 } 
2523
2524                 internal override  Rectangle WorkingArea {
2525                         get {
2526                                 IntPtr                  actual_atom;
2527                                 int                     actual_format;
2528                                 IntPtr                  nitems;
2529                                 IntPtr                  bytes_after;
2530                                 IntPtr                  prop = IntPtr.Zero;
2531                                 int                     width;
2532                                 int                     height;
2533                                 int                     current_desktop;
2534                                 int                     x;
2535                                 int                     y;
2536
2537                                 XGetWindowProperty(DisplayHandle, RootWindow, _NET_CURRENT_DESKTOP, IntPtr.Zero, new IntPtr(1), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
2538                                 if ((long)nitems < 1) {
2539                                         goto failsafe;
2540                                 }
2541
2542                                 current_desktop = Marshal.ReadIntPtr(prop, 0).ToInt32();
2543                                 XFree(prop);
2544
2545                                 XGetWindowProperty(DisplayHandle, RootWindow, _NET_WORKAREA, IntPtr.Zero, new IntPtr (256), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
2546                                 if ((long)nitems < 4 * (current_desktop + 1)) {
2547                                         goto failsafe;
2548                                 }
2549
2550                                 x = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop).ToInt32();
2551                                 y = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size).ToInt32();
2552                                 width = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size * 2).ToInt32();
2553                                 height = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size * 3).ToInt32();
2554                                 XFree(prop);
2555
2556                                 return new Rectangle(x, y, width, height);
2557
2558                         failsafe:
2559                                 XWindowAttributes       attributes=new XWindowAttributes();
2560
2561                                 lock (XlibLock) {
2562                                         XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes);
2563                                 }
2564
2565                                 return new Rectangle(0, 0, attributes.width, attributes.height);
2566                         }
2567                 }
2568
2569                 internal override bool ThemesEnabled {
2570                         get {
2571                                 return XplatUIX11.themes_enabled;
2572                         }
2573                 }
2574  
2575
2576                 #endregion      // Public properties
2577
2578                 #region Public Static Methods
2579                 internal override void RaiseIdle (EventArgs e)
2580                 {
2581                         if (Idle != null)
2582                                 Idle (this, e);
2583                 }
2584                 
2585                 internal override IntPtr InitializeDriver()
2586                 {
2587                         lock (this) {
2588                                 if (DisplayHandle==IntPtr.Zero) {
2589                                         SetDisplay(XOpenDisplay(IntPtr.Zero));
2590                                 }
2591                         }
2592                         return IntPtr.Zero;
2593                 }
2594
2595                 internal override void ShutdownDriver(IntPtr token)
2596                 {
2597                         lock (this) {
2598                                 if (DisplayHandle!=IntPtr.Zero) {
2599                                         XCloseDisplay(DisplayHandle);
2600                                         DisplayHandle=IntPtr.Zero;
2601                                 }
2602                         }
2603                 }
2604
2605                 internal override void EnableThemes()
2606                 {
2607                         themes_enabled = true;
2608                 }
2609
2610
2611                 internal override void Activate(IntPtr handle)
2612                 {
2613                         Hwnd hwnd;
2614
2615                         hwnd = Hwnd.ObjectFromHandle(handle);
2616
2617                         if (hwnd != null) {
2618                                 lock (XlibLock) {
2619                                         if (true /* the window manager supports NET_ACTIVE_WINDOW */) {
2620                                                 SendNetWMMessage(hwnd.whole_window, _NET_ACTIVE_WINDOW, (IntPtr)1, IntPtr.Zero, IntPtr.Zero);
2621                                                 XEventQueue q = null;
2622                                                 lock (unattached_timer_list) {
2623                                                         foreach (Timer t in unattached_timer_list) {
2624                                                                 if (q == null)
2625                                                                         q= (XEventQueue) MessageQueues [Thread.CurrentThread];
2626                                                                 t.thread = q.Thread;
2627                                                                 q.timer_list.Add (t);
2628                                                         }
2629                                                         unattached_timer_list.Clear ();
2630                                                 }
2631                                         }
2632 //                                      else {
2633 //                                              XRaiseWindow(DisplayHandle, handle);
2634 //                                      }
2635                                 }
2636                         }
2637                 }
2638
2639                 internal override void AudibleAlert(AlertType alert)
2640                 {
2641                         XBell(DisplayHandle, 0);
2642                         return;
2643                 }
2644
2645
2646                 internal override void CaretVisible(IntPtr handle, bool visible)
2647                 {
2648                         if (Caret.Hwnd == handle) {
2649                                 if (visible) {
2650                                         if (!Caret.Visible) {
2651                                                 Caret.Visible = true;
2652                                                 ShowCaret();
2653                                                 Caret.Timer.Start();
2654                                         }
2655                                 } else {
2656                                         Caret.Visible = false;
2657                                         Caret.Timer.Stop();
2658                                         HideCaret();
2659                                 }
2660                         }
2661                 }
2662
2663                 internal override bool CalculateWindowRect(ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect)
2664                 {
2665                         WindowRect = Hwnd.GetWindowRectangle (cp, menu, ClientRect);
2666                         return true;
2667                 }
2668
2669                 internal override void ClientToScreen(IntPtr handle, ref int x, ref int y)
2670                 {
2671                         int     dest_x_return;
2672                         int     dest_y_return;
2673                         IntPtr  child;
2674                         Hwnd    hwnd;
2675
2676                         hwnd = Hwnd.ObjectFromHandle(handle);
2677
2678                         lock (XlibLock) {
2679                                 XTranslateCoordinates(DisplayHandle, hwnd.client_window, RootWindow, x, y, out dest_x_return, out dest_y_return, out child);
2680                         }
2681
2682                         x = dest_x_return;
2683                         y = dest_y_return;
2684                 }
2685
2686                 internal override int[] ClipboardAvailableFormats(IntPtr handle)
2687                 {
2688                         DataFormats.Format      f;
2689                         int[]                   result;
2690
2691                         f = DataFormats.Format.List;
2692
2693                         if (XGetSelectionOwner(DisplayHandle, CLIPBOARD) == IntPtr.Zero) {
2694                                 return null;
2695                         }
2696
2697                         Clipboard.Formats = new ArrayList();
2698
2699                         while (f != null) {
2700                                 XConvertSelection(DisplayHandle, CLIPBOARD, (IntPtr)f.Id, (IntPtr)f.Id, FosterParent, IntPtr.Zero);
2701
2702                                 Clipboard.Enumerating = true;
2703                                 while (Clipboard.Enumerating) {
2704                                         UpdateMessageQueue(null, false);
2705                                 }
2706                                 f = f.Next;
2707                         }
2708
2709                         result = new int[Clipboard.Formats.Count];
2710
2711                         for (int i = 0; i < Clipboard.Formats.Count; i++) {
2712                                 result[i] = ((IntPtr)Clipboard.Formats[i]).ToInt32 ();
2713                         }
2714
2715                         Clipboard.Formats = null;
2716                         return result;
2717                 }
2718
2719                 internal override void ClipboardClose(IntPtr handle)
2720                 {
2721                         if (handle != ClipMagic) {
2722                                 throw new ArgumentException("handle is not a valid clipboard handle");
2723                         }
2724                         return;
2725                 }
2726
2727                 internal override int ClipboardGetID(IntPtr handle, string format)
2728                 {
2729                         if (handle != ClipMagic) {
2730                                 throw new ArgumentException("handle is not a valid clipboard handle");
2731                         }
2732
2733                         if (format == "Text" ) return (int)Atom.XA_STRING;
2734                         else if (format == "Bitmap" ) return (int)Atom.XA_BITMAP;
2735                         //else if (format == "MetaFilePict" ) return 3;
2736                         //else if (format == "SymbolicLink" ) return 4;
2737                         //else if (format == "DataInterchangeFormat" ) return 5;
2738                         //else if (format == "Tiff" ) return 6;
2739                         else if (format == "OEMText" ) return OEMTEXT.ToInt32();
2740                         else if (format == "DeviceIndependentBitmap" ) return (int)Atom.XA_PIXMAP;
2741                         else if (format == "Palette" ) return (int)Atom.XA_COLORMAP;    // Useless
2742                         //else if (format == "PenData" ) return 10;
2743                         //else if (format == "RiffAudio" ) return 11;
2744                         //else if (format == "WaveAudio" ) return 12;
2745                         else if (format == "UnicodeText" ) return UTF16_STRING.ToInt32();
2746                         //else if (format == "EnhancedMetafile" ) return 14;
2747                         //else if (format == "FileDrop" ) return 15;
2748                         //else if (format == "Locale" ) return 16;
2749                         else if (format == "Rich Text Format") return RICHTEXTFORMAT.ToInt32 ();
2750
2751                         return XInternAtom(DisplayHandle, format, false).ToInt32();
2752                 }
2753
2754                 internal override IntPtr ClipboardOpen(bool primary_selection)
2755                 {
2756                         if (!primary_selection)
2757                                 ClipMagic = CLIPBOARD;
2758                         else
2759                                 ClipMagic = PRIMARY;
2760                         return ClipMagic;
2761                 }
2762
2763                 internal override object ClipboardRetrieve(IntPtr handle, int type, XplatUI.ClipboardToObject converter)
2764                 {
2765                         XConvertSelection(DisplayHandle, handle, (IntPtr)type, (IntPtr)type, FosterParent, IntPtr.Zero);
2766
2767                         Clipboard.Retrieving = true;
2768                         while (Clipboard.Retrieving) {
2769                                 UpdateMessageQueue(null, false);
2770                         }
2771
2772                         return Clipboard.Item;
2773                 }
2774
2775                 internal override void ClipboardStore(IntPtr handle, object obj, int type, XplatUI.ObjectToClipboard converter)
2776                 {
2777                         Clipboard.Converter = converter;
2778
2779                         if (obj != null) {
2780                                 Clipboard.AddSource (type, obj);
2781                                 XSetSelectionOwner(DisplayHandle, CLIPBOARD, FosterParent, IntPtr.Zero);
2782                         } else {
2783                                 // Clearing the selection
2784                                 Clipboard.ClearSources ();
2785                                 XSetSelectionOwner(DisplayHandle, CLIPBOARD, IntPtr.Zero, IntPtr.Zero);
2786                         }
2787                 }
2788
2789                 internal override void CreateCaret (IntPtr handle, int width, int height)
2790                 {
2791                         XGCValues       gc_values;
2792                         Hwnd            hwnd;
2793
2794                         hwnd = Hwnd.ObjectFromHandle(handle);
2795
2796                         if (Caret.Hwnd != IntPtr.Zero) {
2797                                 DestroyCaret(Caret.Hwnd);
2798                         }
2799
2800                         Caret.Hwnd = handle;
2801                         Caret.Window = hwnd.client_window;
2802                         Caret.Width = width;
2803                         Caret.Height = height;
2804                         Caret.Visible = false;
2805                         Caret.On = false;
2806
2807                         gc_values = new XGCValues();
2808                         gc_values.line_width = width;
2809
2810                         Caret.gc = XCreateGC(DisplayHandle, Caret.Window, new IntPtr ((int)GCFunction.GCLineWidth), ref gc_values);
2811                         if (Caret.gc == IntPtr.Zero) {
2812                                 Caret.Hwnd = IntPtr.Zero;
2813                                 return;
2814                         }
2815
2816                         XSetFunction(DisplayHandle, Caret.gc, GXFunction.GXinvert);
2817                 }
2818
2819                 internal override IntPtr CreateWindow (CreateParams cp)
2820                 {
2821                         XSetWindowAttributes    Attributes;
2822                         Hwnd                    hwnd;
2823                         Hwnd                    parent_hwnd = null;
2824                         int                     X;
2825                         int                     Y;
2826                         int                     Width;
2827                         int                     Height;
2828                         IntPtr                  ParentHandle;
2829                         IntPtr                  WholeWindow;
2830                         IntPtr                  ClientWindow;
2831                         SetWindowValuemask      ValueMask;
2832                         int[]                   atoms;
2833
2834                         hwnd = new Hwnd();
2835
2836                         Attributes = new XSetWindowAttributes();
2837                         X = cp.X;
2838                         Y = cp.Y;
2839                         Width = cp.Width;
2840                         Height = cp.Height;
2841
2842                         if (Width<1) Width=1;
2843                         if (Height<1) Height=1;
2844
2845                         if (cp.Parent != IntPtr.Zero) {
2846                                 parent_hwnd = Hwnd.ObjectFromHandle(cp.Parent);
2847                                 ParentHandle = parent_hwnd.client_window;
2848                         } else {
2849                                 if (StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
2850                                         // We need to use our foster parent window until this poor child gets it's parent assigned
2851                                         ParentHandle=FosterParent;
2852                                 } else {
2853                                         ParentHandle=RootWindow;
2854                                 }
2855                         }
2856
2857                         // Set the default location location for forms.
2858                         Point next;
2859                         if (cp.control is Form) {
2860                                 next = Hwnd.GetNextStackedFormLocation (cp, parent_hwnd);
2861                                 X = next.X;
2862                                 Y = next.Y;
2863                         }
2864                         ValueMask = SetWindowValuemask.BitGravity | SetWindowValuemask.WinGravity;
2865
2866                         Attributes.bit_gravity = Gravity.NorthWestGravity;
2867                         Attributes.win_gravity = Gravity.NorthWestGravity;
2868
2869                         // Save what's under the toolwindow
2870                         if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
2871                                 Attributes.save_under = true;
2872                                 ValueMask |= SetWindowValuemask.SaveUnder;
2873                         }
2874
2875
2876                         // If we're a popup without caption we override the WM
2877                         if (StyleSet (cp.Style, WindowStyles.WS_POPUP) && !StyleSet (cp.Style, WindowStyles.WS_CAPTION)) {
2878                                 Attributes.override_redirect = true;
2879                                 ValueMask |= SetWindowValuemask.OverrideRedirect;
2880                         }
2881
2882                         hwnd.x = X;
2883                         hwnd.y = Y;
2884                         hwnd.width = Width;
2885                         hwnd.height = Height;
2886                         hwnd.parent = Hwnd.ObjectFromHandle(cp.Parent);
2887                         hwnd.initial_style = cp.WindowStyle;
2888                         hwnd.initial_ex_style = cp.WindowExStyle;
2889
2890                         if (StyleSet (cp.Style, WindowStyles.WS_DISABLED)) {
2891                                 hwnd.enabled = false;
2892                         }
2893
2894                         ClientWindow = IntPtr.Zero;
2895
2896                         Size XWindowSize = TranslateWindowSizeToXWindowSize (cp);
2897                         Rectangle XClientRect = TranslateClientRectangleToXClientRectangle (hwnd, cp.control);
2898                                 
2899                         lock (XlibLock) {
2900                                 WholeWindow = XCreateWindow(DisplayHandle, ParentHandle, X, Y, XWindowSize.Width, XWindowSize.Height, 0, (int)CreateWindowArgs.CopyFromParent, (int)CreateWindowArgs.InputOutput, IntPtr.Zero, new UIntPtr ((uint)ValueMask), ref Attributes);
2901                                 if (WholeWindow != IntPtr.Zero) {
2902                                         ValueMask &= ~(SetWindowValuemask.OverrideRedirect | SetWindowValuemask.SaveUnder);
2903
2904                                         if (CustomVisual != IntPtr.Zero && CustomColormap != IntPtr.Zero) {
2905                                                 ValueMask = SetWindowValuemask.ColorMap;
2906                                                 Attributes.colormap = CustomColormap;
2907                                         }
2908                                         ClientWindow = XCreateWindow(DisplayHandle, WholeWindow, XClientRect.X, XClientRect.Y, XClientRect.Width, XClientRect.Height, 0, (int)CreateWindowArgs.CopyFromParent, (int)CreateWindowArgs.InputOutput, CustomVisual, new UIntPtr ((uint)ValueMask), ref Attributes);
2909                                 }
2910                         }
2911
2912                         if ((WholeWindow == IntPtr.Zero) || (ClientWindow == IntPtr.Zero)) {
2913                                 throw new Exception("Could not create X11 windows");
2914                         }
2915
2916                         hwnd.Queue = ThreadQueue(Thread.CurrentThread);
2917                         hwnd.WholeWindow = WholeWindow;
2918                         hwnd.ClientWindow = ClientWindow;
2919
2920                         DriverDebug("Created window {0:X} / {1:X} parent {2:X}, Style {3}, ExStyle {4}", ClientWindow.ToInt32(), WholeWindow.ToInt32(), hwnd.parent != null ? hwnd.parent.Handle.ToInt32() : 0, (WindowStyles)cp.Style, (WindowExStyles)cp.ExStyle);
2921                         
2922                         if (!StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
2923                                 if ((X != unchecked((int)0x80000000)) && (Y != unchecked((int)0x80000000))) {
2924                                         XSizeHints      hints;
2925
2926                                         hints = new XSizeHints();
2927                                         hints.x = X;
2928                                         hints.y = Y;
2929                                         hints.flags = (IntPtr)(XSizeHintsFlags.USPosition | XSizeHintsFlags.PPosition);
2930                                         XSetWMNormalHints(DisplayHandle, WholeWindow, ref hints);
2931                                 }
2932                         }
2933
2934                         lock (XlibLock) {
2935                                 XSelectInput(DisplayHandle, hwnd.whole_window, new IntPtr ((int)(SelectInputMask | EventMask.StructureNotifyMask | EventMask.PropertyChangeMask | Keyboard.KeyEventMask)));
2936                                 if (hwnd.whole_window != hwnd.client_window)
2937                                         XSelectInput(DisplayHandle, hwnd.client_window, new IntPtr ((int)(SelectInputMask | EventMask.StructureNotifyMask | Keyboard.KeyEventMask)));
2938                         }
2939
2940                         if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOPMOST)) {
2941                                 atoms = new int[2];
2942                                 atoms[0] = _NET_WM_WINDOW_TYPE_NORMAL.ToInt32();
2943                                 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
2944
2945                                 XSetTransientForHint (DisplayHandle, hwnd.whole_window, RootWindow);
2946                         }
2947
2948                         SetWMStyles(hwnd, cp);
2949                         
2950                         // set the group leader
2951                         XWMHints wm_hints = new XWMHints ();
2952                         
2953                         wm_hints.flags = (IntPtr)(XWMHintsFlags.InputHint | XWMHintsFlags.StateHint | XWMHintsFlags.WindowGroupHint);
2954                         wm_hints.input = !StyleSet (cp.Style, WindowStyles.WS_DISABLED);
2955                         wm_hints.initial_state = StyleSet (cp.Style, WindowStyles.WS_MINIMIZE) ? XInitialState.IconicState : XInitialState.NormalState;
2956                         
2957                         if (ParentHandle != RootWindow) {
2958                                 wm_hints.window_group = hwnd.whole_window;
2959                         } else {
2960                                 wm_hints.window_group = ParentHandle;
2961                         }
2962                         
2963                         lock (XlibLock) {
2964                                 XSetWMHints(DisplayHandle, hwnd.whole_window, ref wm_hints );
2965                         }
2966
2967                         if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZE)) {
2968                                 SetWindowState(hwnd.Handle, FormWindowState.Minimized);
2969                         } else if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZE)) {
2970                                 SetWindowState(hwnd.Handle, FormWindowState.Maximized);
2971                         }
2972
2973                         // for now make all windows dnd enabled
2974                         Dnd.SetAllowDrop (hwnd, true);
2975
2976                         // Set caption/window title
2977                         Text(hwnd.Handle, cp.Caption);
2978
2979                         SendMessage (hwnd.Handle, Msg.WM_CREATE, (IntPtr)1, IntPtr.Zero /* XXX unused */);
2980                         SendParentNotify (hwnd.Handle, Msg.WM_CREATE, int.MaxValue, int.MaxValue);
2981
2982                         if (StyleSet (cp.Style, WindowStyles.WS_VISIBLE)) {
2983                                 hwnd.visible = true;
2984                                 MapWindow(hwnd, WindowType.Both);
2985                                 if (!(Control.FromHandle(hwnd.Handle) is Form))
2986                                         SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero);
2987                         }
2988
2989                         return hwnd.Handle;
2990                 }
2991
2992                 internal override IntPtr CreateWindow(IntPtr Parent, int X, int Y, int Width, int Height)
2993                 {
2994                         CreateParams create_params = new CreateParams();
2995
2996                         create_params.Caption = "";
2997                         create_params.X = X;
2998                         create_params.Y = Y;
2999                         create_params.Width = Width;
3000                         create_params.Height = Height;
3001
3002                         create_params.ClassName=XplatUI.GetDefaultClassName (GetType ());
3003                         create_params.ClassStyle = 0;
3004                         create_params.ExStyle=0;
3005                         create_params.Parent=IntPtr.Zero;
3006                         create_params.Param=0;
3007
3008                         return CreateWindow(create_params);
3009                 }
3010
3011                 internal override IntPtr DefineCursor(Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot)
3012                 {
3013                         IntPtr  cursor;
3014                         Bitmap  cursor_bitmap;
3015                         Bitmap  cursor_mask;
3016                         Byte[]  cursor_bits;
3017                         Byte[]  mask_bits;
3018                         Color   c_pixel;
3019                         Color   m_pixel;
3020                         int     width;
3021                         int     height;
3022                         IntPtr  cursor_pixmap;
3023                         IntPtr  mask_pixmap;
3024                         XColor  fg;
3025                         XColor  bg;
3026                         bool    and;
3027                         bool    xor;
3028
3029                         if (XQueryBestCursor(DisplayHandle, RootWindow, bitmap.Width, bitmap.Height, out width, out height) == 0) {
3030                                 return IntPtr.Zero;
3031                         }
3032
3033                         // Win32 only allows creation cursors of a certain size
3034                         if ((bitmap.Width != width) || (bitmap.Width != height)) {
3035                                 cursor_bitmap = new Bitmap(bitmap, new Size(width, height));
3036                                 cursor_mask = new Bitmap(mask, new Size(width, height));
3037                         } else {
3038                                 cursor_bitmap = bitmap;
3039                                 cursor_mask = mask;
3040                         }
3041
3042                         width = cursor_bitmap.Width;
3043                         height = cursor_bitmap.Height;
3044
3045                         cursor_bits = new Byte[(width / 8) * height];
3046                         mask_bits = new Byte[(width / 8) * height];
3047
3048                         for (int y = 0; y < height; y++) {
3049                                 for (int x = 0; x < width; x++) {
3050                                         c_pixel = cursor_bitmap.GetPixel(x, y);
3051                                         m_pixel = cursor_mask.GetPixel(x, y);
3052
3053                                         and = c_pixel == cursor_pixel;
3054                                         xor = m_pixel == mask_pixel;
3055
3056                                         if (!and && !xor) {
3057                                                 // Black
3058                                                 // cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8)));       // The bit already is 0
3059                                                 mask_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8));
3060                                         } else if (and && !xor) {
3061                                                 // White
3062                                                 cursor_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8));
3063                                                 mask_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8));
3064 #if notneeded
3065                                         } else if (and && !xor) {
3066                                                 // Screen
3067                                         } else if (and && xor) {
3068                                                 // Inverse Screen
3069
3070                                                 // X11 doesn't know the 'reverse screen' concept, so we'll treat them the same
3071                                                 // we want both to be 0 so nothing to be done
3072                                                 //cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8)));
3073                                                 //mask_bits[y * width / 8 + x / 8] |= (byte)(01 << (x % 8));
3074 #endif
3075                                         }
3076                                 }
3077                         }
3078
3079                         cursor_pixmap = XCreatePixmapFromBitmapData(DisplayHandle, RootWindow, cursor_bits, width, height, (IntPtr)1, (IntPtr)0, 1);
3080                         mask_pixmap = XCreatePixmapFromBitmapData(DisplayHandle, RootWindow, mask_bits, width, height, (IntPtr)1, (IntPtr)0, 1);
3081                         fg = new XColor();
3082                         bg = new XColor();
3083
3084                         fg.pixel = XWhitePixel(DisplayHandle, ScreenNo);
3085                         fg.red = (ushort)65535;
3086                         fg.green = (ushort)65535;
3087                         fg.blue = (ushort)65535;
3088
3089                         bg.pixel = XBlackPixel(DisplayHandle, ScreenNo);
3090
3091                         cursor = XCreatePixmapCursor(DisplayHandle, cursor_pixmap, mask_pixmap, ref fg, ref bg, xHotSpot, yHotSpot);
3092
3093                         XFreePixmap(DisplayHandle, cursor_pixmap);
3094                         XFreePixmap(DisplayHandle, mask_pixmap);
3095
3096                         return cursor;
3097                 }
3098
3099                 internal override Bitmap DefineStdCursorBitmap (StdCursor id)
3100                 {
3101                         CursorFontShape shape;
3102                         string name;
3103                         IntPtr theme;
3104                         int size;
3105                         Bitmap bmp = null;
3106                         
3107                         try {
3108                                 shape = StdCursorToFontShape (id);
3109                                 name = shape.ToString ().Replace ("XC_", string.Empty);
3110                                 size = XcursorGetDefaultSize (DisplayHandle);
3111                                 theme = XcursorGetTheme (DisplayHandle);
3112                                 IntPtr images_ptr = XcursorLibraryLoadImages (name, theme, size);
3113                                 DriverDebug ("DefineStdCursorBitmap, id={0}, #id={1}, name{2}, size={3}, theme: {4}, images_ptr={5}", id, (int) id, name, size, Marshal.PtrToStringAnsi (theme), images_ptr);
3114
3115                                 if (images_ptr == IntPtr.Zero) {
3116                                         return null;
3117                                 }
3118
3119                                 XcursorImages images = (XcursorImages) Marshal.PtrToStructure (images_ptr, typeof (XcursorImages));
3120                                 DriverDebug ("DefineStdCursorBitmap, cursor has {0} images", images.nimage);
3121
3122                                 if (images.nimage > 0) {                        
3123                                         // We only care about the first image.
3124                                         XcursorImage image = (XcursorImage)Marshal.PtrToStructure (Marshal.ReadIntPtr (images.images), typeof (XcursorImage));
3125                                         
3126                                         DriverDebug ("DefineStdCursorBitmap, loaded image <size={0}, height={1}, width={2}, xhot={3}, yhot={4}, pixels={5}", image.size, image.height, image.width, image.xhot, image.yhot, image.pixels);
3127                                         // A sanity check
3128                                         if (image.width <= short.MaxValue && image.height <= short.MaxValue) {
3129                                                 int [] pixels = new int [image.width * image.height];
3130                                                 Marshal.Copy (image.pixels, pixels, 0, pixels.Length);
3131                                                 bmp = new Bitmap (image.width, image.height);
3132                                                 for (int w = 0; w < image.width; w++) {
3133                                                         for (int h = 0; h < image.height; h++) {
3134                                                                 bmp.SetPixel (w, h, Color.FromArgb (pixels [h * image.width + w]));
3135                                                         }
3136                                                 }
3137                                         }
3138                                 }
3139                                 
3140                                 XcursorImagesDestroy (images_ptr);
3141                                 
3142                         } catch (DllNotFoundException ex) {
3143                                 Console.WriteLine ("Could not load libXcursor: " + ex.Message + " (" + ex.GetType ().Name + ")");
3144                                 return null;
3145                         }
3146                         
3147                         return bmp;
3148                 }
3149
3150                 
3151                 internal override IntPtr DefineStdCursor(StdCursor id)
3152                 {
3153                         CursorFontShape shape;
3154                         IntPtr          cursor;
3155
3156                         shape = StdCursorToFontShape (id);
3157
3158                         lock (XlibLock) {
3159                                 cursor = XCreateFontCursor(DisplayHandle, shape);
3160                         }
3161                         return cursor;
3162                 }
3163
3164                 internal static CursorFontShape StdCursorToFontShape (StdCursor id)
3165                 {
3166                         CursorFontShape shape;
3167                         // FIXME - define missing shapes
3168
3169                         switch (id) {
3170                                 case StdCursor.AppStarting: {
3171                                         shape = CursorFontShape.XC_watch;
3172                                         break;
3173                                 }
3174
3175                                 case StdCursor.Arrow: {
3176                                         shape = CursorFontShape.XC_top_left_arrow;
3177                                         break;
3178                                 }
3179
3180                                 case StdCursor.Cross: {
3181                                         shape = CursorFontShape.XC_crosshair;
3182                                         break;
3183                                 }
3184
3185                                 case StdCursor.Default: {
3186                                         shape = CursorFontShape.XC_top_left_arrow;
3187                                         break;
3188                                 }
3189
3190                                 case StdCursor.Hand: {
3191                                         shape = CursorFontShape.XC_hand1;
3192                                         break;
3193                                 }
3194
3195                                 case StdCursor.Help: {
3196                                         shape = CursorFontShape.XC_question_arrow;
3197                                         break;
3198                                 }
3199
3200                                 case StdCursor.HSplit: {
3201                                         shape = CursorFontShape.XC_sb_v_double_arrow; 
3202                                         break;
3203                                 }
3204
3205                                 case StdCursor.IBeam: {
3206                                         shape = CursorFontShape.XC_xterm; 
3207                                         break;
3208                                 }
3209
3210                                 case StdCursor.No: {
3211                                         shape = CursorFontShape.XC_circle; 
3212                                         break;
3213                                 }
3214
3215                                 case StdCursor.NoMove2D: {
3216                                         shape = CursorFontShape.XC_fleur; 
3217                                         break;
3218                                 }
3219
3220                                 case StdCursor.NoMoveHoriz: {
3221                                         shape = CursorFontShape.XC_fleur; 
3222                                         break;
3223                                 }
3224
3225                                 case StdCursor.NoMoveVert: {
3226                                         shape = CursorFontShape.XC_fleur; 
3227                                         break;
3228                                 }
3229
3230                                 case StdCursor.PanEast: {
3231                                         shape = CursorFontShape.XC_fleur; 
3232                                         break;
3233                                 }
3234
3235                                 case StdCursor.PanNE: {
3236                                         shape = CursorFontShape.XC_fleur; 
3237                                         break;
3238                                 }
3239
3240                                 case StdCursor.PanNorth: {
3241                                         shape = CursorFontShape.XC_fleur; 
3242                                         break;
3243                                 }
3244
3245                                 case StdCursor.PanNW: {
3246                                         shape = CursorFontShape.XC_fleur; 
3247                                         break;
3248                                 }
3249
3250                                 case StdCursor.PanSE: {
3251                                         shape = CursorFontShape.XC_fleur; 
3252                                         break;
3253                                 }
3254
3255                                 case StdCursor.PanSouth: {
3256                                         shape = CursorFontShape.XC_fleur; 
3257                                         break;
3258                                 }
3259
3260                                 case StdCursor.PanSW: {
3261                                         shape = CursorFontShape.XC_fleur; 
3262                                         break;
3263                                 }
3264
3265                                 case StdCursor.PanWest: {
3266                                         shape = CursorFontShape.XC_sizing; 
3267                                         break;
3268                                 }
3269
3270                                 case StdCursor.SizeAll: {
3271                                         shape = CursorFontShape.XC_fleur; 
3272                                         break;
3273                                 }
3274
3275                                 case StdCursor.SizeNESW: {
3276                                         shape = CursorFontShape.XC_top_right_corner; 
3277                                         break;
3278                                 }
3279
3280                                 case StdCursor.SizeNS: {
3281                                         shape = CursorFontShape.XC_sb_v_double_arrow;
3282                                         break;
3283                                 }
3284
3285                                 case StdCursor.SizeNWSE: {
3286                                         shape = CursorFontShape.XC_top_left_corner; 
3287                                         break;
3288                                 }
3289
3290                                 case StdCursor.SizeWE: {
3291                                         shape = CursorFontShape.XC_sb_h_double_arrow; 
3292                                         break;
3293                                 }
3294
3295                                 case StdCursor.UpArrow: {
3296                                         shape = CursorFontShape.XC_center_ptr; 
3297                                         break;
3298                                 }
3299
3300                                 case StdCursor.VSplit: {
3301                                         shape = CursorFontShape.XC_sb_h_double_arrow;
3302                                         break;
3303                                 }
3304
3305                                 case StdCursor.WaitCursor: {
3306                                         shape = CursorFontShape.XC_watch; 
3307                                         break;
3308                                 }
3309
3310                                 default: {
3311                                         shape = (CursorFontShape) 0;
3312                                         break;
3313                                 }
3314                         }
3315                         
3316                         return shape;
3317                 }
3318
3319                 internal override IntPtr DefWndProc(ref Message msg)
3320                 {
3321                         switch ((Msg)msg.Msg) {
3322                                 
3323                                 case Msg.WM_IME_COMPOSITION:
3324                                         string s = Keyboard.GetCompositionString ();
3325                                         foreach (char c in s)
3326                                                 SendMessage (msg.HWnd, Msg.WM_IME_CHAR, (IntPtr) c, msg.LParam);
3327                                         return IntPtr.Zero;
3328
3329                                 case Msg.WM_IME_CHAR:
3330                                         // On Windows API it sends two WM_CHAR messages for each byte, but
3331                                         // I wonder if it is worthy to emulate it (also no idea how to 
3332                                         // reconstruct those bytes into chars).
3333                                         SendMessage (msg.HWnd, Msg.WM_CHAR, msg.WParam, msg.LParam);
3334                                         return IntPtr.Zero;
3335
3336                                 case Msg.WM_PAINT: {
3337                                         Hwnd hwnd;
3338
3339                                         hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3340                                         if (hwnd != null) {
3341                                                 hwnd.expose_pending = false;
3342                                         }
3343
3344                                         return IntPtr.Zero;
3345                                 }
3346
3347                                 case Msg.WM_NCPAINT: {
3348                                         Hwnd hwnd;
3349
3350                                         hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3351                                         if (hwnd != null) {
3352                                                 hwnd.nc_expose_pending = false;
3353                                         }
3354
3355                                         return IntPtr.Zero;
3356                                 }
3357
3358                                 case Msg.WM_NCCALCSIZE: {
3359                                         Hwnd hwnd;
3360
3361                                         if (msg.WParam == (IntPtr)1) {
3362                                                 hwnd = Hwnd.GetObjectFromWindow (msg.HWnd);
3363                                                 
3364                                                 XplatUIWin32.NCCALCSIZE_PARAMS ncp;
3365                                                 ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure (msg.LParam, typeof (XplatUIWin32.NCCALCSIZE_PARAMS));
3366
3367                                                 // Add all the stuff X is supposed to draw.
3368                                                 Control ctrl = Control.FromHandle (hwnd.Handle);
3369                                                 
3370                                                 if (ctrl != null) {
3371                                                         Hwnd.Borders rect = Hwnd.GetBorders (ctrl.GetCreateParams (), null);
3372                                                         
3373                                                         ncp.rgrc1.top += rect.top;
3374                                                         ncp.rgrc1.bottom -= rect.bottom;
3375                                                         ncp.rgrc1.left += rect.left;
3376                                                         ncp.rgrc1.right -= rect.right;
3377                                                         
3378                                                         Marshal.StructureToPtr (ncp, msg.LParam, true);
3379                                                 }
3380                                         }
3381
3382                                         return IntPtr.Zero;
3383                                 }
3384
3385                                 case Msg.WM_CONTEXTMENU: {
3386                                         Hwnd hwnd;
3387
3388                                         hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3389
3390                                         if ((hwnd != null) && (hwnd.parent != null)) {
3391                                                 SendMessage(hwnd.parent.client_window, Msg.WM_CONTEXTMENU, msg.WParam, msg.LParam);
3392                                         }
3393                                         return IntPtr.Zero;
3394                                 }
3395
3396                                 case Msg.WM_MOUSEWHEEL: {
3397                                         Hwnd hwnd;
3398
3399                                         hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3400
3401                                         if ((hwnd != null) && (hwnd.parent != null)) {
3402                                                 SendMessage(hwnd.parent.client_window, Msg.WM_MOUSEWHEEL, msg.WParam, msg.LParam);
3403                                                 if (msg.Result == IntPtr.Zero) {
3404                                                         return IntPtr.Zero;
3405                                                 }
3406                                         }
3407                                         return IntPtr.Zero;
3408                                 }
3409
3410                                 case Msg.WM_SETCURSOR: {
3411                                         Hwnd    hwnd;
3412
3413                                         hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3414                                         if (hwnd == null)
3415                                                 break; // not sure how this happens, but it does
3416
3417                                         // Pass to parent window first
3418                                         while ((hwnd.parent != null) && (msg.Result == IntPtr.Zero)) {
3419                                                 hwnd = hwnd.parent;
3420                                                 msg.Result = NativeWindow.WndProc(hwnd.Handle, Msg.WM_SETCURSOR, msg.HWnd, msg.LParam);
3421                                         }
3422
3423                                         if (msg.Result == IntPtr.Zero) {
3424                                                 IntPtr handle;
3425
3426                                                 switch((HitTest)(msg.LParam.ToInt32() & 0xffff)) {
3427                                                         case HitTest.HTBOTTOM:          handle = Cursors.SizeNS.handle; break;
3428                                                         case HitTest.HTBORDER:          handle = Cursors.SizeNS.handle; break;
3429                                                         case HitTest.HTBOTTOMLEFT:      handle = Cursors.SizeNESW.handle; break;
3430                                                         case HitTest.HTBOTTOMRIGHT:     handle = Cursors.SizeNWSE.handle; break;
3431                                                         case HitTest.HTERROR:           if ((msg.LParam.ToInt32() >> 16) == (int)Msg.WM_LBUTTONDOWN) {
3432                                                                                                 AudibleAlert(AlertType.Default);
3433                                                                                         }
3434                                                                                         handle = Cursors.Default.handle;
3435                                                                                         break;
3436
3437                                                         case HitTest.HTHELP:            handle = Cursors.Help.handle; break;
3438                                                         case HitTest.HTLEFT:            handle = Cursors.SizeWE.handle; break;
3439                                                         case HitTest.HTRIGHT:           handle = Cursors.SizeWE.handle; break;
3440                                                         case HitTest.HTTOP:             handle = Cursors.SizeNS.handle; break;
3441                                                         case HitTest.HTTOPLEFT:         handle = Cursors.SizeNWSE.handle; break;
3442                                                         case HitTest.HTTOPRIGHT:        handle = Cursors.SizeNESW.handle; break;
3443
3444                                                         #if SameAsDefault
3445                                                         case HitTest.HTGROWBOX:
3446                                                         case HitTest.HTSIZE:
3447                                                         case HitTest.HTZOOM:
3448                                                         case HitTest.HTVSCROLL:
3449                                                         case HitTest.HTSYSMENU:
3450                                                         case HitTest.HTREDUCE:
3451                                                         case HitTest.HTNOWHERE:
3452                                                         case HitTest.HTMAXBUTTON:
3453                                                         case HitTest.HTMINBUTTON:
3454                                                         case HitTest.HTMENU:
3455                                                         case HitTest.HSCROLL:
3456                                                         case HitTest.HTBOTTOM:
3457                                                         case HitTest.HTCAPTION:
3458                                                         case HitTest.HTCLIENT:
3459                                                         case HitTest.HTCLOSE:
3460                                                         #endif
3461                                                         default: handle = Cursors.Default.handle; break;
3462                                                 }
3463                                                 SetCursor(msg.HWnd, handle);
3464                                         }
3465                                         return (IntPtr)1;
3466                                 }
3467                         }
3468                         return IntPtr.Zero;
3469                 }
3470
3471                 internal override void DestroyCaret(IntPtr handle)
3472                 {
3473                         if (Caret.Hwnd == handle) {
3474                                 if (Caret.Visible) {
3475                                         HideCaret ();
3476                                         Caret.Timer.Stop();
3477                                 }
3478                                 if (Caret.gc != IntPtr.Zero) {
3479                                         XFreeGC(DisplayHandle, Caret.gc);
3480                                         Caret.gc = IntPtr.Zero;
3481                                 }
3482                                 Caret.Hwnd = IntPtr.Zero;
3483                                 Caret.Visible = false;
3484                                 Caret.On = false;
3485                         }
3486                 }
3487
3488                 internal override void DestroyCursor(IntPtr cursor)
3489                 {
3490                         lock (XlibLock) {
3491                                 XFreeCursor(DisplayHandle, cursor);
3492                         }
3493                 }
3494
3495                 internal override void DestroyWindow(IntPtr handle)
3496                 {
3497                         Hwnd    hwnd;
3498                         hwnd = Hwnd.ObjectFromHandle(handle);
3499                         
3500                         // The window should never ever be a zombie here, since we should
3501                         // wait until it's completely dead before returning from 
3502                         // "destroying" calls, but just in case....
3503                         if (hwnd == null || hwnd.zombie) {
3504                                 DriverDebug ("window {0:X} already destroyed", handle.ToInt32());
3505                                 return;
3506                         }
3507
3508                         DriverDebug ("Destroying window {0}", XplatUI.Window(hwnd.client_window));
3509
3510                         SendParentNotify (hwnd.Handle, Msg.WM_DESTROY, int.MaxValue, int.MaxValue);
3511                                 
3512                         CleanupCachedWindows (hwnd);
3513
3514                         ArrayList windows = new ArrayList ();
3515
3516                         AccumulateDestroyedHandles (Control.ControlNativeWindow.ControlFromHandle(hwnd.Handle), windows);
3517
3518
3519                         foreach (Hwnd h in windows) {
3520                                 SendMessage (h.Handle, Msg.WM_DESTROY, IntPtr.Zero, IntPtr.Zero);
3521                                 h.zombie = true;                                
3522                         }
3523
3524                         lock (XlibLock) {
3525                                 if (hwnd.whole_window != IntPtr.Zero) {
3526                                         DriverDebug ("XDestroyWindow (whole_window = {0:X})", hwnd.whole_window.ToInt32());
3527                                         Keyboard.DestroyICForWindow (hwnd.whole_window);
3528                                         XDestroyWindow(DisplayHandle, hwnd.whole_window);
3529                                 }
3530                                 else if (hwnd.client_window != IntPtr.Zero) {
3531                                         DriverDebug ("XDestroyWindow (client_window = {0:X})", hwnd.client_window.ToInt32());
3532                                         Keyboard.DestroyICForWindow (hwnd.client_window);
3533                                         XDestroyWindow(DisplayHandle, hwnd.client_window);
3534                                 }
3535
3536                         }
3537                 }
3538
3539                 internal override IntPtr DispatchMessage(ref MSG msg)
3540                 {
3541                         return NativeWindow.WndProc(msg.hwnd, msg.message, msg.wParam, msg.lParam);
3542                 }
3543
3544                 IntPtr GetReversibleScreenGC (Color backColor)
3545                 {
3546                         XGCValues       gc_values;
3547                         IntPtr          gc;
3548                         uint pixel;
3549
3550                         XColor xcolor = new XColor();
3551                         xcolor.red = (ushort)(backColor.R * 257);
3552                         xcolor.green = (ushort)(backColor.G * 257);
3553                         xcolor.blue = (ushort)(backColor.B * 257);
3554                         XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
3555                         pixel = (uint)xcolor.pixel.ToInt32();
3556
3557
3558                         gc_values = new XGCValues();
3559
3560                         gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors;
3561                         gc_values.foreground = (IntPtr)pixel;
3562
3563                         gc = XCreateGC(DisplayHandle, RootWindow, new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCForeground)), ref gc_values);
3564                         XSetForeground(DisplayHandle, gc, (UIntPtr)pixel);
3565                         XSetFunction(DisplayHandle,   gc, GXFunction.GXxor);
3566
3567                         return gc;
3568                 }
3569
3570                 IntPtr GetReversibleControlGC (Control control, int line_width)
3571                 {
3572                         XGCValues       gc_values;
3573                         IntPtr          gc;
3574
3575                         gc_values = new XGCValues();
3576
3577                         gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors;
3578                         gc_values.line_width = line_width;
3579                         gc_values.foreground = XBlackPixel(DisplayHandle, ScreenNo);
3580
3581                         // This logic will give us true rubber bands: (libsx, SANE_XOR)
3582                         //mask = foreground ^ background; 
3583                         //XSetForeground(DisplayHandle, gc, 0xffffffff);
3584                         //XSetBackground(DisplayHandle, gc, background);
3585                         //XSetFunction(DisplayHandle,   gc, GXxor);
3586                         //XSetPlaneMask(DisplayHandle,  gc, mask);
3587
3588
3589                         gc = XCreateGC(DisplayHandle, control.Handle, new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCLineWidth | GCFunction.GCForeground)), ref gc_values);
3590                         uint foreground;
3591                         uint background;
3592
3593                         XColor xcolor = new XColor();
3594
3595                         xcolor.red = (ushort)(control.ForeColor.R * 257);
3596                         xcolor.green = (ushort)(control.ForeColor.G * 257);
3597                         xcolor.blue = (ushort)(control.ForeColor.B * 257);
3598                         XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
3599                         foreground = (uint)xcolor.pixel.ToInt32();
3600
3601                         xcolor.red = (ushort)(control.BackColor.R * 257);
3602                         xcolor.green = (ushort)(control.BackColor.G * 257);
3603                         xcolor.blue = (ushort)(control.BackColor.B * 257);
3604                         XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
3605                         background = (uint)xcolor.pixel.ToInt32();
3606
3607                         uint mask = foreground ^ background; 
3608
3609                         XSetForeground(DisplayHandle, gc, (UIntPtr)0xffffffff);
3610                         XSetBackground(DisplayHandle, gc, (UIntPtr)background);
3611                         XSetFunction(DisplayHandle,   gc, GXFunction.GXxor);
3612                         XSetPlaneMask(DisplayHandle,  gc, (IntPtr)mask);
3613
3614                         return gc;
3615                 }
3616
3617                 internal override void DrawReversibleLine(Point start, Point end, Color backColor)
3618                 {
3619                         if (backColor.GetBrightness() < 0.5)
3620                                 backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B);
3621
3622                         IntPtr gc = GetReversibleScreenGC (backColor);
3623
3624                         XDrawLine (DisplayHandle, RootWindow, gc, start.X, start.Y, end.X, end.Y);
3625
3626                         XFreeGC(DisplayHandle, gc);
3627                 }
3628
3629                 internal override void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style)
3630                 {
3631                         if (backColor.GetBrightness() < 0.5)
3632                                 backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B);
3633
3634                         IntPtr gc = GetReversibleScreenGC (backColor);
3635
3636                         if (rectangle.Width < 0) {
3637                                 rectangle.X += rectangle.Width;
3638                                 rectangle.Width = -rectangle.Width;
3639                         }
3640                         if (rectangle.Height < 0) {
3641                                 rectangle.Y += rectangle.Height;
3642                                 rectangle.Height = -rectangle.Height;
3643                         }
3644
3645                         int line_width = 1;
3646                         GCLineStyle line_style = GCLineStyle.LineSolid;
3647                         GCCapStyle cap_style = GCCapStyle.CapButt;
3648                         GCJoinStyle join_style = GCJoinStyle.JoinMiter;
3649
3650                         switch (style) {
3651                         case FrameStyle.Dashed:
3652                                 line_style = GCLineStyle.LineOnOffDash;
3653                                 break;
3654                         case FrameStyle.Thick:
3655                                 line_width = 2;
3656                                 break;
3657                         }
3658
3659                         XSetLineAttributes (DisplayHandle, gc, line_width, line_style, cap_style, join_style);
3660
3661                         XDrawRectangle(DisplayHandle, RootWindow, gc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height);
3662
3663                         XFreeGC(DisplayHandle, gc);
3664                 }
3665
3666                 internal override void FillReversibleRectangle (Rectangle rectangle, Color backColor) 
3667                 {
3668                         if (backColor.GetBrightness() < 0.5)
3669                                 backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B);
3670
3671                         IntPtr gc = GetReversibleScreenGC (backColor);
3672
3673                         if (rectangle.Width < 0) {
3674                                 rectangle.X += rectangle.Width;
3675                                 rectangle.Width = -rectangle.Width;
3676                         }
3677                         if (rectangle.Height < 0) {
3678                                 rectangle.Y += rectangle.Height;
3679                                 rectangle.Height = -rectangle.Height;
3680                         }
3681                         XFillRectangle(DisplayHandle, RootWindow, gc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height);
3682
3683                         XFreeGC(DisplayHandle, gc);
3684                 }
3685
3686                 internal override void DrawReversibleRectangle(IntPtr handle, Rectangle rect, int line_width)
3687                 {
3688                         IntPtr          gc;
3689                         Control control = Control.FromHandle(handle);
3690
3691                         gc = GetReversibleControlGC (control, line_width);
3692
3693                         if ((rect.Width > 0) && (rect.Height > 0)) {
3694                                 XDrawRectangle(DisplayHandle, control.Handle, gc, rect.Left, rect.Top, rect.Width, rect.Height);
3695                         } else {
3696                                 if (rect.Width > 0) {
3697                                         XDrawLine(DisplayHandle, control.Handle, gc, rect.X, rect.Y, rect.Right, rect.Y);
3698                                 } else {
3699                                         XDrawLine(DisplayHandle, control.Handle, gc, rect.X, rect.Y, rect.X, rect.Bottom);
3700                                 }
3701                         }
3702                         XFreeGC(DisplayHandle, gc);
3703                 }
3704
3705                 internal override void DoEvents()
3706                 {
3707                         DebugHelper.Enter ();
3708
3709                         MSG     msg = new MSG ();
3710                         XEventQueue queue;
3711
3712                         if (OverrideCursorHandle != IntPtr.Zero) {
3713                                 OverrideCursorHandle = IntPtr.Zero;
3714                         }
3715
3716                         queue = ThreadQueue(Thread.CurrentThread);
3717
3718                         queue.DispatchIdle = false;
3719                         in_doevents = true;
3720
3721                         while (PeekMessage(queue, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) {
3722                                 Message m = Message.Create (msg.hwnd, (int)msg.message, msg.wParam, msg.lParam);
3723
3724                                 if (Application.FilterMessage (ref m))
3725                                         continue;
3726
3727                                 TranslateMessage (ref msg);
3728                                 DispatchMessage (ref msg);
3729
3730                                 string key = msg.hwnd + ":" + msg.message;                              
3731                                 if (messageHold[key] != null) {
3732                                         messageHold[key] = ((int)messageHold[key]) - 1;
3733                                         DebugHelper.WriteLine  ("Got " + msg + " for " + key);
3734                                 }
3735                         }
3736
3737                         in_doevents = false;
3738                         queue.DispatchIdle = true;
3739
3740                         DebugHelper.Leave ();
3741                 }
3742
3743                 internal override void EnableWindow(IntPtr handle, bool Enable)
3744                 {
3745                         Hwnd    hwnd;
3746
3747                         hwnd = Hwnd.ObjectFromHandle(handle);
3748                         if (hwnd != null) {
3749                                 hwnd.Enabled = Enable;
3750                         }
3751                 }
3752
3753                 internal override void EndLoop(Thread thread)
3754                 {
3755                         // This is where we one day will shut down the loop for the thread
3756                 }
3757
3758                 internal override IntPtr GetActive()
3759                 {
3760                         IntPtr  actual_atom;
3761                         int     actual_format;
3762                         IntPtr  nitems;
3763                         IntPtr  bytes_after;
3764                         IntPtr  prop = IntPtr.Zero;
3765                         IntPtr  active = IntPtr.Zero;
3766
3767                         XGetWindowProperty(DisplayHandle, RootWindow, _NET_ACTIVE_WINDOW, IntPtr.Zero, new IntPtr (1), false, (IntPtr)Atom.XA_WINDOW, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
3768                         if (((long)nitems > 0) && (prop != IntPtr.Zero)) {
3769                                 active = (IntPtr)Marshal.ReadInt32(prop);
3770                                 XFree(prop);
3771                         } else {
3772                                 // The window manager does not support _NET_ACTIVE_WINDOW.  Fall back to XGetInputFocus.
3773                                 IntPtr  revert_to = IntPtr.Zero;
3774                                 XGetInputFocus(DisplayHandle, out active, out revert_to);
3775                         }
3776
3777                         if (active != IntPtr.Zero) {
3778                                 Hwnd    hwnd;
3779
3780                                 hwnd = Hwnd.GetObjectFromWindow(active);
3781                                 if (hwnd != null) {
3782                                         active = hwnd.Handle;
3783                                 } else {
3784                                         active = IntPtr.Zero;
3785                                 }
3786                         }
3787                         return active;
3788                 }
3789
3790                 internal override Region GetClipRegion(IntPtr handle)
3791                 {
3792                         Hwnd    hwnd;
3793
3794                         hwnd = Hwnd.ObjectFromHandle(handle);
3795                         if (hwnd != null) {
3796                                 return hwnd.UserClip;
3797                         }
3798
3799                         return null;
3800                 }
3801
3802                 internal override void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y)
3803                 {
3804                         width = 20;
3805                         height = 20;
3806                         hotspot_x = 0;
3807                         hotspot_y = 0;
3808                 }
3809
3810                 internal override void GetDisplaySize(out Size size)
3811                 {
3812                         XWindowAttributes       attributes=new XWindowAttributes();
3813
3814                         lock (XlibLock) {
3815                                 // FIXME - use _NET_WM messages instead?
3816                                 XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes);
3817                         }
3818
3819                         size = new Size(attributes.width, attributes.height);
3820                 }
3821
3822                 internal override SizeF GetAutoScaleSize(Font font)
3823                 {
3824                         Graphics        g;
3825                         float           width;
3826                         string          magic_string = "The quick brown fox jumped over the lazy dog.";
3827                         double          magic_number = 44.549996948242189;
3828
3829                         g = Graphics.FromHwnd(FosterParent);
3830
3831                         width = (float) (g.MeasureString (magic_string, font).Width / magic_number);
3832                         return new SizeF(width, font.Height);
3833                 }
3834
3835                 internal override IntPtr GetParent(IntPtr handle)
3836                 {
3837                         Hwnd    hwnd;
3838
3839                         hwnd = Hwnd.ObjectFromHandle(handle);
3840                         if (hwnd != null && hwnd.parent != null) {
3841                                 return hwnd.parent.Handle;
3842                         }
3843                         return IntPtr.Zero;
3844                 }
3845                 
3846                 // This is a nop on win32 and x11
3847                 internal override IntPtr GetPreviousWindow(IntPtr handle)
3848                 {
3849                         return handle;
3850                 }
3851
3852                 internal override void GetCursorPos(IntPtr handle, out int x, out int y)
3853                 {
3854                         IntPtr  use_handle;
3855                         IntPtr  root;
3856                         IntPtr  child;
3857                         int     root_x;
3858                         int     root_y;
3859                         int     win_x;
3860                         int     win_y;
3861                         int     keys_buttons;
3862
3863                         if (handle != IntPtr.Zero) {
3864                                 use_handle = Hwnd.ObjectFromHandle(handle).client_window;
3865                         } else {
3866                                 use_handle = RootWindow;
3867                         }
3868
3869                         lock (XlibLock) {
3870                                 QueryPointer (DisplayHandle, use_handle, out root, out child, out root_x, out root_y, out win_x, out win_y, out keys_buttons);
3871                         }
3872
3873                         if (handle != IntPtr.Zero) {
3874                                 x = win_x;
3875                                 y = win_y;
3876                         } else {
3877                                 x = root_x;
3878                                 y = root_y;
3879                         }
3880                 }
3881
3882                 internal override IntPtr GetFocus()
3883                 {
3884                         return FocusWindow;
3885                 }
3886
3887
3888                 internal override bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent)
3889                 {
3890                         FontFamily ff = font.FontFamily;
3891                         ascent = ff.GetCellAscent (font.Style);
3892                         descent = ff.GetCellDescent (font.Style);
3893                         return true;
3894                 }
3895
3896                 internal override Point GetMenuOrigin(IntPtr handle)
3897                 {
3898                         Hwnd    hwnd;
3899
3900                         hwnd = Hwnd.ObjectFromHandle(handle);
3901
3902                         if (hwnd != null) {
3903                                 return hwnd.MenuOrigin;
3904                         }
3905                         return Point.Empty;
3906                 }
3907
3908                 [MonoTODO("Implement filtering")]
3909                 internal override bool GetMessage(Object queue_id, ref MSG msg, IntPtr handle, int wFilterMin, int wFilterMax)
3910                 {
3911                         XEvent  xevent;
3912                         bool    client;
3913                         Hwnd    hwnd;
3914
3915                         ProcessNextMessage:
3916
3917                         if (((XEventQueue)queue_id).Count > 0) {
3918                                 xevent = (XEvent) ((XEventQueue)queue_id).Dequeue ();
3919                         } else {
3920                                 UpdateMessageQueue ((XEventQueue)queue_id);
3921
3922                                 if (((XEventQueue)queue_id).Count > 0) {
3923                                         xevent = (XEvent) ((XEventQueue)queue_id).Dequeue ();
3924                                 } else if (((XEventQueue)queue_id).Paint.Count > 0) {
3925                                         xevent = ((XEventQueue)queue_id).Paint.Dequeue();
3926                                 } else {
3927                                         msg.hwnd= IntPtr.Zero;
3928                                         msg.message = Msg.WM_ENTERIDLE;
3929                                         return true;
3930                                 }
3931                         }
3932
3933                         hwnd = Hwnd.GetObjectFromWindow(xevent.AnyEvent.window);
3934
3935 #if DriverDebugDestroy                  
3936                         if (hwnd != null)
3937                                 if (hwnd.zombie)
3938                                         Console.WriteLine ( "GetMessage zombie, got Event: " + xevent.ToString () + " for 0x{0:x}", hwnd.Handle.ToInt32());
3939                                 else    
3940                                         Console.WriteLine ( "GetMessage, got Event: " + xevent.ToString () + " for 0x{0:x}", hwnd.Handle.ToInt32());
3941 #endif
3942                         // Handle messages for windows that are already or are about to be destroyed.
3943
3944                         // we need a special block for this because unless we remove the hwnd from the paint
3945                         // queue it will always stay there (since we don't handle the expose), and we'll
3946                         // effectively loop infinitely trying to repaint a non-existant window.
3947                         if (hwnd != null && hwnd.zombie && xevent.type == XEventName.Expose) {
3948                                 hwnd.expose_pending = hwnd.nc_expose_pending = false;
3949                                 hwnd.Queue.Paint.Remove (hwnd);
3950                                 goto ProcessNextMessage;
3951                         }
3952
3953                         // We need to make sure we only allow DestroyNotify events through for zombie
3954                         // hwnds, since much of the event handling code makes requests using the hwnd's
3955                         // client_window, and that'll result in BadWindow errors if there's some lag
3956                         // between the XDestroyWindow call and the DestroyNotify event.
3957                         if (hwnd == null || hwnd.zombie && xevent.AnyEvent.type != XEventName.ClientMessage) {
3958                                 DriverDebug("GetMessage(): Got message {0} for non-existent or already destroyed window {1:X}", xevent.type, xevent.AnyEvent.window.ToInt32());
3959                                 goto ProcessNextMessage;
3960                         }
3961
3962
3963                         // If we get here, that means the window is no more but there are Client Messages
3964                         // to be processed, probably a Posted message (for instance, an WM_ACTIVATE message) 
3965                         // We don't want anything else to run but the ClientMessage block, so reset all hwnd
3966                         // properties that might cause other processing to occur.
3967                         if (hwnd.zombie) {
3968                                 hwnd.resizing_or_moving = false;
3969                         }
3970
3971                         if (hwnd.client_window == xevent.AnyEvent.window) {
3972                                 client = true;
3973                                 //Console.WriteLine("Client message {1}, sending to window {0:X}", msg.hwnd.ToInt32(), xevent.type);
3974                         } else {
3975                                 client = false;
3976                                 //Console.WriteLine("Non-Client message, sending to window {0:X}", msg.hwnd.ToInt32());
3977                         }
3978
3979                         msg.hwnd = hwnd.Handle;
3980
3981                         // Windows sends WM_ENTERSIZEMOVE when a form resize/move operation starts and WM_EXITSIZEMOVE 
3982                         // when it is done. The problem in X11 is that there is no concept of start-end of a moving/sizing.
3983                         // Configure events ("this window has resized/moved") are sent for each step of the resize. We send a
3984                         // WM_ENTERSIZEMOVE when we get the first Configure event. The problem is the WM_EXITSIZEMOVE.
3985                         // 
3986                         //  - There is no way for us to know which is the last Configure event. We can't traverse the events 
3987                         //    queue, because the next configure event might not be pending yet.
3988                         //  - We can't get ButtonPress/Release events for the window decorations, because they are not part 
3989                         //    of the window(s) we manage.
3990                         //  - We can't rely on the mouse state to change to "up" before the last Configure event. It doesn't.
3991                         // 
3992                         // We are almost 100% guaranteed to get another event (e.g Expose or other), but we can't know for sure 
3993                         // which, so we have here to check if the mouse buttons state is "up" and send the WM_EXITSIZEMOVE
3994                         //
3995                         if (hwnd.resizing_or_moving) {
3996                                 int root_x, root_y, win_x, win_y, keys_buttons;
3997                                 IntPtr  root, child;
3998                                 XQueryPointer (DisplayHandle, hwnd.Handle, out root, out child, out root_x, out root_y, 
3999                                                out win_x, out win_y, out keys_buttons);
4000                                 if ((keys_buttons & (int)MouseKeyMasks.Button1Mask) == 0 &&
4001                                     (keys_buttons & (int)MouseKeyMasks.Button2Mask) == 0 &&
4002                                     (keys_buttons & (int)MouseKeyMasks.Button3Mask) == 0) {
4003                                         hwnd.resizing_or_moving = false;
4004                                         SendMessage (hwnd.Handle, Msg.WM_EXITSIZEMOVE, IntPtr.Zero, IntPtr.Zero);
4005                                 }
4006                         }
4007
4008                         //
4009                         // If you add a new event to this switch make sure to add it in
4010                         // UpdateMessage also unless it is not coming through the X event system.
4011                         //
4012                         switch(xevent.type) {
4013                                 case XEventName.KeyPress: {
4014                                         Keyboard.KeyEvent (FocusWindow, xevent, ref msg);
4015
4016                                         // F1 key special case - WM_HELP sending
4017                                         if (msg.wParam == (IntPtr)VirtualKeys.VK_F1 || msg.wParam == (IntPtr)VirtualKeys.VK_HELP) {
4018                                                 // Send wM_HELP and then return it as a keypress message in
4019                                                 // case it needs to be preproccessed.
4020                                                 HELPINFO helpInfo = new HELPINFO ();
4021                                                 GetCursorPos (IntPtr.Zero, out helpInfo.MousePos.x, out helpInfo.MousePos.y);
4022                                                 IntPtr helpInfoPtr = Marshal.AllocHGlobal (Marshal.SizeOf (helpInfo));
4023                                                 Marshal.StructureToPtr (helpInfo, helpInfoPtr, true);
4024                                                 NativeWindow.WndProc (FocusWindow, Msg.WM_HELP, IntPtr.Zero, helpInfoPtr);
4025                                                 Marshal.FreeHGlobal (helpInfoPtr);
4026                                         }
4027                                         break;
4028                                 }
4029
4030                                 case XEventName.KeyRelease: {
4031                                         Keyboard.KeyEvent (FocusWindow, xevent, ref msg);
4032                                         break;
4033                                 }
4034
4035                                 case XEventName.ButtonPress: {
4036                                         switch(xevent.ButtonEvent.button) {
4037                                                 case 1: {
4038                                                         MouseState |= MouseButtons.Left;
4039                                                         if (client) {
4040                                                                 msg.message = Msg.WM_LBUTTONDOWN;
4041                                                                 msg.wParam = GetMousewParam (0);
4042                                                         } else {
4043                                                                 msg.message = Msg.WM_NCLBUTTONDOWN;
4044                                                                 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4045                                                                 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4046                                                         }
4047                                                         break;
4048                                                 }
4049
4050                                                 case 2: {
4051                                                         MouseState |= MouseButtons.Middle;
4052                                                         if (client) {
4053                                                                 msg.message = Msg.WM_MBUTTONDOWN;
4054                                                                 msg.wParam = GetMousewParam (0);
4055                                                         } else {
4056                                                                 msg.message = Msg.WM_NCMBUTTONDOWN;
4057                                                                 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4058                                                                 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4059                                                         }
4060                                                         break;
4061                                                 }
4062
4063                                                 case 3: {
4064                                                         MouseState |= MouseButtons.Right;
4065                                                         if (client) {
4066                                                                 msg.message = Msg.WM_RBUTTONDOWN;
4067                                                                 msg.wParam = GetMousewParam (0);
4068                                                         } else {
4069                                                                 msg.message = Msg.WM_NCRBUTTONDOWN;
4070                                                                 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4071                                                                 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4072                                                         }
4073                                                         break;
4074                                                 }
4075
4076                                                 case 4: {
4077                                                         msg.hwnd = FocusWindow;
4078                                                         msg.message=Msg.WM_MOUSEWHEEL;
4079                                                         msg.wParam=GetMousewParam(120);
4080                                                         break;
4081                                                 }
4082
4083                                                 case 5: {
4084                                                         msg.hwnd = FocusWindow;
4085                                                         msg.message=Msg.WM_MOUSEWHEEL;
4086                                                         msg.wParam=GetMousewParam(-120);
4087                                                         break;
4088                                                 }
4089
4090                                         }
4091
4092                                         msg.lParam=(IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x);
4093                                         mouse_position.X = xevent.ButtonEvent.x;
4094                                         mouse_position.Y = xevent.ButtonEvent.y;
4095
4096                                         if (!hwnd.Enabled) {
4097                                                 IntPtr dummy;
4098
4099                                                 msg.hwnd = hwnd.EnabledHwnd;
4100                                                 XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.ButtonEvent.x, xevent.ButtonEvent.y, out xevent.ButtonEvent.x, out xevent.ButtonEvent.y, out dummy);
4101                                                 msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4102                                         }
4103
4104                                         if (Grab.Hwnd != IntPtr.Zero) {
4105                                                 msg.hwnd = Grab.Hwnd;
4106                                         }
4107
4108                                         if (ClickPending.Pending && ((((long)xevent.ButtonEvent.time - ClickPending.Time) < DoubleClickInterval) && (msg.wParam == ClickPending.wParam) && (msg.lParam == ClickPending.lParam) && (msg.message == ClickPending.Message))) {
4109                                                 // Looks like a genuine double click, clicked twice on the same spot with the same keys
4110                                                 switch(xevent.ButtonEvent.button) {
4111                                                         case 1: {
4112                                                                 msg.message = client ? Msg.WM_LBUTTONDBLCLK : Msg.WM_NCLBUTTONDBLCLK;
4113                                                                 break;
4114                                                         }
4115
4116                                                         case 2: {
4117                                                                 msg.message = client ? Msg.WM_MBUTTONDBLCLK : Msg.WM_NCMBUTTONDBLCLK;
4118                                                                 break;
4119                                                         }
4120
4121                                                         case 3: {
4122                                                                 msg.message = client ? Msg.WM_RBUTTONDBLCLK : Msg.WM_NCRBUTTONDBLCLK;
4123                                                                 break;
4124                                                         }
4125                                                 }
4126                                                 ClickPending.Pending = false;
4127                                         } else {
4128                                                 ClickPending.Pending = true;
4129                                                 ClickPending.Hwnd = msg.hwnd;
4130                                                 ClickPending.Message = msg.message;
4131                                                 ClickPending.wParam = msg.wParam;
4132                                                 ClickPending.lParam = msg.lParam;
4133                                                 ClickPending.Time = (long)xevent.ButtonEvent.time;
4134                                         }
4135                                         
4136                                         if (msg.message == Msg.WM_LBUTTONDOWN || msg.message == Msg.WM_MBUTTONDOWN || msg.message == Msg.WM_RBUTTONDOWN) {
4137                                                 SendParentNotify(msg.hwnd, msg.message, mouse_position.X, mouse_position.Y);
4138                                         }
4139                                         
4140                                         break;
4141                                 }
4142
4143                                 case XEventName.ButtonRelease: {
4144                                         switch(xevent.ButtonEvent.button) {
4145                                                 case 1: {
4146                                                         if (client) {
4147                                                                 msg.message = Msg.WM_LBUTTONUP;
4148                                                         } else {
4149                                                                 msg.message = Msg.WM_NCLBUTTONUP;
4150                                                                 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4151                                                                 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4152                                                         }
4153                                                         MouseState &= ~MouseButtons.Left;
4154                                                         msg.wParam = GetMousewParam (0);
4155                                                         break;
4156                                                 }
4157
4158                                                 case 2: {
4159                                                         if (client) {
4160                                                                 msg.message = Msg.WM_MBUTTONUP;
4161                                                         } else {
4162                                                                 msg.message = Msg.WM_NCMBUTTONUP;
4163                                                                 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4164                                                                 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4165                                                         }
4166                                                         MouseState &= ~MouseButtons.Middle;
4167                                                         msg.wParam = GetMousewParam (0);
4168                                                         break;
4169                                                 }
4170
4171                                                 case 3: {
4172                                                         if (client) {
4173                                                                 msg.message = Msg.WM_RBUTTONUP;
4174                                                         } else {
4175                                                                 msg.message = Msg.WM_NCRBUTTONUP;
4176                                                                 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4177                                                                 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4178                                                         }
4179                                                         MouseState &= ~MouseButtons.Right;
4180                                                         msg.wParam = GetMousewParam (0);
4181                                                         break;
4182                                                 }
4183
4184                                                 case 4: {
4185                                                         goto ProcessNextMessage;
4186                                                 }
4187
4188                                                 case 5: {
4189                                                         goto ProcessNextMessage;
4190                                                 }
4191                                         }
4192
4193                                         if (!hwnd.Enabled) {
4194                                                 IntPtr dummy;
4195
4196                                                 msg.hwnd = hwnd.EnabledHwnd;
4197                                                 XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.ButtonEvent.x, xevent.ButtonEvent.y, out xevent.ButtonEvent.x, out xevent.ButtonEvent.y, out dummy);
4198                                                 msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4199                                         }
4200
4201                                         if (Grab.Hwnd != IntPtr.Zero) {
4202                                                 msg.hwnd = Grab.Hwnd;
4203                                         }
4204
4205                                         msg.lParam=(IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x);
4206                                         mouse_position.X = xevent.ButtonEvent.x;
4207                                         mouse_position.Y = xevent.ButtonEvent.y;
4208
4209                                         // Win32 splurts MouseMove events all over the place, regardless of whether the mouse is actually moving or
4210                                         // not, especially after mousedown and mouseup. To support apps relying on mousemove events between and after 
4211                                         // mouse clicks to repaint or whatever, we generate a mousemove event here. *sigh*
4212                                         if (msg.message == Msg.WM_LBUTTONUP || msg.message == Msg.WM_MBUTTONUP || msg.message == Msg.WM_RBUTTONUP) {
4213                                                 XEvent motionEvent = new XEvent ();
4214                                                 motionEvent.type = XEventName.MotionNotify;
4215                                                 motionEvent.MotionEvent.display = DisplayHandle;
4216                                                 motionEvent.MotionEvent.window = xevent.ButtonEvent.window;
4217                                                 motionEvent.MotionEvent.x = xevent.ButtonEvent.x;
4218                                                 motionEvent.MotionEvent.y = xevent.ButtonEvent.y;
4219                                                 hwnd.Queue.EnqueueLocked (motionEvent);
4220                                         }
4221                                         break;
4222                                 }
4223
4224                                 case XEventName.MotionNotify: {
4225                                         if (client) {
4226                                                 DriverDebug("GetMessage(): Window {0:X} MotionNotify x={1} y={2}",
4227                                                             client ? hwnd.client_window.ToInt32() : hwnd.whole_window.ToInt32(),
4228                                                             xevent.MotionEvent.x, xevent.MotionEvent.y);
4229
4230                                                 if (Grab.Hwnd != IntPtr.Zero) {
4231                                                         msg.hwnd = Grab.Hwnd;
4232                                                 } else {
4233                                                         if (hwnd.Enabled) {
4234                                                                 NativeWindow.WndProc(msg.hwnd, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)HitTest.HTCLIENT);
4235                                                         }
4236                                                 }
4237
4238                                                 if (xevent.MotionEvent.is_hint != 0)
4239                                                 {
4240                                                         IntPtr root, child;
4241                                                         int mask;
4242                                                         XQueryPointer (DisplayHandle, xevent.AnyEvent.window,
4243                                                                                         out root, out child,
4244                                                                                         out xevent.MotionEvent.x_root, 
4245                                                                                         out xevent.MotionEvent.y_root,
4246                                                                                         out xevent.MotionEvent.x,      
4247                                                                                         out xevent.MotionEvent.y, out mask);
4248                                                 }
4249
4250                                                 msg.message = Msg.WM_MOUSEMOVE;
4251                                                 msg.wParam = GetMousewParam(0);
4252                                                 msg.lParam = (IntPtr) (xevent.MotionEvent.y << 16 | xevent.MotionEvent.x & 0xFFFF);
4253
4254                                                 if (!hwnd.Enabled) {
4255                                                         IntPtr dummy;
4256
4257                                                         msg.hwnd = hwnd.EnabledHwnd;
4258                                                         XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.MotionEvent.x, xevent.MotionEvent.y, out xevent.MotionEvent.x, out xevent.MotionEvent.y, out dummy);
4259                                                         msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4260                                                 }
4261
4262                                                 mouse_position.X = xevent.MotionEvent.x;
4263                                                 mouse_position.Y = xevent.MotionEvent.y;
4264
4265                                                 if ((HoverState.Timer.Enabled) &&
4266                                                     (((mouse_position.X + HoverState.Size.Width) < HoverState.X) ||
4267                                                     ((mouse_position.X - HoverState.Size.Width) > HoverState.X) ||
4268                                                     ((mouse_position.Y + HoverState.Size.Height) < HoverState.Y) ||
4269                                                     ((mouse_position.Y - HoverState.Size.Height) > HoverState.Y))) {
4270                                                         HoverState.Timer.Stop();
4271                                                         HoverState.Timer.Start();
4272                                                         HoverState.X = mouse_position.X;
4273                                                         HoverState.Y = mouse_position.Y;
4274                                                 }
4275
4276                                                 break;
4277                                         } else {
4278                                                 HitTest ht;
4279                                                 IntPtr dummy;
4280
4281                                                 DriverDebug("GetMessage(): non-client area {0:X} MotionNotify x={1} y={2}",
4282                                                             client ? hwnd.client_window.ToInt32() : hwnd.whole_window.ToInt32(),
4283                                                             xevent.MotionEvent.x, xevent.MotionEvent.y);
4284                                                 msg.message = Msg.WM_NCMOUSEMOVE;
4285
4286                                                 if (!hwnd.Enabled) {
4287                                                         msg.hwnd = hwnd.EnabledHwnd;
4288                                                         XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.MotionEvent.x, xevent.MotionEvent.y, out xevent.MotionEvent.x, out xevent.MotionEvent.y, out dummy);
4289                                                         msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4290                                                 }
4291
4292                                                 ht = NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4293                                                 NativeWindow.WndProc(hwnd.client_window, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)ht);
4294
4295                                                 mouse_position.X = xevent.MotionEvent.x;
4296                                                 mouse_position.Y = xevent.MotionEvent.y;
4297                                         }
4298
4299                                         break;
4300                                 }
4301
4302                                 case XEventName.EnterNotify: {
4303                                         if (!hwnd.Enabled) {
4304                                                 goto ProcessNextMessage;
4305                                         }
4306                                         if (xevent.CrossingEvent.mode == NotifyMode.NotifyGrab || xevent.AnyEvent.window != hwnd.client_window) {
4307                                                 goto ProcessNextMessage;
4308                                         }
4309                                         if (xevent.CrossingEvent.mode == NotifyMode.NotifyUngrab) { // Pseudo motion caused by grabbing
4310                                                 if (LastPointerWindow == xevent.AnyEvent.window)
4311                                                         goto ProcessNextMessage;
4312
4313                                                 if (LastPointerWindow != IntPtr.Zero) {
4314                                                         Point enter_loc = new Point (xevent.ButtonEvent.x, xevent.ButtonEvent.y);
4315
4316                                                         // We need this due to EnterNotify being fired on all the parent controls
4317                                                         // of the Control being grabbed, and obviously in that scenario we are not
4318                                                         // actuallty entering them
4319                                                         Control ctrl = Control.FromHandle (hwnd.client_window);
4320                                                         foreach (Control child_control in ctrl.Controls.GetAllControls ())
4321                                                                 if (child_control.Bounds.Contains (enter_loc))
4322                                                                         goto ProcessNextMessage;
4323
4324                                                         // A MouseLeave/LeaveNotify event is sent to the previous window
4325                                                         // until the mouse is ungrabbed, not when actually leaving its bounds
4326                                                         int x = xevent.CrossingEvent.x_root;
4327                                                         int y = xevent.CrossingEvent.y_root;
4328                                                         ScreenToClient (LastPointerWindow, ref x, ref y);
4329
4330                                                         XEvent leaveEvent = new XEvent ();
4331                                                         leaveEvent.type = XEventName.LeaveNotify;
4332                                                         leaveEvent.CrossingEvent.display = DisplayHandle;
4333                                                         leaveEvent.CrossingEvent.window = LastPointerWindow;
4334                                                         leaveEvent.CrossingEvent.x = x;
4335                                                         leaveEvent.CrossingEvent.y = y;
4336                                                         leaveEvent.CrossingEvent.mode = NotifyMode.NotifyNormal;
4337                                                         Hwnd last_pointer_hwnd = Hwnd.ObjectFromHandle (LastPointerWindow);
4338                                                         last_pointer_hwnd.Queue.EnqueueLocked (leaveEvent);
4339                                                 }
4340                                         }
4341
4342                                         LastPointerWindow = xevent.AnyEvent.window;
4343
4344                                         msg.message = Msg.WM_MOUSE_ENTER;
4345                                         HoverState.X = xevent.CrossingEvent.x;
4346                                         HoverState.Y = xevent.CrossingEvent.y;
4347                                         HoverState.Timer.Enabled = true;
4348                                         HoverState.Window = xevent.CrossingEvent.window;
4349
4350                                         // Win32 sends a WM_MOUSEMOVE after mouse enter
4351                                         XEvent motionEvent = new XEvent ();
4352                                         motionEvent.type = XEventName.MotionNotify;
4353                                         motionEvent.MotionEvent.display = DisplayHandle;
4354                                         motionEvent.MotionEvent.window = xevent.ButtonEvent.window;
4355                                         motionEvent.MotionEvent.x = xevent.ButtonEvent.x;
4356                                         motionEvent.MotionEvent.y = xevent.ButtonEvent.y;
4357                                         hwnd.Queue.EnqueueLocked (motionEvent);
4358                                         break;
4359                                 }
4360
4361                                 case XEventName.LeaveNotify: {
4362                                         if (xevent.CrossingEvent.mode == NotifyMode.NotifyUngrab) {
4363                                                 WindowUngrabbed (hwnd.Handle);
4364                                                 goto ProcessNextMessage;
4365                                         }
4366                                         if (!hwnd.Enabled) {
4367                                                 goto ProcessNextMessage;
4368                                         }
4369                                         if ((xevent.CrossingEvent.mode != NotifyMode.NotifyNormal) || (xevent.CrossingEvent.window != hwnd.client_window)) {
4370                                                 goto ProcessNextMessage;
4371                                         }
4372                                         // If a grab is taking place, ignore it - we handle it in EnterNotify
4373                                         if (Grab.Hwnd != IntPtr.Zero)
4374                                                 goto ProcessNextMessage;
4375
4376                                         // Reset the cursor explicitly on X11.
4377                                         // X11 remembers the last set cursor for the window and in cases where 
4378                                         // the control won't get a WM_SETCURSOR X11 will restore the last 
4379                                         // known cursor, which we don't want.
4380                                         // 
4381                                         SetCursor (hwnd.client_window, IntPtr.Zero);
4382
4383                                         msg.message=Msg.WM_MOUSELEAVE;
4384                                         HoverState.Timer.Enabled = false;
4385                                         HoverState.Window = IntPtr.Zero;
4386                                         break;
4387                                 }
4388
4389                                 #if later
4390                                 case XEventName.CreateNotify: {
4391                                         if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) {
4392                                                 msg.message = WM_CREATE;
4393                                                 // Set up CreateStruct
4394                                         } else {
4395                                                 goto ProcessNextMessage;
4396                                         }
4397                                         break;
4398                                 }
4399                                 #endif
4400
4401
4402                                 case XEventName.ReparentNotify: {
4403                                         if (hwnd.parent == null) {      // Toplevel
4404                                                 if ((xevent.ReparentEvent.parent != IntPtr.Zero) && (xevent.ReparentEvent.window == hwnd.whole_window)) {
4405                                                         hwnd.Reparented = true;
4406
4407                                                         // The location given by the event is not reliable between different wm's, 
4408                                                         // so use an alternative way of getting it.
4409                                                         Point location = GetTopLevelWindowLocation (hwnd);
4410                                                         hwnd.X = location.X;
4411                                                         hwnd.Y = location.Y;
4412
4413                                                         if (hwnd.opacity != 0xffffffff) {
4414                                                                 IntPtr opacity;
4415
4416                                                                 opacity = (IntPtr)(Int32)hwnd.opacity;
4417                                                                 XChangeProperty(DisplayHandle, XGetParent(hwnd.whole_window), _NET_WM_WINDOW_OPACITY, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, ref opacity, 1);
4418                                                         }
4419                                                         SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, msg.wParam, msg.lParam);
4420                                                         goto ProcessNextMessage;
4421                                                 } else {
4422                                                         hwnd.Reparented = false;
4423                                                         goto ProcessNextMessage;
4424                                                 }
4425                                         }
4426                                         goto ProcessNextMessage;
4427                                 }
4428
4429                                 case XEventName.ConfigureNotify: {
4430                                         if (!client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) {        // Ignore events for children (SubstructureNotify) and client areas
4431                                                 DriverDebug("GetMessage(): Window {0:X} ConfigureNotify x={1} y={2} width={3} height={4}",
4432                                                             hwnd.client_window.ToInt32(), xevent.ConfigureEvent.x,
4433                                                             xevent.ConfigureEvent.y, xevent.ConfigureEvent.width, xevent.ConfigureEvent.height);
4434
4435                                                 lock (hwnd.configure_lock) {
4436                                                         Form form = Control.FromHandle (hwnd.client_window) as Form;
4437                                                         if (form != null && !hwnd.resizing_or_moving) {
4438                                                                 if (hwnd.x != form.Bounds.X || hwnd.y != form.Bounds.Y) {
4439                                                                         SendMessage (form.Handle, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_MOVE, IntPtr.Zero);
4440                                                                         hwnd.resizing_or_moving = true;
4441                                                                 } else if (hwnd.width != form.Bounds.Width || hwnd.height != form.Bounds.Height) {
4442                                                                         SendMessage (form.Handle, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_SIZE, IntPtr.Zero);
4443                                                                         hwnd.resizing_or_moving = true;
4444                                                                 }
4445                                                                 if (hwnd.resizing_or_moving)
4446                                                                         SendMessage (form.Handle, Msg.WM_ENTERSIZEMOVE, IntPtr.Zero, IntPtr.Zero);
4447                                                         }
4448         
4449                                                         SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
4450                                                         hwnd.configure_pending = false;
4451         
4452                                                         // We need to adjust our client window to track the resize of whole_window
4453                                                         if (hwnd.whole_window != hwnd.client_window)
4454                                                                 PerformNCCalc(hwnd);
4455                                                 }
4456                                         }
4457                                         goto ProcessNextMessage;
4458                                 }
4459
4460                                 case XEventName.FocusIn: {
4461                                         // We received focus. We use X11 focus only to know if the app window does or does not have focus
4462                                         // We do not track the actual focussed window via it. Instead, this is done via FocusWindow internally
4463                                         // Receiving focus means we've gotten activated and therefore we need to let the actual FocusWindow know 
4464                                         // about it having focus again
4465                                         if (xevent.FocusChangeEvent.detail != NotifyDetail.NotifyNonlinear) {
4466                                                 goto ProcessNextMessage;
4467                                         }
4468
4469                                         
4470                                         if (FocusWindow == IntPtr.Zero) {
4471                                                 Control c = Control.FromHandle (hwnd.client_window);
4472
4473                                                 if (c == null)
4474                                                         goto ProcessNextMessage;                                                
4475                                                 Form form = c.FindForm ();
4476                                                 if (form == null)
4477                                                         goto ProcessNextMessage;
4478                                         
4479                                                 if (ActiveWindow != form.Handle) {
4480                                                         ActiveWindow = form.Handle;
4481                                                         SendMessage (ActiveWindow, Msg.WM_ACTIVATE, (IntPtr) WindowActiveFlags.WA_ACTIVE, IntPtr.Zero);
4482                                                 }
4483                                                 goto ProcessNextMessage;
4484                                         }
4485                                         Keyboard.FocusIn (FocusWindow);
4486                                         SendMessage(FocusWindow, Msg.WM_SETFOCUS, IntPtr.Zero, IntPtr.Zero);
4487                                         goto ProcessNextMessage;
4488                                 }
4489
4490                                 case XEventName.FocusOut: {
4491                                         // Se the comment for our FocusIn handler
4492                                         if (xevent.FocusChangeEvent.detail != NotifyDetail.NotifyNonlinear) {
4493                                                 goto ProcessNextMessage;
4494                                         }
4495
4496                                         while (Keyboard.ResetKeyState(FocusWindow, ref msg)) {
4497                                                 SendMessage(FocusWindow, msg.message, msg.wParam, msg.lParam);
4498                                         }
4499
4500                                         Keyboard.FocusOut(hwnd.client_window);
4501                                         SendMessage(FocusWindow, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero);
4502                                         goto ProcessNextMessage;
4503                                 }
4504
4505                                 // We are already firing WM_SHOWWINDOW messages in the proper places, but I'm leaving this code
4506                                 // in case we break a scenario not taken into account in the tests
4507                                 case XEventName.MapNotify: {
4508                                         /*if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) {       // Ignore events for children (SubstructureNotify) and client areas
4509                                                 hwnd.mapped = true;
4510                                                 msg.message = Msg.WM_SHOWWINDOW;
4511                                                 msg.wParam = (IntPtr) 1;
4512                                                 // XXX we're missing the lParam..
4513                                                 break;
4514                                         }*/
4515                                         goto ProcessNextMessage;
4516                                 }
4517
4518                                 case XEventName.UnmapNotify: {
4519                                         /*if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) {       // Ignore events for children (SubstructureNotify) and client areas
4520                                                 hwnd.mapped = false;
4521                                                 msg.message = Msg.WM_SHOWWINDOW;
4522                                                 msg.wParam = (IntPtr) 0;
4523                                                 // XXX we're missing the lParam..
4524                                                 break;
4525                                         }*/
4526                                         goto ProcessNextMessage;
4527                                 }
4528
4529                                 case XEventName.Expose: {
4530                                         if (!hwnd.Mapped) {
4531                                                 if (client) {
4532                                                         hwnd.expose_pending = false;
4533                                                 } else {
4534                                                         hwnd.nc_expose_pending = false;
4535                                                 }
4536                                                 goto ProcessNextMessage;
4537                                         }
4538
4539                                         if (client) {
4540                                                 if (!hwnd.expose_pending) {
4541                                                         goto ProcessNextMessage;
4542                                                 }
4543                                         } else {
4544                                                 if (!hwnd.nc_expose_pending) {
4545                                                         goto ProcessNextMessage;
4546                                                 }
4547
4548                                                 switch (hwnd.border_style) {
4549                                                         case FormBorderStyle.Fixed3D: {
4550                                                                 Graphics g;
4551
4552                                                                 g = Graphics.FromHwnd(hwnd.whole_window);
4553                                                                 if (hwnd.border_static)
4554                                                                         ControlPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Border3DStyle.SunkenOuter);
4555                                                                 else
4556                                                                         ControlPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Border3DStyle.Sunken);
4557                                                                 g.Dispose();
4558                                                                 break;
4559                                                         }
4560
4561                                                         case FormBorderStyle.FixedSingle: {
4562                                                                 Graphics g;
4563
4564                                                                 g = Graphics.FromHwnd(hwnd.whole_window);
4565                                                                 ControlPaint.DrawBorder(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Color.Black, ButtonBorderStyle.Solid);
4566                                                                 g.Dispose();
4567                                                                 break;
4568                                                         }
4569                                                 }
4570                                                 DriverDebug("GetMessage(): Window {0:X} Exposed non-client area {1},{2} {3}x{4}",
4571                                                             hwnd.client_window.ToInt32(), xevent.ExposeEvent.x, xevent.ExposeEvent.y,
4572                                                             xevent.ExposeEvent.width, xevent.ExposeEvent.height);
4573
4574                                                 Rectangle rect = new Rectangle (xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height);
4575                                                 Region region = new Region (rect);
4576                                                 IntPtr hrgn = region.GetHrgn (null); // Graphics object isn't needed
4577                                                 msg.message = Msg.WM_NCPAINT;
4578                                                 msg.wParam = hrgn == IntPtr.Zero ? (IntPtr)1 : hrgn;
4579                                                 msg.refobject = region;
4580                                                 break;
4581                                         }
4582                                         DriverDebug("GetMessage(): Window {0:X} Exposed area {1},{2} {3}x{4}",
4583                                                     hwnd.client_window.ToInt32(), xevent.ExposeEvent.x, xevent.ExposeEvent.y,
4584                                                     xevent.ExposeEvent.width, xevent.ExposeEvent.height);
4585                                         if (Caret.Visible == true) {
4586                                                 Caret.Paused = true;
4587                                                 HideCaret();
4588                                         }
4589
4590                                         if (Caret.Visible == true) {
4591                                                 ShowCaret();
4592                                                 Caret.Paused = false;
4593                                         }
4594                                         msg.message = Msg.WM_PAINT;
4595                                         break;
4596                                 }
4597
4598                                 case XEventName.DestroyNotify: {
4599
4600                                         // This is a bit tricky, we don't receive our own DestroyNotify, we only get those for our children
4601                                         hwnd = Hwnd.ObjectFromHandle(xevent.DestroyWindowEvent.window);
4602
4603                                         // We may get multiple for the same window, act only one the first (when Hwnd still knows about it)
4604                                         if ((hwnd != null) && (hwnd.client_window == xevent.DestroyWindowEvent.window)) {
4605                                                 CleanupCachedWindows (hwnd);
4606
4607                                                 DriverDebug("Received X11 Destroy Notification for {0}", XplatUI.Window(hwnd.client_window));
4608
4609                                                 msg.hwnd = hwnd.client_window;
4610                                                 msg.message=Msg.WM_DESTROY;
4611                                                 hwnd.Dispose();
4612                                         } else {
4613                                                 goto ProcessNextMessage;
4614                                         }
4615
4616                                         break;
4617                                 }
4618
4619                                 case XEventName.ClientMessage: {
4620                                         if (Dnd.HandleClientMessage (ref xevent)) {
4621                                                 goto ProcessNextMessage;
4622                                         }
4623
4624                                         if (xevent.ClientMessageEvent.message_type == AsyncAtom) {
4625                                                 XplatUIDriverSupport.ExecuteClientMessage((GCHandle)xevent.ClientMessageEvent.ptr1);
4626                                                 goto ProcessNextMessage;
4627                                         }
4628
4629                                         if (xevent.ClientMessageEvent.message_type == HoverState.Atom) {
4630                                                 msg.message = Msg.WM_MOUSEHOVER;
4631                                                 msg.wParam = GetMousewParam(0);
4632                                                 msg.lParam = (IntPtr) (xevent.ClientMessageEvent.ptr1);
4633                                                 return true;
4634                                         }
4635
4636                                         if (xevent.ClientMessageEvent.message_type == (IntPtr)PostAtom) {                                               
4637                                                 DebugHelper.Indent ();
4638                                                 DebugHelper.WriteLine (String.Format ("Posted message:" + (Msg) xevent.ClientMessageEvent.ptr2.ToInt32 () + " for 0x{0:x}", xevent.ClientMessageEvent.ptr1.ToInt32 ()));
4639                                                 DebugHelper.Unindent ();
4640                                                 msg.hwnd = xevent.ClientMessageEvent.ptr1;
4641                                                 msg.message = (Msg) xevent.ClientMessageEvent.ptr2.ToInt32 ();
4642                                                 msg.wParam = xevent.ClientMessageEvent.ptr3;
4643                                                 msg.lParam = xevent.ClientMessageEvent.ptr4;
4644                                                 if (msg.message == (Msg)Msg.WM_QUIT)
4645                                                         return false;
4646                                                 else
4647                                                         return true;
4648                                         }
4649
4650                                         if  (xevent.ClientMessageEvent.message_type == _XEMBED) {
4651 #if DriverDebugXEmbed
4652                                                 Console.WriteLine("GOT EMBED MESSAGE {0:X}, detail {1:X}", xevent.ClientMessageEvent.ptr2.ToInt32(), xevent.ClientMessageEvent.ptr3.ToInt32());
4653 #endif
4654
4655                                                 if (xevent.ClientMessageEvent.ptr2.ToInt32() == (int)XEmbedMessage.EmbeddedNotify) {
4656                                                         XSizeHints hints = new XSizeHints();
4657                                                         IntPtr dummy;
4658
4659                                                         XGetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints, out dummy);
4660
4661                                                         hwnd.width = hints.max_width;
4662                                                         hwnd.height = hints.max_height;
4663                                                         hwnd.ClientRect = Rectangle.Empty;
4664                                                         SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
4665                                                 }
4666                                         }
4667
4668                                         if  (xevent.ClientMessageEvent.message_type == WM_PROTOCOLS) {
4669                                                 if (xevent.ClientMessageEvent.ptr1 == WM_DELETE_WINDOW) {
4670                                                         SendMessage (msg.hwnd, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_CLOSE, IntPtr.Zero);
4671                                                         msg.message = Msg.WM_CLOSE;
4672                                                         return true;
4673                                                 }
4674
4675                                                 // We should not get this, but I'll leave the code in case we need it in the future
4676                                                 if (xevent.ClientMessageEvent.ptr1 == WM_TAKE_FOCUS) {
4677                                                         goto ProcessNextMessage;
4678                                                 }
4679                                         }
4680                                         goto ProcessNextMessage;
4681                                 }
4682
4683                                 default: {
4684                                         goto ProcessNextMessage;
4685                                 }
4686                         }
4687
4688                         return true;
4689                 }
4690
4691                 HitTest NCHitTest (Hwnd hwnd, int x, int y)
4692                 {
4693                         // The hit test is sent in screen coordinates
4694                         IntPtr dummy;
4695                         int screen_x, screen_y;
4696                         XTranslateCoordinates (DisplayHandle, hwnd.WholeWindow, RootWindow, x, y, out screen_x, out screen_y, out dummy);
4697                         return (HitTest) NativeWindow.WndProc (hwnd.client_window, Msg.WM_NCHITTEST, IntPtr.Zero, 
4698                                                                (IntPtr) (screen_y << 16 | screen_x & 0xFFFF));
4699                 }
4700
4701                 // Our very basic implementation of MoveResize - we can extend it later
4702                 // *if* needed
4703                 internal override void BeginMoveResize (IntPtr handle)
4704                 {
4705                         // We *need* to ungrab the pointer in the current display
4706                         XplatUI.UngrabWindow (Grab.Hwnd);
4707
4708                         int x_root, y_root;
4709                         GetCursorPos (IntPtr.Zero, out x_root, out y_root);
4710
4711                         Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
4712                         SendNetWMMessage (hwnd.whole_window, _NET_WM_MOVERESIZE, (IntPtr) x_root, (IntPtr) y_root,
4713                                         (IntPtr) NetWmMoveResize._NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT, 
4714                                         (IntPtr) 1); // left button
4715                 }
4716
4717                 internal override bool GetText(IntPtr handle, out string text)
4718                 {
4719
4720                         lock (XlibLock) {
4721                                 IntPtr actual_atom;
4722                                 int actual_format;
4723                                 IntPtr nitems;
4724                                 IntPtr bytes_after;
4725                                 IntPtr prop = IntPtr.Zero;
4726
4727                                 XGetWindowProperty(DisplayHandle, handle,
4728                                                    _NET_WM_NAME, IntPtr.Zero, new IntPtr (1), false,
4729                                                    UTF8_STRING, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
4730
4731                                 if ((long)nitems > 0 && prop != IntPtr.Zero) {
4732                                         text = Marshal.PtrToStringUni (prop, (int)nitems);
4733                                         XFree (prop);
4734                                         return true;
4735                                 }
4736                                 else {
4737                                         // fallback on the non-_NET property
4738                                         IntPtr  textptr;
4739
4740                                         textptr = IntPtr.Zero;
4741
4742                                         XFetchName(DisplayHandle, Hwnd.ObjectFromHandle(handle).whole_window, ref textptr);
4743                                         if (textptr != IntPtr.Zero) {
4744                                                 text = Marshal.PtrToStringAnsi(textptr);
4745                                                 XFree(textptr);
4746                                                 return true;
4747                                         } else {
4748                                                 text = "";
4749                                                 return false;
4750                                         }
4751                                 }
4752                         }
4753                 }
4754
4755                 internal override void GetWindowPos(IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height)
4756                 {
4757                         Hwnd            hwnd;
4758
4759                         hwnd = Hwnd.ObjectFromHandle(handle);
4760
4761                         if (hwnd != null) {
4762                                 x = hwnd.x;
4763                                 y = hwnd.y;
4764                                 width = hwnd.width;
4765                                 height = hwnd.height;
4766
4767                                 PerformNCCalc(hwnd);
4768
4769                                 client_width = hwnd.ClientRect.Width;
4770                                 client_height = hwnd.ClientRect.Height;
4771
4772                                 return;
4773                         }
4774
4775                         // Should we throw an exception or fail silently?
4776                         // throw new ArgumentException("Called with an invalid window handle", "handle");
4777
4778                         x = 0;
4779                         y = 0;
4780                         width = 0;
4781                         height = 0;
4782                         client_width = 0;
4783                         client_height = 0;
4784                 }
4785
4786                 internal override FormWindowState GetWindowState(IntPtr handle)
4787                 {
4788                         Hwnd                    hwnd;
4789
4790                         hwnd = Hwnd.ObjectFromHandle(handle);
4791
4792                         if (hwnd.cached_window_state == (FormWindowState)(-1))
4793                                 hwnd.cached_window_state = UpdateWindowState (handle);
4794
4795                         return hwnd.cached_window_state;
4796                 }
4797
4798                 FormWindowState UpdateWindowState (IntPtr handle) {
4799                         IntPtr                  actual_atom;
4800                         int                     actual_format;
4801                         IntPtr                  nitems;
4802                         IntPtr                  bytes_after;
4803                         IntPtr                  prop = IntPtr.Zero;
4804                         IntPtr                  atom;
4805                         int                     maximized;
4806                         bool                    minimized;
4807                         XWindowAttributes       attributes;
4808                         Hwnd                    hwnd;
4809
4810                         hwnd = Hwnd.ObjectFromHandle(handle);
4811
4812                         maximized = 0;
4813                         minimized = false;
4814                         XGetWindowProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, IntPtr.Zero, new IntPtr (256), false, (IntPtr)Atom.XA_ATOM, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
4815                         if (((long)nitems > 0) && (prop != IntPtr.Zero)) {
4816                                 for (int i = 0; i < (long)nitems; i++) {
4817                                         atom = (IntPtr)Marshal.ReadInt32(prop, i * 4);
4818                                         if ((atom == _NET_WM_STATE_MAXIMIZED_HORZ) || (atom == _NET_WM_STATE_MAXIMIZED_VERT)) {
4819                                                 maximized++;
4820                                         } else if (atom == _NET_WM_STATE_HIDDEN) {
4821                                                 minimized = true;
4822                                         }
4823                                 }
4824                                 XFree(prop);
4825                         }
4826
4827                         if (minimized) {
4828                                 return FormWindowState.Minimized;
4829                         } else if (maximized == 2) {
4830                                 return FormWindowState.Maximized;
4831                         }
4832
4833                         attributes = new XWindowAttributes();
4834                         XGetWindowAttributes(DisplayHandle, hwnd.client_window, ref attributes);
4835                         if (attributes.map_state == MapState.IsUnmapped) {
4836                                 return (FormWindowState)(-1);
4837                         }
4838
4839
4840                         return FormWindowState.Normal;
4841                 }
4842
4843                 internal override void GrabInfo(out IntPtr handle, out bool GrabConfined, out Rectangle GrabArea)
4844                 {
4845                         handle = Grab.Hwnd;
4846                         GrabConfined = Grab.Confined;
4847                         GrabArea = Grab.Area;
4848                 }
4849
4850                 internal override void GrabWindow(IntPtr handle, IntPtr confine_to_handle)
4851                 {
4852                         Hwnd    hwnd;
4853                         IntPtr  confine_to_window;
4854
4855                         confine_to_window = IntPtr.Zero;
4856
4857                         if (confine_to_handle != IntPtr.Zero) {
4858                                 XWindowAttributes       attributes = new XWindowAttributes();
4859
4860                                 hwnd = Hwnd.ObjectFromHandle(confine_to_handle);
4861
4862                                 lock (XlibLock) {
4863                                         XGetWindowAttributes(DisplayHandle, hwnd.client_window, ref attributes);
4864                                 }
4865                                 Grab.Area.X = attributes.x;
4866                                 Grab.Area.Y = attributes.y;
4867                                 Grab.Area.Width = attributes.width;
4868                                 Grab.Area.Height = attributes.height;
4869                                 Grab.Confined = true;
4870                                 confine_to_window = hwnd.client_window;
4871                         }
4872
4873                         Grab.Hwnd = handle;
4874
4875                         hwnd = Hwnd.ObjectFromHandle(handle);
4876
4877                         lock (XlibLock) {
4878                                 XGrabPointer(DisplayHandle, hwnd.client_window, false, 
4879                                         EventMask.ButtonPressMask | EventMask.ButtonMotionMask |
4880                                         EventMask.ButtonReleaseMask | EventMask.PointerMotionMask | 
4881                                         EventMask.PointerMotionHintMask | EventMask.LeaveWindowMask,
4882                                         GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, confine_to_window, IntPtr.Zero, IntPtr.Zero);
4883                         }
4884                 }
4885
4886                 internal override void UngrabWindow(IntPtr hwnd)
4887                 {
4888                         lock (XlibLock) {
4889                                 XUngrabPointer(DisplayHandle, IntPtr.Zero);
4890                                 XFlush(DisplayHandle);
4891                         }
4892                         WindowUngrabbed (hwnd);                 
4893                 }
4894                 
4895                 void WindowUngrabbed (IntPtr hwnd) {
4896                         bool was_grabbed = Grab.Hwnd != IntPtr.Zero;
4897                         
4898                         Grab.Hwnd = IntPtr.Zero;
4899                         Grab.Confined = false;
4900                         
4901                         if (was_grabbed) {
4902                                 // lparam should be the handle to the window gaining the mouse capture,
4903                                 // but X doesn't seem to give us that information.
4904                                 // Also only generate WM_CAPTURECHANGED if the window actually was grabbed.
4905                                 // X will send a NotifyUngrab, but since it comes late sometimes we're
4906                                 // calling WindowUngrabbed directly from UngrabWindow in order to send
4907                                 // this WM right away.
4908                                 SendMessage (hwnd, Msg.WM_CAPTURECHANGED, IntPtr.Zero, IntPtr.Zero);
4909                         }
4910                 }
4911
4912                 internal override void HandleException(Exception e)
4913                 {
4914                         StackTrace st = new StackTrace(e, true);
4915                         Console.WriteLine("Exception '{0}'", e.Message+st.ToString());
4916                         Console.WriteLine("{0}{1}", e.Message, st.ToString());
4917                 }
4918
4919                 internal override void Invalidate(IntPtr handle, Rectangle rc, bool clear)
4920                 {
4921                         Hwnd    hwnd;
4922
4923                         hwnd = Hwnd.ObjectFromHandle(handle);
4924
4925                         if (clear) {
4926                                 AddExpose (hwnd, true, hwnd.X, hwnd.Y, hwnd.Width, hwnd.Height);
4927                         } else {
4928                                 AddExpose (hwnd, true, rc.X, rc.Y, rc.Width, rc.Height);
4929                         }
4930                 }
4931
4932                 internal override void InvalidateNC (IntPtr handle)
4933                 {
4934                         Hwnd    hwnd;
4935
4936                         hwnd = Hwnd.ObjectFromHandle(handle);
4937
4938                         AddExpose (hwnd, hwnd.WholeWindow == hwnd.ClientWindow, 0, 0, hwnd.Width, hwnd.Height);
4939                 }
4940
4941                 internal override bool IsEnabled(IntPtr handle)
4942                 {
4943                         Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
4944                         return (hwnd != null && hwnd.Enabled);
4945                 }
4946                 
4947                 internal override bool IsVisible(IntPtr handle)
4948                 {
4949                         Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
4950                         return (hwnd != null && hwnd.visible);
4951                 }
4952
4953                 internal override void KillTimer(Timer timer)
4954                 {
4955                         XEventQueue queue = (XEventQueue) MessageQueues [timer.thread];
4956
4957                         if (queue == null) {
4958                                 // This isn't really an error, MS doesn't start the timer if
4959                                 // it has no assosciated queue. In this case, remove the timer
4960                                 // from the list of unattached timers (if it was enabled).
4961                                 lock (unattached_timer_list) {
4962                                         if (unattached_timer_list.Contains (timer))
4963                                                 unattached_timer_list.Remove (timer);
4964                                 }
4965                                 return;
4966                         }
4967                         queue.timer_list.Remove (timer);
4968                 }
4969
4970                 internal override void MenuToScreen(IntPtr handle, ref int x, ref int y)
4971                 {
4972                         int     dest_x_return;
4973                         int     dest_y_return;
4974                         IntPtr  child;
4975                         Hwnd    hwnd;
4976
4977                         hwnd = Hwnd.ObjectFromHandle(handle);
4978
4979                         lock (XlibLock) {
4980                                 XTranslateCoordinates(DisplayHandle, hwnd.whole_window, RootWindow, x, y, out dest_x_return, out dest_y_return, out child);
4981                         }
4982
4983                         x = dest_x_return;
4984                         y = dest_y_return;
4985                 }
4986
4987                 internal override void OverrideCursor(IntPtr cursor)
4988                 {
4989                         if (Grab.Hwnd != IntPtr.Zero) {
4990                                 XChangeActivePointerGrab (DisplayHandle,
4991                                                 EventMask.ButtonMotionMask |
4992                                                 EventMask.PointerMotionMask |
4993                                                 EventMask.PointerMotionHintMask |
4994                                                 EventMask.ButtonPressMask |
4995                                                 EventMask.ButtonReleaseMask,
4996                                                 cursor, IntPtr.Zero);
4997                                 return;
4998                         }
4999
5000                         OverrideCursorHandle = cursor;
5001                 }
5002
5003                 internal override PaintEventArgs PaintEventStart(ref Message msg, IntPtr handle, bool client)
5004                 {
5005                         PaintEventArgs  paint_event;
5006                         Hwnd            hwnd;
5007                         Hwnd            paint_hwnd;
5008                         
5009                         // 
5010                         // handle  (and paint_hwnd) refers to the window that is should be painted.
5011                         // msg.HWnd (and hwnd) refers to the window that got the paint message.
5012                         // 
5013                         
5014                         hwnd = Hwnd.ObjectFromHandle(msg.HWnd);
5015                         if (msg.HWnd == handle) {
5016                                 paint_hwnd = hwnd;
5017                         } else {
5018                                 paint_hwnd = Hwnd.ObjectFromHandle (handle);
5019                         }
5020         
5021                         if (Caret.Visible == true) {
5022                                 Caret.Paused = true;
5023                                 HideCaret();
5024                         }
5025
5026                         Graphics dc;
5027
5028                         if (client) {
5029                                 dc = Graphics.FromHwnd (paint_hwnd.client_window);
5030
5031                                 Region clip_region = new Region ();
5032                                 clip_region.MakeEmpty();
5033
5034                                 foreach (Rectangle r in hwnd.ClipRectangles) {
5035                                         /* Expand the region slightly.
5036                                          * See bug 464464.
5037                                          */
5038                                         Rectangle r2 = Rectangle.FromLTRB (r.Left, r.Top, r.Right, r.Bottom + 1);
5039                                         clip_region.Union (r2);
5040                                 }
5041
5042                                 if (hwnd.UserClip != null) {
5043                                         clip_region.Intersect(hwnd.UserClip);
5044                                 }
5045
5046                                 dc.Clip = clip_region;
5047                                 paint_event = new PaintEventArgs(dc, hwnd.Invalid);
5048                                 hwnd.expose_pending = false;
5049
5050                                 hwnd.ClearInvalidArea();
5051
5052                                 hwnd.drawing_stack.Push (paint_event);
5053                                 hwnd.drawing_stack.Push (dc);
5054
5055                                 return paint_event;
5056                         } else {
5057                                 dc = Graphics.FromHwnd (paint_hwnd.whole_window);
5058
5059                                 if (!hwnd.nc_invalid.IsEmpty) {
5060                                         dc.SetClip (hwnd.nc_invalid);
5061                                         paint_event = new PaintEventArgs(dc, hwnd.nc_invalid);
5062                                 } else {
5063                                         paint_event = new PaintEventArgs(dc, new Rectangle(0, 0, hwnd.width, hwnd.height));
5064                                 }
5065                                 hwnd.nc_expose_pending = false;
5066
5067                                 hwnd.ClearNcInvalidArea ();
5068
5069                                 hwnd.drawing_stack.Push (paint_event);
5070                                 hwnd.drawing_stack.Push (dc);
5071
5072                                 return paint_event;
5073                         }
5074                 }
5075
5076                 internal override void PaintEventEnd(ref Message msg, IntPtr handle, bool client)
5077                 {
5078                         Hwnd    hwnd;
5079
5080                         hwnd = Hwnd.ObjectFromHandle (msg.HWnd);
5081
5082                         Graphics dc = (Graphics)hwnd.drawing_stack.Pop ();
5083                         dc.Flush();
5084                         dc.Dispose();
5085                         
5086                         PaintEventArgs pe = (PaintEventArgs)hwnd.drawing_stack.Pop();
5087                         pe.SetGraphics (null);
5088                         pe.Dispose ();
5089
5090                         if (Caret.Visible == true) {
5091                                 ShowCaret();
5092                                 Caret.Paused = false;
5093                         }
5094                 }
5095
5096                 [MonoTODO("Implement filtering and PM_NOREMOVE")]
5097                 internal override bool PeekMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags)
5098                 {
5099                         XEventQueue queue = (XEventQueue) queue_id;
5100                         bool    pending;
5101
5102                         if ((flags & (uint)PeekMessageFlags.PM_REMOVE) == 0) {
5103                                 throw new NotImplementedException("PeekMessage PM_NOREMOVE is not implemented yet");    // FIXME - Implement PM_NOREMOVE flag
5104                         }
5105
5106                         pending = false;
5107                         if (queue.Count > 0) {
5108                                 pending = true;
5109                         } else {
5110                                 // Only call UpdateMessageQueue if real events are pending 
5111                                 // otherwise we go to sleep on the socket
5112                                 if (XPending(DisplayHandle) != 0) {
5113                                         UpdateMessageQueue((XEventQueue)queue_id);
5114                                         pending = true;
5115                                 } else if (((XEventQueue)queue_id).Paint.Count > 0) {
5116                                         pending = true;
5117                                 }
5118                         }
5119
5120                         CheckTimers(queue.timer_list, DateTime.UtcNow);
5121
5122                         if (!pending) {
5123                                 return false;
5124                         }
5125                         return GetMessage(queue_id, ref msg, hWnd, wFilterMin, wFilterMax);
5126                 }
5127
5128                 internal override bool PostMessage (IntPtr handle, Msg message, IntPtr wparam, IntPtr lparam)
5129                 {
5130                         XEvent xevent = new XEvent ();
5131                         Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
5132
5133                         xevent.type = XEventName.ClientMessage;
5134                         xevent.ClientMessageEvent.display = DisplayHandle;
5135
5136                         if (hwnd != null) {
5137                                 xevent.ClientMessageEvent.window = hwnd.whole_window;
5138                         } else {
5139                                 xevent.ClientMessageEvent.window = IntPtr.Zero;
5140                         }
5141
5142                         xevent.ClientMessageEvent.message_type = (IntPtr) PostAtom;
5143                         xevent.ClientMessageEvent.format = 32;
5144                         xevent.ClientMessageEvent.ptr1 = handle;
5145                         xevent.ClientMessageEvent.ptr2 = (IntPtr) message;
5146                         xevent.ClientMessageEvent.ptr3 = wparam;
5147                         xevent.ClientMessageEvent.ptr4 = lparam;
5148
5149                         if (hwnd != null)
5150                                 hwnd.Queue.EnqueueLocked (xevent);
5151                         else
5152                                 ThreadQueue(Thread.CurrentThread).EnqueueLocked (xevent);
5153
5154                         return true;
5155                 }
5156
5157                 internal override void PostQuitMessage(int exitCode)
5158                 {
5159                         ApplicationContext ctx = Application.MWFThread.Current.Context;
5160                         Form f = ctx != null ? ctx.MainForm : null;
5161                         if (f != null)
5162                                 PostMessage (Application.MWFThread.Current.Context.MainForm.window.Handle, Msg.WM_QUIT, IntPtr.Zero, IntPtr.Zero);
5163                         else
5164                                 PostMessage (FosterParent, Msg.WM_QUIT, IntPtr.Zero, IntPtr.Zero);
5165                         XFlush(DisplayHandle);
5166                 }
5167
5168                 internal override void RequestAdditionalWM_NCMessages(IntPtr hwnd, bool hover, bool leave)
5169                 {
5170                         // TODO
5171                 }
5172
5173                 internal override void RequestNCRecalc(IntPtr handle)
5174                 {
5175                         Hwnd                            hwnd;
5176
5177                         hwnd = Hwnd.ObjectFromHandle(handle);
5178
5179                         if (hwnd == null) {
5180                                 return;
5181                         }
5182
5183                         PerformNCCalc(hwnd);
5184                         SendMessage(handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
5185                         InvalidateNC(handle);
5186                 }
5187
5188                 internal override void ResetMouseHover(IntPtr handle)
5189                 {
5190                         Hwnd    hwnd;
5191
5192                         hwnd = Hwnd.ObjectFromHandle(handle);
5193                         if (hwnd == null) {
5194                                 return;
5195                         }
5196
5197                         HoverState.Timer.Enabled = true;
5198                         HoverState.X = mouse_position.X;
5199                         HoverState.Y = mouse_position.Y;
5200                         HoverState.Window = handle;
5201                 }
5202
5203
5204                 internal override void ScreenToClient(IntPtr handle, ref int x, ref int y)
5205                 {
5206                         int     dest_x_return;
5207                         int     dest_y_return;
5208                         IntPtr  child;
5209                         Hwnd    hwnd;
5210
5211                         hwnd = Hwnd.ObjectFromHandle(handle);
5212
5213                         lock (XlibLock) {
5214                                 XTranslateCoordinates (DisplayHandle, RootWindow, hwnd.client_window, x, y, out dest_x_return, out dest_y_return, out child);
5215                         }
5216
5217                         x = dest_x_return;
5218                         y = dest_y_return;
5219                 }
5220
5221                 internal override void ScreenToMenu(IntPtr handle, ref int x, ref int y)
5222                 {
5223                         int     dest_x_return;
5224                         int     dest_y_return;
5225                         IntPtr  child;
5226                         Hwnd    hwnd;
5227
5228                         hwnd = Hwnd.ObjectFromHandle(handle);
5229
5230                         lock (XlibLock) {
5231                                 XTranslateCoordinates (DisplayHandle, RootWindow, hwnd.whole_window, x, y, out dest_x_return, out dest_y_return, out child);
5232                         }
5233
5234                         Form form = Control.FromHandle (handle) as Form;
5235                         if (form != null && form.window_manager != null) {
5236                                 dest_y_return -= form.window_manager.TitleBarHeight;
5237                         }
5238
5239                         x = dest_x_return;
5240                         y = dest_y_return;
5241                 }
5242
5243                 bool GraphicsExposePredicate (IntPtr display, ref XEvent xevent, IntPtr arg)
5244                 {
5245                         return (xevent.type == XEventName.GraphicsExpose || xevent.type == XEventName.NoExpose) &&
5246                                 arg == xevent.GraphicsExposeEvent.drawable;
5247                 }
5248
5249                 delegate bool EventPredicate (IntPtr display, ref XEvent xevent, IntPtr arg);
5250
5251                 void ProcessGraphicsExpose (Hwnd hwnd)
5252                 {
5253                         XEvent xevent = new XEvent ();
5254                         IntPtr handle = Hwnd.HandleFromObject (hwnd);
5255                         EventPredicate predicate = GraphicsExposePredicate;
5256
5257                         for (;;) {
5258                                 XIfEvent (Display, ref xevent, predicate, handle);
5259                                 if (xevent.type != XEventName.GraphicsExpose)
5260                                         break;
5261
5262                                 AddExpose (hwnd, xevent.ExposeEvent.window == hwnd.ClientWindow, xevent.GraphicsExposeEvent.x, xevent.GraphicsExposeEvent.y,
5263                                                 xevent.GraphicsExposeEvent.width, xevent.GraphicsExposeEvent.height);
5264
5265                                 if (xevent.GraphicsExposeEvent.count == 0)
5266                                         break;
5267                         }
5268                 }
5269
5270                 internal override void ScrollWindow(IntPtr handle, Rectangle area, int XAmount, int YAmount, bool with_children)
5271                 {
5272                         Hwnd            hwnd;
5273                         IntPtr          gc;
5274                         XGCValues       gc_values;
5275
5276                         hwnd = Hwnd.ObjectFromHandle(handle);
5277
5278                         Rectangle r = Rectangle.Intersect (hwnd.Invalid, area);
5279                         if (!r.IsEmpty) {
5280                                 /* We have an invalid area in the window we're scrolling. 
5281                                    Adjust our stored invalid rectangle to to match the scrolled amount */
5282
5283                                 r.X += XAmount;
5284                                 r.Y += YAmount;
5285
5286                                 if (r.X < 0) {
5287                                         r.Width += r.X;
5288                                         r.X =0;
5289                                 }
5290
5291                                 if (r.Y < 0) {
5292                                         r.Height += r.Y;
5293                                         r.Y =0;
5294                                 }
5295
5296                                 if (area.Contains (hwnd.Invalid))
5297                                         hwnd.ClearInvalidArea ();
5298                                 hwnd.AddInvalidArea(r);
5299                         }
5300
5301                         gc_values = new XGCValues();
5302
5303                         if (with_children) {
5304                                 gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors;
5305                         }
5306
5307                         gc = XCreateGC(DisplayHandle, hwnd.client_window, IntPtr.Zero, ref gc_values);
5308
5309                         Rectangle visible_rect = GetTotalVisibleArea (hwnd.client_window);
5310                         visible_rect.Intersect (area);
5311
5312                         Rectangle dest_rect = visible_rect;
5313                         dest_rect.Y += YAmount;
5314                         dest_rect.X += XAmount;
5315                         dest_rect.Intersect (area);
5316
5317                         Point src = new Point (dest_rect.X - XAmount, dest_rect.Y - YAmount);
5318                         XCopyArea (DisplayHandle, hwnd.client_window, hwnd.client_window, gc, src.X, src.Y, 
5319                                         dest_rect.Width, dest_rect.Height, dest_rect.X, dest_rect.Y);
5320
5321                         Rectangle dirty_area = GetDirtyArea (area, dest_rect, XAmount, YAmount);
5322                         AddExpose (hwnd, true, dirty_area.X, dirty_area.Y, dirty_area.Width, dirty_area.Height);
5323
5324                         ProcessGraphicsExpose (hwnd);
5325
5326                         XFreeGC(DisplayHandle, gc);
5327                 }
5328
5329                 internal override void ScrollWindow(IntPtr handle, int XAmount, int YAmount, bool with_children)
5330                 {
5331                         Hwnd            hwnd;
5332                         Rectangle       rect;
5333
5334                         hwnd = Hwnd.GetObjectFromWindow(handle);
5335
5336                         rect = hwnd.ClientRect;
5337                         rect.X = 0;
5338                         rect.Y = 0;
5339                         ScrollWindow(handle, rect, XAmount, YAmount, with_children);
5340                 }
5341
5342                 Rectangle GetDirtyArea (Rectangle total_area, Rectangle valid_area, int XAmount, int YAmount)
5343                 {
5344                         Rectangle dirty_area = total_area;
5345
5346                         if (YAmount > 0)
5347                                 dirty_area.Height -= valid_area.Height;
5348                         else if (YAmount < 0) {
5349                                 dirty_area.Height -= valid_area.Height;
5350                                 dirty_area.Y += valid_area.Height;
5351                         }
5352
5353                         if (XAmount > 0)
5354                                 dirty_area.Width -= valid_area.Width;
5355                         else if (XAmount < 0) {
5356                                 dirty_area.Width -= valid_area.Width;
5357                                 dirty_area.X += valid_area.Width;
5358                         }
5359
5360                         return dirty_area;
5361                 }
5362
5363                 Rectangle GetTotalVisibleArea (IntPtr handle)
5364                 {
5365                         Control c = Control.FromHandle (handle);
5366
5367                         Rectangle visible_area = c.ClientRectangle;
5368                         visible_area.Location = c.PointToScreen (Point.Empty);
5369
5370                         for (Control parent = c.Parent; parent != null; parent = parent.Parent) {
5371                                 if (!parent.IsHandleCreated || !parent.Visible)
5372                                         return visible_area; // Non visible, not need to finish computations
5373
5374                                 Rectangle r = parent.ClientRectangle;
5375                                 r.Location = parent.PointToScreen (Point.Empty);
5376
5377                                 visible_area.Intersect (r);
5378                         }
5379
5380                         visible_area.Location = c.PointToClient (visible_area.Location);
5381                         return visible_area;
5382                 }
5383
5384                 internal override void SendAsyncMethod (AsyncMethodData method)
5385                 {
5386                         Hwnd    hwnd;
5387                         XEvent  xevent = new XEvent ();
5388
5389                         hwnd = Hwnd.ObjectFromHandle(method.Handle);
5390
5391                         xevent.type = XEventName.ClientMessage;
5392                         xevent.ClientMessageEvent.display = DisplayHandle;
5393                         xevent.ClientMessageEvent.window = method.Handle;
5394                         xevent.ClientMessageEvent.message_type = (IntPtr)AsyncAtom;
5395                         xevent.ClientMessageEvent.format = 32;
5396                         xevent.ClientMessageEvent.ptr1 = (IntPtr) GCHandle.Alloc (method);
5397
5398                         hwnd.Queue.EnqueueLocked (xevent);
5399
5400                         WakeupMain ();
5401                 }
5402
5403                 delegate IntPtr WndProcDelegate (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam);
5404
5405                 internal override IntPtr SendMessage (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam)
5406                 {
5407                         Hwnd    h;
5408                         h = Hwnd.ObjectFromHandle(hwnd);
5409
5410                         if (h != null && h.queue != ThreadQueue (Thread.CurrentThread)) {
5411                                 AsyncMethodResult       result;
5412                                 AsyncMethodData         data;
5413
5414                                 result = new AsyncMethodResult ();
5415                                 data = new AsyncMethodData ();
5416
5417                                 data.Handle = hwnd;
5418                                 data.Method = new WndProcDelegate (NativeWindow.WndProc);
5419                                 data.Args = new object[] { hwnd, message, wParam, lParam };
5420                                 data.Result = result;
5421                                 
5422                                 SendAsyncMethod (data);
5423                                 DriverDebug("Sending {0} message across.", message);
5424
5425                                 return IntPtr.Zero;
5426                         }
5427                         string key = hwnd + ":" + message;
5428                         if (messageHold[key] != null)
5429                                 messageHold[key] = ((int)messageHold[key]) - 1;
5430                         return NativeWindow.WndProc(hwnd, message, wParam, lParam);
5431                 }
5432
5433                 internal override int SendInput(IntPtr handle, Queue keys)
5434                 { 
5435                         if (handle == IntPtr.Zero)
5436                                 return 0;
5437
5438                         int count = keys.Count;
5439                         Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
5440
5441                         while (keys.Count > 0) {
5442                         
5443                                 MSG msg = (MSG)keys.Dequeue();
5444
5445                                 XEvent xevent = new XEvent ();
5446
5447                                 xevent.type = (msg.message == Msg.WM_KEYUP ? XEventName.KeyRelease : XEventName.KeyPress);
5448                                 xevent.KeyEvent.display = DisplayHandle;
5449
5450                                 if (hwnd != null) {
5451                                         xevent.KeyEvent.window = hwnd.whole_window;
5452                                 } else {
5453                                         xevent.KeyEvent.window = IntPtr.Zero;
5454                                 }
5455
5456                                 xevent.KeyEvent.keycode = Keyboard.ToKeycode((int)msg.wParam);
5457
5458                                 hwnd.Queue.EnqueueLocked (xevent);
5459                         }
5460                         return count;
5461                 }
5462
5463                 internal override void SetAllowDrop (IntPtr handle, bool value)
5464                 {
5465                         // We allow drop on all windows
5466                 }
5467
5468                 internal override DragDropEffects StartDrag (IntPtr handle, object data,
5469                                 DragDropEffects allowed_effects)
5470                 {
5471                         Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
5472
5473                         if (hwnd == null)
5474                                 throw new ArgumentException ("Attempt to begin drag from invalid window handle (" + handle.ToInt32 () + ").");
5475
5476                         return Dnd.StartDrag (hwnd.client_window, data, allowed_effects);
5477                 }
5478
5479                 internal override void SetBorderStyle(IntPtr handle, FormBorderStyle border_style)
5480                 {
5481                         Form form = Control.FromHandle (handle) as Form;
5482                         if (form != null && form.window_manager == null) {
5483                                 CreateParams cp = form.GetCreateParams ();
5484                                 if (border_style == FormBorderStyle.FixedToolWindow ||
5485                                      border_style == FormBorderStyle.SizableToolWindow || 
5486                                      cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) {
5487                                         form.window_manager = new ToolWindowManager (form);
5488                                 }
5489                         }
5490                         
5491                         RequestNCRecalc(handle);
5492                 }
5493
5494                 internal override void SetCaretPos(IntPtr handle, int x, int y)
5495                 {
5496                         if (Caret.Hwnd == handle) {
5497                                 Caret.Timer.Stop();
5498                                 HideCaret();
5499
5500                                 Caret.X = x;
5501                                 Caret.Y = y;
5502
5503                                 Keyboard.SetCaretPos (Caret, handle, x, y);
5504
5505                                 if (Caret.Visible == true) {
5506                                         ShowCaret();
5507                                         Caret.Timer.Start();
5508                                 }
5509                         }
5510                 }
5511
5512                 internal override void SetClipRegion(IntPtr handle, Region region)
5513                 {
5514                         Hwnd    hwnd;
5515
5516                         hwnd = Hwnd.ObjectFromHandle(handle);
5517                         if (hwnd == null) {
5518                                 return;
5519                         }
5520
5521                         hwnd.UserClip = region;
5522                 }
5523
5524                 internal override void SetCursor(IntPtr handle, IntPtr cursor)
5525                 {
5526                         Hwnd    hwnd;
5527
5528                         if (OverrideCursorHandle == IntPtr.Zero) {
5529                                 if ((LastCursorWindow == handle) && (LastCursorHandle == cursor)) {
5530                                         return;
5531                                 }
5532
5533                                 LastCursorHandle = cursor;
5534                                 LastCursorWindow = handle;
5535
5536                                 hwnd = Hwnd.ObjectFromHandle(handle);
5537                                 lock (XlibLock) {
5538                                         if (cursor != IntPtr.Zero) {
5539                                                 XDefineCursor(DisplayHandle, hwnd.whole_window, cursor);
5540                                         } else {
5541                                                 XUndefineCursor(DisplayHandle, hwnd.whole_window);
5542                                         }
5543                                         XFlush(DisplayHandle);
5544                                 }
5545                                 return;
5546                         }
5547
5548                         hwnd = Hwnd.ObjectFromHandle(handle);
5549                         lock (XlibLock) {
5550                                 XDefineCursor(DisplayHandle, hwnd.whole_window, OverrideCursorHandle);
5551                         }
5552                 }
5553
5554                 void QueryPointer (IntPtr display, IntPtr w, out IntPtr root, out IntPtr child,
5555                                            out int root_x, out int root_y, out int child_x, out int child_y,
5556                                            out int mask)
5557                 {
5558                         /* this code was written with the help of
5559                         glance at gdk.  I never would have realized we
5560                         needed a loop in order to traverse down in the
5561                         hierarchy.  I would have assumed you'd get the
5562                         most deeply nested child and have to do
5563                         XQueryTree to move back up the hierarchy..
5564                         stupid me, of course. */
5565                         IntPtr c;
5566
5567                         XGrabServer (display);
5568
5569                         XQueryPointer(display, w, out root, out c,
5570                                       out root_x, out root_y, out child_x, out child_y,
5571                                       out mask);
5572
5573                         if (root != w)
5574                                 c = root;
5575
5576                         IntPtr child_last = IntPtr.Zero;
5577                         while (c != IntPtr.Zero) {
5578                                 child_last = c;
5579                                 XQueryPointer(display, c, out root, out c,
5580                                               out root_x, out root_y, out child_x, out child_y,
5581                                               out mask);
5582                         }
5583                         XUngrabServer (display);
5584                         XFlush (display);
5585
5586                         child = child_last;
5587                 }
5588
5589                 internal override void SetCursorPos(IntPtr handle, int x, int y)
5590                 {
5591                         if (handle == IntPtr.Zero) {
5592                                 lock (XlibLock) {
5593                                         IntPtr root, child;
5594                                         int root_x, root_y, child_x, child_y, mask;
5595
5596                                         /* we need to do a
5597                                          * QueryPointer before warping
5598                                          * because if the warp is on
5599                                          * the RootWindow, the x/y are
5600                                          * relative to the current
5601                                          * mouse position
5602                                          */
5603                                         QueryPointer (DisplayHandle, RootWindow,
5604                                                       out root,
5605                                                       out child,
5606                                                       out root_x, out root_y,
5607                                                       out child_x, out child_y,
5608                                                       out mask);
5609
5610                                         XWarpPointer(DisplayHandle, IntPtr.Zero, IntPtr.Zero, 0, 0, 0, 0, x - root_x, y - root_y);
5611
5612                                         XFlush (DisplayHandle);
5613
5614                                         /* then we need to a
5615                                          * QueryPointer after warping
5616                                          * to manually generate a
5617                                          * motion event for the window
5618                                          * we move into.
5619                                          */
5620                                         QueryPointer (DisplayHandle, RootWindow,
5621                                                       out root,
5622                                                       out child,
5623                                                       out root_x, out root_y,
5624                                                       out child_x, out child_y,
5625                                                       out mask);
5626
5627                                         Hwnd child_hwnd = Hwnd.ObjectFromHandle(child);
5628                                         if (child_hwnd == null) {
5629                                                 return;
5630                                         }
5631
5632                                         XEvent xevent = new XEvent ();
5633
5634                                         xevent.type = XEventName.MotionNotify;
5635                                         xevent.MotionEvent.display = DisplayHandle;
5636                                         xevent.MotionEvent.window = child_hwnd.client_window;
5637                                         xevent.MotionEvent.root = RootWindow;
5638                                         xevent.MotionEvent.x = child_x;
5639                                         xevent.MotionEvent.y = child_y;
5640                                         xevent.MotionEvent.x_root = root_x;
5641                                         xevent.MotionEvent.y_root = root_y;
5642                                         xevent.MotionEvent.state = mask;
5643
5644                                         child_hwnd.Queue.EnqueueLocked (xevent);
5645                                 }
5646                         } else {
5647                                 Hwnd    hwnd;
5648
5649                                 hwnd = Hwnd.ObjectFromHandle(handle);
5650                                 lock (XlibLock) {
5651                                         XWarpPointer(DisplayHandle, IntPtr.Zero, hwnd.client_window, 0, 0, 0, 0, x, y);
5652                                 }
5653                         }
5654                 }
5655
5656                 internal override void SetFocus(IntPtr handle)
5657                 {
5658                         Hwnd    hwnd;
5659                         IntPtr  prev_focus_window;
5660
5661                         hwnd = Hwnd.ObjectFromHandle(handle);
5662
5663                         if (hwnd.client_window == FocusWindow) {
5664                                 return;
5665                         }
5666
5667                         // Win32 doesn't do anything if disabled
5668                         if (!hwnd.enabled)
5669                                 return;
5670
5671                         prev_focus_window = FocusWindow;
5672                         FocusWindow = hwnd.client_window;
5673
5674                         if (prev_focus_window != IntPtr.Zero) {
5675                                 SendMessage(prev_focus_window, Msg.WM_KILLFOCUS, FocusWindow, IntPtr.Zero);
5676                         }                       
5677                         Keyboard.FocusIn (FocusWindow);
5678                         SendMessage(FocusWindow, Msg.WM_SETFOCUS, prev_focus_window, IntPtr.Zero);
5679
5680                         //XSetInputFocus(DisplayHandle, Hwnd.ObjectFromHandle(handle).client_window, RevertTo.None, IntPtr.Zero);
5681                 }
5682
5683                 internal override void SetIcon(IntPtr handle, Icon icon)
5684                 {
5685                         Hwnd    hwnd;
5686
5687                         hwnd = Hwnd.ObjectFromHandle(handle);
5688                         if (hwnd != null) {
5689                                 SetIcon(hwnd, icon);
5690                         }
5691                 }
5692
5693                 internal override void SetMenu(IntPtr handle, Menu menu)
5694                 {
5695                         Hwnd    hwnd;
5696
5697                         hwnd = Hwnd.ObjectFromHandle(handle);
5698                         hwnd.menu = menu;
5699
5700                         RequestNCRecalc(handle);
5701                 }
5702
5703                 internal override void SetModal(IntPtr handle, bool Modal)
5704                 {
5705                         if (Modal) {
5706                                 ModalWindows.Push(handle);
5707                         } else {
5708                                 if (ModalWindows.Contains(handle)) {
5709                                         ModalWindows.Pop();
5710                                 }
5711                                 if (ModalWindows.Count > 0) {
5712                                         Activate((IntPtr)ModalWindows.Peek());
5713                                 }
5714                         }
5715
5716                         Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
5717                         Control ctrl = Control.FromHandle (handle);
5718                         SetWMStyles (hwnd, ctrl.GetCreateParams ());
5719                 }
5720
5721                 internal override IntPtr SetParent(IntPtr handle, IntPtr parent)
5722                 {
5723                         Hwnd    hwnd;
5724
5725                         hwnd = Hwnd.ObjectFromHandle(handle);
5726                         hwnd.parent = Hwnd.ObjectFromHandle(parent);
5727
5728                         lock (XlibLock) {
5729                                 DriverDebug("Parent for window {0} = {1}", XplatUI.Window(hwnd.Handle), XplatUI.Window(hwnd.parent != null ? hwnd.parent.Handle : IntPtr.Zero));
5730                                 XReparentWindow(DisplayHandle, hwnd.whole_window, hwnd.parent == null ? FosterParent : hwnd.parent.client_window, hwnd.x, hwnd.y);
5731                         }
5732
5733                         return IntPtr.Zero;
5734                 }
5735
5736                 internal override void SetTimer (Timer timer)
5737                 {
5738                         XEventQueue queue = (XEventQueue) MessageQueues [timer.thread];
5739
5740                         if (queue == null) {
5741                                 // This isn't really an error, MS doesn't start the timer if
5742                                 // it has no assosciated queue at this stage (it will be
5743                                 // enabled when a window is activated).
5744                                 unattached_timer_list.Add (timer);
5745                                 return;
5746                         }
5747                         queue.timer_list.Add (timer);
5748                         WakeupMain ();
5749                 }
5750
5751                 internal override bool SetTopmost(IntPtr handle, bool enabled)
5752                 {
5753
5754                         Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
5755
5756                         if (enabled) {
5757                                 lock (XlibLock) {
5758                                         if (hwnd.Mapped) {
5759                                                 SendNetWMMessage(hwnd.WholeWindow, _NET_WM_STATE, (IntPtr) NetWmStateRequest._NET_WM_STATE_ADD, _NET_WM_STATE_ABOVE, IntPtr.Zero);
5760                                         } else {
5761                                                 int[] atoms = new int[8];
5762                                                 atoms[0] = _NET_WM_STATE_ABOVE.ToInt32();
5763                                                 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
5764                                         }
5765                                 }
5766                         } else {
5767                                 lock (XlibLock) {
5768                                         if (hwnd.Mapped)
5769                                                 SendNetWMMessage(hwnd.WholeWindow, _NET_WM_STATE, (IntPtr) NetWmStateRequest._NET_WM_STATE_REMOVE, _NET_WM_STATE_ABOVE, IntPtr.Zero);
5770                                         else
5771                                                 XDeleteProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE);
5772                                 }
5773                         }
5774                         return true;
5775                 }
5776
5777                 internal override bool SetOwner(IntPtr handle, IntPtr handle_owner)
5778                 {
5779                         Hwnd hwnd;
5780                         Hwnd hwnd_owner;
5781
5782                         hwnd = Hwnd.ObjectFromHandle(handle);
5783
5784                         if (handle_owner != IntPtr.Zero) {
5785                                 hwnd_owner = Hwnd.ObjectFromHandle(handle_owner);
5786                                 lock (XlibLock) {
5787                                         int[]   atoms;
5788
5789                                         atoms = new int[8];
5790
5791                                         atoms[0] = _NET_WM_WINDOW_TYPE_NORMAL.ToInt32();
5792                                         XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
5793
5794                                         if (hwnd_owner != null) {
5795                                                 XSetTransientForHint(DisplayHandle, hwnd.whole_window, hwnd_owner.whole_window);
5796                                         } else {
5797                                                 XSetTransientForHint(DisplayHandle, hwnd.whole_window, RootWindow);
5798                                         }
5799                                 }
5800                         } else {
5801                                 lock (XlibLock) {
5802                                         XDeleteProperty(DisplayHandle, hwnd.whole_window, (IntPtr)Atom.XA_WM_TRANSIENT_FOR);
5803                                 }
5804                         }
5805                         return true;
5806                 }
5807
5808                 internal override bool SetVisible (IntPtr handle, bool visible, bool activate)
5809                 {
5810                         Hwnd    hwnd;
5811
5812                         hwnd = Hwnd.ObjectFromHandle(handle);
5813                         hwnd.visible = visible;
5814
5815                         lock (XlibLock) {
5816                                 if (visible) {
5817                                         MapWindow(hwnd, WindowType.Both);
5818
5819                                         if (Control.FromHandle(handle) is Form) {
5820                                                 FormWindowState s;
5821
5822                                                 s = ((Form)Control.FromHandle(handle)).WindowState;
5823
5824                                                 switch(s) {
5825                                                         case FormWindowState.Minimized: SetWindowState(handle, FormWindowState.Minimized); break;
5826                                                         case FormWindowState.Maximized: SetWindowState(handle, FormWindowState.Maximized); break;
5827                                                 }
5828                                         }
5829
5830                                         SendMessage(handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
5831                                 }
5832                                 else {
5833                                         UnmapWindow(hwnd, WindowType.Both);
5834                                 }
5835                         }
5836                         return true;
5837                 }
5838
5839                 internal override void SetWindowMinMax(IntPtr handle, Rectangle maximized, Size min, Size max)
5840                 {
5841                         Control ctrl = Control.FromHandle (handle);
5842                         SetWindowMinMax (handle, maximized, min, max, ctrl != null ? ctrl.GetCreateParams () : null);
5843                 }
5844
5845                 internal void SetWindowMinMax (IntPtr handle, Rectangle maximized, Size min, Size max, CreateParams cp)
5846                 {
5847                         Hwnd            hwnd;
5848                         XSizeHints      hints;
5849                         IntPtr          dummy;
5850
5851                         hwnd = Hwnd.ObjectFromHandle(handle);
5852                         if (hwnd == null) {
5853                                 return;
5854                         }
5855
5856                         min.Width = Math.Max (min.Width, SystemInformation.MinimumWindowSize.Width);
5857                         min.Height = Math.Max (min.Height, SystemInformation.MinimumWindowSize.Height);
5858                         
5859                         hints = new XSizeHints();
5860
5861                         XGetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints, out dummy);
5862                         if ((min != Size.Empty) && (min.Width > 0) && (min.Height > 0)) {
5863                                 if (cp != null)
5864                                         min = TranslateWindowSizeToXWindowSize (cp, min);
5865                                 hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMinSize);
5866                                 hints.min_width = min.Width;
5867                                 hints.min_height = min.Height;
5868                         }
5869
5870                         if ((max != Size.Empty) && (max.Width > 0) && (max.Height > 0)) {
5871                                 if (cp != null)
5872                                         max = TranslateWindowSizeToXWindowSize (cp, max);
5873                                 hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMaxSize);
5874                                 hints.max_width = max.Width;
5875                                 hints.max_height = max.Height;
5876                         }
5877
5878                         if (hints.flags != IntPtr.Zero) {
5879                                 // The Metacity team has decided that they won't care about this when clicking the maximize icon, 
5880                                 // they will maximize the window to fill the screen/parent no matter what.
5881                                 // http://bugzilla.ximian.com/show_bug.cgi?id=80021
5882                                 XSetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints);
5883                         }
5884
5885                         if ((maximized != Rectangle.Empty) && (maximized.Width > 0) && (maximized.Height > 0)) {
5886                                 if (cp != null)
5887                                         maximized.Size = TranslateWindowSizeToXWindowSize (cp);
5888                                 hints.flags = (IntPtr)XSizeHintsFlags.PPosition;
5889                                 hints.x = maximized.X;
5890                                 hints.y = maximized.Y;
5891                                 hints.width = maximized.Width;
5892                                 hints.height = maximized.Height;
5893
5894                                 // Metacity does not seem to follow this constraint for maximized (zoomed) windows
5895                                 XSetZoomHints(DisplayHandle, hwnd.whole_window, ref hints);
5896                         }
5897                 }
5898
5899
5900                 internal override void SetWindowPos(IntPtr handle, int x, int y, int width, int height)
5901                 {
5902                         Hwnd            hwnd;
5903
5904                         hwnd = Hwnd.ObjectFromHandle(handle);
5905
5906                         if (hwnd == null) {
5907                                 return;
5908                         }
5909
5910                         // Win32 automatically changes negative width/height to 0.
5911                         if (width < 0)
5912                                 width = 0;
5913                         if (height < 0)
5914                                 height = 0;
5915                                 
5916                         // X requires a sanity check for width & height; otherwise it dies
5917                         if (hwnd.zero_sized && width > 0 && height > 0) {
5918                                 if (hwnd.visible) {
5919                                         MapWindow(hwnd, WindowType.Whole);
5920                                 }
5921                                 hwnd.zero_sized = false;
5922                         }
5923
5924                         if ((width < 1) || (height < 1)) {
5925                                 hwnd.zero_sized = true;
5926                                 UnmapWindow(hwnd, WindowType.Whole);
5927                         }
5928
5929                         // Save a server roundtrip (and prevent a feedback loop)
5930                         if ((hwnd.x == x) && (hwnd.y == y) && 
5931                                 (hwnd.width == width) && (hwnd.height == height)) {
5932                                 return;
5933                         }
5934
5935                         if (!hwnd.zero_sized) {
5936                                 //Hack?
5937                                 hwnd.x = x;
5938                                 hwnd.y = y;
5939                                 hwnd.width = width;
5940                                 hwnd.height = height;
5941                                 SendMessage(hwnd.client_window, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
5942
5943                                 if (hwnd.fixed_size) {
5944                                         SetWindowMinMax(handle, Rectangle.Empty, new Size(width, height), new Size(width, height));
5945                                 }
5946
5947                                 lock (XlibLock) {
5948                                         Control ctrl = Control.FromHandle (handle);
5949                                         Size TranslatedSize = TranslateWindowSizeToXWindowSize (ctrl.GetCreateParams (), new Size (width, height));
5950                                         MoveResizeWindow (DisplayHandle, hwnd.whole_window, x, y, TranslatedSize.Width, TranslatedSize.Height);
5951                                         PerformNCCalc(hwnd);
5952                                 }
5953                         }
5954
5955                         // Update our position/size immediately, so
5956                         // that future calls to SetWindowPos aren't
5957                         // kept from calling XMoveResizeWindow (by the
5958                         // "Save a server roundtrip" block above).
5959                         hwnd.x = x;
5960                         hwnd.y = y;
5961                         hwnd.width = width;
5962                         hwnd.height = height;
5963                         hwnd.ClientRect = Rectangle.Empty;
5964                 }
5965
5966                 internal override void SetWindowState(IntPtr handle, FormWindowState state)
5967                 {
5968                         FormWindowState current_state;
5969                         Hwnd            hwnd;
5970
5971                         hwnd = Hwnd.ObjectFromHandle(handle);
5972
5973                         current_state = GetWindowState(handle);
5974
5975                         if (current_state == state) {
5976                                 return;
5977                         }
5978
5979                         switch(state) {
5980                                 case FormWindowState.Normal: {
5981                                         lock (XlibLock) {
5982                                                 if (current_state == FormWindowState.Minimized) {
5983                                                         MapWindow(hwnd, WindowType.Both);
5984                                                 } else if (current_state == FormWindowState.Maximized) {
5985                                                         SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)2 /* toggle */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT);
5986                                                 }
5987                                         }
5988                                         Activate(handle);
5989                                         return;
5990                                 }
5991
5992                                 case FormWindowState.Minimized: {
5993                                         lock (XlibLock) {
5994                                                 if (current_state == FormWindowState.Maximized) {
5995                                                         SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)2 /* toggle */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT);
5996                                                 }
5997                                                 XIconifyWindow(DisplayHandle, hwnd.whole_window, ScreenNo);
5998                                         }
5999                                         return;
6000                                 }
6001
6002                                 case FormWindowState.Maximized: {
6003                                         lock (XlibLock) {
6004                                                 if (current_state == FormWindowState.Minimized) {
6005                                                         MapWindow(hwnd, WindowType.Both);
6006                                                 }
6007
6008                                                 SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)1 /* Add */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT);
6009                                         }
6010                                         Activate(handle);
6011                                         return;
6012                                 }
6013                         }
6014                 }
6015
6016                 internal override void SetWindowStyle(IntPtr handle, CreateParams cp)
6017                 {
6018                         Hwnd    hwnd;
6019
6020                         hwnd = Hwnd.ObjectFromHandle(handle);
6021                         SetHwndStyles(hwnd, cp);
6022                         SetWMStyles(hwnd, cp);
6023                 }
6024
6025                 internal override double GetWindowTransparency(IntPtr handle)
6026                 {
6027                         return 1.0;
6028                 }
6029
6030                 internal override void SetWindowTransparency(IntPtr handle, double transparency, Color key)
6031                 {
6032                         Hwnd    hwnd;
6033                         IntPtr  opacity;
6034
6035                         hwnd = Hwnd.ObjectFromHandle(handle);
6036
6037                         if (hwnd == null) {
6038                                 return;
6039                         }
6040
6041                         hwnd.opacity = (uint)(0xffffffff * transparency);
6042                         opacity = (IntPtr)((int)hwnd.opacity);
6043
6044                         IntPtr w = hwnd.whole_window;
6045                         if (hwnd.reparented)
6046                                 w = XGetParent (hwnd.whole_window);
6047                         XChangeProperty(DisplayHandle, w, _NET_WM_WINDOW_OPACITY, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, ref opacity, 1);
6048                 }
6049
6050                 internal override bool SetZOrder(IntPtr handle, IntPtr after_handle, bool top, bool bottom)
6051                 {
6052                         Hwnd    hwnd = Hwnd.ObjectFromHandle(handle);
6053
6054                         if (!hwnd.mapped) {
6055                                 return false;
6056                         }
6057
6058                         if (top) {
6059                                 lock (XlibLock) {
6060                                         XRaiseWindow(DisplayHandle, hwnd.whole_window);
6061                                 }
6062                                 return true;
6063                         } else if (!bottom) {
6064                                 Hwnd    after_hwnd = null;
6065
6066                                 if (after_handle != IntPtr.Zero) {
6067                                         after_hwnd = Hwnd.ObjectFromHandle(after_handle);
6068                                 }
6069
6070                                 XWindowChanges  values = new XWindowChanges();
6071
6072                                 if (after_hwnd == null) {
6073                                         // Work around metacity 'issues'
6074                                         int[]   atoms;
6075
6076                                         atoms = new int[2];
6077                                         atoms[0] = unixtime();
6078                                         XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_USER_TIME, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, atoms, 1);
6079
6080                                         XRaiseWindow(DisplayHandle, hwnd.whole_window);
6081                                         SendNetWMMessage(hwnd.whole_window, _NET_ACTIVE_WINDOW, (IntPtr)1, IntPtr.Zero, IntPtr.Zero);
6082                                         return true;
6083                                         //throw new ArgumentNullException("after_handle", "Need sibling to adjust z-order");
6084                                 }
6085
6086                                 values.sibling = after_hwnd.whole_window;
6087                                 values.stack_mode = StackMode.Below;
6088
6089                                 lock (XlibLock) {
6090                                         XConfigureWindow(DisplayHandle, hwnd.whole_window, ChangeWindowFlags.CWStackMode | ChangeWindowFlags.CWSibling, ref values);
6091                                 }
6092                         } else {
6093                                 // Bottom
6094                                 lock (XlibLock) {
6095                                         XLowerWindow(DisplayHandle, hwnd.whole_window);
6096                                 }
6097                                 return true;
6098                         }
6099                         return false;
6100                 }
6101
6102                 internal override void ShowCursor(bool show)
6103                 {
6104                         ;       // FIXME - X11 doesn't 'hide' the cursor. we could create an empty cursor
6105                 }
6106
6107                 internal override object StartLoop(Thread thread)
6108                 {
6109                         XEventQueue q = ThreadQueue(thread);
6110                         return q;
6111                 }
6112
6113                 internal override TransparencySupport SupportsTransparency()
6114                 {
6115                         // We need to check if the x compositing manager is running
6116                         return TransparencySupport.Set;
6117                 }
6118
6119                 internal override bool SystrayAdd(IntPtr handle, string tip, Icon icon, out ToolTip tt)
6120                 {
6121                         GetSystrayManagerWindow();
6122
6123                         if (SystrayMgrWindow != IntPtr.Zero) {
6124                                 XSizeHints      size_hints;
6125                                 Hwnd            hwnd;
6126
6127                                 hwnd = Hwnd.ObjectFromHandle(handle);
6128                                 DriverDebug("Adding Systray Whole:{0:X}, Client:{1:X}", hwnd.whole_window.ToInt32(), hwnd.client_window.ToInt32());
6129
6130                                 // Oh boy.
6131                                 if (hwnd.client_window != hwnd.whole_window) {
6132                                         Keyboard.DestroyICForWindow (hwnd.client_window);
6133                                         XDestroyWindow(DisplayHandle, hwnd.client_window);
6134                                         hwnd.client_window = hwnd.whole_window;
6135                                 }       
6136
6137                                 /* by virtue of the way the tests are ordered when determining if it's PAINT
6138                                    or NCPAINT, client_window == whole_window will always be PAINT.  So, if we're
6139                                    waiting on an nc_expose, drop it and remove the hwnd from the list (unless
6140                                    there's a pending expose). */
6141                                 if (hwnd.nc_expose_pending) {
6142                                         hwnd.nc_expose_pending = false;
6143                                         if (!hwnd.expose_pending)
6144                                                 hwnd.Queue.Paint.Remove (hwnd);
6145                                 }
6146
6147                                 // We are going to be directly mapped by the system tray, so mark as mapped
6148                                 // so we can later properly unmap it.
6149                                 hwnd.mapped = true;
6150
6151                                 size_hints = new XSizeHints();
6152
6153                                 size_hints.flags = (IntPtr)(XSizeHintsFlags.PMinSize | XSizeHintsFlags.PMaxSize | XSizeHintsFlags.PBaseSize);
6154
6155                                 size_hints.min_width = 24;
6156                                 size_hints.min_height = 24;
6157                                 size_hints.max_width = 24;
6158                                 size_hints.max_height = 24;
6159                                 size_hints.base_width = 24;
6160                                 size_hints.base_height = 24;
6161
6162                                 XSetWMNormalHints(DisplayHandle, hwnd.whole_window, ref size_hints);
6163
6164                                 int[] atoms = new int[2];
6165                                 atoms [0] = 1;                  // Version 1
6166                                 atoms [1] = 1;                  // we want to be mapped
6167
6168                                 // This line cost me 3 days...
6169                                 XChangeProperty(DisplayHandle, hwnd.whole_window, _XEMBED_INFO, _XEMBED_INFO, 32, PropertyMode.Replace, atoms, 2);
6170
6171                                 // Need to pick some reasonable defaults
6172                                 tt = new ToolTip();
6173                                 tt.AutomaticDelay = 350;
6174                                 tt.InitialDelay = 250;
6175                                 tt.ReshowDelay = 250;
6176                                 tt.ShowAlways = true;
6177
6178                                 if ((tip != null) && (tip != string.Empty)) {
6179                                         tt.SetToolTip(Control.FromHandle(handle), tip);
6180                                         tt.Active = true;
6181                                 } else {
6182                                         tt.Active = false;
6183                                 }
6184
6185                                 SendNetClientMessage(SystrayMgrWindow, _NET_SYSTEM_TRAY_OPCODE, IntPtr.Zero, (IntPtr)SystrayRequest.SYSTEM_TRAY_REQUEST_DOCK, hwnd.whole_window);
6186
6187                                 return true;
6188                         }
6189                         tt = null;
6190                         return false;
6191                 }
6192
6193                 internal override bool SystrayChange(IntPtr handle, string tip, Icon icon, ref ToolTip tt)
6194                 {
6195                         Control control;
6196
6197                         control = Control.FromHandle(handle);
6198                         if (control != null && tt != null) {
6199                                 tt.SetToolTip(control, tip);
6200                                 tt.Active = true;
6201                                 SendMessage(handle, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero);
6202                                 return true;
6203                         } else {
6204                                 return false;
6205                         }
6206                 }
6207
6208                 internal override void SystrayRemove(IntPtr handle, ref ToolTip tt)
6209                 {
6210
6211                         SetVisible (handle, false, false);
6212
6213                         // The caller can now re-dock it later...
6214                         if (tt != null) {
6215                                 tt.Dispose();
6216                                 tt = null;
6217                         }
6218                         // Close any balloon window *we* fired.
6219                         ThemeEngine.Current.HideBalloonWindow (handle);
6220                 }
6221
6222                 internal override void SystrayBalloon(IntPtr handle, int timeout, string title, string text, ToolTipIcon icon)
6223                 {
6224                         ThemeEngine.Current.ShowBalloonWindow (handle, timeout, title, text, icon);
6225                         SendMessage(handle, Msg.WM_USER, IntPtr.Zero, (IntPtr) Msg.NIN_BALLOONSHOW);    
6226                 }
6227
6228                 internal override bool Text(IntPtr handle, string text)
6229 {
6230                         Hwnd    hwnd;
6231
6232                         hwnd = Hwnd.ObjectFromHandle(handle);
6233
6234                         lock (XlibLock) {
6235                                 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_NAME, UTF8_STRING, 8,
6236                                                 PropertyMode.Replace, text, Encoding.UTF8.GetByteCount (text));
6237
6238                                 // XXX this has problems with UTF8.
6239                                 // we need to either use the actual
6240                                 // text if it's latin-1, or convert it
6241                                 // to compound text if it's in a
6242                                 // different charset.
6243                                 XStoreName(DisplayHandle, Hwnd.ObjectFromHandle(handle).whole_window, text);
6244                         }
6245                         return true;
6246                 }
6247
6248                 internal override bool TranslateMessage(ref MSG msg)
6249                 {
6250                         return Keyboard.TranslateMessage (ref msg);
6251                 }
6252
6253                 internal override void UpdateWindow(IntPtr handle)
6254                 {
6255                         Hwnd    hwnd;
6256
6257                         hwnd = Hwnd.ObjectFromHandle(handle);
6258
6259                         if (!hwnd.visible || !hwnd.expose_pending || !hwnd.Mapped) {
6260                                 return;
6261                         }
6262
6263                         SendMessage(handle, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero);
6264                         hwnd.Queue.Paint.Remove(hwnd);
6265                 }
6266
6267                 internal override void CreateOffscreenDrawable (IntPtr handle,
6268                                                                 int width, int height,
6269                                                                 out object offscreen_drawable)
6270                 {
6271                         IntPtr root_out;
6272                         int x_out, y_out, width_out, height_out, border_width_out, depth_out;
6273
6274                         XGetGeometry (DisplayHandle, handle,
6275                                       out root_out,
6276                                       out x_out, out y_out,
6277                                       out width_out, out height_out,
6278                                       out border_width_out, out depth_out);
6279
6280                         IntPtr pixmap = XCreatePixmap (DisplayHandle, handle, width, height, depth_out);
6281
6282                         offscreen_drawable = pixmap;
6283
6284                 }
6285
6286                 internal override void DestroyOffscreenDrawable (object offscreen_drawable)
6287                 {
6288                         XFreePixmap (DisplayHandle, (IntPtr)offscreen_drawable);
6289                 }
6290
6291                 internal override Graphics GetOffscreenGraphics (object offscreen_drawable)
6292                 {
6293                         return Graphics.FromHwnd ((IntPtr) offscreen_drawable);
6294                 }
6295                 
6296                 internal override void BlitFromOffscreen (IntPtr dest_handle,
6297                                                           Graphics dest_dc,
6298                                                           object offscreen_drawable,
6299                                                           Graphics offscreen_dc,
6300                                                           Rectangle r)
6301                 {
6302                         XGCValues gc_values;
6303                         IntPtr gc;
6304
6305                         gc_values = new XGCValues();
6306
6307                         gc = XCreateGC (DisplayHandle, dest_handle, IntPtr.Zero, ref gc_values);
6308
6309                         XCopyArea (DisplayHandle, (IntPtr)offscreen_drawable, dest_handle,
6310                                    gc, r.X, r.Y, r.Width, r.Height, r.X, r.Y);
6311
6312                         XFreeGC (DisplayHandle, gc);
6313                 }
6314
6315                 #endregion      // Public Static Methods
6316
6317                 #region Events
6318                 internal override event EventHandler Idle;
6319                 #endregion      // Events
6320
6321                 
6322 #if TRACE
6323                 
6324 #region Xcursor imports
6325                 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadCursor")]
6326                 internal extern static IntPtr XcursorLibraryLoadCursor (IntPtr display, [MarshalAs (UnmanagedType.LPStr)] string name);
6327
6328                 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadImages")]
6329                 internal extern static IntPtr XcursorLibraryLoadImages ([MarshalAs (UnmanagedType.LPStr)] string file, IntPtr theme, int size);
6330                 
6331                 [DllImport ("libXcursor", EntryPoint = "XcursorImagesDestroy")]
6332                 internal extern static void XcursorImagesDestroy (IntPtr images);
6333                 
6334                 [DllImport ("libXcursor", EntryPoint = "XcursorGetDefaultSize")]
6335                 internal extern static int XcursorGetDefaultSize (IntPtr display);
6336
6337                 [DllImport ("libXcursor", EntryPoint = "XcursorImageLoadCursor")]
6338                 internal extern static IntPtr XcursorImageLoadCursor (IntPtr display, IntPtr image);
6339
6340                 [DllImport ("libXcursor", EntryPoint = "XcursorGetTheme")]
6341                 internal extern static IntPtr XcursorGetTheme (IntPtr display);
6342 #endregion
6343 #region X11 Imports
6344                 [DllImport ("libX11", EntryPoint="XOpenDisplay")]
6345                 internal extern static IntPtr XOpenDisplay(IntPtr display);
6346                 [DllImport ("libX11", EntryPoint="XCloseDisplay")]
6347                 internal extern static int XCloseDisplay(IntPtr display);                                                   
6348                 [DllImport ("libX11", EntryPoint="XSynchronize")]
6349                 internal extern static IntPtr XSynchronize(IntPtr display, bool onoff);
6350
6351                 [DllImport ("libX11", EntryPoint="XCreateWindow")]
6352                 internal extern static IntPtr _XCreateWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, UIntPtr valuemask, ref XSetWindowAttributes attributes);
6353                 internal static IntPtr XCreateWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, UIntPtr valuemask, ref XSetWindowAttributes attributes)
6354                 {
6355                         DebugHelper.TraceWriteLine ("XCreateWindow");
6356                         return _XCreateWindow(display, parent, x, y, width, height, 
6357                                        border_width, depth, xclass, visual, valuemask, ref attributes);
6358                 }
6359                 [DllImport ("libX11", EntryPoint="XCreateSimpleWindow")]
6360                 internal extern static IntPtr _XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background);
6361                 internal static IntPtr XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background)
6362                 {
6363                         DebugHelper.TraceWriteLine ("XCreateSimpleWindow");
6364                         return _XCreateSimpleWindow(display, parent, x, y, width, height, border_width, border, background);
6365                 }
6366                 [DllImport ("libX11", EntryPoint="XMapWindow")]
6367                 internal extern static int _XMapWindow(IntPtr display, IntPtr window);
6368                 internal static int XMapWindow(IntPtr display, IntPtr window)
6369                 {
6370                         DebugHelper.TraceWriteLine ("XMapWindow");
6371                         return _XMapWindow(display, window);
6372                 }
6373                 [DllImport ("libX11", EntryPoint="XUnmapWindow")]
6374                 internal extern static int _XUnmapWindow(IntPtr display, IntPtr window);
6375                 internal static int XUnmapWindow(IntPtr display, IntPtr window)
6376                 {
6377                         DebugHelper.TraceWriteLine ("XUnmapWindow");
6378                         return _XUnmapWindow(display, window);
6379                 }
6380                 [DllImport ("libX11", EntryPoint="XMapSubwindows")]
6381                 internal extern static int _XMapSubindows(IntPtr display, IntPtr window);
6382                 internal static int XMapSubindows(IntPtr display, IntPtr window)
6383                 {
6384                         DebugHelper.TraceWriteLine ("XMapSubindows");
6385                         return _XMapSubindows(display, window);
6386                 }
6387                 [DllImport ("libX11", EntryPoint="XUnmapSubwindows")]
6388                 internal extern static int _XUnmapSubwindows(IntPtr display, IntPtr window);
6389                 internal static int XUnmapSubwindows(IntPtr display, IntPtr window)
6390                 {
6391                         DebugHelper.TraceWriteLine ("XUnmapSubwindows");
6392                         return _XUnmapSubwindows(display, window);
6393                 }
6394                 [DllImport ("libX11", EntryPoint="XRootWindow")]
6395                 internal extern static IntPtr _XRootWindow(IntPtr display, int screen_number);
6396                 internal static IntPtr XRootWindow(IntPtr display, int screen_number)
6397                 {
6398                         DebugHelper.TraceWriteLine ("XRootWindow");
6399                         return _XRootWindow(display, screen_number);
6400                 }
6401                 [DllImport ("libX11", EntryPoint="XNextEvent")]
6402                 internal extern static IntPtr _XNextEvent(IntPtr display, ref XEvent xevent);
6403                 internal static IntPtr XNextEvent(IntPtr display, ref XEvent xevent)
6404                 {
6405                         DebugHelper.TraceWriteLine ("XNextEvent");
6406                         return _XNextEvent(display, ref xevent);
6407                 }
6408                 [DllImport ("libX11", EntryPoint="XConnectionNumber")]
6409                 internal extern static int _XConnectionNumber (IntPtr display);
6410                 internal static int XConnectionNumber (IntPtr display)
6411                 {
6412                         DebugHelper.TraceWriteLine ("XConnectionNumber");
6413                         return _XConnectionNumber (display);
6414                 }
6415                 [DllImport ("libX11", EntryPoint="XPending")]
6416                 internal extern static int _XPending (IntPtr display);
6417                 internal static int XPending (IntPtr display)
6418                 {
6419                         DebugHelper.TraceWriteLine ("XPending");
6420                         DebugHelper.DumpCallers (3);
6421                         return _XPending (display);
6422                 }
6423                 [DllImport ("libX11", EntryPoint="XSelectInput")]
6424                 internal extern static IntPtr _XSelectInput(IntPtr display, IntPtr window, IntPtr mask);
6425                 internal static IntPtr XSelectInput(IntPtr display, IntPtr window, IntPtr mask)
6426                 {
6427                         DebugHelper.TraceWriteLine ("XSelectInput");
6428                         return _XSelectInput(display, window, mask);
6429                 }
6430
6431                 [DllImport ("libX11", EntryPoint="XDestroyWindow")]
6432                 internal extern static int _XDestroyWindow(IntPtr display, IntPtr window);
6433                 internal static int XDestroyWindow(IntPtr display, IntPtr window)
6434                 {
6435                         DebugHelper.TraceWriteLine ("XDestroyWindow 0x{0:x}", window.ToInt32());
6436                         return _XDestroyWindow(display, window);
6437                 }
6438
6439                 [DllImport ("libX11", EntryPoint="XReparentWindow")]
6440                 internal extern static int _XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y);
6441                 internal static int XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y)
6442                 {
6443                         DebugHelper.TraceWriteLine ("XReparentWindow");
6444                         return _XReparentWindow(display, window, parent, x, y);
6445                 }
6446                 
6447                 [DllImport ("libX11", EntryPoint="XMoveResizeWindow")]
6448                 extern static int _XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height);
6449                 static int XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height) {
6450                         DebugHelper.TraceWriteLine ("XMoveResizeWindow");
6451                         return _XMoveResizeWindow(display, window, x, y, width, height);
6452                 }
6453
6454                 internal static int MoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height)
6455                 {
6456                         int ret = XMoveResizeWindow (display, window, x, y, width, height);
6457                         Keyboard.MoveCurrentCaretPos ();
6458                         return ret;
6459                 }
6460
6461                 [DllImport ("libX11", EntryPoint="XResizeWindow")]
6462                 internal extern static int _XResizeWindow(IntPtr display, IntPtr window, int width, int height);
6463                 internal static int XResizeWindow(IntPtr display, IntPtr window, int width, int height)
6464                 {
6465                         DebugHelper.TraceWriteLine ("XResizeWindow");
6466                         return _XResizeWindow(display, window, width, height);
6467                 }
6468
6469                 [DllImport ("libX11", EntryPoint="XGetWindowAttributes")]
6470                 internal extern static int _XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes);
6471                 internal static int XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes)
6472                 {
6473                         DebugHelper.TraceWriteLine ("XGetWindowAttributes");
6474                         return _XGetWindowAttributes(display, window, ref attributes);
6475                 }
6476
6477                 [DllImport ("libX11", EntryPoint="XFlush")]
6478                 internal extern static int _XFlush(IntPtr display);
6479                 internal static int XFlush(IntPtr display)
6480                 {
6481                         DebugHelper.TraceWriteLine ("XFlush");
6482                         return _XFlush(display);
6483                 }
6484
6485                 [DllImport ("libX11", EntryPoint="XSetWMName")]
6486                 internal extern static int _XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop);
6487                 internal static int XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop)
6488                 {
6489                         DebugHelper.TraceWriteLine ("XSetWMName");
6490                         return _XSetWMName(display, window, ref text_prop);
6491                 }
6492
6493                 [DllImport ("libX11", EntryPoint="XStoreName")]
6494                 internal extern static int _XStoreName(IntPtr display, IntPtr window, string window_name);
6495                 internal static int XStoreName(IntPtr display, IntPtr window, string window_name)
6496                 {
6497                         DebugHelper.TraceWriteLine ("XStoreName");
6498                         return _XStoreName(display, window, window_name);
6499                 }
6500
6501                 [DllImport ("libX11", EntryPoint="XFetchName")]
6502                 internal extern static int _XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name);
6503                 internal static int XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name)
6504                 {
6505                         DebugHelper.TraceWriteLine ("XFetchName");
6506                         return _XFetchName(display, window, ref window_name);
6507                 }
6508
6509                 [DllImport ("libX11", EntryPoint="XSendEvent")]
6510                 internal extern static int _XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event);
6511                 internal static int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event)
6512                 {
6513                         DebugHelper.TraceWriteLine ("XSendEvent");
6514                         return _XSendEvent(display, window, propagate, event_mask, ref send_event);
6515                 }
6516
6517                 [DllImport ("libX11", EntryPoint="XQueryTree")]
6518                 internal extern static int _XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return);
6519                 internal static int XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return)
6520                 {
6521                         DebugHelper.TraceWriteLine ("XQueryTree");
6522                         return _XQueryTree(display, window, out root_return, out parent_return, out children_return, out nchildren_return);
6523                 }
6524
6525                 [DllImport ("libX11", EntryPoint="XFree")]
6526                 internal extern static int _XFree(IntPtr data);
6527                 internal static int XFree(IntPtr data)
6528                 {
6529                         DebugHelper.TraceWriteLine ("XFree");
6530                         return _XFree(data);
6531                 }
6532
6533                 [DllImport ("libX11", EntryPoint="XRaiseWindow")]
6534                 internal extern static int _XRaiseWindow(IntPtr display, IntPtr window);
6535                 internal static int XRaiseWindow(IntPtr display, IntPtr window)
6536                 {
6537                         DebugHelper.TraceWriteLine ("XRaiseWindow");
6538                         return _XRaiseWindow(display, window);
6539                 }
6540
6541                 [DllImport ("libX11", EntryPoint="XLowerWindow")]
6542                 internal extern static uint _XLowerWindow(IntPtr display, IntPtr window);
6543                 internal static uint XLowerWindow(IntPtr display, IntPtr window)
6544                 {
6545                         DebugHelper.TraceWriteLine ("XLowerWindow");
6546                         return _XLowerWindow(display, window);
6547                 }
6548
6549                 [DllImport ("libX11", EntryPoint="XConfigureWindow")]
6550                 internal extern static uint _XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values);
6551                 internal static uint XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values)
6552                 {
6553                         DebugHelper.TraceWriteLine ("XConfigureWindow");
6554                         return _XConfigureWindow(display, window, value_mask, ref values);
6555                 }
6556
6557                 [DllImport ("libX11", EntryPoint="XInternAtom")]
6558                 internal extern static IntPtr _XInternAtom(IntPtr display, string atom_name, bool only_if_exists);
6559                 internal static IntPtr XInternAtom(IntPtr display, string atom_name, bool only_if_exists)
6560                 {
6561                         DebugHelper.TraceWriteLine ("XInternAtom");
6562                         return _XInternAtom(display, atom_name, only_if_exists);
6563                 }
6564
6565                 [DllImport ("libX11", EntryPoint="XInternAtoms")]
6566                 internal extern static int _XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms);
6567                 internal static int XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms)
6568                 {
6569                         DebugHelper.TraceWriteLine ("XInternAtoms");
6570                         return _XInternAtoms(display, atom_names, atom_count, only_if_exists, atoms);
6571                 }
6572
6573                 [DllImport ("libX11", EntryPoint="XSetWMProtocols")]
6574                 internal extern static int _XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count);
6575                 internal static int XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count)
6576                 {
6577                         DebugHelper.TraceWriteLine ("XSetWMProtocols");
6578                         return _XSetWMProtocols(display, window, protocols, count);
6579                 }
6580
6581                 [DllImport ("libX11", EntryPoint="XGrabPointer")]
6582                 internal extern static int _XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp);
6583                 internal static int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp)
6584                 {
6585                         DebugHelper.TraceWriteLine ("XGrabPointer");
6586                         return _XGrabPointer(display, window, owner_events, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, timestamp);
6587                 }
6588
6589                 [DllImport ("libX11", EntryPoint="XUngrabPointer")]
6590                 internal extern static int _XUngrabPointer(IntPtr display, IntPtr timestamp);
6591                 internal static int XUngrabPointer(IntPtr display, IntPtr timestamp)
6592                 {
6593                         DebugHelper.TraceWriteLine ("XUngrabPointer");
6594                         return _XUngrabPointer(display, timestamp);
6595                 }
6596
6597                 [DllImport ("libX11", EntryPoint="XQueryPointer")]
6598                 internal extern static bool _XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons);
6599                 internal static bool XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons)
6600                 {
6601                         DebugHelper.TraceWriteLine ("XQueryPointer");
6602                         return _XQueryPointer(display, window, out root, out child, out root_x, out root_y, out win_x, out win_y, out keys_buttons);
6603                 }
6604
6605                 [DllImport ("libX11", EntryPoint="XTranslateCoordinates")]
6606                 internal extern static bool _XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return);
6607                 internal static bool XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return,         out int dest_y_return, out IntPtr child_return)
6608                 {
6609                         DebugHelper.TraceWriteLine ("XTranslateCoordinates");
6610                         return _XTranslateCoordinates (display, src_w, dest_w, src_x, src_y, out intdest_x_return, out dest_y_return, out child_return);
6611                 }
6612
6613                 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6614                 internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth);
6615                 internal static bool XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth)
6616                 {
6617                         DebugHelper.TraceWriteLine ("XGetGeometry");
6618                         return _XGetGeometry(display, window, out root, out x, out y, out width, out height, out border_width, out depth);
6619                 }
6620
6621                 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6622                 internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, out int width, out int height, IntPtr border_width, IntPtr depth);
6623                 internal static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, out int width, out int height, IntPtr border_width, IntPtr depth)
6624                 {
6625                         DebugHelper.TraceWriteLine ("XGetGeometry");
6626                         return _XGetGeometry(display, window, root, out x, out y, out width, out height, border_width, depth);
6627                 }
6628
6629                 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6630                 internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, IntPtr width, IntPtr height, IntPtr border_width, IntPtr depth);
6631                 internal static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, IntPtr width, IntPtr height, IntPtr border_width, IntPtr depth)
6632                 {
6633                         DebugHelper.TraceWriteLine ("XGetGeometry");
6634                         return _XGetGeometry(display, window, root, out x, out y, width, height, border_width, depth);
6635                 }
6636
6637                 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6638                 internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, IntPtr root, IntPtr x, IntPtr y, out int width, out int height, IntPtr border_width, IntPtr depth);
6639                 internal static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, IntPtr x, IntPtr y, out int width, out int height, IntPtr border_width, IntPtr depth)
6640                 {
6641                         DebugHelper.TraceWriteLine ("XGetGeometry");
6642                         return _XGetGeometry(display, window, root, x, y, out width, out height, border_width, depth);
6643                 }
6644
6645                 [DllImport ("libX11", EntryPoint="XWarpPointer")]
6646                 internal extern static uint _XWarpPointer(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y);
6647                 internal static uint XWarpPointer(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y)
6648                 {
6649                         DebugHelper.TraceWriteLine ("XWarpPointer");
6650                         return _XWarpPointer(display, src_w, dest_w, src_x, src_y, src_width, src_height, dest_x, dest_y);
6651                 }
6652
6653                 [DllImport ("libX11", EntryPoint="XClearWindow")]
6654                 internal extern static int _XClearWindow(IntPtr display, IntPtr window);
6655                 internal static int XClearWindow(IntPtr display, IntPtr window)
6656                 {
6657                         DebugHelper.TraceWriteLine ("XClearWindow");
6658                         return _XClearWindow(display, window);
6659                 }
6660
6661                 [DllImport ("libX11", EntryPoint="XClearArea")]
6662                 internal extern static int _XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures);
6663                 internal static int XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures)
6664                 {
6665                         DebugHelper.TraceWriteLine ("XClearArea");
6666                         return _XClearArea(display, window, x, y, width, height, exposures);
6667                 }
6668
6669                 // Colormaps
6670                 [DllImport ("libX11", EntryPoint="XDefaultScreenOfDisplay")]
6671                 internal extern static IntPtr _XDefaultScreenOfDisplay(IntPtr display);
6672                 internal static IntPtr XDefaultScreenOfDisplay(IntPtr display)
6673                 {
6674                         DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay");
6675                         return _XDefaultScreenOfDisplay(display);
6676                 }
6677
6678                 [DllImport ("libX11", EntryPoint="XScreenNumberOfScreen")]
6679                 internal extern static int _XScreenNumberOfScreen(IntPtr display, IntPtr Screen);
6680                 internal static int XDefaultScreenOfDisplay(IntPtr display, IntPtr Screen)
6681                 {
6682                         DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay");
6683                         return _XScreenNumberOfScreen(display, Screen);
6684                 }
6685
6686                 [DllImport ("libX11", EntryPoint="XDefaultVisual")]
6687                 internal extern static IntPtr _XDefaultVisual(IntPtr display, int screen_number);
6688                 internal static IntPtr XDefaultScreenOfDisplay(IntPtr display, int screen_number)
6689                 {
6690                         DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay");
6691                         return _XDefaultVisual(display, screen_number);
6692                 }
6693
6694                 [DllImport ("libX11", EntryPoint="XDefaultDepth")]
6695                 internal extern static uint _XDefaultDepth(IntPtr display, int screen_number);
6696                 internal static uint XDefaultDepth(IntPtr display, int screen_number)
6697                 {
6698                         DebugHelper.TraceWriteLine ("XDefaultDepth");
6699                         return _XDefaultDepth(display, screen_number);
6700                 }
6701
6702                 [DllImport ("libX11", EntryPoint="XDefaultScreen")]
6703                 internal extern static int _XDefaultScreen(IntPtr display);
6704                 internal static int XDefaultScreen(IntPtr display)
6705                 {
6706                         DebugHelper.TraceWriteLine ("XDefaultScreen");
6707                         return _XDefaultScreen(display);
6708                 }
6709
6710                 [DllImport ("libX11", EntryPoint="XDefaultColormap")]
6711                 internal extern static IntPtr _XDefaultColormap(IntPtr display, int screen_number);
6712                 internal static IntPtr XDefaultColormap(IntPtr display, int screen_number)
6713                 {
6714                         DebugHelper.TraceWriteLine ("XDefaultColormap");
6715                         return _XDefaultColormap(display, screen_number);
6716                 }
6717
6718                 [DllImport ("libX11", EntryPoint="XLookupColor")]
6719                 internal extern static int _XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color);
6720                 internal static int XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color)
6721                 {
6722                         DebugHelper.TraceWriteLine ("XLookupColor");
6723                         return _XLookupColor(display, Colormap, Coloranem, ref exact_def_color, ref screen_def_color);
6724                 }
6725
6726                 [DllImport ("libX11", EntryPoint="XAllocColor")]
6727                 internal extern static int _XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def);
6728                 internal static int XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def)
6729                 {
6730                         DebugHelper.TraceWriteLine ("XAllocColor");
6731                         return _XAllocColor(display, Colormap, ref colorcell_def);
6732                 }
6733
6734                 [DllImport ("libX11", EntryPoint="XSetTransientForHint")]
6735                 internal extern static int _XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window);
6736                 internal static int XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window)
6737                 {
6738                         DebugHelper.TraceWriteLine ("XSetTransientForHint");
6739                         return _XSetTransientForHint(display, window, prop_window);
6740                 }
6741
6742                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6743                 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements);
6744                 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements)
6745                 {
6746                         DebugHelper.TraceWriteLine ("XChangeProperty");
6747                         return _XChangeProperty(display, window, property, type, format, mode, ref data, nelements);
6748                 }
6749
6750                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6751                 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements);
6752                 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements)
6753                 {
6754                         DebugHelper.TraceWriteLine ("XChangeProperty");
6755                         return _XChangeProperty(display, window, property, type, format, mode, ref value, nelements);
6756                 }
6757
6758                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6759                 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements);
6760                 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements)
6761                 {
6762                         DebugHelper.TraceWriteLine ("XChangeProperty");
6763                         return _XChangeProperty(display, window, property, type, format, mode, ref value, nelements);
6764                 }
6765
6766                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6767                 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements);
6768                 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements)
6769                 {
6770                         DebugHelper.TraceWriteLine ("XChangeProperty");
6771                         return _XChangeProperty(display, window, property, type, format, mode, data, nelements);
6772                 }
6773
6774                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6775                 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements);
6776                 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements)
6777                 {
6778                         DebugHelper.TraceWriteLine ("XChangeProperty");
6779                         return _XChangeProperty(display, window, property, type, format, mode, data, nelements);
6780                 }
6781
6782                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6783                 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements);
6784                 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements)
6785                 {
6786                         DebugHelper.TraceWriteLine ("XChangeProperty");
6787                         return _XChangeProperty(display, window, property, type, format, mode, data, nelements);
6788                 }
6789
6790                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6791                 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements);
6792                 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements)
6793                 {
6794                         DebugHelper.TraceWriteLine ("XChangeProperty");
6795                         return _XChangeProperty(display, window, property, type, format, mode, atoms, nelements);
6796                 }
6797
6798                 [DllImport ("libX11", EntryPoint="XChangeProperty", CharSet=CharSet.Ansi)]
6799                 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length);
6800                 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length)
6801                 {
6802                         DebugHelper.TraceWriteLine ("XChangeProperty");
6803                         return _XChangeProperty(display, window, property, type, format, mode, text, text_length);
6804                 }
6805
6806                 [DllImport ("libX11", EntryPoint="XDeleteProperty")]
6807                 internal extern static int _XDeleteProperty(IntPtr display, IntPtr window, IntPtr property);
6808                 internal static int XDeleteProperty(IntPtr display, IntPtr window, IntPtr property)
6809                 {
6810                         DebugHelper.TraceWriteLine ("XDeleteProperty");
6811                         return _XDeleteProperty(display, window, property);
6812                 }
6813
6814                 // Drawing
6815                 [DllImport ("libX11", EntryPoint="XCreateGC")]
6816                 internal extern static IntPtr _XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values);
6817                 internal static IntPtr XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values)
6818                 {
6819                         DebugHelper.TraceWriteLine ("XCreateGC");
6820                         return _XCreateGC(display, window, valuemask, ref values);
6821                 }
6822
6823                 [DllImport ("libX11", EntryPoint="XFreeGC")]
6824                 internal extern static int _XFreeGC(IntPtr display, IntPtr gc);
6825                 internal static int XFreeGC(IntPtr display, IntPtr gc)
6826                 {
6827                         DebugHelper.TraceWriteLine ("XFreeGC");
6828                         return _XFreeGC(display, gc);
6829                 }
6830
6831                 [DllImport ("libX11", EntryPoint="XSetFunction")]
6832                 internal extern static int _XSetFunction(IntPtr display, IntPtr gc, GXFunction function);
6833                 internal static int XSetFunction(IntPtr display, IntPtr gc, GXFunction function)
6834                 {
6835                         DebugHelper.TraceWriteLine ("XSetFunction");
6836                         return _XSetFunction(display, gc, function);
6837                 }
6838
6839                 [DllImport ("libX11", EntryPoint="XSetLineAttributes")]
6840                 internal extern static int _XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style);
6841                 internal static int XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style)
6842                 {
6843                         DebugHelper.TraceWriteLine ("XSetLineAttributes");
6844                         return _XSetLineAttributes(display, gc, line_width, line_style, cap_style, join_style);
6845                 }
6846
6847                 [DllImport ("libX11", EntryPoint="XDrawLine")]
6848                 internal extern static int _XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2);
6849                 internal static int XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2)
6850                 {
6851                         DebugHelper.TraceWriteLine ("XDrawLine");
6852                         return _XDrawLine(display, drawable, gc, x1, y1, x2, y2);
6853                 }
6854
6855                 [DllImport ("libX11", EntryPoint="XDrawRectangle")]
6856                 internal extern static int _XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
6857                 internal static int XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height)
6858                 {
6859                         DebugHelper.TraceWriteLine ("XDrawRectangle");
6860                         return _XDrawRectangle(display, drawable, gc, x1, y1, width, height);
6861                 }
6862
6863                 [DllImport ("libX11", EntryPoint="XFillRectangle")]
6864                 internal extern static int _XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
6865                 internal static int XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height)
6866                 {
6867                         DebugHelper.TraceWriteLine ("XFillRectangle");
6868                         return _XFillRectangle(display, drawable, gc, x1, y1, width, height);
6869                 }
6870
6871                 [DllImport ("libX11", EntryPoint="XSetWindowBackground")]
6872                 internal extern static int _XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background);
6873                 internal static int XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background)
6874                 {
6875                         DebugHelper.TraceWriteLine ("XSetWindowBackground");
6876                         return _XSetWindowBackground(display, window, background);
6877                 }
6878
6879                 [DllImport ("libX11", EntryPoint="XCopyArea")]
6880                 internal extern static int _XCopyArea(IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y);
6881                 internal static int XCopyArea(IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y)
6882                 {
6883                         DebugHelper.TraceWriteLine ("XCopyArea");
6884                         return _XCopyArea(display, src, dest, gc, src_x, src_y, width, height, dest_x, dest_y);
6885                 }
6886
6887                 [DllImport ("libX11", EntryPoint="XGetWindowProperty")]
6888                 internal extern static int _XGetWindowProperty(IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, out int actual_format, out IntPtr nitems, out IntPtr bytes_after, ref IntPtr prop);
6889                 internal static int XGetWindowProperty(IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, out int actual_format, out IntPtr nitems, out IntPtr bytes_after, ref IntPtr prop)
6890                 {
6891                         DebugHelper.TraceWriteLine ("XGetWindowProperty");
6892                         return _XGetWindowProperty(display, window, atom, long_offset, long_length, delete, req_type, out actual_type, out actual_format, out nitems, out bytes_after, ref prop);
6893                 }
6894
6895                 [DllImport ("libX11", EntryPoint="XSetInputFocus")]
6896                 internal extern static int _XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time);
6897                 internal static int XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time)
6898                 {
6899                         DebugHelper.TraceWriteLine ("XSetInputFocus");
6900                         return _XSetInputFocus(display, window, revert_to, time);
6901                 }
6902
6903                 [DllImport ("libX11", EntryPoint="XIconifyWindow")]
6904                 internal extern static int _XIconifyWindow(IntPtr display, IntPtr window, int screen_number);
6905                 internal static int XIconifyWindow(IntPtr display, IntPtr window, int screen_number)
6906                 {
6907                         DebugHelper.TraceWriteLine ("XIconifyWindow");
6908                         return _XIconifyWindow(display, window, screen_number);
6909                 }
6910
6911                 [DllImport ("libX11", EntryPoint="XDefineCursor")]
6912                 internal extern static int _XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor);
6913                 internal static int XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor)
6914                 {
6915                         DebugHelper.TraceWriteLine ("XDefineCursor");
6916                         return _XDefineCursor(display, window, cursor);
6917                 }
6918
6919                 [DllImport ("libX11", EntryPoint="XUndefineCursor")]
6920                 internal extern static int _XUndefineCursor(IntPtr display, IntPtr window);
6921                 internal static int XUndefineCursor(IntPtr display, IntPtr window)
6922                 {
6923                         DebugHelper.TraceWriteLine ("XUndefineCursor");
6924                         return _XUndefineCursor(display, window);
6925                 }
6926
6927                 [DllImport ("libX11", EntryPoint="XFreeCursor")]
6928                 internal extern static int _XFreeCursor(IntPtr display, IntPtr cursor);
6929                 internal static int XFreeCursor(IntPtr display, IntPtr cursor)
6930                 {
6931                         DebugHelper.TraceWriteLine ("XFreeCursor");
6932                         return _XFreeCursor(display, cursor);
6933                 }
6934
6935                 [DllImport ("libX11", EntryPoint="XCreateFontCursor")]
6936                 internal extern static IntPtr _XCreateFontCursor(IntPtr display, CursorFontShape shape);
6937                 internal static IntPtr XCreateFontCursor(IntPtr display, CursorFontShape shape)
6938                 {
6939                         DebugHelper.TraceWriteLine ("XCreateFontCursor");
6940                         return _XCreateFontCursor(display, shape);
6941                 }
6942
6943                 [DllImport ("libX11", EntryPoint="XCreatePixmapCursor")]
6944                 internal extern static IntPtr _XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot);
6945                 internal static IntPtr XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot)
6946                 {
6947                         DebugHelper.TraceWriteLine ("XCreatePixmapCursor");
6948                         return _XCreatePixmapCursor(display, source, mask, ref foreground_color, ref background_color, x_hot, y_hot);
6949                 }
6950
6951                 [DllImport ("libX11", EntryPoint="XCreatePixmapFromBitmapData")]
6952                 internal extern static IntPtr _XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth);
6953                 internal static IntPtr XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth)
6954                 {
6955                         DebugHelper.TraceWriteLine ("XCreatePixmapFromBitmapData");
6956                         return _XCreatePixmapFromBitmapData(display, drawable, data, width, height, fg, bg, depth);
6957                 }
6958
6959                 [DllImport ("libX11", EntryPoint="XCreatePixmap")]
6960                 internal extern static IntPtr _XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth);
6961                 internal static IntPtr XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth)
6962                 {
6963                         DebugHelper.TraceWriteLine ("XCreatePixmap");
6964                         return _XCreatePixmap(display, d, width, height, depth);
6965                 }
6966
6967                 [DllImport ("libX11", EntryPoint="XFreePixmap")]
6968                 internal extern static IntPtr _XFreePixmap(IntPtr display, IntPtr pixmap);
6969                 internal static IntPtr XFreePixmap(IntPtr display, IntPtr pixmap)
6970                 {
6971                         DebugHelper.TraceWriteLine ("XFreePixmap");
6972                         return _XFreePixmap(display, pixmap);
6973                 }
6974
6975                 [DllImport ("libX11", EntryPoint="XQueryBestCursor")]
6976                 internal extern static int _XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height);
6977                 internal static int XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height)
6978                 {
6979                         DebugHelper.TraceWriteLine ("XQueryBestCursor");
6980                         return _XQueryBestCursor(display, drawable, width, height, out best_width, out best_height);
6981                 }
6982
6983                 [DllImport ("libX11", EntryPoint="XQueryExtension")]
6984                 internal extern static int _XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error);
6985                 internal static int XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error)
6986                 {
6987                         DebugHelper.TraceWriteLine ("XQueryExtension");
6988                         return _XQueryExtension(display, extension_name, ref major, ref first_event, ref first_error);
6989                 }
6990
6991                 [DllImport ("libX11", EntryPoint="XWhitePixel")]
6992                 internal extern static IntPtr _XWhitePixel(IntPtr display, int screen_no);
6993                 internal static IntPtr XWhitePixel(IntPtr display, int screen_no)
6994                 {
6995                         DebugHelper.TraceWriteLine ("XWhitePixel");
6996                         return _XWhitePixel(display, screen_no);
6997                 }
6998
6999                 [DllImport ("libX11", EntryPoint="XBlackPixel")]
7000                 internal extern static IntPtr _XBlackPixel(IntPtr display, int screen_no);
7001                 internal static IntPtr XBlackPixel(IntPtr display, int screen_no)
7002                 {
7003                         DebugHelper.TraceWriteLine ("XBlackPixel");
7004                         return _XBlackPixel(display, screen_no);
7005                 }
7006
7007                 [DllImport ("libX11", EntryPoint="XGrabServer")]
7008                 internal extern static void _XGrabServer(IntPtr display);
7009                 internal static void XGrabServer(IntPtr display)
7010                 {
7011                         DebugHelper.TraceWriteLine ("XGrabServer");
7012                         _XGrabServer(display);
7013                 }
7014
7015                 [DllImport ("libX11", EntryPoint="XUngrabServer")]
7016                 internal extern static void _XUngrabServer(IntPtr display);
7017                 internal static void XUngrabServer(IntPtr display)
7018                 {
7019                         DebugHelper.TraceWriteLine ("XUngrabServer");
7020                         _XUngrabServer(display);
7021                 }
7022
7023                 [DllImport ("libX11", EntryPoint="XGetWMNormalHints")]
7024                 internal extern static void _XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return);
7025                 internal static void XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return)
7026                 {
7027                         DebugHelper.TraceWriteLine ("XGetWMNormalHints");
7028                         _XGetWMNormalHints(display, window, ref hints, out supplied_return);
7029                 }
7030
7031                 [DllImport ("libX11", EntryPoint="XSetWMNormalHints")]
7032                 internal extern static void _XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints);
7033                 internal static void XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints)
7034                 {
7035                         DebugHelper.TraceWriteLine ("XSetWMNormalHints");
7036                         _XSetWMNormalHints(display, window, ref hints);
7037                 }
7038
7039                 [DllImport ("libX11", EntryPoint="XSetZoomHints")]
7040                 internal extern static void _XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints);
7041                 internal static void XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints)
7042                 {
7043                         DebugHelper.TraceWriteLine ("XSetZoomHints");
7044                         _XSetZoomHints(display, window, ref hints);
7045                 }
7046
7047                 [DllImport ("libX11", EntryPoint="XSetWMHints")]
7048                 internal extern static void _XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints);
7049                 internal static void XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints)
7050                 {
7051                         DebugHelper.TraceWriteLine ("XSetWMHints");
7052                         _XSetWMHints(display, window, ref wmhints);
7053                 }
7054
7055                 [DllImport ("libX11", EntryPoint="XGetIconSizes")]
7056                 internal extern static int _XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count);
7057                 internal static int XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count)
7058                 {
7059                         DebugHelper.TraceWriteLine ("XGetIconSizes");
7060                         return _XGetIconSizes(display, window, out size_list, out count);
7061                 }
7062
7063                 [DllImport ("libX11", EntryPoint="XSetErrorHandler")]
7064                 internal extern static IntPtr _XSetErrorHandler(XErrorHandler error_handler);
7065                 internal static IntPtr XSetErrorHandler(XErrorHandler error_handler)
7066                 {
7067                         DebugHelper.TraceWriteLine ("XSetErrorHandler");
7068                         return _XSetErrorHandler(error_handler);
7069                 }
7070
7071                 [DllImport ("libX11", EntryPoint="XGetErrorText")]
7072                 internal extern static IntPtr _XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length);
7073                 internal static IntPtr XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length)
7074                 {
7075                         DebugHelper.TraceWriteLine ("XGetErrorText");
7076                         return _XGetErrorText(display, code, buffer, length);
7077                 }
7078
7079                 [DllImport ("libX11", EntryPoint="XInitThreads")]
7080                 internal extern static int _XInitThreads();
7081                 internal static int XInitThreads()
7082                 {
7083                         DebugHelper.TraceWriteLine ("XInitThreads");
7084                         return _XInitThreads();
7085                 }
7086
7087                 [DllImport ("libX11", EntryPoint="XConvertSelection")]
7088                 internal extern static int _XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time);
7089                 internal static int XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time)
7090                 {
7091                         DebugHelper.TraceWriteLine ("XConvertSelection");
7092                         return _XConvertSelection(display, selection, target, property, requestor, time);
7093                 }
7094
7095                 [DllImport ("libX11", EntryPoint="XGetSelectionOwner")]
7096                 internal extern static IntPtr _XGetSelectionOwner(IntPtr display, IntPtr selection);
7097                 internal static IntPtr XGetSelectionOwner(IntPtr display, IntPtr selection)
7098                 {
7099                         DebugHelper.TraceWriteLine ("XGetSelectionOwner");
7100                         return _XGetSelectionOwner(display, selection);
7101                 }
7102
7103                 [DllImport ("libX11", EntryPoint="XSetSelectionOwner")]
7104                 internal extern static int _XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time);
7105                 internal static int XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time)
7106                 {
7107                         DebugHelper.TraceWriteLine ("XSetSelectionOwner");
7108                         return _XSetSelectionOwner(display, selection, owner, time);
7109                 }
7110
7111                 [DllImport ("libX11", EntryPoint="XSetPlaneMask")]
7112                 internal extern static int _XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask);
7113                 internal static int XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask)
7114                 {
7115                         DebugHelper.TraceWriteLine ("XSetPlaneMask");
7116                         return _XSetPlaneMask(display, gc, mask);
7117                 }
7118
7119                 [DllImport ("libX11", EntryPoint="XSetForeground")]
7120                 internal extern static int _XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground);
7121                 internal static int XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground)
7122                 {
7123                         DebugHelper.TraceWriteLine ("XSetForeground");
7124                         return _XSetForeground(display, gc, foreground);
7125                 }
7126
7127                 [DllImport ("libX11", EntryPoint="XSetBackground")]
7128                 internal extern static int _XSetBackground(IntPtr display, IntPtr gc, UIntPtr background);
7129                 internal static int XSetBackground(IntPtr display, IntPtr gc, UIntPtr background)
7130                 {
7131                         DebugHelper.TraceWriteLine ("XSetBackground");
7132                         return _XSetBackground(display, gc, background);
7133                 }
7134
7135                 [DllImport ("libX11", EntryPoint="XBell")]
7136                 internal extern static int _XBell(IntPtr display, int percent);
7137                 internal static int XBell(IntPtr display, int percent)
7138                 {
7139                         DebugHelper.TraceWriteLine ("XBell");
7140                         return _XBell(display, percent);
7141                 }
7142
7143                 [DllImport ("libX11", EntryPoint="XChangeActivePointerGrab")]
7144                 internal extern static int _XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time);
7145                 internal static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time)
7146                 {
7147                         DebugHelper.TraceWriteLine ("XChangeActivePointerGrab");
7148                         return _XChangeActivePointerGrab (display, event_mask, cursor, time);
7149                 }
7150
7151                 [DllImport ("libX11", EntryPoint="XFilterEvent")]
7152                 internal extern static bool _XFilterEvent(ref XEvent xevent, IntPtr window);
7153                 internal static bool XFilterEvent(ref XEvent xevent, IntPtr window)
7154                 {
7155                         DebugHelper.TraceWriteLine ("XFilterEvent");
7156                         return _XFilterEvent(ref xevent, window);
7157                 }
7158
7159                 [DllImport ("libX11", EntryPoint="XkbSetDetectableAutoRepeat")]
7160                 internal extern static void _XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported);
7161                 internal static void XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported)
7162                 {
7163                         DebugHelper.TraceWriteLine ("XkbSetDetectableAutoRepeat");
7164                         _XkbSetDetectableAutoRepeat (display, detectable, supported);
7165                 }
7166
7167                 [DllImport ("libX11", EntryPoint="XPeekEvent")]
7168                 internal extern static void _XPeekEvent (IntPtr display, ref XEvent xevent);
7169                 internal static void XPeekEvent (IntPtr display, ref XEvent xevent)
7170                 {
7171                         DebugHelper.TraceWriteLine ("XPeekEvent");
7172                         _XPeekEvent (display, ref xevent);
7173                 }
7174
7175                 [DllImport ("libX11", EntryPoint="XIfEvent")]
7176                 internal extern static void _XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg);
7177                 internal static void XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg)
7178                 {
7179                         DebugHelper.TraceWriteLine ("XIfEvent");
7180                         _XIfEvent (display, ref xevent, event_predicate, arg);
7181                 }
7182 #endregion
7183
7184
7185 #else //no TRACE defined
7186
7187 #region Xcursor imports
7188                 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadCursor")]
7189                 internal extern static IntPtr XcursorLibraryLoadCursor (IntPtr display, [MarshalAs (UnmanagedType.LPStr)] string name);
7190
7191                 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadImages")]
7192                 internal extern static IntPtr XcursorLibraryLoadImages ([MarshalAs (UnmanagedType.LPStr)] string file, IntPtr theme, int size);
7193                 
7194                 [DllImport ("libXcursor", EntryPoint = "XcursorImagesDestroy")]
7195                 internal extern static void XcursorImagesDestroy (IntPtr images);
7196                 
7197                 [DllImport ("libXcursor", EntryPoint = "XcursorGetDefaultSize")]
7198                 internal extern static int XcursorGetDefaultSize (IntPtr display);
7199
7200                 [DllImport ("libXcursor", EntryPoint = "XcursorImageLoadCursor")]
7201                 internal extern static IntPtr XcursorImageLoadCursor (IntPtr display, IntPtr image);
7202
7203                 [DllImport ("libXcursor", EntryPoint = "XcursorGetTheme")]
7204                 internal extern static IntPtr XcursorGetTheme (IntPtr display);
7205 #endregion
7206                 #region X11 Imports
7207                 [DllImport ("libX11", EntryPoint="XOpenDisplay")]
7208                 internal extern static IntPtr XOpenDisplay(IntPtr display);
7209                 [DllImport ("libX11", EntryPoint="XCloseDisplay")]
7210                 internal extern static int XCloseDisplay(IntPtr display);                                                   
7211                 [DllImport ("libX11", EntryPoint="XSynchronize")]
7212                 internal extern static IntPtr XSynchronize(IntPtr display, bool onoff);
7213
7214                 [DllImport ("libX11", EntryPoint="XCreateWindow")]
7215                 internal extern static IntPtr XCreateWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, UIntPtr valuemask, ref XSetWindowAttributes attributes);
7216                 
7217                 [DllImport ("libX11", EntryPoint="XCreateSimpleWindow")]
7218                 internal extern static IntPtr XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background);
7219                 
7220                 [DllImport ("libX11", EntryPoint="XMapWindow")]
7221                 internal extern static int XMapWindow(IntPtr display, IntPtr window);
7222                 
7223                 [DllImport ("libX11", EntryPoint="XUnmapWindow")]
7224                 internal extern static int XUnmapWindow(IntPtr display, IntPtr window);
7225                 
7226                 [DllImport ("libX11", EntryPoint="XMapSubwindows")]
7227                 internal extern static int XMapSubindows(IntPtr display, IntPtr window);
7228                 
7229                 [DllImport ("libX11", EntryPoint="XUnmapSubwindows")]
7230                 internal extern static int XUnmapSubwindows(IntPtr display, IntPtr window);
7231                 
7232                 [DllImport ("libX11", EntryPoint="XRootWindow")]
7233                 internal extern static IntPtr XRootWindow(IntPtr display, int screen_number);
7234                 
7235                 [DllImport ("libX11", EntryPoint="XNextEvent")]
7236                 internal extern static IntPtr XNextEvent(IntPtr display, ref XEvent xevent);
7237
7238                 [DllImport ("libX11", EntryPoint="XConnectionNumber")]
7239                 internal extern static int XConnectionNumber (IntPtr display);
7240                 
7241                 [DllImport ("libX11", EntryPoint="XPending")]
7242                 internal extern static int XPending (IntPtr display);
7243                 
7244                 [DllImport ("libX11", EntryPoint="XSelectInput")]
7245                 internal extern static IntPtr XSelectInput(IntPtr display, IntPtr window, IntPtr mask);
7246                 
7247                 [DllImport ("libX11", EntryPoint="XDestroyWindow")]
7248                 internal extern static int XDestroyWindow(IntPtr display, IntPtr window);
7249                 
7250                 [DllImport ("libX11", EntryPoint="XReparentWindow")]
7251                 internal extern static int XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y);
7252                 
7253                 [DllImport ("libX11", EntryPoint="XMoveResizeWindow")]
7254                 extern static int XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height);
7255                 internal static int MoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height)
7256                 {
7257                         int ret = XMoveResizeWindow (display, window, x, y, width, height);
7258                         Keyboard.MoveCurrentCaretPos ();
7259                         return ret;
7260                 }
7261
7262                 [DllImport ("libX11", EntryPoint="XResizeWindow")]
7263                 internal extern static int XResizeWindow(IntPtr display, IntPtr window, int width, int height);
7264
7265                 [DllImport ("libX11", EntryPoint="XGetWindowAttributes")]
7266                 internal extern static int XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes);
7267
7268                 [DllImport ("libX11", EntryPoint="XFlush")]
7269                 internal extern static int XFlush(IntPtr display);
7270
7271                 [DllImport ("libX11", EntryPoint="XSetWMName")]
7272                 internal extern static int XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop);
7273
7274                 [DllImport ("libX11", EntryPoint="XStoreName")]
7275                 internal extern static int XStoreName(IntPtr display, IntPtr window, string window_name);
7276
7277                 [DllImport ("libX11", EntryPoint="XFetchName")]
7278                 internal extern static int XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name);
7279
7280                 [DllImport ("libX11", EntryPoint="XSendEvent")]
7281                 internal extern static int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event);
7282
7283                 [DllImport ("libX11", EntryPoint="XQueryTree")]
7284                 internal extern static int XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return);
7285
7286                 [DllImport ("libX11", EntryPoint="XFree")]
7287                 internal extern static int XFree(IntPtr data);
7288
7289                 [DllImport ("libX11", EntryPoint="XRaiseWindow")]
7290                 internal extern static int XRaiseWindow(IntPtr display, IntPtr window);
7291
7292                 [DllImport ("libX11", EntryPoint="XLowerWindow")]
7293                 internal extern static uint XLowerWindow(IntPtr display, IntPtr window);
7294
7295                 [DllImport ("libX11", EntryPoint="XConfigureWindow")]
7296                 internal extern static uint XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values);
7297
7298                 [DllImport ("libX11", EntryPoint="XInternAtom")]
7299                 internal extern static IntPtr XInternAtom(IntPtr display, string atom_name, bool only_if_exists);
7300
7301                 [DllImport ("libX11", EntryPoint="XInternAtoms")]
7302                 internal extern static int XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms);
7303
7304                 [DllImport ("libX11", EntryPoint="XSetWMProtocols")]
7305                 internal extern static int XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count);
7306
7307                 [DllImport ("libX11", EntryPoint="XGrabPointer")]
7308                 internal extern static int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp);
7309
7310                 [DllImport ("libX11", EntryPoint="XUngrabPointer")]
7311                 internal extern static int XUngrabPointer(IntPtr display, IntPtr timestamp);
7312
7313                 [DllImport ("libX11", EntryPoint="XQueryPointer")]
7314                 internal extern static bool XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons);
7315
7316                 [DllImport ("libX11", EntryPoint="XTranslateCoordinates")]
7317                 internal extern static bool XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return);
7318
7319                 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7320                 internal extern static bool XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth);
7321
7322                 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7323                 internal extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, out int width, out int height, IntPtr border_width, IntPtr depth);
7324
7325                 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7326                 internal extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, IntPtr width, IntPtr height, IntPtr border_width, IntPtr depth);
7327
7328                 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7329                 internal extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, IntPtr x, IntPtr y, out int width, out int height, IntPtr border_width, IntPtr depth);
7330
7331                 [DllImport ("libX11", EntryPoint="XWarpPointer")]
7332                 internal extern static uint XWarpPointer(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y);
7333
7334                 [DllImport ("libX11", EntryPoint="XClearWindow")]
7335                 internal extern static int XClearWindow(IntPtr display, IntPtr window);
7336
7337                 [DllImport ("libX11", EntryPoint="XClearArea")]
7338                 internal extern static int XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures);
7339
7340                 // Colormaps
7341                 [DllImport ("libX11", EntryPoint="XDefaultScreenOfDisplay")]
7342                 internal extern static IntPtr XDefaultScreenOfDisplay(IntPtr display);
7343
7344                 [DllImport ("libX11", EntryPoint="XScreenNumberOfScreen")]
7345                 internal extern static int XScreenNumberOfScreen(IntPtr display, IntPtr Screen);
7346
7347                 [DllImport ("libX11", EntryPoint="XDefaultVisual")]
7348                 internal extern static IntPtr XDefaultVisual(IntPtr display, int screen_number);
7349
7350                 [DllImport ("libX11", EntryPoint="XDefaultDepth")]
7351                 internal extern static uint XDefaultDepth(IntPtr display, int screen_number);
7352
7353                 [DllImport ("libX11", EntryPoint="XDefaultScreen")]
7354                 internal extern static int XDefaultScreen(IntPtr display);
7355
7356                 [DllImport ("libX11", EntryPoint="XDefaultColormap")]
7357                 internal extern static IntPtr XDefaultColormap(IntPtr display, int screen_number);
7358
7359                 [DllImport ("libX11", EntryPoint="XLookupColor")]
7360                 internal extern static int XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color);
7361
7362                 [DllImport ("libX11", EntryPoint="XAllocColor")]
7363                 internal extern static int XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def);
7364
7365                 [DllImport ("libX11", EntryPoint="XSetTransientForHint")]
7366                 internal extern static int XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window);
7367
7368                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7369                 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements);
7370
7371                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7372                 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements);
7373
7374                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7375                 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements);
7376
7377                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7378                 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements);
7379
7380                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7381                 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements);
7382
7383                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7384                 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements);
7385
7386                 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7387                 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements);
7388
7389                 [DllImport ("libX11", EntryPoint="XChangeProperty", CharSet=CharSet.Ansi)]
7390                 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length);
7391
7392                 [DllImport ("libX11", EntryPoint="XDeleteProperty")]
7393                 internal extern static int XDeleteProperty(IntPtr display, IntPtr window, IntPtr property);
7394
7395                 // Drawing
7396                 [DllImport ("libX11", EntryPoint="XCreateGC")]
7397                 internal extern static IntPtr XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values);
7398
7399                 [DllImport ("libX11", EntryPoint="XFreeGC")]
7400                 internal extern static int XFreeGC(IntPtr display, IntPtr gc);
7401
7402                 [DllImport ("libX11", EntryPoint="XSetFunction")]
7403                 internal extern static int XSetFunction(IntPtr display, IntPtr gc, GXFunction function);
7404
7405                 [DllImport ("libX11", EntryPoint="XSetLineAttributes")]
7406                 internal extern static int XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style);
7407
7408                 [DllImport ("libX11", EntryPoint="XDrawLine")]
7409                 internal extern static int XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2);
7410
7411                 [DllImport ("libX11", EntryPoint="XDrawRectangle")]
7412                 internal extern static int XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
7413
7414                 [DllImport ("libX11", EntryPoint="XFillRectangle")]
7415                 internal extern static int XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
7416
7417                 [DllImport ("libX11", EntryPoint="XSetWindowBackground")]
7418                 internal extern static int XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background);
7419
7420                 [DllImport ("libX11", EntryPoint="XCopyArea")]
7421                 internal extern static int XCopyArea(IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y);
7422
7423                 [DllImport ("libX11", EntryPoint="XGetWindowProperty")]
7424                 internal extern static int XGetWindowProperty(IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, out int actual_format, out IntPtr nitems, out IntPtr bytes_after, ref IntPtr prop);
7425
7426                 [DllImport ("libX11", EntryPoint="XSetInputFocus")]
7427                 internal extern static int XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time);
7428
7429                 [DllImport ("libX11", EntryPoint="XIconifyWindow")]
7430                 internal extern static int XIconifyWindow(IntPtr display, IntPtr window, int screen_number);
7431
7432                 [DllImport ("libX11", EntryPoint="XDefineCursor")]
7433                 internal extern static int XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor);
7434
7435                 [DllImport ("libX11", EntryPoint="XUndefineCursor")]
7436                 internal extern static int XUndefineCursor(IntPtr display, IntPtr window);
7437
7438                 [DllImport ("libX11", EntryPoint="XFreeCursor")]
7439                 internal extern static int XFreeCursor(IntPtr display, IntPtr cursor);
7440
7441                 [DllImport ("libX11", EntryPoint="XCreateFontCursor")]
7442                 internal extern static IntPtr XCreateFontCursor(IntPtr display, CursorFontShape shape);
7443
7444                 [DllImport ("libX11", EntryPoint="XCreatePixmapCursor")]
7445                 internal extern static IntPtr XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot);
7446
7447                 [DllImport ("libX11", EntryPoint="XCreatePixmapFromBitmapData")]
7448                 internal extern static IntPtr XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth);
7449
7450                 [DllImport ("libX11", EntryPoint="XCreatePixmap")]
7451                 internal extern static IntPtr XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth);
7452
7453                 [DllImport ("libX11", EntryPoint="XFreePixmap")]
7454                 internal extern static IntPtr XFreePixmap(IntPtr display, IntPtr pixmap);
7455
7456                 [DllImport ("libX11", EntryPoint="XQueryBestCursor")]
7457                 internal extern static int XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height);
7458
7459                 [DllImport ("libX11", EntryPoint="XQueryExtension")]
7460                 internal extern static int XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error);
7461
7462                 [DllImport ("libX11", EntryPoint="XWhitePixel")]
7463                 internal extern static IntPtr XWhitePixel(IntPtr display, int screen_no);
7464
7465                 [DllImport ("libX11", EntryPoint="XBlackPixel")]
7466                 internal extern static IntPtr XBlackPixel(IntPtr display, int screen_no);
7467
7468                 [DllImport ("libX11", EntryPoint="XGrabServer")]
7469                 internal extern static void XGrabServer(IntPtr display);
7470
7471                 [DllImport ("libX11", EntryPoint="XUngrabServer")]
7472                 internal extern static void XUngrabServer(IntPtr display);
7473
7474                 [DllImport ("libX11", EntryPoint="XGetWMNormalHints")]
7475                 internal extern static void XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return);
7476
7477                 [DllImport ("libX11", EntryPoint="XSetWMNormalHints")]
7478                 internal extern static void XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints);
7479
7480                 [DllImport ("libX11", EntryPoint="XSetZoomHints")]
7481                 internal extern static void XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints);
7482
7483                 [DllImport ("libX11", EntryPoint="XSetWMHints")]
7484                 internal extern static void XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints);
7485
7486                 [DllImport ("libX11", EntryPoint="XGetIconSizes")]
7487                 internal extern static int XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count);
7488
7489                 [DllImport ("libX11", EntryPoint="XSetErrorHandler")]
7490                 internal extern static IntPtr XSetErrorHandler(XErrorHandler error_handler);
7491
7492                 [DllImport ("libX11", EntryPoint="XGetErrorText")]
7493                 internal extern static IntPtr XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length);
7494
7495                 [DllImport ("libX11", EntryPoint="XInitThreads")]
7496                 internal extern static int XInitThreads();
7497
7498                 [DllImport ("libX11", EntryPoint="XConvertSelection")]
7499                 internal extern static int XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time);
7500
7501                 [DllImport ("libX11", EntryPoint="XGetSelectionOwner")]
7502                 internal extern static IntPtr XGetSelectionOwner(IntPtr display, IntPtr selection);
7503
7504                 [DllImport ("libX11", EntryPoint="XSetSelectionOwner")]
7505                 internal extern static int XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time);
7506
7507                 [DllImport ("libX11", EntryPoint="XSetPlaneMask")]
7508                 internal extern static int XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask);
7509
7510                 [DllImport ("libX11", EntryPoint="XSetForeground")]
7511                 internal extern static int XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground);
7512
7513                 [DllImport ("libX11", EntryPoint="XSetBackground")]
7514                 internal extern static int XSetBackground(IntPtr display, IntPtr gc, UIntPtr background);
7515
7516                 [DllImport ("libX11", EntryPoint="XBell")]
7517                 internal extern static int XBell(IntPtr display, int percent);
7518
7519                 [DllImport ("libX11", EntryPoint="XChangeActivePointerGrab")]
7520                 internal extern static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time);
7521
7522                 [DllImport ("libX11", EntryPoint="XFilterEvent")]
7523                 internal extern static bool XFilterEvent(ref XEvent xevent, IntPtr window);
7524
7525                 [DllImport ("libX11", EntryPoint="XkbSetDetectableAutoRepeat")]
7526                 internal extern static void XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported);
7527
7528                 [DllImport ("libX11", EntryPoint="XPeekEvent")]
7529                 internal extern static void XPeekEvent (IntPtr display, ref XEvent xevent);
7530
7531                 [DllImport ("libX11", EntryPoint="XIfEvent")]
7532                 internal extern static void XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg);
7533
7534                 [DllImport ("libX11", EntryPoint="XGetInputFocus")]
7535                 internal extern static void XGetInputFocus (IntPtr display, out IntPtr focus, out IntPtr revert_to);
7536                 #endregion
7537 #endif
7538         }
7539 }