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:
9 // The above copyright notice and this permission notice shall be
10 // included in all copies or substantial portions of the Software.
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.
20 // Copyright (c) 2004-2006 Novell, Inc.
23 // Peter Bartok pbartok@novell.com
28 // This driver understands the following environment variables: (Set the var to enable feature)
30 // MONO_XEXCEPTIONS = throw an exception when a X11 error is encountered;
31 // by default a message is displayed but execution continues
33 // MONO_XSYNC = perform all X11 commands synchronous; this is slower but
34 // helps in debugging errors
39 // define to log Window handles and relationships to stdout
42 // Extra detailed debug
43 #undef DriverDebugExtra
44 #undef DriverDebugParent
45 #undef DriverDebugCreate
46 #undef DriverDebugDestroy
47 #undef DriverDebugThreads
48 #undef DriverDebugXEmbed
54 using System.ComponentModel;
55 using System.Collections;
56 using System.Diagnostics;
58 using System.Drawing.Drawing2D;
59 using System.Drawing.Imaging;
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;
68 using System.Threading;
70 // Only do the poll when building with mono for now
72 using Mono.Unix.Native;
76 namespace System.Windows.Forms {
77 internal class XplatUIX11 : XplatUIDriver {
78 #region Local Variables
80 static volatile XplatUIX11 Instance;
81 private static int RefCount;
82 private static object XlibLock; // Our locking object
83 private static bool themes_enabled;
86 private static IntPtr DisplayHandle; // X11 handle to display
87 private static int ScreenNo; // Screen number used
88 private static IntPtr DefaultColormap; // Colormap for screen
89 private static IntPtr CustomVisual; // Visual for window creation
90 private static IntPtr CustomColormap; // Colormap for window creation
91 private static IntPtr RootWindow; // Handle of the root window for the screen/display
92 private static IntPtr FosterParent; // Container to hold child windows until their parent exists
93 private static XErrorHandler ErrorHandler; // Error handler delegate
94 private static bool ErrorExceptions; // Throw exceptions on X errors
95 private int render_major_opcode;
96 private int render_first_event;
97 private int render_first_error;
100 private static IntPtr ClipMagic;
101 private static ClipboardData Clipboard; // Our clipboard
104 private static IntPtr PostAtom; // PostMessage atom
105 private static IntPtr AsyncAtom; // Support for async messages
108 private static Hashtable MessageQueues; // Holds our thread-specific XEventQueues
109 private static ArrayList unattached_timer_list; // holds timers that are enabled but not attached to a window.
111 private static Pollfd[] pollfds; // For watching the X11 socket
112 private static bool wake_waiting;
113 private static object wake_waiting_lock = new object ();
115 private static X11Keyboard Keyboard; //
116 private static X11Dnd Dnd;
117 private static Socket listen; //
118 private static Socket wake; //
119 private static Socket wake_receive; //
120 private static byte[] network_buffer; //
121 private static bool detectable_key_auto_repeat;
124 private static IntPtr ActiveWindow; // Handle of the active window
125 private static IntPtr FocusWindow; // Handle of the window with keyboard focus (if any)
128 private static Stack ModalWindows; // Stack of our modal windows
131 private static IntPtr SystrayMgrWindow; // Handle of the Systray Manager window
134 private static IntPtr LastCursorWindow; // The last window we set the cursor on
135 private static IntPtr LastCursorHandle; // The handle that was last set on LastCursorWindow
136 private static IntPtr OverrideCursorHandle; // The cursor that is set to override any other cursors
139 private static CaretStruct Caret; //
141 // Last window containing the pointer
142 private static IntPtr LastPointerWindow; // The last window containing the pointer
145 private static IntPtr WM_PROTOCOLS;
146 private static IntPtr WM_DELETE_WINDOW;
147 private static IntPtr WM_TAKE_FOCUS;
148 //private static IntPtr _NET_SUPPORTED;
149 //private static IntPtr _NET_CLIENT_LIST;
150 //private static IntPtr _NET_NUMBER_OF_DESKTOPS;
151 private static IntPtr _NET_DESKTOP_GEOMETRY;
152 //private static IntPtr _NET_DESKTOP_VIEWPORT;
153 private static IntPtr _NET_CURRENT_DESKTOP;
154 //private static IntPtr _NET_DESKTOP_NAMES;
155 private static IntPtr _NET_ACTIVE_WINDOW;
156 private static IntPtr _NET_WORKAREA;
157 //private static IntPtr _NET_SUPPORTING_WM_CHECK;
158 //private static IntPtr _NET_VIRTUAL_ROOTS;
159 //private static IntPtr _NET_DESKTOP_LAYOUT;
160 //private static IntPtr _NET_SHOWING_DESKTOP;
161 //private static IntPtr _NET_CLOSE_WINDOW;
162 //private static IntPtr _NET_MOVERESIZE_WINDOW;
163 private static IntPtr _NET_WM_MOVERESIZE;
164 //private static IntPtr _NET_RESTACK_WINDOW;
165 //private static IntPtr _NET_REQUEST_FRAME_EXTENTS;
166 private static IntPtr _NET_WM_NAME;
167 //private static IntPtr _NET_WM_VISIBLE_NAME;
168 //private static IntPtr _NET_WM_ICON_NAME;
169 //private static IntPtr _NET_WM_VISIBLE_ICON_NAME;
170 //private static IntPtr _NET_WM_DESKTOP;
171 private static IntPtr _NET_WM_WINDOW_TYPE;
172 private static IntPtr _NET_WM_STATE;
173 //private static IntPtr _NET_WM_ALLOWED_ACTIONS;
174 //private static IntPtr _NET_WM_STRUT;
175 //private static IntPtr _NET_WM_STRUT_PARTIAL;
176 //private static IntPtr _NET_WM_ICON_GEOMETRY;
177 private static IntPtr _NET_WM_ICON;
178 //private static IntPtr _NET_WM_PID;
179 //private static IntPtr _NET_WM_HANDLED_ICONS;
180 private static IntPtr _NET_WM_USER_TIME;
181 private static IntPtr _NET_FRAME_EXTENTS;
182 //private static IntPtr _NET_WM_PING;
183 //private static IntPtr _NET_WM_SYNC_REQUEST;
184 private static IntPtr _NET_SYSTEM_TRAY_S;
185 //private static IntPtr _NET_SYSTEM_TRAY_ORIENTATION;
186 private static IntPtr _NET_SYSTEM_TRAY_OPCODE;
187 private static IntPtr _NET_WM_STATE_MAXIMIZED_HORZ;
188 private static IntPtr _NET_WM_STATE_MAXIMIZED_VERT;
189 private static IntPtr _XEMBED;
190 private static IntPtr _XEMBED_INFO;
191 private static IntPtr _MOTIF_WM_HINTS;
192 private static IntPtr _NET_WM_STATE_SKIP_TASKBAR;
193 private static IntPtr _NET_WM_STATE_ABOVE;
194 private static IntPtr _NET_WM_STATE_MODAL;
195 private static IntPtr _NET_WM_STATE_HIDDEN;
196 private static IntPtr _NET_WM_CONTEXT_HELP;
197 private static IntPtr _NET_WM_WINDOW_OPACITY;
198 //private static IntPtr _NET_WM_WINDOW_TYPE_DESKTOP;
199 //private static IntPtr _NET_WM_WINDOW_TYPE_DOCK;
200 //private static IntPtr _NET_WM_WINDOW_TYPE_TOOLBAR;
201 //private static IntPtr _NET_WM_WINDOW_TYPE_MENU;
202 private static IntPtr _NET_WM_WINDOW_TYPE_UTILITY;
203 //private static IntPtr _NET_WM_WINDOW_TYPE_SPLASH;
204 // private static IntPtr _NET_WM_WINDOW_TYPE_DIALOG;
205 private static IntPtr _NET_WM_WINDOW_TYPE_NORMAL;
206 private static IntPtr CLIPBOARD;
207 private static IntPtr PRIMARY;
208 //private static IntPtr DIB;
209 private static IntPtr OEMTEXT;
210 private static IntPtr UTF8_STRING;
211 private static IntPtr UTF16_STRING;
212 private static IntPtr RICHTEXTFORMAT;
213 private static IntPtr TARGETS;
215 // mouse hover message generation
216 private static HoverStruct HoverState; //
218 // double click message generation
219 private static ClickStruct ClickPending; //
221 // Support for mouse grab
222 private static GrabStruct Grab; //
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;
229 private static int DoubleClickInterval; // msec; max interval between clicks to count as double click
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);
243 static readonly object lockobj = new object ();
245 // messages WaitForHwndMwssage is waiting on
246 static Hashtable messageHold;
248 #endregion // Local Variables
250 private XplatUIX11() {
251 // Handle singleton stuff first
255 // Now regular initialization
256 XlibLock = new object ();
257 X11Keyboard.XlibLock = XlibLock;
258 MessageQueues = Hashtable.Synchronized (new Hashtable(7));
259 unattached_timer_list = ArrayList.Synchronized (new ArrayList (3));
260 messageHold = Hashtable.Synchronized (new Hashtable(3));
261 Clipboard = new ClipboardData ();
264 ErrorExceptions = false;
266 // X11 Initialization
267 SetDisplay(XOpenDisplay(IntPtr.Zero));
268 X11DesktopColors.Initialize();
271 // Disable keyboard autorepeat
273 XkbSetDetectableAutoRepeat (DisplayHandle, true, IntPtr.Zero);
274 detectable_key_auto_repeat = true;
276 Console.Error.WriteLine ("Could not disable keyboard auto repeat, will attempt to disable manually.");
277 detectable_key_auto_repeat = false;
280 // Handle any upcoming errors; we re-set it here, X11DesktopColor stuff might have stolen it (gtk does)
281 ErrorHandler = new XErrorHandler(HandleError);
282 XSetErrorHandler(ErrorHandler);
286 // Remove our display handle from S.D
287 Graphics.FromHdcInternal (IntPtr.Zero);
290 #endregion // Constructors
292 #region Singleton Specific Code
293 public static XplatUIX11 GetInstance() {
295 if (Instance == null) {
296 Instance=new XplatUIX11();
303 public int Reference {
310 #region Internal Properties
311 internal static IntPtr Display {
313 return DisplayHandle;
317 XplatUIX11.GetInstance().SetDisplay(value);
321 internal static int Screen {
331 internal static IntPtr RootWindowHandle {
341 internal static IntPtr Visual {
347 CustomVisual = value;
351 internal static IntPtr ColorMap {
353 return CustomColormap;
357 CustomColormap = value;
362 internal static IntPtr DefaultColorMap {
364 return DefaultColormap;
370 #region XExceptionClass
371 internal class XException : ApplicationException {
375 XRequest RequestCode;
379 public XException(IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) {
380 this.Display = Display;
381 this.ResourceID = ResourceID;
382 this.Serial = Serial;
383 this.RequestCode = RequestCode;
384 this.ErrorCode = ErrorCode;
385 this.MinorCode = MinorCode;
388 public override string Message {
390 return GetMessage(Display, ResourceID, Serial, ErrorCode, RequestCode, MinorCode);
394 public static string GetMessage(IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) {
403 sb = new StringBuilder(160);
404 XGetErrorText(Display, ErrorCode, sb, sb.Capacity);
405 x_error_text = sb.ToString();
406 hwnd = Hwnd.ObjectFromHandle(ResourceID);
408 hwnd_text = hwnd.ToString();
409 c = Control.FromHandle(hwnd.Handle);
411 control_text = c.ToString();
413 control_text = String.Format("<handle {0:X} non-existant>", hwnd.Handle.ToInt32());
416 hwnd_text = "<null>";
417 control_text = "<null>";
421 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);
425 #endregion // XExceptionClass
427 #region Internal Methods
428 internal void SetDisplay(IntPtr display_handle) {
429 if (display_handle != IntPtr.Zero) {
432 if ((DisplayHandle != IntPtr.Zero) && (FosterParent != IntPtr.Zero)) {
433 hwnd = Hwnd.ObjectFromHandle(FosterParent);
434 XDestroyWindow(DisplayHandle, FosterParent);
438 if (DisplayHandle != IntPtr.Zero) {
439 XCloseDisplay(DisplayHandle);
442 DisplayHandle=display_handle;
444 // We need to tell System.Drawing our DisplayHandle. FromHdcInternal has
445 // been hacked to do this for us.
446 Graphics.FromHdcInternal (DisplayHandle);
448 // query for the render extension so
449 // we can ignore the spurious
450 // BadPicture errors that are
451 // generated by cairo/render.
452 XQueryExtension (DisplayHandle, "RENDER",
453 ref render_major_opcode, ref render_first_event, ref render_first_error);
456 if (Environment.GetEnvironmentVariable ("MONO_XSYNC") != null) {
457 XSynchronize(DisplayHandle, true);
460 if (Environment.GetEnvironmentVariable ("MONO_XEXCEPTIONS") != null) {
461 ErrorExceptions = true;
465 ScreenNo = XDefaultScreen(DisplayHandle);
466 RootWindow = XRootWindow(DisplayHandle, ScreenNo);
467 DefaultColormap = XDefaultColormap(DisplayHandle, ScreenNo);
469 // Create the foster parent
470 // it is important that border_width is kept in synch with the other XCreateWindow calls
471 FosterParent=XCreateSimpleWindow(DisplayHandle, RootWindow, 0, 0, 1, 1, 0, UIntPtr.Zero, UIntPtr.Zero);
472 if (FosterParent==IntPtr.Zero) {
473 Console.WriteLine("XplatUIX11 Constructor failed to create FosterParent");
476 DebugHelper.WriteLine ("FosterParent created 0x{0:x}", FosterParent.ToInt32());
479 hwnd.Queue = ThreadQueue(Thread.CurrentThread);
480 hwnd.WholeWindow = FosterParent;
481 hwnd.ClientWindow = FosterParent;
483 // Create a HWND for RootWIndow as well, so our queue doesn't eat the events
485 hwnd.Queue = ThreadQueue(Thread.CurrentThread);
486 hwnd.whole_window = RootWindow;
487 hwnd.ClientWindow = RootWindow;
489 // For sleeping on the X11 socket
490 listen = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
491 IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, 0);
495 // To wake up when a timer is ready
496 network_buffer = new byte[10];
498 wake = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
499 wake.Connect(listen.LocalEndPoint);
500 wake_receive = listen.Accept();
503 pollfds = new Pollfd [2];
504 pollfds [0] = new Pollfd ();
505 pollfds [0].fd = XConnectionNumber (DisplayHandle);
506 pollfds [0].events = PollEvents.POLLIN;
508 pollfds [1] = new Pollfd ();
509 pollfds [1].fd = wake_receive.Handle.ToInt32 ();
510 pollfds [1].events = PollEvents.POLLIN;
513 Keyboard = new X11Keyboard(DisplayHandle, FosterParent);
514 Dnd = new X11Dnd (DisplayHandle, Keyboard);
516 DoubleClickInterval = 500;
518 HoverState.Interval = 500;
519 HoverState.Timer = new Timer();
520 HoverState.Timer.Enabled = false;
521 HoverState.Timer.Interval = HoverState.Interval;
522 HoverState.Timer.Tick += new EventHandler(MouseHover);
523 HoverState.Size = new Size(4, 4);
527 ActiveWindow = IntPtr.Zero;
528 FocusWindow = IntPtr.Zero;
529 ModalWindows = new Stack(3);
531 MouseState = MouseButtons.None;
532 mouse_position = new Point(0, 0);
534 Caret.Timer = new Timer();
535 Caret.Timer.Interval = 500; // FIXME - where should this number come from?
536 Caret.Timer.Tick += new EventHandler(CaretCallback);
540 // Grab atom changes off the root window to catch certain WM events
541 XSelectInput(DisplayHandle, RootWindow, new IntPtr ((int) (EventMask.PropertyChangeMask | Keyboard.KeyEventMask)));
543 // Handle any upcoming errors
544 ErrorHandler = new XErrorHandler(HandleError);
545 XSetErrorHandler(ErrorHandler);
547 throw new ArgumentNullException("Display", "Could not open display (X-Server required. Check you DISPLAY environment variable)");
550 #endregion // Internal Methods
552 #region Private Methods
553 private int unixtime() {
554 TimeSpan t = (DateTime.UtcNow - new DateTime(1970, 1, 1));
556 return (int) t.TotalSeconds;
559 private static void SetupAtoms() {
560 // make sure this array stays in sync with the statements below
561 string [] atom_names = new string[] {
566 //"_NET_CLIENT_LIST",
567 //"_NET_NUMBER_OF_DESKTOPS",
568 "_NET_DESKTOP_GEOMETRY",
569 //"_NET_DESKTOP_VIEWPORT",
570 "_NET_CURRENT_DESKTOP",
571 //"_NET_DESKTOP_NAMES",
572 "_NET_ACTIVE_WINDOW",
574 //"_NET_SUPPORTING_WM_CHECK",
575 //"_NET_VIRTUAL_ROOTS",
576 //"_NET_DESKTOP_LAYOUT",
577 //"_NET_SHOWING_DESKTOP",
578 //"_NET_CLOSE_WINDOW",
579 //"_NET_MOVERESIZE_WINDOW",
580 "_NET_WM_MOVERESIZE",
581 //"_NET_RESTACK_WINDOW",
582 //"_NET_REQUEST_FRAME_EXTENTS",
584 //"_NET_WM_VISIBLE_NAME",
585 //"_NET_WM_ICON_NAME",
586 //"_NET_WM_VISIBLE_ICON_NAME",
588 "_NET_WM_WINDOW_TYPE",
590 //"_NET_WM_ALLOWED_ACTIONS",
592 //"_NET_WM_STRUT_PARTIAL",
593 //"_NET_WM_ICON_GEOMETRY",
596 //"_NET_WM_HANDLED_ICONS",
598 "_NET_FRAME_EXTENTS",
600 //"_NET_WM_SYNC_REQUEST",
601 "_NET_SYSTEM_TRAY_OPCODE",
602 //"_NET_SYSTEM_TRAY_ORIENTATION",
603 "_NET_WM_STATE_MAXIMIZED_HORZ",
604 "_NET_WM_STATE_MAXIMIZED_VERT",
605 "_NET_WM_STATE_HIDDEN",
609 "_NET_WM_STATE_SKIP_TASKBAR",
610 "_NET_WM_STATE_ABOVE",
611 "_NET_WM_STATE_MODAL",
612 "_NET_WM_CONTEXT_HELP",
613 "_NET_WM_WINDOW_OPACITY",
614 //"_NET_WM_WINDOW_TYPE_DESKTOP",
615 //"_NET_WM_WINDOW_TYPE_DOCK",
616 //"_NET_WM_WINDOW_TYPE_TOOLBAR",
617 //"_NET_WM_WINDOW_TYPE_MENU",
618 "_NET_WM_WINDOW_TYPE_UTILITY",
619 // "_NET_WM_WINDOW_TYPE_DIALOG",
620 //"_NET_WM_WINDOW_TYPE_SPLASH",
621 "_NET_WM_WINDOW_TYPE_NORMAL",
630 "_SWF_PostMessageAtom",
633 IntPtr[] atoms = new IntPtr [atom_names.Length];;
635 XInternAtoms (DisplayHandle, atom_names, atom_names.Length, false, atoms);
638 WM_PROTOCOLS = atoms [off++];
639 WM_DELETE_WINDOW = atoms [off++];
640 WM_TAKE_FOCUS = atoms [off++];
641 //_NET_SUPPORTED = atoms [off++];
642 //_NET_CLIENT_LIST = atoms [off++];
643 //_NET_NUMBER_OF_DESKTOPS = atoms [off++];
644 _NET_DESKTOP_GEOMETRY = atoms [off++];
645 //_NET_DESKTOP_VIEWPORT = atoms [off++];
646 _NET_CURRENT_DESKTOP = atoms [off++];
647 //_NET_DESKTOP_NAMES = atoms [off++];
648 _NET_ACTIVE_WINDOW = atoms [off++];
649 _NET_WORKAREA = atoms [off++];
650 //_NET_SUPPORTING_WM_CHECK = atoms [off++];
651 //_NET_VIRTUAL_ROOTS = atoms [off++];
652 //_NET_DESKTOP_LAYOUT = atoms [off++];
653 //_NET_SHOWING_DESKTOP = atoms [off++];
654 //_NET_CLOSE_WINDOW = atoms [off++];
655 //_NET_MOVERESIZE_WINDOW = atoms [off++];
656 _NET_WM_MOVERESIZE = atoms [off++];
657 //_NET_RESTACK_WINDOW = atoms [off++];
658 //_NET_REQUEST_FRAME_EXTENTS = atoms [off++];
659 _NET_WM_NAME = atoms [off++];
660 //_NET_WM_VISIBLE_NAME = atoms [off++];
661 //_NET_WM_ICON_NAME = atoms [off++];
662 //_NET_WM_VISIBLE_ICON_NAME = atoms [off++];
663 //_NET_WM_DESKTOP = atoms [off++];
664 _NET_WM_WINDOW_TYPE = atoms [off++];
665 _NET_WM_STATE = atoms [off++];
666 //_NET_WM_ALLOWED_ACTIONS = atoms [off++];
667 //_NET_WM_STRUT = atoms [off++];
668 //_NET_WM_STRUT_PARTIAL = atoms [off++];
669 //_NET_WM_ICON_GEOMETRY = atoms [off++];
670 _NET_WM_ICON = atoms [off++];
671 //_NET_WM_PID = atoms [off++];
672 //_NET_WM_HANDLED_ICONS = atoms [off++];
673 _NET_WM_USER_TIME = atoms [off++];
674 _NET_FRAME_EXTENTS = atoms [off++];
675 //_NET_WM_PING = atoms [off++];
676 //_NET_WM_SYNC_REQUEST = atoms [off++];
677 _NET_SYSTEM_TRAY_OPCODE = atoms [off++];
678 //_NET_SYSTEM_TRAY_ORIENTATION = atoms [off++];
679 _NET_WM_STATE_MAXIMIZED_HORZ = atoms [off++];
680 _NET_WM_STATE_MAXIMIZED_VERT = atoms [off++];
681 _NET_WM_STATE_HIDDEN = atoms [off++];
682 _XEMBED = atoms [off++];
683 _XEMBED_INFO = atoms [off++];
684 _MOTIF_WM_HINTS = atoms [off++];
685 _NET_WM_STATE_SKIP_TASKBAR = atoms [off++];
686 _NET_WM_STATE_ABOVE = atoms [off++];
687 _NET_WM_STATE_MODAL = atoms [off++];
688 _NET_WM_CONTEXT_HELP = atoms [off++];
689 _NET_WM_WINDOW_OPACITY = atoms [off++];
690 //_NET_WM_WINDOW_TYPE_DESKTOP = atoms [off++];
691 //_NET_WM_WINDOW_TYPE_DOCK = atoms [off++];
692 //_NET_WM_WINDOW_TYPE_TOOLBAR = atoms [off++];
693 //_NET_WM_WINDOW_TYPE_MENU = atoms [off++];
694 _NET_WM_WINDOW_TYPE_UTILITY = atoms [off++];
695 // _NET_WM_WINDOW_TYPE_DIALOG = atoms [off++];
696 //_NET_WM_WINDOW_TYPE_SPLASH = atoms [off++];
697 _NET_WM_WINDOW_TYPE_NORMAL = atoms [off++];
698 CLIPBOARD = atoms [off++];
699 PRIMARY = atoms [off++];
700 OEMTEXT = atoms [off++];
701 UTF8_STRING = atoms [off++];
702 UTF16_STRING = atoms [off++];
703 RICHTEXTFORMAT = atoms [off++];
704 TARGETS = atoms [off++];
705 AsyncAtom = atoms [off++];
706 PostAtom = atoms [off++];
707 HoverState.Atom = atoms [off++];
709 //DIB = (IntPtr)Atom.XA_PIXMAP;
710 _NET_SYSTEM_TRAY_S = XInternAtom (DisplayHandle, "_NET_SYSTEM_TRAY_S" + ScreenNo.ToString(), false);
713 private void GetSystrayManagerWindow() {
714 XGrabServer(DisplayHandle);
715 SystrayMgrWindow = XGetSelectionOwner(DisplayHandle, _NET_SYSTEM_TRAY_S);
716 XUngrabServer(DisplayHandle);
717 XFlush(DisplayHandle);
720 private void SendNetWMMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) {
721 SendNetWMMessage (window, message_type, l0, l1, l2, IntPtr.Zero);
724 private void SendNetWMMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2, IntPtr l3) {
728 xev.ClientMessageEvent.type = XEventName.ClientMessage;
729 xev.ClientMessageEvent.send_event = true;
730 xev.ClientMessageEvent.window = window;
731 xev.ClientMessageEvent.message_type = message_type;
732 xev.ClientMessageEvent.format = 32;
733 xev.ClientMessageEvent.ptr1 = l0;
734 xev.ClientMessageEvent.ptr2 = l1;
735 xev.ClientMessageEvent.ptr3 = l2;
736 xev.ClientMessageEvent.ptr4 = l3;
737 XSendEvent(DisplayHandle, RootWindow, false, new IntPtr ((int) (EventMask.SubstructureRedirectMask | EventMask.SubstructureNotifyMask)), ref xev);
740 private void SendNetClientMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) {
744 xev.ClientMessageEvent.type = XEventName.ClientMessage;
745 xev.ClientMessageEvent.send_event = true;
746 xev.ClientMessageEvent.window = window;
747 xev.ClientMessageEvent.message_type = message_type;
748 xev.ClientMessageEvent.format = 32;
749 xev.ClientMessageEvent.ptr1 = l0;
750 xev.ClientMessageEvent.ptr2 = l1;
751 xev.ClientMessageEvent.ptr3 = l2;
752 XSendEvent(DisplayHandle, window, false, new IntPtr ((int)EventMask.NoEventMask), ref xev);
755 // For WM_LBUTTONDOWN, WM_MBUTTONDOWN, WM_RBUTTONDOWN, WM_XBUTTONDOWN
756 // WM_CREATE and WM_DESTROY causes
757 void SendParentNotify(IntPtr child, Msg cause, int x, int y)
761 if (child == IntPtr.Zero) {
765 hwnd = Hwnd.GetObjectFromWindow (child);
771 if (hwnd.Handle == IntPtr.Zero) {
775 if (ExStyleSet ((int) hwnd.initial_ex_style, WindowExStyles.WS_EX_NOPARENTNOTIFY)) {
779 if (hwnd.Parent == null) {
783 if (hwnd.Parent.Handle == IntPtr.Zero) {
787 if (cause == Msg.WM_CREATE || cause == Msg.WM_DESTROY) {
788 SendMessage(hwnd.Parent.Handle, Msg.WM_PARENTNOTIFY, Control.MakeParam((int)cause, 0), child);
790 SendMessage(hwnd.Parent.Handle, Msg.WM_PARENTNOTIFY, Control.MakeParam((int)cause, 0), Control.MakeParam(x, y));
793 SendParentNotify (hwnd.Parent.Handle, cause, x, y);
796 bool StyleSet (int s, WindowStyles ws)
798 return (s & (int)ws) == (int)ws;
801 bool ExStyleSet (int ex, WindowExStyles exws)
803 return (ex & (int)exws) == (int)exws;
806 internal static Rectangle TranslateClientRectangleToXClientRectangle (Hwnd hwnd)
808 return TranslateClientRectangleToXClientRectangle (hwnd, Control.FromHandle (hwnd.Handle));
811 internal static Rectangle TranslateClientRectangleToXClientRectangle (Hwnd hwnd, Control ctrl)
814 * If this is a form with no window manager, X is handling all the border and caption painting
815 * so remove that from the area (since the area we set of the window here is the part of the window
816 * we're painting in only)
818 Rectangle rect = hwnd.ClientRect;
819 Form form = ctrl as Form;
820 CreateParams cp = null;
823 cp = form.GetCreateParams ();
825 if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) {
826 Hwnd.Borders borders = Hwnd.GetBorders (cp, null);
827 Rectangle xrect = rect;
829 xrect.Y -= borders.top;
830 xrect.X -= borders.left;
831 xrect.Width += borders.left + borders.right;
832 xrect.Height += borders.top + borders.bottom;
837 if (rect.Width < 1 || rect.Height < 1) {
847 internal static Size TranslateWindowSizeToXWindowSize (CreateParams cp)
849 return TranslateWindowSizeToXWindowSize (cp, new Size (cp.Width, cp.Height));
852 internal static Size TranslateWindowSizeToXWindowSize (CreateParams cp, Size size)
855 * If this is a form with no window manager, X is handling all the border and caption painting
856 * so remove that from the area (since the area we set of the window here is the part of the window
857 * we're painting in only)
859 Form form = cp.control as Form;
860 if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) {
861 Hwnd.Borders borders = Hwnd.GetBorders (cp, null);
864 xrect.Width -= borders.left + borders.right;
865 xrect.Height -= borders.top + borders.bottom;
869 if (size.Height == 0)
876 internal static Size TranslateXWindowSizeToWindowSize (CreateParams cp, int xWidth, int xHeight)
879 * If this is a form with no window manager, X is handling all the border and caption painting
880 * so remove that from the area (since the area we set of the window here is the part of the window
881 * we're painting in only)
883 Size rect = new Size (xWidth, xHeight);
884 Form form = cp.control as Form;
885 if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) {
886 Hwnd.Borders borders = Hwnd.GetBorders (cp, null);
889 xrect.Width += borders.left + borders.right;
890 xrect.Height += borders.top + borders.bottom;
897 internal static Point GetTopLevelWindowLocation (Hwnd hwnd)
903 XTranslateCoordinates (DisplayHandle, hwnd.whole_window, RootWindow, 0, 0, out x, out y, out dummy);
904 frame = FrameExtents (hwnd.whole_window);
909 return new Point (x, y);
912 private 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) {
915 tool_caption_height = 19;
916 border_static = false;
918 if (StyleSet (Style, WindowStyles.WS_CHILD)) {
919 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) {
920 border_style = FormBorderStyle.Fixed3D;
921 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) {
922 border_style = FormBorderStyle.Fixed3D;
923 border_static = true;
924 } else if (!StyleSet (Style, WindowStyles.WS_BORDER)) {
925 border_style = FormBorderStyle.None;
927 border_style = FormBorderStyle.FixedSingle;
929 title_style = TitleStyle.None;
931 if (StyleSet (Style, WindowStyles.WS_CAPTION)) {
933 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
934 title_style = TitleStyle.Tool;
936 title_style = TitleStyle.Normal;
940 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_MDICHILD)) {
943 if (StyleSet (Style, WindowStyles.WS_OVERLAPPEDWINDOW) ||
944 ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
945 border_style = (FormBorderStyle) 0xFFFF;
947 border_style = FormBorderStyle.None;
952 title_style = TitleStyle.None;
953 if (StyleSet (Style, WindowStyles.WS_CAPTION)) {
954 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
955 title_style = TitleStyle.Tool;
957 title_style = TitleStyle.Normal;
961 border_style = FormBorderStyle.None;
963 if (StyleSet (Style, WindowStyles.WS_THICKFRAME)) {
964 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
965 border_style = FormBorderStyle.SizableToolWindow;
967 border_style = FormBorderStyle.Sizable;
970 if (StyleSet (Style, WindowStyles.WS_CAPTION)) {
971 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) {
972 border_style = FormBorderStyle.Fixed3D;
973 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) {
974 border_style = FormBorderStyle.Fixed3D;
975 border_static = true;
976 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) {
977 border_style = FormBorderStyle.FixedDialog;
978 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
979 border_style = FormBorderStyle.FixedToolWindow;
980 } else if (StyleSet (Style, WindowStyles.WS_BORDER)) {
981 border_style = FormBorderStyle.FixedSingle;
984 if (StyleSet (Style, WindowStyles.WS_BORDER)) {
985 border_style = FormBorderStyle.FixedSingle;
992 private void SetHwndStyles(Hwnd hwnd, CreateParams cp) {
993 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);
996 private void SetWMStyles(Hwnd hwnd, CreateParams cp) {
997 MotifWmHints mwmHints;
998 MotifFunctions functions;
999 MotifDecorations decorations;
1002 Rectangle client_rect;
1005 bool hide_from_taskbar;
1006 IntPtr transient_for_parent;
1008 // Windows we manage ourselves don't need WM window styles.
1009 if (cp.HasWindowManager && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) {
1014 mwmHints = new MotifWmHints();
1017 window_type = _NET_WM_WINDOW_TYPE_NORMAL;
1018 transient_for_parent = IntPtr.Zero;
1020 mwmHints.flags = (IntPtr)(MotifFlags.Functions | MotifFlags.Decorations);
1021 mwmHints.functions = (IntPtr)0;
1022 mwmHints.decorations = (IntPtr)0;
1024 form = cp.control as Form;
1026 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
1027 /* tool windows get no window manager
1031 /* just because the window doesn't get any decorations doesn't
1032 mean we should disable the functions. for instance, without
1033 MotifFunctions.Maximize, changing the windowstate to Maximized
1034 is ignored by metacity. */
1035 functions |= MotifFunctions.Move | MotifFunctions.Resize | MotifFunctions.Minimize | MotifFunctions.Maximize;
1036 } else if (form != null && form.FormBorderStyle == FormBorderStyle.None) {
1037 /* allow borderless window to be maximized */
1038 functions |= MotifFunctions.All | MotifFunctions.Resize;
1040 if (StyleSet (cp.Style, WindowStyles.WS_CAPTION)) {
1041 functions |= MotifFunctions.Move;
1042 decorations |= MotifDecorations.Title | MotifDecorations.Menu;
1045 if (StyleSet (cp.Style, WindowStyles.WS_THICKFRAME)) {
1046 functions |= MotifFunctions.Move | MotifFunctions.Resize;
1047 decorations |= MotifDecorations.Border | MotifDecorations.ResizeH;
1050 if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZEBOX)) {
1051 functions |= MotifFunctions.Minimize;
1052 decorations |= MotifDecorations.Minimize;
1055 if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZEBOX)) {
1056 functions |= MotifFunctions.Maximize;
1057 decorations |= MotifDecorations.Maximize;
1060 if (StyleSet (cp.Style, WindowStyles.WS_SIZEBOX)) {
1061 functions |= MotifFunctions.Resize;
1062 decorations |= MotifDecorations.ResizeH;
1065 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) {
1066 decorations |= MotifDecorations.Border;
1069 if (StyleSet (cp.Style, WindowStyles.WS_BORDER)) {
1070 decorations |= MotifDecorations.Border;
1073 if (StyleSet (cp.Style, WindowStyles.WS_DLGFRAME)) {
1074 decorations |= MotifDecorations.Border;
1077 if (StyleSet (cp.Style, WindowStyles.WS_SYSMENU)) {
1078 functions |= MotifFunctions.Close;
1081 functions &= ~(MotifFunctions.Maximize | MotifFunctions.Minimize | MotifFunctions.Close);
1082 decorations &= ~(MotifDecorations.Menu | MotifDecorations.Maximize | MotifDecorations.Minimize);
1083 if (cp.Caption == "") {
1084 functions &= ~MotifFunctions.Move;
1085 decorations &= ~(MotifDecorations.Title | MotifDecorations.ResizeH);
1090 if ((functions & MotifFunctions.Resize) == 0) {
1091 hwnd.fixed_size = true;
1092 Rectangle fixed_rectangle = new Rectangle (cp.X, cp.Y, cp.Width, cp.Height);
1093 SetWindowMinMax(hwnd.Handle, fixed_rectangle, fixed_rectangle.Size, fixed_rectangle.Size, cp);
1095 hwnd.fixed_size = false;
1098 mwmHints.functions = (IntPtr)functions;
1099 mwmHints.decorations = (IntPtr)decorations;
1102 Console.WriteLine ("SetWMStyles ({0}, {1}) functions = {2}, decorations = {3}", hwnd, cp, functions, decorations);
1105 if (cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) {
1106 // needed! map toolwindows to _NET_WM_WINDOW_TYPE_UTILITY to make newer metacity versions happy
1107 // and get those windows in front of their parents
1108 window_type = _NET_WM_WINDOW_TYPE_UTILITY;
1110 window_type = _NET_WM_WINDOW_TYPE_NORMAL;
1113 if (!cp.IsSet (WindowExStyles.WS_EX_APPWINDOW)) {
1114 hide_from_taskbar = true;
1115 } else if (cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW) && form != null && form.Parent != null && !form.ShowInTaskbar) {
1116 hide_from_taskbar = true;
1118 hide_from_taskbar = false;
1121 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
1122 if (form != null && !hwnd.reparented) {
1123 if (form.Owner != null && form.Owner.Handle != IntPtr.Zero) {
1124 Hwnd owner_hwnd = Hwnd.ObjectFromHandle (form.Owner.Handle);
1125 if (owner_hwnd != null)
1126 transient_for_parent = owner_hwnd.whole_window;
1130 if (StyleSet (cp.Style, WindowStyles.WS_POPUP) && (hwnd.parent != null) && (hwnd.parent.whole_window != IntPtr.Zero)) {
1131 transient_for_parent = hwnd.parent.whole_window;
1134 FormWindowState current_state = GetWindowState (hwnd.Handle);
1135 if (current_state == (FormWindowState)(-1))
1136 current_state = FormWindowState.Normal;
1138 client_rect = TranslateClientRectangleToXClientRectangle (hwnd);
1143 atoms [0] = window_type.ToInt32 ();
1144 XChangeProperty (DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
1146 XChangeProperty(DisplayHandle, hwnd.whole_window, _MOTIF_WM_HINTS, _MOTIF_WM_HINTS, 32, PropertyMode.Replace, ref mwmHints, 5);
1148 if (transient_for_parent != IntPtr.Zero) {
1149 XSetTransientForHint (DisplayHandle, hwnd.whole_window, transient_for_parent);
1152 MoveResizeWindow(DisplayHandle, hwnd.client_window, client_rect.X, client_rect.Y, client_rect.Width, client_rect.Height);
1154 if (hide_from_taskbar) {
1155 /* this line keeps the window from showing up in gnome's taskbar */
1156 atoms[atom_count++] = _NET_WM_STATE_SKIP_TASKBAR.ToInt32();
1158 /* we need to add these atoms in the
1159 * event we're maximized, since we're
1160 * replacing the existing
1161 * _NET_WM_STATE here. If we don't
1162 * add them, future calls to
1163 * GetWindowState will return Normal
1164 * for a window which is maximized. */
1165 if (current_state == FormWindowState.Maximized) {
1166 atoms[atom_count++] = _NET_WM_STATE_MAXIMIZED_HORZ.ToInt32();
1167 atoms[atom_count++] = _NET_WM_STATE_MAXIMIZED_VERT.ToInt32();
1170 if (form != null && form.Modal) {
1171 atoms[atom_count++] = _NET_WM_STATE_MODAL.ToInt32 ();
1174 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, atom_count);
1177 IntPtr[] atom_ptrs = new IntPtr[2];
1178 atom_ptrs[atom_count++] = WM_DELETE_WINDOW;
1179 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_CONTEXTHELP)) {
1180 atom_ptrs[atom_count++] = _NET_WM_CONTEXT_HELP;
1183 XSetWMProtocols(DisplayHandle, hwnd.whole_window, atom_ptrs, atom_count);
1187 private void SetIcon(Hwnd hwnd, Icon icon)
1192 // This really needs to do whatever it
1193 // takes to remove the window manager
1194 // menu, not just delete the ICON
1195 // property. This will cause metacity
1196 // to use the "no icon set" icon, and
1197 // we'll still have an icon.
1198 XDeleteProperty (DisplayHandle, hwnd.whole_window, _NET_WM_ICON);
1206 bitmap = icon.ToBitmap();
1208 size = bitmap.Width * bitmap.Height + 2;
1209 data = new IntPtr[size];
1211 data[index++] = (IntPtr)bitmap.Width;
1212 data[index++] = (IntPtr)bitmap.Height;
1214 for (int y = 0; y < bitmap.Height; y++) {
1215 for (int x = 0; x < bitmap.Width; x++) {
1216 data[index++] = (IntPtr)bitmap.GetPixel (x, y).ToArgb ();
1220 XChangeProperty (DisplayHandle, hwnd.whole_window,
1221 _NET_WM_ICON, (IntPtr)Atom.XA_CARDINAL, 32,
1222 PropertyMode.Replace, data, size);
1226 private void WakeupMain () {
1227 wake.Send (new byte [] { 0xFF });
1230 private XEventQueue ThreadQueue(Thread thread) {
1233 queue = (XEventQueue)MessageQueues[thread];
1234 if (queue == null) {
1235 queue = new XEventQueue(thread);
1236 MessageQueues[thread] = queue;
1242 private void TranslatePropertyToClipboard(IntPtr property) {
1247 IntPtr prop = IntPtr.Zero;
1249 Clipboard.Item = null;
1251 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);
1253 if ((long)nitems > 0) {
1254 if (property == (IntPtr)Atom.XA_STRING) {
1255 // Some X managers/apps pass unicode chars as escaped strings, so
1256 // we may need to unescape them.
1257 Clipboard.Item = UnescapeUnicodeFromAnsi (Marshal.PtrToStringAnsi(prop));
1258 } else if (property == (IntPtr)Atom.XA_BITMAP) {
1259 // FIXME - convert bitmap to image
1260 } else if (property == (IntPtr)Atom.XA_PIXMAP) {
1261 // FIXME - convert pixmap to image
1262 } else if (property == OEMTEXT) {
1263 Clipboard.Item = UnescapeUnicodeFromAnsi (Marshal.PtrToStringAnsi(prop));
1264 } else if (property == UTF8_STRING) {
1265 byte [] buffer = new byte [(int)nitems];
1266 for (int i = 0; i < (int)nitems; i++)
1267 buffer [i] = Marshal.ReadByte (prop, i);
1268 Clipboard.Item = Encoding.UTF8.GetString (buffer);
1269 } else if (property == UTF16_STRING) {
1270 Clipboard.Item = Marshal.PtrToStringUni (prop, Encoding.Unicode.GetMaxCharCount ((int)nitems));
1271 } else if (property == RICHTEXTFORMAT)
1272 Clipboard.Item = Marshal.PtrToStringAnsi(prop);
1273 else if (DataFormats.ContainsFormat (property.ToInt32 ())) {
1274 if (DataFormats.GetFormat (property.ToInt32 ()).is_serializable) {
1275 MemoryStream memory_stream = new MemoryStream ((int)nitems);
1276 for (int i = 0; i < (int)nitems; i++)
1277 memory_stream.WriteByte (Marshal.ReadByte (prop, i));
1279 memory_stream.Position = 0;
1280 BinaryFormatter formatter = new BinaryFormatter ();
1281 Clipboard.Item = formatter.Deserialize (memory_stream);
1282 memory_stream.Close ();
1290 private string UnescapeUnicodeFromAnsi (string value)
1292 if (value == null || value.IndexOf ("\\u") == -1)
1295 StringBuilder sb = new StringBuilder (value.Length);
1299 while (start < value.Length) {
1300 pos = value.IndexOf ("\\u", start);
1304 sb.Append (value, start, pos - start);
1309 while (pos < value.Length) {
1310 if (!Char.IsLetterOrDigit (value [pos]))
1317 if (!Int32.TryParse (value.Substring (start, length), System.Globalization.NumberStyles.HexNumber,
1319 return value; // Error, return the unescaped original value.
1321 sb.Append ((char)res);
1325 // Append any remaining data.
1326 if (start < value.Length)
1327 sb.Append (value, start, value.Length - start);
1329 return sb.ToString ();
1332 private void AddExpose (Hwnd hwnd, bool client, int x, int y, int width, int height) {
1334 if ((hwnd == null) || (x > hwnd.Width) || (y > hwnd.Height) || ((x + width) < 0) || ((y + height) < 0)) {
1338 // Keep the invalid area as small as needed
1339 if ((x + width) > hwnd.width) {
1340 width = hwnd.width - x;
1343 if ((y + height) > hwnd.height) {
1344 height = hwnd.height - y;
1348 hwnd.AddInvalidArea(x, y, width, height);
1349 if (!hwnd.expose_pending) {
1350 if (!hwnd.nc_expose_pending) {
1351 hwnd.Queue.Paint.Enqueue(hwnd);
1353 hwnd.expose_pending = true;
1356 hwnd.AddNcInvalidArea (x, y, width, height);
1358 if (!hwnd.nc_expose_pending) {
1359 if (!hwnd.expose_pending) {
1360 hwnd.Queue.Paint.Enqueue(hwnd);
1362 hwnd.nc_expose_pending = true;
1367 private static Hwnd.Borders FrameExtents (IntPtr window)
1373 IntPtr prop = IntPtr.Zero;
1374 Hwnd.Borders rect = new Hwnd.Borders ();
1376 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);
1377 if (prop != IntPtr.Zero) {
1378 if (nitems.ToInt32 () == 4) {
1379 rect.left = Marshal.ReadInt32 (prop, 0);
1380 rect.right = Marshal.ReadInt32 (prop, IntPtr.Size);
1381 rect.top = Marshal.ReadInt32 (prop, 2 * IntPtr.Size);
1382 rect.bottom = Marshal.ReadInt32 (prop, 3 * IntPtr.Size);
1390 private void AddConfigureNotify (XEvent xevent) {
1393 hwnd = Hwnd.GetObjectFromWindow(xevent.ConfigureEvent.window);
1396 if (hwnd == null || hwnd.zombie) {
1399 if ((xevent.ConfigureEvent.window == hwnd.whole_window)/* && (xevent.ConfigureEvent.window == xevent.ConfigureEvent.xevent)*/) {
1400 if (hwnd.parent == null) {
1401 // The location given by the event is not reliable between different wm's,
1402 // so use an alternative way of getting it.
1403 Point location = GetTopLevelWindowLocation (hwnd);
1404 hwnd.x = location.X;
1405 hwnd.y = location.Y;
1408 // XXX this sucks. this isn't thread safe
1409 Control ctrl = Control.FromHandle (hwnd.Handle);
1410 Size TranslatedSize;
1412 TranslatedSize = TranslateXWindowSizeToWindowSize (ctrl.GetCreateParams (), xevent.ConfigureEvent.width, xevent.ConfigureEvent.height);
1414 TranslatedSize = new Size (xevent.ConfigureEvent.width, xevent.ConfigureEvent.height);
1416 hwnd.width = TranslatedSize.Width;
1417 hwnd.height = TranslatedSize.Height;
1418 hwnd.ClientRect = Rectangle.Empty;
1421 Console.WriteLine ("AddConfigureNotify (hwnd.Handle = {1}, final hwnd.rect = {0}, reported rect={2})", new Rectangle (hwnd.x, hwnd.y, hwnd.width, hwnd.height), hwnd.Handle, new Rectangle (xevent.ConfigureEvent.x, xevent.ConfigureEvent.y, xevent.ConfigureEvent.width, xevent.ConfigureEvent.width));
1423 lock (hwnd.configure_lock) {
1424 if (!hwnd.configure_pending) {
1425 hwnd.Queue.EnqueueLocked (xevent);
1426 hwnd.configure_pending = true;
1430 // We drop configure events for Client windows
1433 private void ShowCaret() {
1434 if ((Caret.gc == IntPtr.Zero) || Caret.On) {
1440 XDrawLine(DisplayHandle, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height);
1444 private void HideCaret() {
1445 if ((Caret.gc == IntPtr.Zero) || !Caret.On) {
1451 XDrawLine(DisplayHandle, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height);
1455 private int NextTimeout (ArrayList timers, DateTime now) {
1458 foreach (Timer timer in timers) {
1459 int next = (int) (timer.Expires - now).TotalMilliseconds;
1461 return 0; // Have a timer that has already expired
1464 if (next < timeout) {
1468 if (timeout < Timer.Minimum) {
1469 timeout = Timer.Minimum;
1477 private void CheckTimers (ArrayList timers, DateTime now) {
1480 count = timers.Count;
1485 for (int i = 0; i < timers.Count; i++) {
1488 timer = (Timer) timers [i];
1490 if (timer.Enabled && timer.Expires <= now && !timer.Busy) {
1492 // - Before MainForm.OnLoad if DoEvents () is called.
1493 // - After MainForm.OnLoad if not.
1496 (Application.MWFThread.Current.Context != null &&
1497 (Application.MWFThread.Current.Context.MainForm == null ||
1498 Application.MWFThread.Current.Context.MainForm.IsLoaded))) {
1508 private void WaitForHwndMessage (Hwnd hwnd, Msg message) {
1509 WaitForHwndMessage (hwnd, message, false);
1513 private void WaitForHwndMessage (Hwnd hwnd, Msg message, bool process) {
1514 MSG msg = new MSG ();
1517 queue = ThreadQueue(Thread.CurrentThread);
1519 queue.DispatchIdle = false;
1522 string key = hwnd.Handle + ":" + message;
1523 if (!messageHold.ContainsKey (key))
1524 messageHold.Add (key, 1);
1526 messageHold[key] = ((int)messageHold[key]) + 1;
1531 DebugHelper.WriteLine ("Waiting for message " + message + " on hwnd " + String.Format("0x{0:x}", hwnd.Handle.ToInt32 ()));
1532 DebugHelper.Indent ();
1534 if (PeekMessage(queue, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) {
1535 if ((Msg)msg.message == Msg.WM_QUIT) {
1536 PostQuitMessage (0);
1541 DebugHelper.WriteLine ("PeekMessage got " + msg);
1543 if (msg.hwnd == hwnd.Handle) {
1544 if ((Msg)msg.message == message) {
1546 TranslateMessage (ref msg);
1547 DispatchMessage (ref msg);
1551 else if ((Msg)msg.message == Msg.WM_DESTROY)
1555 TranslateMessage (ref msg);
1556 DispatchMessage (ref msg);
1560 done = !messageHold.ContainsKey (key) || ((int)messageHold[key] < 1) || done;
1563 messageHold.Remove (key);
1565 DebugHelper.Unindent ();
1566 DebugHelper.WriteLine ("Finished waiting for " + key);
1568 queue.DispatchIdle = true;
1572 private void MapWindow(Hwnd hwnd, WindowType windows) {
1574 Form f = Control.FromHandle(hwnd.Handle) as Form;
1576 if (f.WindowState == FormWindowState.Normal) {
1577 f.waiting_showwindow = true;
1578 SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero);
1582 // it's possible that our Hwnd is no
1583 // longer valid after making that
1584 // SendMessage call, so check here.
1588 if ((windows & WindowType.Whole) != 0) {
1589 XMapWindow(DisplayHandle, hwnd.whole_window);
1591 if ((windows & WindowType.Client) != 0) {
1592 XMapWindow(DisplayHandle, hwnd.client_window);
1598 if (f.waiting_showwindow) {
1599 WaitForHwndMessage (hwnd, Msg.WM_SHOWWINDOW);
1600 CreateParams cp = f.GetCreateParams();
1601 if (!ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_MDICHILD) &&
1602 !StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
1603 WaitForHwndMessage (hwnd, Msg.WM_ACTIVATE, true);
1610 private void UnmapWindow(Hwnd hwnd, WindowType windows) {
1613 if (Control.FromHandle(hwnd.Handle) is Form) {
1614 f = Control.FromHandle(hwnd.Handle) as Form;
1615 if (f.WindowState == FormWindowState.Normal) {
1616 f.waiting_showwindow = true;
1617 SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, IntPtr.Zero, IntPtr.Zero);
1621 // it's possible that our Hwnd is no
1622 // longer valid after making that
1623 // SendMessage call, so check here.
1624 // FIXME: it is likely wrong, as it has already sent WM_SHOWWINDOW
1628 if ((windows & WindowType.Client) != 0) {
1629 XUnmapWindow(DisplayHandle, hwnd.client_window);
1631 if ((windows & WindowType.Whole) != 0) {
1632 XUnmapWindow(DisplayHandle, hwnd.whole_window);
1635 hwnd.mapped = false;
1638 if (f.waiting_showwindow) {
1639 WaitForHwndMessage (hwnd, Msg.WM_SHOWWINDOW);
1640 CreateParams cp = f.GetCreateParams();
1641 if (!ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_MDICHILD) &&
1642 !StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
1643 WaitForHwndMessage (hwnd, Msg.WM_ACTIVATE, true);
1650 private void UpdateMessageQueue (XEventQueue queue) {
1655 now = DateTime.UtcNow;
1658 pending = XPending (DisplayHandle);
1662 if ((queue == null || queue.DispatchIdle) && Idle != null) {
1663 Idle (this, EventArgs.Empty);
1667 pending = XPending (DisplayHandle);
1674 if (queue != null) {
1675 if (queue.Paint.Count > 0)
1678 timeout = NextTimeout (queue.timer_list, now);
1683 int length = pollfds.Length - 1;
1684 lock (wake_waiting_lock) {
1685 if (wake_waiting == false) {
1687 wake_waiting = true;
1691 Syscall.poll (pollfds, (uint)length, timeout);
1692 // Clean out buffer, so we're not busy-looping on the same data
1693 if (length == pollfds.Length) {
1694 if (pollfds[1].revents != 0)
1695 wake_receive.Receive(network_buffer, 0, 1, SocketFlags.None);
1696 lock (wake_waiting_lock) {
1697 wake_waiting = false;
1702 pending = XPending (DisplayHandle);
1708 CheckTimers (queue.timer_list, now);
1711 XEvent xevent = new XEvent ();
1714 if (XPending (DisplayHandle) == 0)
1717 XNextEvent (DisplayHandle, ref xevent);
1719 if (xevent.AnyEvent.type == XEventName.KeyPress ||
1720 xevent.AnyEvent.type == XEventName.KeyRelease) {
1721 // PreFilter() handles "shift key state updates.
1722 Keyboard.PreFilter (xevent);
1723 if (XFilterEvent (ref xevent, Keyboard.ClientWindow)) {
1724 // probably here we could raise WM_IME_KEYDOWN and
1725 // WM_IME_KEYUP, but I'm not sure it is worthy.
1729 else if (XFilterEvent (ref xevent, IntPtr.Zero))
1733 hwnd = Hwnd.GetObjectFromWindow(xevent.AnyEvent.window);
1738 Console.WriteLine ("UpdateMessageQueue (), got Event: {0}", xevent.ToString ());
1740 DebugHelper.WriteLine ("UpdateMessageQueue got Event: " + xevent.ToString ());
1742 switch (xevent.type) {
1743 case XEventName.Expose:
1744 AddExpose (hwnd, xevent.ExposeEvent.window == hwnd.ClientWindow, xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height);
1747 case XEventName.SelectionClear: {
1748 // Should we do something?
1752 case XEventName.SelectionRequest: {
1753 if (Dnd.HandleSelectionRequestEvent (ref xevent))
1757 sel_event = new XEvent();
1758 sel_event.SelectionEvent.type = XEventName.SelectionNotify;
1759 sel_event.SelectionEvent.send_event = true;
1760 sel_event.SelectionEvent.display = DisplayHandle;
1761 sel_event.SelectionEvent.selection = xevent.SelectionRequestEvent.selection;
1762 sel_event.SelectionEvent.target = xevent.SelectionRequestEvent.target;
1763 sel_event.SelectionEvent.requestor = xevent.SelectionRequestEvent.requestor;
1764 sel_event.SelectionEvent.time = xevent.SelectionRequestEvent.time;
1765 sel_event.SelectionEvent.property = IntPtr.Zero;
1767 IntPtr format_atom = xevent.SelectionRequestEvent.target;
1769 // Seems that some apps support asking for supported types
1770 if (format_atom == TARGETS) {
1777 if (Clipboard.IsSourceText) {
1778 atoms[atom_count++] = (int)Atom.XA_STRING;
1779 atoms[atom_count++] = (int)OEMTEXT;
1780 atoms[atom_count++] = (int)UTF8_STRING;
1781 atoms[atom_count++] = (int)UTF16_STRING;
1782 atoms[atom_count++] = (int)RICHTEXTFORMAT;
1783 } else if (Clipboard.IsSourceImage) {
1784 atoms[atom_count++] = (int)Atom.XA_PIXMAP;
1785 atoms[atom_count++] = (int)Atom.XA_BITMAP;
1787 // FIXME - handle other types
1790 XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property,
1791 (IntPtr)xevent.SelectionRequestEvent.target, 32, PropertyMode.Replace, atoms, atom_count);
1792 sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1793 } else if (format_atom == (IntPtr)RICHTEXTFORMAT) {
1794 string rtf_text = Clipboard.GetRtfText ();
1795 if (rtf_text != null) {
1796 // The RTF spec mentions that ascii is enough to contain it
1797 Byte [] bytes = Encoding.ASCII.GetBytes (rtf_text);
1798 int buflen = bytes.Length;
1799 IntPtr buffer = Marshal.AllocHGlobal (buflen);
1801 for (int i = 0; i < buflen; i++)
1802 Marshal.WriteByte (buffer, i, bytes[i]);
1804 XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property,
1805 (IntPtr)xevent.SelectionRequestEvent.target, 8, PropertyMode.Replace, buffer, buflen);
1806 sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1807 Marshal.FreeHGlobal(buffer);
1809 } else if (Clipboard.IsSourceText &&
1810 (format_atom == (IntPtr)Atom.XA_STRING
1811 || format_atom == OEMTEXT
1812 || format_atom == UTF16_STRING
1813 || format_atom == UTF8_STRING)) {
1814 IntPtr buffer = IntPtr.Zero;
1816 Encoding encoding = null;
1820 // Select an encoding depending on the target
1821 IntPtr target_atom = xevent.SelectionRequestEvent.target;
1822 if (target_atom == (IntPtr)Atom.XA_STRING || target_atom == OEMTEXT)
1823 // FIXME - EOMTEXT should encode into ISO2022
1824 encoding = Encoding.ASCII;
1825 else if (target_atom == UTF16_STRING)
1826 encoding = Encoding.Unicode;
1827 else if (target_atom == UTF8_STRING)
1828 encoding = Encoding.UTF8;
1832 bytes = encoding.GetBytes (Clipboard.GetPlainText ());
1833 buffer = Marshal.AllocHGlobal (bytes.Length);
1834 buflen = bytes.Length;
1836 for (int i = 0; i < buflen; i++)
1837 Marshal.WriteByte (buffer, i, bytes [i]);
1839 if (buffer != IntPtr.Zero) {
1840 XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, (IntPtr)xevent.SelectionRequestEvent.target, 8, PropertyMode.Replace, buffer, buflen);
1841 sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1842 Marshal.FreeHGlobal(buffer);
1844 } else if (Clipboard.GetSource (format_atom.ToInt32 ()) != null) { // check if we have an available value of this format
1845 if (DataFormats.GetFormat (format_atom.ToInt32 ()).is_serializable) {
1846 object serializable = Clipboard.GetSource (format_atom.ToInt32 ());
1848 BinaryFormatter formatter = new BinaryFormatter ();
1849 MemoryStream memory_stream = new MemoryStream ();
1850 formatter.Serialize (memory_stream, serializable);
1852 int buflen = (int)memory_stream.Length;
1853 IntPtr buffer = Marshal.AllocHGlobal (buflen);
1854 memory_stream.Position = 0;
1855 for (int i = 0; i < buflen; i++)
1856 Marshal.WriteByte (buffer, i, (byte)memory_stream.ReadByte ());
1857 memory_stream.Close ();
1859 XChangeProperty (DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, (IntPtr)xevent.SelectionRequestEvent.target,
1860 8, PropertyMode.Replace, buffer, buflen);
1861 sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1862 Marshal.FreeHGlobal (buffer);
1865 } else if (Clipboard.IsSourceImage) {
1866 if (xevent.SelectionEvent.target == (IntPtr)Atom.XA_PIXMAP) {
1867 // FIXME - convert image and store as property
1868 } else if (xevent.SelectionEvent.target == (IntPtr)Atom.XA_PIXMAP) {
1869 // FIXME - convert image and store as property
1873 XSendEvent(DisplayHandle, xevent.SelectionRequestEvent.requestor, false, new IntPtr ((int)EventMask.NoEventMask), ref sel_event);
1877 case XEventName.SelectionNotify: {
1878 if (Clipboard.Enumerating) {
1879 Clipboard.Enumerating = false;
1880 if (xevent.SelectionEvent.property != IntPtr.Zero) {
1881 XDeleteProperty(DisplayHandle, FosterParent, (IntPtr)xevent.SelectionEvent.property);
1882 if (!Clipboard.Formats.Contains(xevent.SelectionEvent.property)) {
1883 Clipboard.Formats.Add(xevent.SelectionEvent.property);
1884 #if DriverDebugExtra
1885 Console.WriteLine("Got supported clipboard atom format: {0}", xevent.SelectionEvent.property);
1889 } else if (Clipboard.Retrieving) {
1890 Clipboard.Retrieving = false;
1891 if (xevent.SelectionEvent.property != IntPtr.Zero) {
1892 TranslatePropertyToClipboard(xevent.SelectionEvent.property);
1894 Clipboard.ClearSources ();
1895 Clipboard.Item = null;
1898 Dnd.HandleSelectionNotifyEvent (ref xevent);
1903 case XEventName.KeyRelease:
1904 if (!detectable_key_auto_repeat && XPending (DisplayHandle) != 0) {
1905 XEvent nextevent = new XEvent ();
1907 XPeekEvent (DisplayHandle, ref nextevent);
1909 if (nextevent.type == XEventName.KeyPress &&
1910 nextevent.KeyEvent.keycode == xevent.KeyEvent.keycode &&
1911 nextevent.KeyEvent.time == xevent.KeyEvent.time) {
1915 goto case XEventName.KeyPress;
1917 case XEventName.MotionNotify: {
1920 /* we can't do motion compression across threads, so just punt if we don't match up */
1921 if (Thread.CurrentThread == hwnd.Queue.Thread && hwnd.Queue.Count > 0) {
1922 peek = hwnd.Queue.Peek();
1923 if (peek.AnyEvent.type == XEventName.MotionNotify) {
1927 goto case XEventName.KeyPress;
1930 case XEventName.KeyPress:
1931 hwnd.Queue.EnqueueLocked (xevent);
1932 /* Process KeyPresses immediately. Otherwise multiple Compose messages as a result of a
1933 * single physical keypress are not processed correctly */
1935 case XEventName.ButtonPress:
1936 case XEventName.ButtonRelease:
1937 case XEventName.EnterNotify:
1938 case XEventName.LeaveNotify:
1939 case XEventName.CreateNotify:
1940 case XEventName.DestroyNotify:
1941 case XEventName.FocusIn:
1942 case XEventName.FocusOut:
1943 case XEventName.ClientMessage:
1944 case XEventName.ReparentNotify:
1945 case XEventName.MapNotify:
1946 case XEventName.UnmapNotify:
1947 hwnd.Queue.EnqueueLocked (xevent);
1950 case XEventName.ConfigureNotify:
1951 AddConfigureNotify(xevent);
1954 case XEventName.PropertyNotify:
1956 Console.WriteLine ("UpdateMessageQueue (), got Event: {0}", xevent.ToString ());
1958 if (xevent.PropertyEvent.atom == _NET_ACTIVE_WINDOW) {
1963 IntPtr prop = IntPtr.Zero;
1966 prev_active = ActiveWindow;
1967 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);
1968 if (((long)nitems > 0) && (prop != IntPtr.Zero)) {
1969 ActiveWindow = Hwnd.GetHandleFromWindow((IntPtr)Marshal.ReadInt32(prop));
1972 DebugHelper.WriteLine ("PropertyNotify: _NET_ACTIVE_WINDOW: previous = 0x{0:x}, new = 0x{1:x}", prev_active.ToInt32 (), ActiveWindow.ToInt32 ());
1974 if (prev_active != ActiveWindow) {
1975 if (prev_active != IntPtr.Zero) {
1976 PostMessage(prev_active, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero);
1978 if (ActiveWindow != IntPtr.Zero) {
1979 PostMessage(ActiveWindow, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_ACTIVE, IntPtr.Zero);
1982 if (ModalWindows.Count == 0) {
1985 // Modality Handling
1987 // If there is a modal window on the stack and the new active
1988 // window is MWF window, but not the modal one and not a non-modal
1989 // child of the modal one, switch back to the modal window.
1991 // To identify if a non-modal form is child of a modal form
1992 // we match their ApplicationContexts, which will be the same.
1993 // This is because each modal form runs the loop with a
1994 // new ApplicationContext, which is inherited by the non-modal
1997 Form activeForm = Control.FromHandle (ActiveWindow) as Form;
1998 if (activeForm != null) {
1999 Form modalForm = Control.FromHandle ((IntPtr)ModalWindows.Peek()) as Form;
2000 if (ActiveWindow != (IntPtr)ModalWindows.Peek() &&
2001 (modalForm == null || activeForm.context == modalForm.context)) {
2002 Activate((IntPtr)ModalWindows.Peek());
2009 else if (xevent.PropertyEvent.atom == _NET_WM_STATE) {
2010 // invalidate our cache - we'll query again the next time someone does GetWindowState.
2011 hwnd.cached_window_state = (FormWindowState)(-1);
2012 PostMessage (hwnd.Handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
2020 private IntPtr GetMousewParam(int Delta) {
2023 if ((MouseState & MouseButtons.Left) != 0) {
2024 result |= (int)MsgButtons.MK_LBUTTON;
2027 if ((MouseState & MouseButtons.Middle) != 0) {
2028 result |= (int)MsgButtons.MK_MBUTTON;
2031 if ((MouseState & MouseButtons.Right) != 0) {
2032 result |= (int)MsgButtons.MK_RBUTTON;
2035 Keys mods = ModifierKeys;
2036 if ((mods & Keys.Control) != 0) {
2037 result |= (int)MsgButtons.MK_CONTROL;
2040 if ((mods & Keys.Shift) != 0) {
2041 result |= (int)MsgButtons.MK_SHIFT;
2044 result |= Delta << 16;
2046 return (IntPtr)result;
2048 private IntPtr XGetParent(IntPtr handle) {
2055 XQueryTree(DisplayHandle, handle, out Root, out Parent, out Children, out ChildCount);
2058 if (Children!=IntPtr.Zero) {
2066 private int HandleError (IntPtr display, ref XErrorEvent error_event)
2068 // we need to workaround a problem with the
2069 // ordering of destruction of Drawables and
2070 // Pictures that exists between cairo and
2071 // RENDER on the server.
2072 if (error_event.request_code == (XRequest)render_major_opcode
2073 && error_event.minor_code == 7 /* X_RenderFreePicture from render.h */
2074 && error_event.error_code == render_first_error + 1 /* BadPicture from render.h */) {
2078 if (ErrorExceptions) {
2079 XUngrabPointer (display, IntPtr.Zero);
2080 throw new XException (error_event.display, error_event.resourceid,
2081 error_event.serial, error_event.error_code,
2082 error_event.request_code, error_event.minor_code);
2084 Console.WriteLine("X11 Error encountered: {0}{1}\n",
2085 XException.GetMessage (error_event.display, error_event.resourceid,
2086 error_event.serial, error_event.error_code,
2087 error_event.request_code, error_event.minor_code),
2088 Environment.StackTrace);
2093 private void AccumulateDestroyedHandles (Control c, ArrayList list)
2095 DebugHelper.Enter ();
2098 Control[] controls = c.Controls.GetAllControls ();
2100 DebugHelper.WriteLine ("Checking control:0x{0:x}", c.IsHandleCreated ? c.Handle.ToInt32() : 0);
2102 if (c.IsHandleCreated && !c.IsDisposed) {
2103 Hwnd hwnd = Hwnd.ObjectFromHandle(c.Handle);
2105 #if DriverDebug || DriverDebugDestroy
2106 Console.WriteLine (" + adding {0} to the list of zombie windows", XplatUI.Window (hwnd.Handle));
2107 Console.WriteLine (" + parent X window is {0:X}", XGetParent (hwnd.whole_window).ToInt32());
2111 CleanupCachedWindows (hwnd);
2114 for (int i = 0; i < controls.Length; i ++) {
2115 AccumulateDestroyedHandles (controls[i], list);
2118 DebugHelper.Leave ();
2121 void CleanupCachedWindows (Hwnd hwnd)
2123 if (ActiveWindow == hwnd.Handle) {
2124 SendMessage(hwnd.client_window, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero);
2125 ActiveWindow = IntPtr.Zero;
2128 if (FocusWindow == hwnd.Handle) {
2129 SendMessage(hwnd.client_window, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero);
2130 FocusWindow = IntPtr.Zero;
2133 if (Grab.Hwnd == hwnd.Handle) {
2134 Grab.Hwnd = IntPtr.Zero;
2135 Grab.Confined = false;
2138 DestroyCaret (hwnd.Handle);
2141 private void PerformNCCalc(Hwnd hwnd) {
2142 XplatUIWin32.NCCALCSIZE_PARAMS ncp;
2146 rect = new Rectangle (0, 0, hwnd.Width, hwnd.Height);
2148 ncp = new XplatUIWin32.NCCALCSIZE_PARAMS();
2149 ptr = Marshal.AllocHGlobal(Marshal.SizeOf(ncp));
2151 ncp.rgrc1.left = rect.Left;
2152 ncp.rgrc1.top = rect.Top;
2153 ncp.rgrc1.right = rect.Right;
2154 ncp.rgrc1.bottom = rect.Bottom;
2156 Marshal.StructureToPtr(ncp, ptr, true);
2157 NativeWindow.WndProc(hwnd.client_window, Msg.WM_NCCALCSIZE, (IntPtr)1, ptr);
2158 ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure(ptr, typeof(XplatUIWin32.NCCALCSIZE_PARAMS));
2159 Marshal.FreeHGlobal(ptr);
2162 rect = new Rectangle(ncp.rgrc1.left, ncp.rgrc1.top, ncp.rgrc1.right - ncp.rgrc1.left, ncp.rgrc1.bottom - ncp.rgrc1.top);
2163 hwnd.ClientRect = rect;
2165 rect = TranslateClientRectangleToXClientRectangle (hwnd);
2168 MoveResizeWindow (DisplayHandle, hwnd.client_window, rect.X, rect.Y, rect.Width, rect.Height);
2171 AddExpose (hwnd, hwnd.WholeWindow == hwnd.ClientWindow, 0, 0, hwnd.Width, hwnd.Height);
2173 #endregion // Private Methods
2176 private void MouseHover(object sender, EventArgs e) {
2180 HoverState.Timer.Enabled = false;
2182 if (HoverState.Window != IntPtr.Zero) {
2183 hwnd = Hwnd.GetObjectFromWindow(HoverState.Window);
2185 xevent = new XEvent ();
2187 xevent.type = XEventName.ClientMessage;
2188 xevent.ClientMessageEvent.display = DisplayHandle;
2189 xevent.ClientMessageEvent.window = HoverState.Window;
2190 xevent.ClientMessageEvent.message_type = HoverState.Atom;
2191 xevent.ClientMessageEvent.format = 32;
2192 xevent.ClientMessageEvent.ptr1 = (IntPtr) (HoverState.Y << 16 | HoverState.X);
2194 hwnd.Queue.EnqueueLocked (xevent);
2201 private void CaretCallback(object sender, EventArgs e) {
2205 Caret.On = !Caret.On;
2207 XDrawLine(DisplayHandle, Caret.Hwnd, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height);
2209 #endregion // Callbacks
2211 #region Public Properties
2213 internal override int CaptionHeight {
2219 internal override Size CursorSize {
2224 if (XQueryBestCursor(DisplayHandle, RootWindow, 32, 32, out x, out y) != 0) {
2225 return new Size(x, y);
2227 return new Size(16, 16);
2232 internal override bool DragFullWindows {
2238 internal override Size DragSize {
2240 return new Size(4, 4);
2244 internal override Size FrameBorderSize {
2246 return new Size (4, 4);
2250 internal override Size IconSize {
2256 if (XGetIconSizes(DisplayHandle, RootWindow, out list, out count) != 0) {
2260 current = (long)list;
2263 size = new XIconSize();
2265 for (int i = 0; i < count; i++) {
2266 size = (XIconSize)Marshal.PtrToStructure((IntPtr)current, size.GetType());
2267 current += Marshal.SizeOf(size);
2269 // Look for our preferred size
2270 if (size.min_width == 32) {
2272 return new Size(32, 32);
2275 if (size.max_width == 32) {
2277 return new Size(32, 32);
2280 if (size.min_width < 32 && size.max_width > 32) {
2283 // check if we can fit one
2285 while (x < size.max_width) {
2286 x += size.width_inc;
2289 return new Size(32, 32);
2294 if (largest < size.max_width) {
2295 largest = size.max_width;
2299 // We didn't find a match or we wouldn't be here
2300 return new Size(largest, largest);
2303 return new Size(32, 32);
2308 internal override int KeyboardSpeed {
2311 // A lot harder: need to do:
2312 // XkbQueryExtension(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58) = 1
2313 // XkbAllocKeyboard(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58) = 0x080517a8
2314 // XkbGetControls(0x08051008, 1, 0x080517a8, 0xbfffdf54, 0xbfffdf58) = 0
2316 // And from that we can tell the repetition rate
2318 // Notice, the values must map to:
2319 // [0, 31] which maps to 2.5 to 30 repetitions per second.
2325 internal override int KeyboardDelay {
2328 // Return values must range from 0 to 4, 0 meaning 250ms,
2329 // and 4 meaning 1000 ms.
2331 return 1; // ie, 500 ms
2335 internal override Size MaxWindowTrackSize {
2337 return new Size (WorkingArea.Width, WorkingArea.Height);
2341 internal override bool MenuAccessKeysUnderlined {
2347 internal override Size MinimizedWindowSpacingSize {
2349 return new Size(1, 1);
2353 internal override Size MinimumWindowSize {
2355 return new Size(110, 22);
2359 internal override Size MinimumFixedToolWindowSize {
2360 get { return new Size (27, 22); }
2363 internal override Size MinimumSizeableToolWindowSize {
2364 get { return new Size (37, 22); }
2367 internal override Size MinimumNoBorderWindowSize {
2368 get { return new Size (2, 2); }
2371 internal override Keys ModifierKeys {
2373 return Keyboard.ModifierKeys;
2377 internal override Size SmallIconSize {
2383 if (XGetIconSizes(DisplayHandle, RootWindow, out list, out count) != 0) {
2387 current = (long)list;
2390 size = new XIconSize();
2392 for (int i = 0; i < count; i++) {
2393 size = (XIconSize)Marshal.PtrToStructure((IntPtr)current, size.GetType());
2394 current += Marshal.SizeOf(size);
2396 // Look for our preferred size
2397 if (size.min_width == 16) {
2399 return new Size(16, 16);
2402 if (size.max_width == 16) {
2404 return new Size(16, 16);
2407 if (size.min_width < 16 && size.max_width > 16) {
2410 // check if we can fit one
2412 while (x < size.max_width) {
2413 x += size.width_inc;
2416 return new Size(16, 16);
2421 if (smallest == 0 || smallest > size.min_width) {
2422 smallest = size.min_width;
2426 // We didn't find a match or we wouldn't be here
2427 return new Size(smallest, smallest);
2430 return new Size(16, 16);
2435 internal override int MouseButtonCount {
2441 internal override bool MouseButtonsSwapped {
2443 return false; // FIXME - how to detect?
2447 internal override Point MousePosition {
2449 return mouse_position;
2453 internal override Size MouseHoverSize {
2455 return new Size (1, 1);
2459 internal override int MouseHoverTime {
2461 return HoverState.Interval;
2467 internal override bool MouseWheelPresent {
2469 return true; // FIXME - how to detect?
2473 internal override MouseButtons MouseButtons {
2479 internal override Rectangle VirtualScreen {
2485 IntPtr prop = IntPtr.Zero;
2489 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);
2490 if ((long)nitems < 2)
2493 width = Marshal.ReadIntPtr(prop, 0).ToInt32();
2494 height = Marshal.ReadIntPtr(prop, IntPtr.Size).ToInt32();
2498 return new Rectangle(0, 0, width, height);
2501 XWindowAttributes attributes=new XWindowAttributes();
2504 XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes);
2507 return new Rectangle(0, 0, attributes.width, attributes.height);
2511 internal override Rectangle WorkingArea {
2517 IntPtr prop = IntPtr.Zero;
2520 int current_desktop;
2524 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);
2525 if ((long)nitems < 1) {
2529 current_desktop = Marshal.ReadIntPtr(prop, 0).ToInt32();
2532 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);
2533 if ((long)nitems < 4 * (current_desktop + 1)) {
2537 x = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop).ToInt32();
2538 y = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size).ToInt32();
2539 width = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size * 2).ToInt32();
2540 height = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size * 3).ToInt32();
2543 return new Rectangle(x, y, width, height);
2546 XWindowAttributes attributes=new XWindowAttributes();
2549 XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes);
2552 return new Rectangle(0, 0, attributes.width, attributes.height);
2556 internal override bool ThemesEnabled {
2558 return XplatUIX11.themes_enabled;
2563 #endregion // Public properties
2565 #region Public Static Methods
2566 internal override void RaiseIdle (EventArgs e)
2572 internal override IntPtr InitializeDriver() {
2574 if (DisplayHandle==IntPtr.Zero) {
2575 SetDisplay(XOpenDisplay(IntPtr.Zero));
2581 internal override void ShutdownDriver(IntPtr token) {
2583 if (DisplayHandle!=IntPtr.Zero) {
2584 XCloseDisplay(DisplayHandle);
2585 DisplayHandle=IntPtr.Zero;
2590 internal override void EnableThemes() {
2591 themes_enabled = true;
2595 internal override void Activate(IntPtr handle) {
2598 hwnd = Hwnd.ObjectFromHandle(handle);
2602 if (true /* the window manager supports NET_ACTIVE_WINDOW */) {
2603 SendNetWMMessage(hwnd.whole_window, _NET_ACTIVE_WINDOW, (IntPtr)1, IntPtr.Zero, IntPtr.Zero);
2604 XEventQueue q = null;
2605 lock (unattached_timer_list) {
2606 foreach (Timer t in unattached_timer_list) {
2608 q= (XEventQueue) MessageQueues [Thread.CurrentThread];
2609 t.thread = q.Thread;
2610 q.timer_list.Add (t);
2612 unattached_timer_list.Clear ();
2616 // XRaiseWindow(DisplayHandle, handle);
2622 internal override void AudibleAlert(AlertType alert) {
2623 XBell(DisplayHandle, 0);
2628 internal override void CaretVisible(IntPtr handle, bool visible) {
2629 if (Caret.Hwnd == handle) {
2631 if (!Caret.Visible) {
2632 Caret.Visible = true;
2634 Caret.Timer.Start();
2637 Caret.Visible = false;
2644 internal override bool CalculateWindowRect(ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect) {
2645 WindowRect = Hwnd.GetWindowRectangle (cp, menu, ClientRect);
2649 internal override void ClientToScreen(IntPtr handle, ref int x, ref int y) {
2655 hwnd = Hwnd.ObjectFromHandle(handle);
2658 XTranslateCoordinates(DisplayHandle, hwnd.client_window, RootWindow, x, y, out dest_x_return, out dest_y_return, out child);
2665 internal override int[] ClipboardAvailableFormats(IntPtr handle) {
2666 DataFormats.Format f;
2669 f = DataFormats.Format.List;
2671 if (XGetSelectionOwner(DisplayHandle, CLIPBOARD) == IntPtr.Zero) {
2675 Clipboard.Formats = new ArrayList();
2678 XConvertSelection(DisplayHandle, CLIPBOARD, (IntPtr)f.Id, (IntPtr)f.Id, FosterParent, IntPtr.Zero);
2680 Clipboard.Enumerating = true;
2681 while (Clipboard.Enumerating) {
2682 UpdateMessageQueue(null);
2687 result = new int[Clipboard.Formats.Count];
2689 for (int i = 0; i < Clipboard.Formats.Count; i++) {
2690 result[i] = ((IntPtr)Clipboard.Formats[i]).ToInt32 ();
2693 Clipboard.Formats = null;
2697 internal override void ClipboardClose(IntPtr handle) {
2698 if (handle != ClipMagic) {
2699 throw new ArgumentException("handle is not a valid clipboard handle");
2704 internal override int ClipboardGetID(IntPtr handle, string format) {
2705 if (handle != ClipMagic) {
2706 throw new ArgumentException("handle is not a valid clipboard handle");
2709 if (format == "Text" ) return (int)Atom.XA_STRING;
2710 else if (format == "Bitmap" ) return (int)Atom.XA_BITMAP;
2711 //else if (format == "MetaFilePict" ) return 3;
2712 //else if (format == "SymbolicLink" ) return 4;
2713 //else if (format == "DataInterchangeFormat" ) return 5;
2714 //else if (format == "Tiff" ) return 6;
2715 else if (format == "OEMText" ) return OEMTEXT.ToInt32();
2716 else if (format == "DeviceIndependentBitmap" ) return (int)Atom.XA_PIXMAP;
2717 else if (format == "Palette" ) return (int)Atom.XA_COLORMAP; // Useless
2718 //else if (format == "PenData" ) return 10;
2719 //else if (format == "RiffAudio" ) return 11;
2720 //else if (format == "WaveAudio" ) return 12;
2721 else if (format == "UnicodeText" ) return UTF16_STRING.ToInt32();
2722 //else if (format == "EnhancedMetafile" ) return 14;
2723 //else if (format == "FileDrop" ) return 15;
2724 //else if (format == "Locale" ) return 16;
2725 else if (format == "Rich Text Format") return RICHTEXTFORMAT.ToInt32 ();
2727 return XInternAtom(DisplayHandle, format, false).ToInt32();
2730 internal override IntPtr ClipboardOpen(bool primary_selection) {
2731 if (!primary_selection)
2732 ClipMagic = CLIPBOARD;
2734 ClipMagic = PRIMARY;
2738 internal override object ClipboardRetrieve(IntPtr handle, int type, XplatUI.ClipboardToObject converter) {
2739 XConvertSelection(DisplayHandle, handle, (IntPtr)type, (IntPtr)type, FosterParent, IntPtr.Zero);
2741 Clipboard.Retrieving = true;
2742 while (Clipboard.Retrieving) {
2743 UpdateMessageQueue(null);
2746 return Clipboard.Item;
2749 internal override void ClipboardStore(IntPtr handle, object obj, int type, XplatUI.ObjectToClipboard converter) {
2750 Clipboard.Converter = converter;
2753 Clipboard.AddSource (type, obj);
2754 XSetSelectionOwner(DisplayHandle, CLIPBOARD, FosterParent, IntPtr.Zero);
2756 // Clearing the selection
2757 Clipboard.ClearSources ();
2758 XSetSelectionOwner(DisplayHandle, CLIPBOARD, IntPtr.Zero, IntPtr.Zero);
2762 internal override void CreateCaret (IntPtr handle, int width, int height)
2764 XGCValues gc_values;
2767 hwnd = Hwnd.ObjectFromHandle(handle);
2769 if (Caret.Hwnd != IntPtr.Zero) {
2770 DestroyCaret(Caret.Hwnd);
2773 Caret.Hwnd = handle;
2774 Caret.Window = hwnd.client_window;
2775 Caret.Width = width;
2776 Caret.Height = height;
2777 Caret.Visible = false;
2780 gc_values = new XGCValues();
2781 gc_values.line_width = width;
2783 Caret.gc = XCreateGC(DisplayHandle, Caret.Window, new IntPtr ((int)GCFunction.GCLineWidth), ref gc_values);
2784 if (Caret.gc == IntPtr.Zero) {
2785 Caret.Hwnd = IntPtr.Zero;
2789 XSetFunction(DisplayHandle, Caret.gc, GXFunction.GXinvert);
2792 internal override IntPtr CreateWindow (CreateParams cp)
2794 XSetWindowAttributes Attributes;
2796 Hwnd parent_hwnd = null;
2801 IntPtr ParentHandle;
2803 IntPtr ClientWindow;
2804 SetWindowValuemask ValueMask;
2809 Attributes = new XSetWindowAttributes();
2815 if (Width<1) Width=1;
2816 if (Height<1) Height=1;
2818 if (cp.Parent != IntPtr.Zero) {
2819 parent_hwnd = Hwnd.ObjectFromHandle(cp.Parent);
2820 ParentHandle = parent_hwnd.client_window;
2822 if (StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
2823 // We need to use our foster parent window until this poor child gets it's parent assigned
2824 ParentHandle=FosterParent;
2826 ParentHandle=RootWindow;
2830 // Set the default location location for forms.
2832 if (cp.control is Form) {
2833 next = Hwnd.GetNextStackedFormLocation (cp, parent_hwnd);
2837 ValueMask = SetWindowValuemask.BitGravity | SetWindowValuemask.WinGravity;
2839 Attributes.bit_gravity = Gravity.NorthWestGravity;
2840 Attributes.win_gravity = Gravity.NorthWestGravity;
2842 // Save what's under the toolwindow
2843 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
2844 Attributes.save_under = true;
2845 ValueMask |= SetWindowValuemask.SaveUnder;
2849 // If we're a popup without caption we override the WM
2850 if (StyleSet (cp.Style, WindowStyles.WS_POPUP) && !StyleSet (cp.Style, WindowStyles.WS_CAPTION)) {
2851 Attributes.override_redirect = true;
2852 ValueMask |= SetWindowValuemask.OverrideRedirect;
2858 hwnd.height = Height;
2859 hwnd.parent = Hwnd.ObjectFromHandle(cp.Parent);
2860 hwnd.initial_style = cp.WindowStyle;
2861 hwnd.initial_ex_style = cp.WindowExStyle;
2863 if (StyleSet (cp.Style, WindowStyles.WS_DISABLED)) {
2864 hwnd.enabled = false;
2867 ClientWindow = IntPtr.Zero;
2869 Size XWindowSize = TranslateWindowSizeToXWindowSize (cp);
2870 Rectangle XClientRect = TranslateClientRectangleToXClientRectangle (hwnd, cp.control);
2873 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);
2874 if (WholeWindow != IntPtr.Zero) {
2875 ValueMask &= ~(SetWindowValuemask.OverrideRedirect | SetWindowValuemask.SaveUnder);
2877 if (CustomVisual != IntPtr.Zero && CustomColormap != IntPtr.Zero) {
2878 ValueMask = SetWindowValuemask.ColorMap;
2879 Attributes.colormap = CustomColormap;
2881 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);
2885 if ((WholeWindow == IntPtr.Zero) || (ClientWindow == IntPtr.Zero)) {
2886 throw new Exception("Could not create X11 windows");
2889 hwnd.Queue = ThreadQueue(Thread.CurrentThread);
2890 hwnd.WholeWindow = WholeWindow;
2891 hwnd.ClientWindow = ClientWindow;
2893 #if DriverDebug || DriverDebugCreate
2894 Console.WriteLine("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);
2897 if (!StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
2898 if ((X != unchecked((int)0x80000000)) && (Y != unchecked((int)0x80000000))) {
2901 hints = new XSizeHints();
2904 hints.flags = (IntPtr)(XSizeHintsFlags.USPosition | XSizeHintsFlags.PPosition);
2905 XSetWMNormalHints(DisplayHandle, WholeWindow, ref hints);
2910 XSelectInput(DisplayHandle, hwnd.whole_window, new IntPtr ((int)(SelectInputMask | EventMask.StructureNotifyMask | EventMask.PropertyChangeMask | Keyboard.KeyEventMask)));
2911 if (hwnd.whole_window != hwnd.client_window)
2912 XSelectInput(DisplayHandle, hwnd.client_window, new IntPtr ((int)(SelectInputMask | EventMask.StructureNotifyMask | Keyboard.KeyEventMask)));
2915 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOPMOST)) {
2917 atoms[0] = _NET_WM_WINDOW_TYPE_NORMAL.ToInt32();
2918 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
2920 XSetTransientForHint (DisplayHandle, hwnd.whole_window, RootWindow);
2923 SetWMStyles(hwnd, cp);
2925 // set the group leader
2926 XWMHints wm_hints = new XWMHints ();
2928 wm_hints.flags = (IntPtr)(XWMHintsFlags.InputHint | XWMHintsFlags.StateHint | XWMHintsFlags.WindowGroupHint);
2929 wm_hints.input = !StyleSet (cp.Style, WindowStyles.WS_DISABLED);
2930 wm_hints.initial_state = StyleSet (cp.Style, WindowStyles.WS_MINIMIZE) ? XInitialState.IconicState : XInitialState.NormalState;
2932 if (ParentHandle != RootWindow) {
2933 wm_hints.window_group = hwnd.whole_window;
2935 wm_hints.window_group = ParentHandle;
2939 XSetWMHints(DisplayHandle, hwnd.whole_window, ref wm_hints );
2942 if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZE)) {
2943 SetWindowState(hwnd.Handle, FormWindowState.Minimized);
2944 } else if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZE)) {
2945 SetWindowState(hwnd.Handle, FormWindowState.Maximized);
2948 // for now make all windows dnd enabled
2949 Dnd.SetAllowDrop (hwnd, true);
2951 // Set caption/window title
2952 Text(hwnd.Handle, cp.Caption);
2954 SendMessage (hwnd.Handle, Msg.WM_CREATE, (IntPtr)1, IntPtr.Zero /* XXX unused */);
2955 SendParentNotify (hwnd.Handle, Msg.WM_CREATE, int.MaxValue, int.MaxValue);
2957 if (StyleSet (cp.Style, WindowStyles.WS_VISIBLE)) {
2958 hwnd.visible = true;
2959 MapWindow(hwnd, WindowType.Both);
2960 if (!(Control.FromHandle(hwnd.Handle) is Form))
2961 SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero);
2967 internal override IntPtr CreateWindow(IntPtr Parent, int X, int Y, int Width, int Height) {
2968 CreateParams create_params = new CreateParams();
2970 create_params.Caption = "";
2971 create_params.X = X;
2972 create_params.Y = Y;
2973 create_params.Width = Width;
2974 create_params.Height = Height;
2976 create_params.ClassName=XplatUI.DefaultClassName;
2977 create_params.ClassStyle = 0;
2978 create_params.ExStyle=0;
2979 create_params.Parent=IntPtr.Zero;
2980 create_params.Param=0;
2982 return CreateWindow(create_params);
2985 internal override IntPtr DefineCursor(Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) {
2987 Bitmap cursor_bitmap;
2995 IntPtr cursor_pixmap;
3002 if (XQueryBestCursor(DisplayHandle, RootWindow, bitmap.Width, bitmap.Height, out width, out height) == 0) {
3006 // Win32 only allows creation cursors of a certain size
3007 if ((bitmap.Width != width) || (bitmap.Width != height)) {
3008 cursor_bitmap = new Bitmap(bitmap, new Size(width, height));
3009 cursor_mask = new Bitmap(mask, new Size(width, height));
3011 cursor_bitmap = bitmap;
3015 width = cursor_bitmap.Width;
3016 height = cursor_bitmap.Height;
3018 cursor_bits = new Byte[(width / 8) * height];
3019 mask_bits = new Byte[(width / 8) * height];
3021 for (int y = 0; y < height; y++) {
3022 for (int x = 0; x < width; x++) {
3023 c_pixel = cursor_bitmap.GetPixel(x, y);
3024 m_pixel = cursor_mask.GetPixel(x, y);
3026 and = c_pixel == cursor_pixel;
3027 xor = m_pixel == mask_pixel;
3031 // cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8))); // The bit already is 0
3032 mask_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8));
3033 } else if (and && !xor) {
3035 cursor_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8));
3036 mask_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8));
3038 } else if (and && !xor) {
3040 } else if (and && xor) {
3043 // X11 doesn't know the 'reverse screen' concept, so we'll treat them the same
3044 // we want both to be 0 so nothing to be done
3045 //cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8)));
3046 //mask_bits[y * width / 8 + x / 8] |= (byte)(01 << (x % 8));
3052 cursor_pixmap = XCreatePixmapFromBitmapData(DisplayHandle, RootWindow, cursor_bits, width, height, (IntPtr)1, (IntPtr)0, 1);
3053 mask_pixmap = XCreatePixmapFromBitmapData(DisplayHandle, RootWindow, mask_bits, width, height, (IntPtr)1, (IntPtr)0, 1);
3057 fg.pixel = XWhitePixel(DisplayHandle, ScreenNo);
3058 fg.red = (ushort)65535;
3059 fg.green = (ushort)65535;
3060 fg.blue = (ushort)65535;
3062 bg.pixel = XBlackPixel(DisplayHandle, ScreenNo);
3064 cursor = XCreatePixmapCursor(DisplayHandle, cursor_pixmap, mask_pixmap, ref fg, ref bg, xHotSpot, yHotSpot);
3066 XFreePixmap(DisplayHandle, cursor_pixmap);
3067 XFreePixmap(DisplayHandle, mask_pixmap);
3072 internal override Bitmap DefineStdCursorBitmap (StdCursor id) {
3073 CursorFontShape shape;
3080 shape = StdCursorToFontShape (id);
3081 name = shape.ToString ().Replace ("XC_", string.Empty);
3082 size = XcursorGetDefaultSize (DisplayHandle);
3083 theme = XcursorGetTheme (DisplayHandle);
3084 IntPtr images_ptr = XcursorLibraryLoadImages (name, theme, size);
3086 Console.WriteLine ("DefineStdCursorBitmap, id={0}, #id={1}, name{2}, size={3}, theme: {4}, images_ptr={5}", id, (int) id, name, size, Marshal.PtrToStringAnsi (theme), images_ptr);
3089 if (images_ptr == IntPtr.Zero) {
3093 XcursorImages images = (XcursorImages) Marshal.PtrToStructure (images_ptr, typeof (XcursorImages));
3095 Console.WriteLine ("DefineStdCursorBitmap, cursor has {0} images", images.nimage);
3098 if (images.nimage > 0) {
3099 // We only care about the first image.
3100 XcursorImage image = (XcursorImage)Marshal.PtrToStructure (Marshal.ReadIntPtr (images.images), typeof (XcursorImage));
3103 Console.WriteLine ("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);
3106 if (image.width <= short.MaxValue && image.height <= short.MaxValue) {
3107 int [] pixels = new int [image.width * image.height];
3108 Marshal.Copy (image.pixels, pixels, 0, pixels.Length);
3109 bmp = new Bitmap (image.width, image.height);
3110 for (int w = 0; w < image.width; w++) {
3111 for (int h = 0; h < image.height; h++) {
3112 bmp.SetPixel (w, h, Color.FromArgb (pixels [h * image.width + w]));
3118 XcursorImagesDestroy (images_ptr);
3120 } catch (DllNotFoundException ex) {
3121 Console.WriteLine ("Could not load libXcursor: " + ex.Message + " (" + ex.GetType ().Name + ")");
3129 internal override IntPtr DefineStdCursor(StdCursor id) {
3130 CursorFontShape shape;
3133 shape = StdCursorToFontShape (id);
3136 cursor = XCreateFontCursor(DisplayHandle, shape);
3141 internal static CursorFontShape StdCursorToFontShape (StdCursor id) {
3142 CursorFontShape shape;
3143 // FIXME - define missing shapes
3146 case StdCursor.AppStarting: {
3147 shape = CursorFontShape.XC_watch;
3151 case StdCursor.Arrow: {
3152 shape = CursorFontShape.XC_top_left_arrow;
3156 case StdCursor.Cross: {
3157 shape = CursorFontShape.XC_crosshair;
3161 case StdCursor.Default: {
3162 shape = CursorFontShape.XC_top_left_arrow;
3166 case StdCursor.Hand: {
3167 shape = CursorFontShape.XC_hand1;
3171 case StdCursor.Help: {
3172 shape = CursorFontShape.XC_question_arrow;
3176 case StdCursor.HSplit: {
3177 shape = CursorFontShape.XC_sb_v_double_arrow;
3181 case StdCursor.IBeam: {
3182 shape = CursorFontShape.XC_xterm;
3186 case StdCursor.No: {
3187 shape = CursorFontShape.XC_circle;
3191 case StdCursor.NoMove2D: {
3192 shape = CursorFontShape.XC_fleur;
3196 case StdCursor.NoMoveHoriz: {
3197 shape = CursorFontShape.XC_fleur;
3201 case StdCursor.NoMoveVert: {
3202 shape = CursorFontShape.XC_fleur;
3206 case StdCursor.PanEast: {
3207 shape = CursorFontShape.XC_fleur;
3211 case StdCursor.PanNE: {
3212 shape = CursorFontShape.XC_fleur;
3216 case StdCursor.PanNorth: {
3217 shape = CursorFontShape.XC_fleur;
3221 case StdCursor.PanNW: {
3222 shape = CursorFontShape.XC_fleur;
3226 case StdCursor.PanSE: {
3227 shape = CursorFontShape.XC_fleur;
3231 case StdCursor.PanSouth: {
3232 shape = CursorFontShape.XC_fleur;
3236 case StdCursor.PanSW: {
3237 shape = CursorFontShape.XC_fleur;
3241 case StdCursor.PanWest: {
3242 shape = CursorFontShape.XC_sizing;
3246 case StdCursor.SizeAll: {
3247 shape = CursorFontShape.XC_fleur;
3251 case StdCursor.SizeNESW: {
3252 shape = CursorFontShape.XC_top_right_corner;
3256 case StdCursor.SizeNS: {
3257 shape = CursorFontShape.XC_sb_v_double_arrow;
3261 case StdCursor.SizeNWSE: {
3262 shape = CursorFontShape.XC_top_left_corner;
3266 case StdCursor.SizeWE: {
3267 shape = CursorFontShape.XC_sb_h_double_arrow;
3271 case StdCursor.UpArrow: {
3272 shape = CursorFontShape.XC_center_ptr;
3276 case StdCursor.VSplit: {
3277 shape = CursorFontShape.XC_sb_h_double_arrow;
3281 case StdCursor.WaitCursor: {
3282 shape = CursorFontShape.XC_watch;
3287 shape = (CursorFontShape) 0;
3295 internal override IntPtr DefWndProc(ref Message msg) {
3296 switch ((Msg)msg.Msg) {
3298 case Msg.WM_IME_COMPOSITION:
3299 string s = Keyboard.GetCompositionString ();
3300 foreach (char c in s)
3301 SendMessage (msg.HWnd, Msg.WM_IME_CHAR, (IntPtr) c, msg.LParam);
3304 case Msg.WM_IME_CHAR:
3305 // On Windows API it sends two WM_CHAR messages for each byte, but
3306 // I wonder if it is worthy to emulate it (also no idea how to
3307 // reconstruct those bytes into chars).
3308 SendMessage (msg.HWnd, Msg.WM_CHAR, msg.WParam, msg.LParam);
3311 case Msg.WM_PAINT: {
3314 hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3316 hwnd.expose_pending = false;
3322 case Msg.WM_NCPAINT: {
3325 hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3327 hwnd.nc_expose_pending = false;
3333 case Msg.WM_NCCALCSIZE: {
3336 if (msg.WParam == (IntPtr)1) {
3337 hwnd = Hwnd.GetObjectFromWindow (msg.HWnd);
3339 XplatUIWin32.NCCALCSIZE_PARAMS ncp;
3340 ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure (msg.LParam, typeof (XplatUIWin32.NCCALCSIZE_PARAMS));
3342 // Add all the stuff X is supposed to draw.
3343 Control ctrl = Control.FromHandle (hwnd.Handle);
3346 Hwnd.Borders rect = Hwnd.GetBorders (ctrl.GetCreateParams (), null);
3348 ncp.rgrc1.top += rect.top;
3349 ncp.rgrc1.bottom -= rect.bottom;
3350 ncp.rgrc1.left += rect.left;
3351 ncp.rgrc1.right -= rect.right;
3353 Marshal.StructureToPtr (ncp, msg.LParam, true);
3360 case Msg.WM_CONTEXTMENU: {
3363 hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3365 if ((hwnd != null) && (hwnd.parent != null)) {
3366 SendMessage(hwnd.parent.client_window, Msg.WM_CONTEXTMENU, msg.WParam, msg.LParam);
3371 case Msg.WM_MOUSEWHEEL: {
3374 hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3376 if ((hwnd != null) && (hwnd.parent != null)) {
3377 SendMessage(hwnd.parent.client_window, Msg.WM_MOUSEWHEEL, msg.WParam, msg.LParam);
3378 if (msg.Result == IntPtr.Zero) {
3385 case Msg.WM_SETCURSOR: {
3388 hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3390 break; // not sure how this happens, but it does
3392 // Pass to parent window first
3393 while ((hwnd.parent != null) && (msg.Result == IntPtr.Zero)) {
3395 msg.Result = NativeWindow.WndProc(hwnd.Handle, Msg.WM_SETCURSOR, msg.HWnd, msg.LParam);
3398 if (msg.Result == IntPtr.Zero) {
3401 switch((HitTest)(msg.LParam.ToInt32() & 0xffff)) {
3402 case HitTest.HTBOTTOM: handle = Cursors.SizeNS.handle; break;
3403 case HitTest.HTBORDER: handle = Cursors.SizeNS.handle; break;
3404 case HitTest.HTBOTTOMLEFT: handle = Cursors.SizeNESW.handle; break;
3405 case HitTest.HTBOTTOMRIGHT: handle = Cursors.SizeNWSE.handle; break;
3406 case HitTest.HTERROR: if ((msg.LParam.ToInt32() >> 16) == (int)Msg.WM_LBUTTONDOWN) {
3407 AudibleAlert(AlertType.Default);
3409 handle = Cursors.Default.handle;
3412 case HitTest.HTHELP: handle = Cursors.Help.handle; break;
3413 case HitTest.HTLEFT: handle = Cursors.SizeWE.handle; break;
3414 case HitTest.HTRIGHT: handle = Cursors.SizeWE.handle; break;
3415 case HitTest.HTTOP: handle = Cursors.SizeNS.handle; break;
3416 case HitTest.HTTOPLEFT: handle = Cursors.SizeNWSE.handle; break;
3417 case HitTest.HTTOPRIGHT: handle = Cursors.SizeNESW.handle; break;
3420 case HitTest.HTGROWBOX:
3421 case HitTest.HTSIZE:
3422 case HitTest.HTZOOM:
3423 case HitTest.HTVSCROLL:
3424 case HitTest.HTSYSMENU:
3425 case HitTest.HTREDUCE:
3426 case HitTest.HTNOWHERE:
3427 case HitTest.HTMAXBUTTON:
3428 case HitTest.HTMINBUTTON:
3429 case HitTest.HTMENU:
3430 case HitTest.HSCROLL:
3431 case HitTest.HTBOTTOM:
3432 case HitTest.HTCAPTION:
3433 case HitTest.HTCLIENT:
3434 case HitTest.HTCLOSE:
3436 default: handle = Cursors.Default.handle; break;
3438 SetCursor(msg.HWnd, handle);
3446 internal override void DestroyCaret(IntPtr handle) {
3447 if (Caret.Hwnd == handle) {
3448 if (Caret.Visible) {
3452 if (Caret.gc != IntPtr.Zero) {
3453 XFreeGC(DisplayHandle, Caret.gc);
3454 Caret.gc = IntPtr.Zero;
3456 Caret.Hwnd = IntPtr.Zero;
3457 Caret.Visible = false;
3462 internal override void DestroyCursor(IntPtr cursor) {
3464 XFreeCursor(DisplayHandle, cursor);
3468 internal override void DestroyWindow(IntPtr handle) {
3470 hwnd = Hwnd.ObjectFromHandle(handle);
3472 // The window should never ever be a zombie here, since we should
3473 // wait until it's completely dead before returning from
3474 // "destroying" calls, but just in case....
3475 if (hwnd == null || hwnd.zombie) {
3476 #if DriverDebug || DriverDebugDestroy
3477 Console.WriteLine("window {0:X} already destroyed", handle.ToInt32());
3482 #if DriverDebug || DriverDebugDestroy
3483 Console.WriteLine("Destroying window {0}", XplatUI.Window(hwnd.client_window));
3486 SendParentNotify (hwnd.Handle, Msg.WM_DESTROY, int.MaxValue, int.MaxValue);
3488 CleanupCachedWindows (hwnd);
3490 ArrayList windows = new ArrayList ();
3492 AccumulateDestroyedHandles (Control.ControlNativeWindow.ControlFromHandle(hwnd.Handle), windows);
3495 foreach (Hwnd h in windows) {
3496 SendMessage (h.Handle, Msg.WM_DESTROY, IntPtr.Zero, IntPtr.Zero);
3501 if (hwnd.whole_window != IntPtr.Zero) {
3502 #if DriverDebug || DriverDebugDestroy
3503 Console.WriteLine ("XDestroyWindow (whole_window = {0:X})", hwnd.whole_window.ToInt32());
3505 Keyboard.DestroyICForWindow (hwnd.whole_window);
3506 XDestroyWindow(DisplayHandle, hwnd.whole_window);
3508 else if (hwnd.client_window != IntPtr.Zero) {
3509 #if DriverDebug || DriverDebugDestroy
3510 Console.WriteLine ("XDestroyWindow (client_window = {0:X})", hwnd.client_window.ToInt32());
3512 Keyboard.DestroyICForWindow (hwnd.client_window);
3513 XDestroyWindow(DisplayHandle, hwnd.client_window);
3519 internal override IntPtr DispatchMessage(ref MSG msg) {
3520 return NativeWindow.WndProc(msg.hwnd, msg.message, msg.wParam, msg.lParam);
3523 IntPtr GetReversibleScreenGC (Color backColor)
3525 XGCValues gc_values;
3529 XColor xcolor = new XColor();
3530 xcolor.red = (ushort)(backColor.R * 257);
3531 xcolor.green = (ushort)(backColor.G * 257);
3532 xcolor.blue = (ushort)(backColor.B * 257);
3533 XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
3534 pixel = (uint)xcolor.pixel.ToInt32();
3537 gc_values = new XGCValues();
3539 gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors;
3540 gc_values.foreground = (IntPtr)pixel;
3542 gc = XCreateGC(DisplayHandle, RootWindow, new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCForeground)), ref gc_values);
3543 XSetForeground(DisplayHandle, gc, (UIntPtr)pixel);
3544 XSetFunction(DisplayHandle, gc, GXFunction.GXxor);
3549 IntPtr GetReversibleControlGC (Control control, int line_width)
3551 XGCValues gc_values;
3554 gc_values = new XGCValues();
3556 gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors;
3557 gc_values.line_width = line_width;
3558 gc_values.foreground = XBlackPixel(DisplayHandle, ScreenNo);
3560 // This logic will give us true rubber bands: (libsx, SANE_XOR)
3561 //mask = foreground ^ background;
3562 //XSetForeground(DisplayHandle, gc, 0xffffffff);
3563 //XSetBackground(DisplayHandle, gc, background);
3564 //XSetFunction(DisplayHandle, gc, GXxor);
3565 //XSetPlaneMask(DisplayHandle, gc, mask);
3568 gc = XCreateGC(DisplayHandle, control.Handle, new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCLineWidth | GCFunction.GCForeground)), ref gc_values);
3572 XColor xcolor = new XColor();
3574 xcolor.red = (ushort)(control.ForeColor.R * 257);
3575 xcolor.green = (ushort)(control.ForeColor.G * 257);
3576 xcolor.blue = (ushort)(control.ForeColor.B * 257);
3577 XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
3578 foreground = (uint)xcolor.pixel.ToInt32();
3580 xcolor.red = (ushort)(control.BackColor.R * 257);
3581 xcolor.green = (ushort)(control.BackColor.G * 257);
3582 xcolor.blue = (ushort)(control.BackColor.B * 257);
3583 XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
3584 background = (uint)xcolor.pixel.ToInt32();
3586 uint mask = foreground ^ background;
3588 XSetForeground(DisplayHandle, gc, (UIntPtr)0xffffffff);
3589 XSetBackground(DisplayHandle, gc, (UIntPtr)background);
3590 XSetFunction(DisplayHandle, gc, GXFunction.GXxor);
3591 XSetPlaneMask(DisplayHandle, gc, (IntPtr)mask);
3596 internal override void DrawReversibleLine(Point start, Point end, Color backColor)
3598 if (backColor.GetBrightness() < 0.5)
3599 backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B);
3601 IntPtr gc = GetReversibleScreenGC (backColor);
3603 XDrawLine (DisplayHandle, RootWindow, gc, start.X, start.Y, end.X, end.Y);
3605 XFreeGC(DisplayHandle, gc);
3608 internal override void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style)
3610 if (backColor.GetBrightness() < 0.5)
3611 backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B);
3613 IntPtr gc = GetReversibleScreenGC (backColor);
3615 if (rectangle.Width < 0) {
3616 rectangle.X += rectangle.Width;
3617 rectangle.Width = -rectangle.Width;
3619 if (rectangle.Height < 0) {
3620 rectangle.Y += rectangle.Height;
3621 rectangle.Height = -rectangle.Height;
3625 GCLineStyle line_style = GCLineStyle.LineSolid;
3626 GCCapStyle cap_style = GCCapStyle.CapButt;
3627 GCJoinStyle join_style = GCJoinStyle.JoinMiter;
3630 case FrameStyle.Dashed:
3631 line_style = GCLineStyle.LineOnOffDash;
3633 case FrameStyle.Thick:
3638 XSetLineAttributes (DisplayHandle, gc, line_width, line_style, cap_style, join_style);
3640 XDrawRectangle(DisplayHandle, RootWindow, gc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height);
3642 XFreeGC(DisplayHandle, gc);
3645 internal override void FillReversibleRectangle (Rectangle rectangle, Color backColor)
3647 if (backColor.GetBrightness() < 0.5)
3648 backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B);
3650 IntPtr gc = GetReversibleScreenGC (backColor);
3652 if (rectangle.Width < 0) {
3653 rectangle.X += rectangle.Width;
3654 rectangle.Width = -rectangle.Width;
3656 if (rectangle.Height < 0) {
3657 rectangle.Y += rectangle.Height;
3658 rectangle.Height = -rectangle.Height;
3660 XFillRectangle(DisplayHandle, RootWindow, gc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height);
3662 XFreeGC(DisplayHandle, gc);
3665 internal override void DrawReversibleRectangle(IntPtr handle, Rectangle rect, int line_width)
3668 Control control = Control.FromHandle(handle);
3670 gc = GetReversibleControlGC (control, line_width);
3672 if ((rect.Width > 0) && (rect.Height > 0)) {
3673 XDrawRectangle(DisplayHandle, control.Handle, gc, rect.Left, rect.Top, rect.Width, rect.Height);
3675 if (rect.Width > 0) {
3676 XDrawLine(DisplayHandle, control.Handle, gc, rect.X, rect.Y, rect.Right, rect.Y);
3678 XDrawLine(DisplayHandle, control.Handle, gc, rect.X, rect.Y, rect.X, rect.Bottom);
3681 XFreeGC(DisplayHandle, gc);
3684 internal override void DoEvents() {
3685 DebugHelper.Enter ();
3687 MSG msg = new MSG ();
3690 if (OverrideCursorHandle != IntPtr.Zero) {
3691 OverrideCursorHandle = IntPtr.Zero;
3694 queue = ThreadQueue(Thread.CurrentThread);
3696 queue.DispatchIdle = false;
3699 while (PeekMessage(queue, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) {
3700 Message m = Message.Create (msg.hwnd, (int)msg.message, msg.wParam, msg.lParam);
3702 if (Application.FilterMessage (ref m))
3705 TranslateMessage (ref msg);
3706 DispatchMessage (ref msg);
3708 string key = msg.hwnd + ":" + msg.message;
3709 if (messageHold[key] != null) {
3710 messageHold[key] = ((int)messageHold[key]) - 1;
3711 DebugHelper.WriteLine ("Got " + msg + " for " + key);
3715 in_doevents = false;
3716 queue.DispatchIdle = true;
3718 DebugHelper.Leave ();
3721 internal override void EnableWindow(IntPtr handle, bool Enable) {
3724 hwnd = Hwnd.ObjectFromHandle(handle);
3726 hwnd.Enabled = Enable;
3730 internal override void EndLoop(Thread thread) {
3731 // This is where we one day will shut down the loop for the thread
3734 internal override IntPtr GetActive() {
3739 IntPtr prop = IntPtr.Zero;
3740 IntPtr active = IntPtr.Zero;
3742 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);
3743 if (((long)nitems > 0) && (prop != IntPtr.Zero)) {
3744 active = (IntPtr)Marshal.ReadInt32(prop);
3748 if (active != IntPtr.Zero) {
3751 hwnd = Hwnd.GetObjectFromWindow(active);
3753 active = hwnd.Handle;
3755 active = IntPtr.Zero;
3761 internal override Region GetClipRegion(IntPtr handle) {
3764 hwnd = Hwnd.ObjectFromHandle(handle);
3766 return hwnd.UserClip;
3772 internal override void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y) {
3779 internal override void GetDisplaySize(out Size size) {
3780 XWindowAttributes attributes=new XWindowAttributes();
3783 // FIXME - use _NET_WM messages instead?
3784 XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes);
3787 size = new Size(attributes.width, attributes.height);
3790 internal override SizeF GetAutoScaleSize(Font font) {
3793 string magic_string = "The quick brown fox jumped over the lazy dog.";
3794 double magic_number = 44.549996948242189;
3796 g = Graphics.FromHwnd(FosterParent);
3798 width = (float) (g.MeasureString (magic_string, font).Width / magic_number);
3799 return new SizeF(width, font.Height);
3802 internal override IntPtr GetParent(IntPtr handle) {
3805 hwnd = Hwnd.ObjectFromHandle(handle);
3806 if (hwnd != null && hwnd.parent != null) {
3807 return hwnd.parent.Handle;
3812 // This is a nop on win32 and x11
3813 internal override IntPtr GetPreviousWindow(IntPtr handle) {
3817 internal override void GetCursorPos(IntPtr handle, out int x, out int y) {
3827 if (handle != IntPtr.Zero) {
3828 use_handle = Hwnd.ObjectFromHandle(handle).client_window;
3830 use_handle = RootWindow;
3834 QueryPointer (DisplayHandle, use_handle, out root, out child, out root_x, out root_y, out win_x, out win_y, out keys_buttons);
3837 if (handle != IntPtr.Zero) {
3846 internal override IntPtr GetFocus() {
3851 internal override bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent) {
3852 FontFamily ff = font.FontFamily;
3853 ascent = ff.GetCellAscent (font.Style);
3854 descent = ff.GetCellDescent (font.Style);
3858 internal override Point GetMenuOrigin(IntPtr handle) {
3861 hwnd = Hwnd.ObjectFromHandle(handle);
3864 return hwnd.MenuOrigin;
3869 [MonoTODO("Implement filtering")]
3870 internal override bool GetMessage(Object queue_id, ref MSG msg, IntPtr handle, int wFilterMin, int wFilterMax) {
3877 if (((XEventQueue)queue_id).Count > 0) {
3878 xevent = (XEvent) ((XEventQueue)queue_id).Dequeue ();
3880 UpdateMessageQueue ((XEventQueue)queue_id);
3882 if (((XEventQueue)queue_id).Count > 0) {
3883 xevent = (XEvent) ((XEventQueue)queue_id).Dequeue ();
3884 } else if (((XEventQueue)queue_id).Paint.Count > 0) {
3885 xevent = ((XEventQueue)queue_id).Paint.Dequeue();
3887 msg.hwnd= IntPtr.Zero;
3888 msg.message = Msg.WM_ENTERIDLE;
3893 hwnd = Hwnd.GetObjectFromWindow(xevent.AnyEvent.window);
3895 #if DriverDebugDestroy
3898 Console.WriteLine ( "GetMessage zombie, got Event: " + xevent.ToString () + " for 0x{0:x}", hwnd.Handle.ToInt32());
3900 Console.WriteLine ( "GetMessage, got Event: " + xevent.ToString () + " for 0x{0:x}", hwnd.Handle.ToInt32());
3902 // Handle messages for windows that are already or are about to be destroyed.
3904 // we need a special block for this because unless we remove the hwnd from the paint
3905 // queue it will always stay there (since we don't handle the expose), and we'll
3906 // effectively loop infinitely trying to repaint a non-existant window.
3907 if (hwnd != null && hwnd.zombie && xevent.type == XEventName.Expose) {
3908 hwnd.expose_pending = hwnd.nc_expose_pending = false;
3909 hwnd.Queue.Paint.Remove (hwnd);
3910 goto ProcessNextMessage;
3913 // We need to make sure we only allow DestroyNotify events through for zombie
3914 // hwnds, since much of the event handling code makes requests using the hwnd's
3915 // client_window, and that'll result in BadWindow errors if there's some lag
3916 // between the XDestroyWindow call and the DestroyNotify event.
3917 if (hwnd == null || hwnd.zombie && xevent.AnyEvent.type != XEventName.ClientMessage) {
3918 #if DriverDebug || DriverDebugDestroy
3919 Console.WriteLine("GetMessage(): Got message {0} for non-existent or already destroyed window {1:X}", xevent.type, xevent.AnyEvent.window.ToInt32());
3921 goto ProcessNextMessage;
3925 // If we get here, that means the window is no more but there are Client Messages
3926 // to be processed, probably a Posted message (for instance, an WM_ACTIVATE message)
3927 // We don't want anything else to run but the ClientMessage block, so reset all hwnd
3928 // properties that might cause other processing to occur.
3930 hwnd.resizing_or_moving = false;
3933 if (hwnd.client_window == xevent.AnyEvent.window) {
3935 //Console.WriteLine("Client message {1}, sending to window {0:X}", msg.hwnd.ToInt32(), xevent.type);
3938 //Console.WriteLine("Non-Client message, sending to window {0:X}", msg.hwnd.ToInt32());
3941 msg.hwnd = hwnd.Handle;
3943 // Windows sends WM_ENTERSIZEMOVE when a form resize/move operation starts and WM_EXITSIZEMOVE
3944 // when it is done. The problem in X11 is that there is no concept of start-end of a moving/sizing.
3945 // Configure events ("this window has resized/moved") are sent for each step of the resize. We send a
3946 // WM_ENTERSIZEMOVE when we get the first Configure event. The problem is the WM_EXITSIZEMOVE.
3948 // - There is no way for us to know which is the last Configure event. We can't traverse the events
3949 // queue, because the next configure event might not be pending yet.
3950 // - We can't get ButtonPress/Release events for the window decorations, because they are not part
3951 // of the window(s) we manage.
3952 // - We can't rely on the mouse state to change to "up" before the last Configure event. It doesn't.
3954 // We are almost 100% guaranteed to get another event (e.g Expose or other), but we can't know for sure
3955 // which, so we have here to check if the mouse buttons state is "up" and send the WM_EXITSIZEMOVE
3957 if (hwnd.resizing_or_moving) {
3958 int root_x, root_y, win_x, win_y, keys_buttons;
3960 XQueryPointer (DisplayHandle, hwnd.Handle, out root, out child, out root_x, out root_y,
3961 out win_x, out win_y, out keys_buttons);
3962 if ((keys_buttons & (int)MouseKeyMasks.Button1Mask) == 0 &&
3963 (keys_buttons & (int)MouseKeyMasks.Button2Mask) == 0 &&
3964 (keys_buttons & (int)MouseKeyMasks.Button3Mask) == 0) {
3965 hwnd.resizing_or_moving = false;
3966 SendMessage (hwnd.Handle, Msg.WM_EXITSIZEMOVE, IntPtr.Zero, IntPtr.Zero);
3971 // If you add a new event to this switch make sure to add it in
3972 // UpdateMessage also unless it is not coming through the X event system.
3974 switch(xevent.type) {
3975 case XEventName.KeyPress: {
3976 Keyboard.KeyEvent (FocusWindow, xevent, ref msg);
3978 // F1 key special case - WM_HELP sending
3979 if (msg.wParam == (IntPtr)VirtualKeys.VK_F1 || msg.wParam == (IntPtr)VirtualKeys.VK_HELP) {
3980 // Send wM_HELP and then return it as a keypress message in
3981 // case it needs to be preproccessed.
3982 HELPINFO helpInfo = new HELPINFO ();
3983 GetCursorPos (IntPtr.Zero, out helpInfo.MousePos.x, out helpInfo.MousePos.y);
3984 IntPtr helpInfoPtr = Marshal.AllocHGlobal (Marshal.SizeOf (helpInfo));
3985 Marshal.StructureToPtr (helpInfo, helpInfoPtr, true);
3986 NativeWindow.WndProc (FocusWindow, Msg.WM_HELP, IntPtr.Zero, helpInfoPtr);
3987 Marshal.FreeHGlobal (helpInfoPtr);
3992 case XEventName.KeyRelease: {
3993 Keyboard.KeyEvent (FocusWindow, xevent, ref msg);
3997 case XEventName.ButtonPress: {
3998 switch(xevent.ButtonEvent.button) {
4000 MouseState |= MouseButtons.Left;
4002 msg.message = Msg.WM_LBUTTONDOWN;
4003 msg.wParam = GetMousewParam (0);
4005 msg.message = Msg.WM_NCLBUTTONDOWN;
4006 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4007 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4013 MouseState |= MouseButtons.Middle;
4015 msg.message = Msg.WM_MBUTTONDOWN;
4016 msg.wParam = GetMousewParam (0);
4018 msg.message = Msg.WM_NCMBUTTONDOWN;
4019 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4020 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4026 MouseState |= MouseButtons.Right;
4028 msg.message = Msg.WM_RBUTTONDOWN;
4029 msg.wParam = GetMousewParam (0);
4031 msg.message = Msg.WM_NCRBUTTONDOWN;
4032 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4033 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4039 msg.hwnd = FocusWindow;
4040 msg.message=Msg.WM_MOUSEWHEEL;
4041 msg.wParam=GetMousewParam(120);
4046 msg.hwnd = FocusWindow;
4047 msg.message=Msg.WM_MOUSEWHEEL;
4048 msg.wParam=GetMousewParam(-120);
4054 msg.lParam=(IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x);
4055 mouse_position.X = xevent.ButtonEvent.x;
4056 mouse_position.Y = xevent.ButtonEvent.y;
4058 if (!hwnd.Enabled) {
4061 msg.hwnd = hwnd.EnabledHwnd;
4062 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);
4063 msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4066 if (Grab.Hwnd != IntPtr.Zero) {
4067 msg.hwnd = Grab.Hwnd;
4070 if (ClickPending.Pending && ((((long)xevent.ButtonEvent.time - ClickPending.Time) < DoubleClickInterval) && (msg.wParam == ClickPending.wParam) && (msg.lParam == ClickPending.lParam) && (msg.message == ClickPending.Message))) {
4071 // Looks like a genuine double click, clicked twice on the same spot with the same keys
4072 switch(xevent.ButtonEvent.button) {
4074 msg.message = client ? Msg.WM_LBUTTONDBLCLK : Msg.WM_NCLBUTTONDBLCLK;
4079 msg.message = client ? Msg.WM_MBUTTONDBLCLK : Msg.WM_NCMBUTTONDBLCLK;
4084 msg.message = client ? Msg.WM_RBUTTONDBLCLK : Msg.WM_NCRBUTTONDBLCLK;
4088 ClickPending.Pending = false;
4090 ClickPending.Pending = true;
4091 ClickPending.Hwnd = msg.hwnd;
4092 ClickPending.Message = msg.message;
4093 ClickPending.wParam = msg.wParam;
4094 ClickPending.lParam = msg.lParam;
4095 ClickPending.Time = (long)xevent.ButtonEvent.time;
4098 if (msg.message == Msg.WM_LBUTTONDOWN || msg.message == Msg.WM_MBUTTONDOWN || msg.message == Msg.WM_RBUTTONDOWN) {
4099 SendParentNotify(msg.hwnd, msg.message, mouse_position.X, mouse_position.Y);
4105 case XEventName.ButtonRelease: {
4106 switch(xevent.ButtonEvent.button) {
4109 msg.message = Msg.WM_LBUTTONUP;
4111 msg.message = Msg.WM_NCLBUTTONUP;
4112 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4113 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4115 MouseState &= ~MouseButtons.Left;
4116 msg.wParam = GetMousewParam (0);
4122 msg.message = Msg.WM_MBUTTONUP;
4124 msg.message = Msg.WM_NCMBUTTONUP;
4125 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4126 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4128 MouseState &= ~MouseButtons.Middle;
4129 msg.wParam = GetMousewParam (0);
4135 msg.message = Msg.WM_RBUTTONUP;
4137 msg.message = Msg.WM_NCRBUTTONUP;
4138 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4139 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4141 MouseState &= ~MouseButtons.Right;
4142 msg.wParam = GetMousewParam (0);
4147 goto ProcessNextMessage;
4151 goto ProcessNextMessage;
4155 if (!hwnd.Enabled) {
4158 msg.hwnd = hwnd.EnabledHwnd;
4159 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);
4160 msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4163 if (Grab.Hwnd != IntPtr.Zero) {
4164 msg.hwnd = Grab.Hwnd;
4167 msg.lParam=(IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x);
4168 mouse_position.X = xevent.ButtonEvent.x;
4169 mouse_position.Y = xevent.ButtonEvent.y;
4171 // Win32 splurts MouseMove events all over the place, regardless of whether the mouse is actually moving or
4172 // not, especially after mousedown and mouseup. To support apps relying on mousemove events between and after
4173 // mouse clicks to repaint or whatever, we generate a mousemove event here. *sigh*
4174 if (msg.message == Msg.WM_LBUTTONUP || msg.message == Msg.WM_MBUTTONUP || msg.message == Msg.WM_RBUTTONUP) {
4175 XEvent motionEvent = new XEvent ();
4176 motionEvent.type = XEventName.MotionNotify;
4177 motionEvent.MotionEvent.display = DisplayHandle;
4178 motionEvent.MotionEvent.window = xevent.ButtonEvent.window;
4179 motionEvent.MotionEvent.x = xevent.ButtonEvent.x;
4180 motionEvent.MotionEvent.y = xevent.ButtonEvent.y;
4181 hwnd.Queue.EnqueueLocked (motionEvent);
4186 case XEventName.MotionNotify: {
4188 #if DriverDebugExtra
4189 Console.WriteLine("GetMessage(): Window {0:X} MotionNotify x={1} y={2}", client ? hwnd.client_window.ToInt32() : hwnd.whole_window.ToInt32(), xevent.MotionEvent.x, xevent.MotionEvent.y);
4192 if (Grab.Hwnd != IntPtr.Zero) {
4193 msg.hwnd = Grab.Hwnd;
4196 NativeWindow.WndProc(msg.hwnd, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)HitTest.HTCLIENT);
4200 if (xevent.MotionEvent.is_hint != 0)
4204 XQueryPointer (DisplayHandle, xevent.AnyEvent.window,
4205 out root, out child,
4206 out xevent.MotionEvent.x_root,
4207 out xevent.MotionEvent.y_root,
4208 out xevent.MotionEvent.x,
4209 out xevent.MotionEvent.y, out mask);
4212 msg.message = Msg.WM_MOUSEMOVE;
4213 msg.wParam = GetMousewParam(0);
4214 msg.lParam = (IntPtr) (xevent.MotionEvent.y << 16 | xevent.MotionEvent.x & 0xFFFF);
4216 if (!hwnd.Enabled) {
4219 msg.hwnd = hwnd.EnabledHwnd;
4220 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);
4221 msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4224 mouse_position.X = xevent.MotionEvent.x;
4225 mouse_position.Y = xevent.MotionEvent.y;
4227 if ((HoverState.Timer.Enabled) &&
4228 (((mouse_position.X + HoverState.Size.Width) < HoverState.X) ||
4229 ((mouse_position.X - HoverState.Size.Width) > HoverState.X) ||
4230 ((mouse_position.Y + HoverState.Size.Height) < HoverState.Y) ||
4231 ((mouse_position.Y - HoverState.Size.Height) > HoverState.Y))) {
4232 HoverState.Timer.Stop();
4233 HoverState.Timer.Start();
4234 HoverState.X = mouse_position.X;
4235 HoverState.Y = mouse_position.Y;
4243 #if DriverDebugExtra
4244 Console.WriteLine("GetMessage(): non-client area {0:X} MotionNotify x={1} y={2}", client ? hwnd.client_window.ToInt32() : hwnd.whole_window.ToInt32(), xevent.MotionEvent.x, xevent.MotionEvent.y);
4246 msg.message = Msg.WM_NCMOUSEMOVE;
4248 if (!hwnd.Enabled) {
4249 msg.hwnd = hwnd.EnabledHwnd;
4250 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);
4251 msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4254 ht = NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4255 NativeWindow.WndProc(hwnd.client_window, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)ht);
4257 mouse_position.X = xevent.MotionEvent.x;
4258 mouse_position.Y = xevent.MotionEvent.y;
4264 case XEventName.EnterNotify: {
4265 if (!hwnd.Enabled) {
4266 goto ProcessNextMessage;
4268 if (xevent.CrossingEvent.mode == NotifyMode.NotifyGrab || xevent.AnyEvent.window != hwnd.client_window) {
4269 goto ProcessNextMessage;
4271 if (xevent.CrossingEvent.mode == NotifyMode.NotifyUngrab) { // Pseudo motion caused by grabbing
4272 if (LastPointerWindow == xevent.AnyEvent.window)
4273 goto ProcessNextMessage;
4275 if (LastPointerWindow != IntPtr.Zero) {
4276 Point enter_loc = new Point (xevent.ButtonEvent.x, xevent.ButtonEvent.y);
4278 // We need this due to EnterNotify being fired on all the parent controls
4279 // of the Control being grabbed, and obviously in that scenario we are not
4280 // actuallty entering them
4281 Control ctrl = Control.FromHandle (hwnd.client_window);
4282 foreach (Control child_control in ctrl.Controls.GetAllControls ())
4283 if (child_control.Bounds.Contains (enter_loc))
4284 goto ProcessNextMessage;
4286 // A MouseLeave/LeaveNotify event is sent to the previous window
4287 // until the mouse is ungrabbed, not when actually leaving its bounds
4288 int x = xevent.CrossingEvent.x_root;
4289 int y = xevent.CrossingEvent.y_root;
4290 ScreenToClient (LastPointerWindow, ref x, ref y);
4292 XEvent leaveEvent = new XEvent ();
4293 leaveEvent.type = XEventName.LeaveNotify;
4294 leaveEvent.CrossingEvent.display = DisplayHandle;
4295 leaveEvent.CrossingEvent.window = LastPointerWindow;
4296 leaveEvent.CrossingEvent.x = x;
4297 leaveEvent.CrossingEvent.y = y;
4298 leaveEvent.CrossingEvent.mode = NotifyMode.NotifyNormal;
4299 Hwnd last_pointer_hwnd = Hwnd.ObjectFromHandle (LastPointerWindow);
4300 last_pointer_hwnd.Queue.EnqueueLocked (leaveEvent);
4304 LastPointerWindow = xevent.AnyEvent.window;
4306 msg.message = Msg.WM_MOUSE_ENTER;
4307 HoverState.X = xevent.CrossingEvent.x;
4308 HoverState.Y = xevent.CrossingEvent.y;
4309 HoverState.Timer.Enabled = true;
4310 HoverState.Window = xevent.CrossingEvent.window;
4312 // Win32 sends a WM_MOUSEMOVE after mouse enter
4313 XEvent motionEvent = new XEvent ();
4314 motionEvent.type = XEventName.MotionNotify;
4315 motionEvent.MotionEvent.display = DisplayHandle;
4316 motionEvent.MotionEvent.window = xevent.ButtonEvent.window;
4317 motionEvent.MotionEvent.x = xevent.ButtonEvent.x;
4318 motionEvent.MotionEvent.y = xevent.ButtonEvent.y;
4319 hwnd.Queue.EnqueueLocked (motionEvent);
4323 case XEventName.LeaveNotify: {
4324 if (xevent.CrossingEvent.mode == NotifyMode.NotifyUngrab) {
4325 WindowUngrabbed (hwnd.Handle);
4326 goto ProcessNextMessage;
4328 if (!hwnd.Enabled) {
4329 goto ProcessNextMessage;
4331 if ((xevent.CrossingEvent.mode != NotifyMode.NotifyNormal) || (xevent.CrossingEvent.window != hwnd.client_window)) {
4332 goto ProcessNextMessage;
4334 // If a grab is taking place, ignore it - we handle it in EnterNotify
4335 if (Grab.Hwnd != IntPtr.Zero)
4336 goto ProcessNextMessage;
4338 // Reset the cursor explicitly on X11.
4339 // X11 remembers the last set cursor for the window and in cases where
4340 // the control won't get a WM_SETCURSOR X11 will restore the last
4341 // known cursor, which we don't want.
4343 SetCursor (hwnd.client_window, IntPtr.Zero);
4345 msg.message=Msg.WM_MOUSELEAVE;
4346 HoverState.Timer.Enabled = false;
4347 HoverState.Window = IntPtr.Zero;
4352 case XEventName.CreateNotify: {
4353 if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) {
4354 msg.message = WM_CREATE;
4355 // Set up CreateStruct
4357 goto ProcessNextMessage;
4364 case XEventName.ReparentNotify: {
4365 if (hwnd.parent == null) { // Toplevel
4366 if ((xevent.ReparentEvent.parent != IntPtr.Zero) && (xevent.ReparentEvent.window == hwnd.whole_window)) {
4367 hwnd.Reparented = true;
4369 // The location given by the event is not reliable between different wm's,
4370 // so use an alternative way of getting it.
4371 Point location = GetTopLevelWindowLocation (hwnd);
4372 hwnd.X = location.X;
4373 hwnd.Y = location.Y;
4375 if (hwnd.opacity != 0xffffffff) {
4378 opacity = (IntPtr)(Int32)hwnd.opacity;
4379 XChangeProperty(DisplayHandle, XGetParent(hwnd.whole_window), _NET_WM_WINDOW_OPACITY, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, ref opacity, 1);
4381 SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, msg.wParam, msg.lParam);
4382 goto ProcessNextMessage;
4384 hwnd.Reparented = false;
4385 goto ProcessNextMessage;
4388 goto ProcessNextMessage;
4391 case XEventName.ConfigureNotify: {
4392 if (!client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas
4393 #if DriverDebugExtra
4394 Console.WriteLine("GetMessage(): Window {0:X} ConfigureNotify x={1} y={2} width={3} height={4}", hwnd.client_window.ToInt32(), xevent.ConfigureEvent.x, xevent.ConfigureEvent.y, xevent.ConfigureEvent.width, xevent.ConfigureEvent.height);
4397 lock (hwnd.configure_lock) {
4398 Form form = Control.FromHandle (hwnd.client_window) as Form;
4399 if (form != null && !hwnd.resizing_or_moving) {
4400 if (hwnd.x != form.Bounds.X || hwnd.y != form.Bounds.Y) {
4401 SendMessage (form.Handle, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_MOVE, IntPtr.Zero);
4402 hwnd.resizing_or_moving = true;
4403 } else if (hwnd.width != form.Bounds.Width || hwnd.height != form.Bounds.Height) {
4404 SendMessage (form.Handle, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_SIZE, IntPtr.Zero);
4405 hwnd.resizing_or_moving = true;
4407 if (hwnd.resizing_or_moving)
4408 SendMessage (form.Handle, Msg.WM_ENTERSIZEMOVE, IntPtr.Zero, IntPtr.Zero);
4411 SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
4412 hwnd.configure_pending = false;
4414 // We need to adjust our client window to track the resize of whole_window
4415 if (hwnd.whole_window != hwnd.client_window)
4416 PerformNCCalc(hwnd);
4419 goto ProcessNextMessage;
4422 case XEventName.FocusIn: {
4423 // We received focus. We use X11 focus only to know if the app window does or does not have focus
4424 // We do not track the actual focussed window via it. Instead, this is done via FocusWindow internally
4425 // Receiving focus means we've gotten activated and therefore we need to let the actual FocusWindow know
4426 // about it having focus again
4427 if (xevent.FocusChangeEvent.detail != NotifyDetail.NotifyNonlinear) {
4428 goto ProcessNextMessage;
4432 if (FocusWindow == IntPtr.Zero) {
4433 Control c = Control.FromHandle (hwnd.client_window);
4436 goto ProcessNextMessage;
4437 Form form = c.FindForm ();
4439 goto ProcessNextMessage;
4441 if (ActiveWindow != form.Handle) {
4442 ActiveWindow = form.Handle;
4443 SendMessage (ActiveWindow, Msg.WM_ACTIVATE, (IntPtr) WindowActiveFlags.WA_ACTIVE, IntPtr.Zero);
4445 goto ProcessNextMessage;
4447 SendMessage(FocusWindow, Msg.WM_SETFOCUS, IntPtr.Zero, IntPtr.Zero);
4448 Keyboard.FocusIn (FocusWindow);
4449 goto ProcessNextMessage;
4452 case XEventName.FocusOut: {
4453 // Se the comment for our FocusIn handler
4454 if (xevent.FocusChangeEvent.detail != NotifyDetail.NotifyNonlinear) {
4455 goto ProcessNextMessage;
4458 while (Keyboard.ResetKeyState(FocusWindow, ref msg)) {
4459 SendMessage(FocusWindow, msg.message, msg.wParam, msg.lParam);
4462 Keyboard.FocusOut(hwnd.client_window);
4463 SendMessage(FocusWindow, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero);
4464 goto ProcessNextMessage;
4467 // We are already firing WM_SHOWWINDOW messages in the proper places, but I'm leaving this code
4468 // in case we break a scenario not taken into account in the tests
4469 case XEventName.MapNotify: {
4470 /*if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas
4472 msg.message = Msg.WM_SHOWWINDOW;
4473 msg.wParam = (IntPtr) 1;
4474 // XXX we're missing the lParam..
4477 goto ProcessNextMessage;
4480 case XEventName.UnmapNotify: {
4481 /*if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas
4482 hwnd.mapped = false;
4483 msg.message = Msg.WM_SHOWWINDOW;
4484 msg.wParam = (IntPtr) 0;
4485 // XXX we're missing the lParam..
4488 goto ProcessNextMessage;
4491 case XEventName.Expose: {
4494 hwnd.expose_pending = false;
4496 hwnd.nc_expose_pending = false;
4498 goto ProcessNextMessage;
4502 if (!hwnd.expose_pending) {
4503 goto ProcessNextMessage;
4506 if (!hwnd.nc_expose_pending) {
4507 goto ProcessNextMessage;
4510 switch (hwnd.border_style) {
4511 case FormBorderStyle.Fixed3D: {
4514 g = Graphics.FromHwnd(hwnd.whole_window);
4515 if (hwnd.border_static)
4516 ControlPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Border3DStyle.SunkenOuter);
4518 ControlPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Border3DStyle.Sunken);
4523 case FormBorderStyle.FixedSingle: {
4526 g = Graphics.FromHwnd(hwnd.whole_window);
4527 ControlPaint.DrawBorder(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Color.Black, ButtonBorderStyle.Solid);
4532 #if DriverDebugExtra
4533 Console.WriteLine("GetMessage(): Window {0:X} Exposed non-client area {1},{2} {3}x{4}", hwnd.client_window.ToInt32(), xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height);
4536 Rectangle rect = new Rectangle (xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height);
4537 Region region = new Region (rect);
4538 IntPtr hrgn = region.GetHrgn (null); // Graphics object isn't needed
4539 msg.message = Msg.WM_NCPAINT;
4540 msg.wParam = hrgn == IntPtr.Zero ? (IntPtr)1 : hrgn;
4541 msg.refobject = region;
4544 #if DriverDebugExtra
4545 Console.WriteLine("GetMessage(): Window {0:X} Exposed area {1},{2} {3}x{4}", hwnd.client_window.ToInt32(), xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height);
4547 if (Caret.Visible == true) {
4548 Caret.Paused = true;
4552 if (Caret.Visible == true) {
4554 Caret.Paused = false;
4556 msg.message = Msg.WM_PAINT;
4560 case XEventName.DestroyNotify: {
4562 // This is a bit tricky, we don't receive our own DestroyNotify, we only get those for our children
4563 hwnd = Hwnd.ObjectFromHandle(xevent.DestroyWindowEvent.window);
4565 // We may get multiple for the same window, act only one the first (when Hwnd still knows about it)
4566 if ((hwnd != null) && (hwnd.client_window == xevent.DestroyWindowEvent.window)) {
4567 CleanupCachedWindows (hwnd);
4569 #if DriverDebugDestroy
4570 Console.WriteLine("Received X11 Destroy Notification for {0}", XplatUI.Window(hwnd.client_window));
4573 msg.hwnd = hwnd.client_window;
4574 msg.message=Msg.WM_DESTROY;
4577 goto ProcessNextMessage;
4583 case XEventName.ClientMessage: {
4584 if (Dnd.HandleClientMessage (ref xevent)) {
4585 goto ProcessNextMessage;
4588 if (xevent.ClientMessageEvent.message_type == AsyncAtom) {
4589 XplatUIDriverSupport.ExecuteClientMessage((GCHandle)xevent.ClientMessageEvent.ptr1);
4590 goto ProcessNextMessage;
4593 if (xevent.ClientMessageEvent.message_type == HoverState.Atom) {
4594 msg.message = Msg.WM_MOUSEHOVER;
4595 msg.wParam = GetMousewParam(0);
4596 msg.lParam = (IntPtr) (xevent.ClientMessageEvent.ptr1);
4600 if (xevent.ClientMessageEvent.message_type == (IntPtr)PostAtom) {
4601 DebugHelper.Indent ();
4602 DebugHelper.WriteLine (String.Format ("Posted message:" + (Msg) xevent.ClientMessageEvent.ptr2.ToInt32 () + " for 0x{0:x}", xevent.ClientMessageEvent.ptr1.ToInt32 ()));
4603 DebugHelper.Unindent ();
4604 msg.hwnd = xevent.ClientMessageEvent.ptr1;
4605 msg.message = (Msg) xevent.ClientMessageEvent.ptr2.ToInt32 ();
4606 msg.wParam = xevent.ClientMessageEvent.ptr3;
4607 msg.lParam = xevent.ClientMessageEvent.ptr4;
4608 if (msg.message == (Msg)Msg.WM_QUIT)
4614 if (xevent.ClientMessageEvent.message_type == _XEMBED) {
4615 #if DriverDebugXEmbed
4616 Console.WriteLine("GOT EMBED MESSAGE {0:X}, detail {1:X}", xevent.ClientMessageEvent.ptr2.ToInt32(), xevent.ClientMessageEvent.ptr3.ToInt32());
4619 if (xevent.ClientMessageEvent.ptr2.ToInt32() == (int)XEmbedMessage.EmbeddedNotify) {
4620 XSizeHints hints = new XSizeHints();
4623 XGetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints, out dummy);
4625 hwnd.width = hints.max_width;
4626 hwnd.height = hints.max_height;
4627 hwnd.ClientRect = Rectangle.Empty;
4628 SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
4632 if (xevent.ClientMessageEvent.message_type == WM_PROTOCOLS) {
4633 if (xevent.ClientMessageEvent.ptr1 == WM_DELETE_WINDOW) {
4634 SendMessage (msg.hwnd, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_CLOSE, IntPtr.Zero);
4635 msg.message = Msg.WM_CLOSE;
4639 // We should not get this, but I'll leave the code in case we need it in the future
4640 if (xevent.ClientMessageEvent.ptr1 == WM_TAKE_FOCUS) {
4641 goto ProcessNextMessage;
4644 goto ProcessNextMessage;
4648 goto ProcessNextMessage;
4655 private HitTest NCHitTest (Hwnd hwnd, int x, int y)
4657 // The hit test is sent in screen coordinates
4659 int screen_x, screen_y;
4660 XTranslateCoordinates (DisplayHandle, hwnd.WholeWindow, RootWindow, x, y, out screen_x, out screen_y, out dummy);
4661 return (HitTest) NativeWindow.WndProc (hwnd.client_window, Msg.WM_NCHITTEST, IntPtr.Zero,
4662 (IntPtr) (screen_y << 16 | screen_x & 0xFFFF));
4665 // Our very basic implementation of MoveResize - we can extend it later
4667 internal override void BeginMoveResize (IntPtr handle)
4669 // We *need* to ungrab the pointer in the current display
4670 XplatUI.UngrabWindow (Grab.Hwnd);
4673 GetCursorPos (IntPtr.Zero, out x_root, out y_root);
4675 Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
4676 SendNetWMMessage (hwnd.whole_window, _NET_WM_MOVERESIZE, (IntPtr) x_root, (IntPtr) y_root,
4677 (IntPtr) NetWmMoveResize._NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT,
4678 (IntPtr) 1); // left button
4681 internal override bool GetText(IntPtr handle, out string text) {
4688 IntPtr prop = IntPtr.Zero;
4690 XGetWindowProperty(DisplayHandle, handle,
4691 _NET_WM_NAME, IntPtr.Zero, new IntPtr (1), false,
4692 UTF8_STRING, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
4694 if ((long)nitems > 0 && prop != IntPtr.Zero) {
4695 text = Marshal.PtrToStringUni (prop, (int)nitems);
4700 // fallback on the non-_NET property
4703 textptr = IntPtr.Zero;
4705 XFetchName(DisplayHandle, Hwnd.ObjectFromHandle(handle).whole_window, ref textptr);
4706 if (textptr != IntPtr.Zero) {
4707 text = Marshal.PtrToStringAnsi(textptr);
4718 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) {
4721 hwnd = Hwnd.ObjectFromHandle(handle);
4727 height = hwnd.height;
4729 PerformNCCalc(hwnd);
4731 client_width = hwnd.ClientRect.Width;
4732 client_height = hwnd.ClientRect.Height;
4737 // Should we throw an exception or fail silently?
4738 // throw new ArgumentException("Called with an invalid window handle", "handle");
4748 internal override FormWindowState GetWindowState(IntPtr handle) {
4751 hwnd = Hwnd.ObjectFromHandle(handle);
4753 if (hwnd.cached_window_state == (FormWindowState)(-1))
4754 hwnd.cached_window_state = UpdateWindowState (handle);
4756 return hwnd.cached_window_state;
4759 private FormWindowState UpdateWindowState (IntPtr handle) {
4764 IntPtr prop = IntPtr.Zero;
4768 XWindowAttributes attributes;
4771 hwnd = Hwnd.ObjectFromHandle(handle);
4775 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);
4776 if (((long)nitems > 0) && (prop != IntPtr.Zero)) {
4777 for (int i = 0; i < (long)nitems; i++) {
4778 atom = (IntPtr)Marshal.ReadInt32(prop, i * 4);
4779 if ((atom == _NET_WM_STATE_MAXIMIZED_HORZ) || (atom == _NET_WM_STATE_MAXIMIZED_VERT)) {
4781 } else if (atom == _NET_WM_STATE_HIDDEN) {
4789 return FormWindowState.Minimized;
4790 } else if (maximized == 2) {
4791 return FormWindowState.Maximized;
4794 attributes = new XWindowAttributes();
4795 XGetWindowAttributes(DisplayHandle, hwnd.client_window, ref attributes);
4796 if (attributes.map_state == MapState.IsUnmapped) {
4797 return (FormWindowState)(-1);
4801 return FormWindowState.Normal;
4804 internal override void GrabInfo(out IntPtr handle, out bool GrabConfined, out Rectangle GrabArea) {
4806 GrabConfined = Grab.Confined;
4807 GrabArea = Grab.Area;
4810 internal override void GrabWindow(IntPtr handle, IntPtr confine_to_handle) {
4812 IntPtr confine_to_window;
4814 confine_to_window = IntPtr.Zero;
4816 if (confine_to_handle != IntPtr.Zero) {
4817 XWindowAttributes attributes = new XWindowAttributes();
4819 hwnd = Hwnd.ObjectFromHandle(confine_to_handle);
4822 XGetWindowAttributes(DisplayHandle, hwnd.client_window, ref attributes);
4824 Grab.Area.X = attributes.x;
4825 Grab.Area.Y = attributes.y;
4826 Grab.Area.Width = attributes.width;
4827 Grab.Area.Height = attributes.height;
4828 Grab.Confined = true;
4829 confine_to_window = hwnd.client_window;
4834 hwnd = Hwnd.ObjectFromHandle(handle);
4837 XGrabPointer(DisplayHandle, hwnd.client_window, false,
4838 EventMask.ButtonPressMask | EventMask.ButtonMotionMask |
4839 EventMask.ButtonReleaseMask | EventMask.PointerMotionMask |
4840 EventMask.PointerMotionHintMask | EventMask.LeaveWindowMask,
4841 GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, confine_to_window, IntPtr.Zero, IntPtr.Zero);
4845 internal override void UngrabWindow(IntPtr hwnd) {
4847 XUngrabPointer(DisplayHandle, IntPtr.Zero);
4848 XFlush(DisplayHandle);
4850 WindowUngrabbed (hwnd);
4853 private void WindowUngrabbed (IntPtr hwnd) {
4854 bool was_grabbed = Grab.Hwnd != IntPtr.Zero;
4856 Grab.Hwnd = IntPtr.Zero;
4857 Grab.Confined = false;
4860 // lparam should be the handle to the window gaining the mouse capture,
4861 // but X doesn't seem to give us that information.
4862 // Also only generate WM_CAPTURECHANGED if the window actually was grabbed.
4863 // X will send a NotifyUngrab, but since it comes late sometimes we're
4864 // calling WindowUngrabbed directly from UngrabWindow in order to send
4865 // this WM right away.
4866 SendMessage (hwnd, Msg.WM_CAPTURECHANGED, IntPtr.Zero, IntPtr.Zero);
4870 internal override void HandleException(Exception e) {
4871 StackTrace st = new StackTrace(e, true);
4872 Console.WriteLine("Exception '{0}'", e.Message+st.ToString());
4873 Console.WriteLine("{0}{1}", e.Message, st.ToString());
4876 internal override void Invalidate(IntPtr handle, Rectangle rc, bool clear) {
4879 hwnd = Hwnd.ObjectFromHandle(handle);
4882 AddExpose (hwnd, true, hwnd.X, hwnd.Y, hwnd.Width, hwnd.Height);
4884 AddExpose (hwnd, true, rc.X, rc.Y, rc.Width, rc.Height);
4888 internal override void InvalidateNC (IntPtr handle) {
4891 hwnd = Hwnd.ObjectFromHandle(handle);
4893 AddExpose (hwnd, hwnd.WholeWindow == hwnd.ClientWindow, 0, 0, hwnd.Width, hwnd.Height);
4896 internal override bool IsEnabled(IntPtr handle) {
4897 Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
4898 return (hwnd != null && hwnd.Enabled);
4901 internal override bool IsVisible(IntPtr handle) {
4902 Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
4903 return (hwnd != null && hwnd.visible);
4906 internal override void KillTimer(Timer timer) {
4907 XEventQueue queue = (XEventQueue) MessageQueues [timer.thread];
4909 if (queue == null) {
4910 // This isn't really an error, MS doesn't start the timer if
4911 // it has no assosciated queue. In this case, remove the timer
4912 // from the list of unattached timers (if it was enabled).
4913 lock (unattached_timer_list) {
4914 if (unattached_timer_list.Contains (timer))
4915 unattached_timer_list.Remove (timer);
4919 queue.timer_list.Remove (timer);
4922 internal override void MenuToScreen(IntPtr handle, ref int x, ref int y) {
4928 hwnd = Hwnd.ObjectFromHandle(handle);
4931 XTranslateCoordinates(DisplayHandle, hwnd.whole_window, RootWindow, x, y, out dest_x_return, out dest_y_return, out child);
4938 internal override void OverrideCursor(IntPtr cursor)
4940 if (Grab.Hwnd != IntPtr.Zero) {
4941 XChangeActivePointerGrab (DisplayHandle,
4942 EventMask.ButtonMotionMask |
4943 EventMask.PointerMotionMask |
4944 EventMask.PointerMotionHintMask |
4945 EventMask.ButtonPressMask |
4946 EventMask.ButtonReleaseMask,
4947 cursor, IntPtr.Zero);
4951 OverrideCursorHandle = cursor;
4954 internal override PaintEventArgs PaintEventStart(ref Message msg, IntPtr handle, bool client) {
4955 PaintEventArgs paint_event;
4960 // handle (and paint_hwnd) refers to the window that is should be painted.
4961 // msg.HWnd (and hwnd) refers to the window that got the paint message.
4964 hwnd = Hwnd.ObjectFromHandle(msg.HWnd);
4965 if (msg.HWnd == handle) {
4968 paint_hwnd = Hwnd.ObjectFromHandle (handle);
4971 if (Caret.Visible == true) {
4972 Caret.Paused = true;
4979 dc = Graphics.FromHwnd (paint_hwnd.client_window);
4981 Region clip_region = new Region ();
4982 clip_region.MakeEmpty();
4984 foreach (Rectangle r in hwnd.ClipRectangles) {
4985 clip_region.Union (r);
4988 if (hwnd.UserClip != null) {
4989 clip_region.Intersect(hwnd.UserClip);
4992 dc.Clip = clip_region;
4993 paint_event = new PaintEventArgs(dc, hwnd.Invalid);
4994 hwnd.expose_pending = false;
4996 hwnd.ClearInvalidArea();
4998 hwnd.drawing_stack.Push (paint_event);
4999 hwnd.drawing_stack.Push (dc);
5003 dc = Graphics.FromHwnd (paint_hwnd.whole_window);
5005 if (!hwnd.nc_invalid.IsEmpty) {
5006 dc.SetClip (hwnd.nc_invalid);
5007 paint_event = new PaintEventArgs(dc, hwnd.nc_invalid);
5009 paint_event = new PaintEventArgs(dc, new Rectangle(0, 0, hwnd.width, hwnd.height));
5011 hwnd.nc_expose_pending = false;
5013 hwnd.ClearNcInvalidArea ();
5015 hwnd.drawing_stack.Push (paint_event);
5016 hwnd.drawing_stack.Push (dc);
5022 internal override void PaintEventEnd(ref Message msg, IntPtr handle, bool client) {
5025 hwnd = Hwnd.ObjectFromHandle (msg.HWnd);
5027 Graphics dc = (Graphics)hwnd.drawing_stack.Pop ();
5031 PaintEventArgs pe = (PaintEventArgs)hwnd.drawing_stack.Pop();
5032 pe.SetGraphics (null);
5035 if (Caret.Visible == true) {
5037 Caret.Paused = false;
5041 [MonoTODO("Implement filtering and PM_NOREMOVE")]
5042 internal override bool PeekMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags) {
5043 XEventQueue queue = (XEventQueue) queue_id;
5046 if ((flags & (uint)PeekMessageFlags.PM_REMOVE) == 0) {
5047 throw new NotImplementedException("PeekMessage PM_NOREMOVE is not implemented yet"); // FIXME - Implement PM_NOREMOVE flag
5051 if (queue.Count > 0) {
5054 // Only call UpdateMessageQueue if real events are pending
5055 // otherwise we go to sleep on the socket
5056 if (XPending(DisplayHandle) != 0) {
5057 UpdateMessageQueue((XEventQueue)queue_id);
5059 } else if (((XEventQueue)queue_id).Paint.Count > 0) {
5064 CheckTimers(queue.timer_list, DateTime.UtcNow);
5069 return GetMessage(queue_id, ref msg, hWnd, wFilterMin, wFilterMax);
5072 internal override bool PostMessage (IntPtr handle, Msg message, IntPtr wparam, IntPtr lparam) {
5073 XEvent xevent = new XEvent ();
5074 Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
5076 xevent.type = XEventName.ClientMessage;
5077 xevent.ClientMessageEvent.display = DisplayHandle;
5080 xevent.ClientMessageEvent.window = hwnd.whole_window;
5082 xevent.ClientMessageEvent.window = IntPtr.Zero;
5085 xevent.ClientMessageEvent.message_type = (IntPtr) PostAtom;
5086 xevent.ClientMessageEvent.format = 32;
5087 xevent.ClientMessageEvent.ptr1 = handle;
5088 xevent.ClientMessageEvent.ptr2 = (IntPtr) message;
5089 xevent.ClientMessageEvent.ptr3 = wparam;
5090 xevent.ClientMessageEvent.ptr4 = lparam;
5093 hwnd.Queue.EnqueueLocked (xevent);
5095 ThreadQueue(Thread.CurrentThread).EnqueueLocked (xevent);
5100 internal override void PostQuitMessage(int exitCode) {
5101 ApplicationContext ctx = Application.MWFThread.Current.Context;
5102 Form f = ctx != null ? ctx.MainForm : null;
5104 PostMessage (Application.MWFThread.Current.Context.MainForm.window.Handle, Msg.WM_QUIT, IntPtr.Zero, IntPtr.Zero);
5106 PostMessage (FosterParent, Msg.WM_QUIT, IntPtr.Zero, IntPtr.Zero);
5107 XFlush(DisplayHandle);
5110 internal override void RequestAdditionalWM_NCMessages(IntPtr hwnd, bool hover, bool leave)
5115 internal override void RequestNCRecalc(IntPtr handle) {
5118 hwnd = Hwnd.ObjectFromHandle(handle);
5124 PerformNCCalc(hwnd);
5125 SendMessage(handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
5126 InvalidateNC(handle);
5129 internal override void ResetMouseHover(IntPtr handle) {
5132 hwnd = Hwnd.ObjectFromHandle(handle);
5137 HoverState.Timer.Enabled = true;
5138 HoverState.X = mouse_position.X;
5139 HoverState.Y = mouse_position.Y;
5140 HoverState.Window = handle;
5144 internal override void ScreenToClient(IntPtr handle, ref int x, ref int y) {
5150 hwnd = Hwnd.ObjectFromHandle(handle);
5153 XTranslateCoordinates (DisplayHandle, RootWindow, hwnd.client_window, x, y, out dest_x_return, out dest_y_return, out child);
5160 internal override void ScreenToMenu(IntPtr handle, ref int x, ref int y) {
5166 hwnd = Hwnd.ObjectFromHandle(handle);
5169 XTranslateCoordinates (DisplayHandle, RootWindow, hwnd.whole_window, x, y, out dest_x_return, out dest_y_return, out child);
5172 Form form = Control.FromHandle (handle) as Form;
5173 if (form != null && form.window_manager != null) {
5174 dest_y_return -= form.window_manager.TitleBarHeight;
5181 bool GraphicsExposePredicate (IntPtr display, ref XEvent xevent, IntPtr arg)
5183 return (xevent.type == XEventName.GraphicsExpose || xevent.type == XEventName.NoExpose) &&
5184 arg == xevent.GraphicsExposeEvent.drawable;
5187 delegate bool EventPredicate (IntPtr display, ref XEvent xevent, IntPtr arg);
5189 void ProcessGraphicsExpose (Hwnd hwnd)
5191 XEvent xevent = new XEvent ();
5192 IntPtr handle = Hwnd.HandleFromObject (hwnd);
5193 EventPredicate predicate = GraphicsExposePredicate;
5196 XIfEvent (Display, ref xevent, predicate, handle);
5197 if (xevent.type != XEventName.GraphicsExpose)
5200 AddExpose (hwnd, xevent.ExposeEvent.window == hwnd.ClientWindow, xevent.GraphicsExposeEvent.x, xevent.GraphicsExposeEvent.y,
5201 xevent.GraphicsExposeEvent.width, xevent.GraphicsExposeEvent.height);
5203 if (xevent.GraphicsExposeEvent.count == 0)
5208 internal override void ScrollWindow(IntPtr handle, Rectangle area, int XAmount, int YAmount, bool with_children) {
5211 XGCValues gc_values;
5213 hwnd = Hwnd.ObjectFromHandle(handle);
5215 Rectangle r = Rectangle.Intersect (hwnd.Invalid, area);
5217 /* We have an invalid area in the window we're scrolling.
5218 Adjust our stored invalid rectangle to to match the scrolled amount */
5233 if (area.Contains (hwnd.Invalid))
5234 hwnd.ClearInvalidArea ();
5235 hwnd.AddInvalidArea(r);
5238 gc_values = new XGCValues();
5240 if (with_children) {
5241 gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors;
5244 gc = XCreateGC(DisplayHandle, hwnd.client_window, IntPtr.Zero, ref gc_values);
5246 Rectangle visible_rect = GetTotalVisibleArea (hwnd.client_window);
5247 visible_rect.Intersect (area);
5249 Rectangle dest_rect = visible_rect;
5250 dest_rect.Y += YAmount;
5251 dest_rect.X += XAmount;
5252 dest_rect.Intersect (area);
5254 Point src = new Point (dest_rect.X - XAmount, dest_rect.Y - YAmount);
5255 XCopyArea (DisplayHandle, hwnd.client_window, hwnd.client_window, gc, src.X, src.Y,
5256 dest_rect.Width, dest_rect.Height, dest_rect.X, dest_rect.Y);
5258 Rectangle dirty_area = GetDirtyArea (area, dest_rect, XAmount, YAmount);
5259 AddExpose (hwnd, true, dirty_area.X, dirty_area.Y, dirty_area.Width, dirty_area.Height);
5261 ProcessGraphicsExpose (hwnd);
5263 XFreeGC(DisplayHandle, gc);
5266 internal override void ScrollWindow(IntPtr handle, int XAmount, int YAmount, bool with_children) {
5270 hwnd = Hwnd.GetObjectFromWindow(handle);
5272 rect = hwnd.ClientRect;
5275 ScrollWindow(handle, rect, XAmount, YAmount, with_children);
5278 Rectangle GetDirtyArea (Rectangle total_area, Rectangle valid_area, int XAmount, int YAmount)
5280 Rectangle dirty_area = total_area;
5283 dirty_area.Height -= valid_area.Height;
5284 else if (YAmount < 0) {
5285 dirty_area.Height -= valid_area.Height;
5286 dirty_area.Y += valid_area.Height;
5290 dirty_area.Width -= valid_area.Width;
5291 else if (XAmount < 0) {
5292 dirty_area.Width -= valid_area.Width;
5293 dirty_area.X += valid_area.Width;
5299 Rectangle GetTotalVisibleArea (IntPtr handle)
5301 Control c = Control.FromHandle (handle);
5303 Rectangle visible_area = c.ClientRectangle;
5304 visible_area.Location = c.PointToScreen (Point.Empty);
5306 for (Control parent = c.Parent; parent != null; parent = parent.Parent) {
5307 if (!parent.IsHandleCreated || !parent.Visible)
5308 return visible_area; // Non visible, not need to finish computations
5310 Rectangle r = parent.ClientRectangle;
5311 r.Location = parent.PointToScreen (Point.Empty);
5313 visible_area.Intersect (r);
5316 visible_area.Location = c.PointToClient (visible_area.Location);
5317 return visible_area;
5320 internal override void SendAsyncMethod (AsyncMethodData method) {
5322 XEvent xevent = new XEvent ();
5324 hwnd = Hwnd.ObjectFromHandle(method.Handle);
5326 xevent.type = XEventName.ClientMessage;
5327 xevent.ClientMessageEvent.display = DisplayHandle;
5328 xevent.ClientMessageEvent.window = method.Handle;
5329 xevent.ClientMessageEvent.message_type = (IntPtr)AsyncAtom;
5330 xevent.ClientMessageEvent.format = 32;
5331 xevent.ClientMessageEvent.ptr1 = (IntPtr) GCHandle.Alloc (method);
5333 hwnd.Queue.EnqueueLocked (xevent);
5338 delegate IntPtr WndProcDelegate (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam);
5340 internal override IntPtr SendMessage (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam)
5343 h = Hwnd.ObjectFromHandle(hwnd);
5345 if (h != null && h.queue != ThreadQueue (Thread.CurrentThread)) {
5346 AsyncMethodResult result;
5347 AsyncMethodData data;
5349 result = new AsyncMethodResult ();
5350 data = new AsyncMethodData ();
5353 data.Method = new WndProcDelegate (NativeWindow.WndProc);
5354 data.Args = new object[] { hwnd, message, wParam, lParam };
5355 data.Result = result;
5357 SendAsyncMethod (data);
5358 #if DriverDebug || DriverDebugThreads
5359 Console.WriteLine ("Sending {0} message across.", message);
5364 string key = hwnd + ":" + message;
5365 if (messageHold[key] != null)
5366 messageHold[key] = ((int)messageHold[key]) - 1;
5367 return NativeWindow.WndProc(hwnd, message, wParam, lParam);
5370 internal override int SendInput(IntPtr handle, Queue keys) {
5371 if (handle == IntPtr.Zero)
5374 int count = keys.Count;
5375 Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
5377 while (keys.Count > 0) {
5379 MSG msg = (MSG)keys.Dequeue();
5381 XEvent xevent = new XEvent ();
5383 xevent.type = (msg.message == Msg.WM_KEYUP ? XEventName.KeyRelease : XEventName.KeyPress);
5384 xevent.KeyEvent.display = DisplayHandle;
5387 xevent.KeyEvent.window = hwnd.whole_window;
5389 xevent.KeyEvent.window = IntPtr.Zero;
5392 xevent.KeyEvent.keycode = Keyboard.ToKeycode((int)msg.wParam);
5394 hwnd.Queue.EnqueueLocked (xevent);
5399 internal override void SetAllowDrop (IntPtr handle, bool value)
5401 // We allow drop on all windows
5404 internal override DragDropEffects StartDrag (IntPtr handle, object data,
5405 DragDropEffects allowed_effects)
5407 Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
5410 throw new ArgumentException ("Attempt to begin drag from invalid window handle (" + handle.ToInt32 () + ").");
5412 return Dnd.StartDrag (hwnd.client_window, data, allowed_effects);
5415 internal override void SetBorderStyle(IntPtr handle, FormBorderStyle border_style) {
5416 Form form = Control.FromHandle (handle) as Form;
5417 if (form != null && form.window_manager == null) {
5418 CreateParams cp = form.GetCreateParams ();
5419 if (border_style == FormBorderStyle.FixedToolWindow ||
5420 border_style == FormBorderStyle.SizableToolWindow ||
5421 cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) {
5422 form.window_manager = new ToolWindowManager (form);
5426 RequestNCRecalc(handle);
5429 internal override void SetCaretPos(IntPtr handle, int x, int y) {
5430 if (Caret.Hwnd == handle) {
5437 Keyboard.SetCaretPos (Caret, handle, x, y);
5439 if (Caret.Visible == true) {
5441 Caret.Timer.Start();
5446 internal override void SetClipRegion(IntPtr handle, Region region) {
5449 hwnd = Hwnd.ObjectFromHandle(handle);
5454 hwnd.UserClip = region;
5457 internal override void SetCursor(IntPtr handle, IntPtr cursor) {
5460 if (OverrideCursorHandle == IntPtr.Zero) {
5461 if ((LastCursorWindow == handle) && (LastCursorHandle == cursor)) {
5465 LastCursorHandle = cursor;
5466 LastCursorWindow = handle;
5468 hwnd = Hwnd.ObjectFromHandle(handle);
5470 if (cursor != IntPtr.Zero) {
5471 XDefineCursor(DisplayHandle, hwnd.whole_window, cursor);
5473 XUndefineCursor(DisplayHandle, hwnd.whole_window);
5475 XFlush(DisplayHandle);
5480 hwnd = Hwnd.ObjectFromHandle(handle);
5482 XDefineCursor(DisplayHandle, hwnd.whole_window, OverrideCursorHandle);
5486 private void QueryPointer (IntPtr display, IntPtr w, out IntPtr root, out IntPtr child,
5487 out int root_x, out int root_y, out int child_x, out int child_y,
5490 /* this code was written with the help of
5491 glance at gdk. I never would have realized we
5492 needed a loop in order to traverse down in the
5493 hierarchy. I would have assumed you'd get the
5494 most deeply nested child and have to do
5495 XQueryTree to move back up the hierarchy..
5496 stupid me, of course. */
5499 XGrabServer (display);
5501 XQueryPointer(display, w, out root, out c,
5502 out root_x, out root_y, out child_x, out child_y,
5508 IntPtr child_last = IntPtr.Zero;
5509 while (c != IntPtr.Zero) {
5511 XQueryPointer(display, c, out root, out c,
5512 out root_x, out root_y, out child_x, out child_y,
5515 XUngrabServer (display);
5521 internal override void SetCursorPos(IntPtr handle, int x, int y) {
5522 if (handle == IntPtr.Zero) {
5525 int root_x, root_y, child_x, child_y, mask;
5528 * QueryPointer before warping
5529 * because if the warp is on
5530 * the RootWindow, the x/y are
5531 * relative to the current
5534 QueryPointer (DisplayHandle, RootWindow,
5537 out root_x, out root_y,
5538 out child_x, out child_y,
5541 XWarpPointer(DisplayHandle, IntPtr.Zero, IntPtr.Zero, 0, 0, 0, 0, x - root_x, y - root_y);
5543 XFlush (DisplayHandle);
5545 /* then we need to a
5546 * QueryPointer after warping
5547 * to manually generate a
5548 * motion event for the window
5551 QueryPointer (DisplayHandle, RootWindow,
5554 out root_x, out root_y,
5555 out child_x, out child_y,
5558 Hwnd child_hwnd = Hwnd.ObjectFromHandle(child);
5559 if (child_hwnd == null) {
5563 XEvent xevent = new XEvent ();
5565 xevent.type = XEventName.MotionNotify;
5566 xevent.MotionEvent.display = DisplayHandle;
5567 xevent.MotionEvent.window = child_hwnd.client_window;
5568 xevent.MotionEvent.root = RootWindow;
5569 xevent.MotionEvent.x = child_x;
5570 xevent.MotionEvent.y = child_y;
5571 xevent.MotionEvent.x_root = root_x;
5572 xevent.MotionEvent.y_root = root_y;
5573 xevent.MotionEvent.state = mask;
5575 child_hwnd.Queue.EnqueueLocked (xevent);
5580 hwnd = Hwnd.ObjectFromHandle(handle);
5582 XWarpPointer(DisplayHandle, IntPtr.Zero, hwnd.client_window, 0, 0, 0, 0, x, y);
5587 internal override void SetFocus(IntPtr handle) {
5589 IntPtr prev_focus_window;
5591 hwnd = Hwnd.ObjectFromHandle(handle);
5593 if (hwnd.client_window == FocusWindow) {
5597 // Win32 doesn't do anything if disabled
5601 prev_focus_window = FocusWindow;
5602 FocusWindow = hwnd.client_window;
5604 if (prev_focus_window != IntPtr.Zero) {
5605 SendMessage(prev_focus_window, Msg.WM_KILLFOCUS, FocusWindow, IntPtr.Zero);
5607 SendMessage(FocusWindow, Msg.WM_SETFOCUS, prev_focus_window, IntPtr.Zero);
5608 Keyboard.FocusIn (FocusWindow);
5610 //XSetInputFocus(DisplayHandle, Hwnd.ObjectFromHandle(handle).client_window, RevertTo.None, IntPtr.Zero);
5613 internal override void SetIcon(IntPtr handle, Icon icon) {
5616 hwnd = Hwnd.ObjectFromHandle(handle);
5618 SetIcon(hwnd, icon);
5622 internal override void SetMenu(IntPtr handle, Menu menu) {
5625 hwnd = Hwnd.ObjectFromHandle(handle);
5628 RequestNCRecalc(handle);
5631 internal override void SetModal(IntPtr handle, bool Modal) {
5633 ModalWindows.Push(handle);
5635 if (ModalWindows.Contains(handle)) {
5638 if (ModalWindows.Count > 0) {
5639 Activate((IntPtr)ModalWindows.Peek());
5643 Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
5644 Control ctrl = Control.FromHandle (handle);
5645 SetWMStyles (hwnd, ctrl.GetCreateParams ());
5648 internal override IntPtr SetParent(IntPtr handle, IntPtr parent) {
5651 hwnd = Hwnd.ObjectFromHandle(handle);
5652 hwnd.parent = Hwnd.ObjectFromHandle(parent);
5655 #if DriverDebug || DriverDebugParent
5656 Console.WriteLine("Parent for window {0} = {1}", XplatUI.Window(hwnd.Handle), XplatUI.Window(hwnd.parent != null ? hwnd.parent.Handle : IntPtr.Zero));
5658 XReparentWindow(DisplayHandle, hwnd.whole_window, hwnd.parent == null ? FosterParent : hwnd.parent.client_window, hwnd.x, hwnd.y);
5664 internal override void SetTimer (Timer timer) {
5665 XEventQueue queue = (XEventQueue) MessageQueues [timer.thread];
5667 if (queue == null) {
5668 // This isn't really an error, MS doesn't start the timer if
5669 // it has no assosciated queue at this stage (it will be
5670 // enabled when a window is activated).
5671 unattached_timer_list.Add (timer);
5674 queue.timer_list.Add (timer);
5678 internal override bool SetTopmost(IntPtr handle, bool enabled) {
5680 Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
5685 SendNetWMMessage(hwnd.WholeWindow, _NET_WM_STATE, (IntPtr) NetWmStateRequest._NET_WM_STATE_ADD, _NET_WM_STATE_ABOVE, IntPtr.Zero);
5687 int[] atoms = new int[8];
5688 atoms[0] = _NET_WM_STATE_ABOVE.ToInt32();
5689 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
5695 SendNetWMMessage(hwnd.WholeWindow, _NET_WM_STATE, (IntPtr) NetWmStateRequest._NET_WM_STATE_REMOVE, _NET_WM_STATE_ABOVE, IntPtr.Zero);
5697 XDeleteProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE);
5703 internal override bool SetOwner(IntPtr handle, IntPtr handle_owner) {
5707 hwnd = Hwnd.ObjectFromHandle(handle);
5709 if (handle_owner != IntPtr.Zero) {
5710 hwnd_owner = Hwnd.ObjectFromHandle(handle_owner);
5716 atoms[0] = _NET_WM_WINDOW_TYPE_NORMAL.ToInt32();
5717 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
5719 if (hwnd_owner != null) {
5720 XSetTransientForHint(DisplayHandle, hwnd.whole_window, hwnd_owner.whole_window);
5722 XSetTransientForHint(DisplayHandle, hwnd.whole_window, RootWindow);
5727 XDeleteProperty(DisplayHandle, hwnd.whole_window, (IntPtr)Atom.XA_WM_TRANSIENT_FOR);
5733 internal override bool SetVisible (IntPtr handle, bool visible, bool activate)
5737 hwnd = Hwnd.ObjectFromHandle(handle);
5738 hwnd.visible = visible;
5742 MapWindow(hwnd, WindowType.Both);
5744 if (Control.FromHandle(handle) is Form) {
5747 s = ((Form)Control.FromHandle(handle)).WindowState;
5750 case FormWindowState.Minimized: SetWindowState(handle, FormWindowState.Minimized); break;
5751 case FormWindowState.Maximized: SetWindowState(handle, FormWindowState.Maximized); break;
5755 SendMessage(handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
5758 UnmapWindow(hwnd, WindowType.Both);
5764 internal override void SetWindowMinMax(IntPtr handle, Rectangle maximized, Size min, Size max) {
5765 Control ctrl = Control.FromHandle (handle);
5766 SetWindowMinMax (handle, maximized, min, max, ctrl != null ? ctrl.GetCreateParams () : null);
5769 internal void SetWindowMinMax (IntPtr handle, Rectangle maximized, Size min, Size max, CreateParams cp)
5775 hwnd = Hwnd.ObjectFromHandle(handle);
5780 min.Width = Math.Max (min.Width, SystemInformation.MinimumWindowSize.Width);
5781 min.Height = Math.Max (min.Height, SystemInformation.MinimumWindowSize.Height);
5783 hints = new XSizeHints();
5785 XGetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints, out dummy);
5786 if ((min != Size.Empty) && (min.Width > 0) && (min.Height > 0)) {
5788 min = TranslateWindowSizeToXWindowSize (cp, min);
5789 hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMinSize);
5790 hints.min_width = min.Width;
5791 hints.min_height = min.Height;
5794 if ((max != Size.Empty) && (max.Width > 0) && (max.Height > 0)) {
5796 max = TranslateWindowSizeToXWindowSize (cp, max);
5797 hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMaxSize);
5798 hints.max_width = max.Width;
5799 hints.max_height = max.Height;
5802 if (hints.flags != IntPtr.Zero) {
5803 // The Metacity team has decided that they won't care about this when clicking the maximize icon,
5804 // they will maximize the window to fill the screen/parent no matter what.
5805 // http://bugzilla.ximian.com/show_bug.cgi?id=80021
5806 XSetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints);
5809 if ((maximized != Rectangle.Empty) && (maximized.Width > 0) && (maximized.Height > 0)) {
5811 maximized.Size = TranslateWindowSizeToXWindowSize (cp);
5812 hints.flags = (IntPtr)XSizeHintsFlags.PPosition;
5813 hints.x = maximized.X;
5814 hints.y = maximized.Y;
5815 hints.width = maximized.Width;
5816 hints.height = maximized.Height;
5818 // Metacity does not seem to follow this constraint for maximized (zoomed) windows
5819 XSetZoomHints(DisplayHandle, hwnd.whole_window, ref hints);
5824 internal override void SetWindowPos(IntPtr handle, int x, int y, int width, int height) {
5827 hwnd = Hwnd.ObjectFromHandle(handle);
5833 // Win32 automatically changes negative width/height to 0.
5839 // X requires a sanity check for width & height; otherwise it dies
5840 if (hwnd.zero_sized && width > 0 && height > 0) {
5842 MapWindow(hwnd, WindowType.Whole);
5844 hwnd.zero_sized = false;
5847 if ((width < 1) || (height < 1)) {
5848 hwnd.zero_sized = true;
5849 UnmapWindow(hwnd, WindowType.Whole);
5852 // Save a server roundtrip (and prevent a feedback loop)
5853 if ((hwnd.x == x) && (hwnd.y == y) &&
5854 (hwnd.width == width) && (hwnd.height == height)) {
5858 if (!hwnd.zero_sized) {
5863 hwnd.height = height;
5864 SendMessage(hwnd.client_window, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
5866 if (hwnd.fixed_size) {
5867 SetWindowMinMax(handle, Rectangle.Empty, new Size(width, height), new Size(width, height));
5871 Control ctrl = Control.FromHandle (handle);
5872 Size TranslatedSize = TranslateWindowSizeToXWindowSize (ctrl.GetCreateParams (), new Size (width, height));
5873 MoveResizeWindow (DisplayHandle, hwnd.whole_window, x, y, TranslatedSize.Width, TranslatedSize.Height);
5874 PerformNCCalc(hwnd);
5878 // Update our position/size immediately, so
5879 // that future calls to SetWindowPos aren't
5880 // kept from calling XMoveResizeWindow (by the
5881 // "Save a server roundtrip" block above).
5885 hwnd.height = height;
5886 hwnd.ClientRect = Rectangle.Empty;
5889 internal override void SetWindowState(IntPtr handle, FormWindowState state) {
5890 FormWindowState current_state;
5893 hwnd = Hwnd.ObjectFromHandle(handle);
5895 current_state = GetWindowState(handle);
5897 if (current_state == state) {
5902 case FormWindowState.Normal: {
5904 if (current_state == FormWindowState.Minimized) {
5905 MapWindow(hwnd, WindowType.Both);
5906 } else if (current_state == FormWindowState.Maximized) {
5907 SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)2 /* toggle */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT);
5914 case FormWindowState.Minimized: {
5916 if (current_state == FormWindowState.Maximized) {
5917 SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)2 /* toggle */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT);
5919 XIconifyWindow(DisplayHandle, hwnd.whole_window, ScreenNo);
5924 case FormWindowState.Maximized: {
5926 if (current_state == FormWindowState.Minimized) {
5927 MapWindow(hwnd, WindowType.Both);
5930 SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)1 /* Add */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT);
5938 internal override void SetWindowStyle(IntPtr handle, CreateParams cp) {
5941 hwnd = Hwnd.ObjectFromHandle(handle);
5942 SetHwndStyles(hwnd, cp);
5943 SetWMStyles(hwnd, cp);
5946 internal override double GetWindowTransparency(IntPtr handle)
5951 internal override void SetWindowTransparency(IntPtr handle, double transparency, Color key) {
5955 hwnd = Hwnd.ObjectFromHandle(handle);
5961 hwnd.opacity = (uint)(0xffffffff * transparency);
5962 opacity = (IntPtr)((int)hwnd.opacity);
5964 IntPtr w = hwnd.whole_window;
5965 if (hwnd.reparented)
5966 w = XGetParent (hwnd.whole_window);
5967 XChangeProperty(DisplayHandle, w, _NET_WM_WINDOW_OPACITY, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, ref opacity, 1);
5970 internal override bool SetZOrder(IntPtr handle, IntPtr after_handle, bool top, bool bottom) {
5971 Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
5979 XRaiseWindow(DisplayHandle, hwnd.whole_window);
5982 } else if (!bottom) {
5983 Hwnd after_hwnd = null;
5985 if (after_handle != IntPtr.Zero) {
5986 after_hwnd = Hwnd.ObjectFromHandle(after_handle);
5989 XWindowChanges values = new XWindowChanges();
5991 if (after_hwnd == null) {
5992 // Work around metacity 'issues'
5996 atoms[0] = unixtime();
5997 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_USER_TIME, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, atoms, 1);
5999 XRaiseWindow(DisplayHandle, hwnd.whole_window);
6000 SendNetWMMessage(hwnd.whole_window, _NET_ACTIVE_WINDOW, (IntPtr)1, IntPtr.Zero, IntPtr.Zero);
6002 //throw new ArgumentNullException("after_handle", "Need sibling to adjust z-order");
6005 values.sibling = after_hwnd.whole_window;
6006 values.stack_mode = StackMode.Below;
6009 XConfigureWindow(DisplayHandle, hwnd.whole_window, ChangeWindowFlags.CWStackMode | ChangeWindowFlags.CWSibling, ref values);
6014 XLowerWindow(DisplayHandle, hwnd.whole_window);
6021 internal override void ShowCursor(bool show) {
6022 ; // FIXME - X11 doesn't 'hide' the cursor. we could create an empty cursor
6025 internal override object StartLoop(Thread thread) {
6026 XEventQueue q = ThreadQueue(thread);
6030 internal override TransparencySupport SupportsTransparency() {
6031 // We need to check if the x compositing manager is running
6032 return TransparencySupport.Set;
6035 internal override bool SystrayAdd(IntPtr handle, string tip, Icon icon, out ToolTip tt) {
6036 GetSystrayManagerWindow();
6038 if (SystrayMgrWindow != IntPtr.Zero) {
6039 XSizeHints size_hints;
6042 hwnd = Hwnd.ObjectFromHandle(handle);
6044 Console.WriteLine("Adding Systray Whole:{0:X}, Client:{1:X}", hwnd.whole_window.ToInt32(), hwnd.client_window.ToInt32());
6048 if (hwnd.client_window != hwnd.whole_window) {
6049 Keyboard.DestroyICForWindow (hwnd.client_window);
6050 XDestroyWindow(DisplayHandle, hwnd.client_window);
6051 hwnd.client_window = hwnd.whole_window;
6054 /* by virtue of the way the tests are ordered when determining if it's PAINT
6055 or NCPAINT, client_window == whole_window will always be PAINT. So, if we're
6056 waiting on an nc_expose, drop it and remove the hwnd from the list (unless
6057 there's a pending expose). */
6058 if (hwnd.nc_expose_pending) {
6059 hwnd.nc_expose_pending = false;
6060 if (!hwnd.expose_pending)
6061 hwnd.Queue.Paint.Remove (hwnd);
6064 // We are going to be directly mapped by the system tray, so mark as mapped
6065 // so we can later properly unmap it.
6068 size_hints = new XSizeHints();
6070 size_hints.flags = (IntPtr)(XSizeHintsFlags.PMinSize | XSizeHintsFlags.PMaxSize | XSizeHintsFlags.PBaseSize);
6072 size_hints.min_width = 24;
6073 size_hints.min_height = 24;
6074 size_hints.max_width = 24;
6075 size_hints.max_height = 24;
6076 size_hints.base_width = 24;
6077 size_hints.base_height = 24;
6079 XSetWMNormalHints(DisplayHandle, hwnd.whole_window, ref size_hints);
6081 int[] atoms = new int[2];
6082 atoms [0] = 1; // Version 1
6083 atoms [1] = 1; // we want to be mapped
6085 // This line cost me 3 days...
6086 XChangeProperty(DisplayHandle, hwnd.whole_window, _XEMBED_INFO, _XEMBED_INFO, 32, PropertyMode.Replace, atoms, 2);
6088 // Need to pick some reasonable defaults
6090 tt.AutomaticDelay = 350;
6091 tt.InitialDelay = 250;
6092 tt.ReshowDelay = 250;
6093 tt.ShowAlways = true;
6095 if ((tip != null) && (tip != string.Empty)) {
6096 tt.SetToolTip(Control.FromHandle(handle), tip);
6102 SendNetClientMessage(SystrayMgrWindow, _NET_SYSTEM_TRAY_OPCODE, IntPtr.Zero, (IntPtr)SystrayRequest.SYSTEM_TRAY_REQUEST_DOCK, hwnd.whole_window);
6110 internal override bool SystrayChange(IntPtr handle, string tip, Icon icon, ref ToolTip tt) {
6113 control = Control.FromHandle(handle);
6114 if (control != null && tt != null) {
6115 tt.SetToolTip(control, tip);
6117 SendMessage(handle, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero);
6124 internal override void SystrayRemove(IntPtr handle, ref ToolTip tt) {
6126 SetVisible (handle, false, false);
6128 // The caller can now re-dock it later...
6134 // Close any balloon window *we* fired.
6135 ThemeEngine.Current.HideBalloonWindow (handle);
6140 internal override void SystrayBalloon(IntPtr handle, int timeout, string title, string text, ToolTipIcon icon)
6142 ThemeEngine.Current.ShowBalloonWindow (handle, timeout, title, text, icon);
6143 SendMessage(handle, Msg.WM_USER, IntPtr.Zero, (IntPtr) Msg.NIN_BALLOONSHOW);
6147 internal override bool Text(IntPtr handle, string text) {
6150 hwnd = Hwnd.ObjectFromHandle(handle);
6153 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_NAME, UTF8_STRING, 8,
6154 PropertyMode.Replace, text, Encoding.UTF8.GetByteCount (text));
6156 // XXX this has problems with UTF8.
6157 // we need to either use the actual
6158 // text if it's latin-1, or convert it
6159 // to compound text if it's in a
6160 // different charset.
6161 XStoreName(DisplayHandle, Hwnd.ObjectFromHandle(handle).whole_window, text);
6166 internal override bool TranslateMessage(ref MSG msg) {
6167 return Keyboard.TranslateMessage (ref msg);
6170 internal override void UpdateWindow(IntPtr handle) {
6173 hwnd = Hwnd.ObjectFromHandle(handle);
6175 if (!hwnd.visible || !hwnd.expose_pending || !hwnd.Mapped) {
6179 SendMessage(handle, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero);
6180 hwnd.Queue.Paint.Remove(hwnd);
6183 internal override void CreateOffscreenDrawable (IntPtr handle,
6184 int width, int height,
6185 out object offscreen_drawable)
6188 int x_out, y_out, width_out, height_out, border_width_out, depth_out;
6190 XGetGeometry (DisplayHandle, handle,
6192 out x_out, out y_out,
6193 out width_out, out height_out,
6194 out border_width_out, out depth_out);
6196 IntPtr pixmap = XCreatePixmap (DisplayHandle, handle, width, height, depth_out);
6198 offscreen_drawable = pixmap;
6202 internal override void DestroyOffscreenDrawable (object offscreen_drawable)
6204 XFreePixmap (DisplayHandle, (IntPtr)offscreen_drawable);
6207 internal override Graphics GetOffscreenGraphics (object offscreen_drawable)
6209 return Graphics.FromHwnd ((IntPtr) offscreen_drawable);
6212 internal override void BlitFromOffscreen (IntPtr dest_handle,
6214 object offscreen_drawable,
6215 Graphics offscreen_dc,
6218 XGCValues gc_values;
6221 gc_values = new XGCValues();
6223 gc = XCreateGC (DisplayHandle, dest_handle, IntPtr.Zero, ref gc_values);
6225 XCopyArea (DisplayHandle, (IntPtr)offscreen_drawable, dest_handle,
6226 gc, r.X, r.Y, r.Width, r.Height, r.X, r.Y);
6228 XFreeGC (DisplayHandle, gc);
6231 #endregion // Public Static Methods
6234 internal override event EventHandler Idle;
6235 #endregion // Events
6240 #region Xcursor imports
6241 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadCursor")]
6242 internal extern static IntPtr XcursorLibraryLoadCursor (IntPtr display, [MarshalAs (UnmanagedType.LPStr)] string name);
6244 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadImages")]
6245 internal extern static IntPtr XcursorLibraryLoadImages ([MarshalAs (UnmanagedType.LPStr)] string file, IntPtr theme, int size);
6247 [DllImport ("libXcursor", EntryPoint = "XcursorImagesDestroy")]
6248 internal extern static void XcursorImagesDestroy (IntPtr images);
6250 [DllImport ("libXcursor", EntryPoint = "XcursorGetDefaultSize")]
6251 internal extern static int XcursorGetDefaultSize (IntPtr display);
6253 [DllImport ("libXcursor", EntryPoint = "XcursorImageLoadCursor")]
6254 internal extern static IntPtr XcursorImageLoadCursor (IntPtr display, IntPtr image);
6256 [DllImport ("libXcursor", EntryPoint = "XcursorGetTheme")]
6257 internal extern static IntPtr XcursorGetTheme (IntPtr display);
6260 [DllImport ("libX11", EntryPoint="XOpenDisplay")]
6261 internal extern static IntPtr XOpenDisplay(IntPtr display);
6262 [DllImport ("libX11", EntryPoint="XCloseDisplay")]
6263 internal extern static int XCloseDisplay(IntPtr display);
6264 [DllImport ("libX11", EntryPoint="XSynchronize")]
6265 internal extern static IntPtr XSynchronize(IntPtr display, bool onoff);
6267 [DllImport ("libX11", EntryPoint="XCreateWindow")]
6268 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);
6269 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) {
6270 DebugHelper.TraceWriteLine ("XCreateWindow");
6271 return _XCreateWindow(display, parent, x, y, width, height,
6272 border_width, depth, xclass, visual, valuemask, ref attributes);
6274 [DllImport ("libX11", EntryPoint="XCreateSimpleWindow")]
6275 internal extern static IntPtr _XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background);
6276 internal static IntPtr XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background) {
6277 DebugHelper.TraceWriteLine ("XCreateSimpleWindow");
6278 return _XCreateSimpleWindow(display, parent, x, y, width, height, border_width, border, background);
6280 [DllImport ("libX11", EntryPoint="XMapWindow")]
6281 internal extern static int _XMapWindow(IntPtr display, IntPtr window);
6282 internal static int XMapWindow(IntPtr display, IntPtr window) {
6283 DebugHelper.TraceWriteLine ("XMapWindow");
6284 return _XMapWindow(display, window);
6286 [DllImport ("libX11", EntryPoint="XUnmapWindow")]
6287 internal extern static int _XUnmapWindow(IntPtr display, IntPtr window);
6288 internal static int XUnmapWindow(IntPtr display, IntPtr window) {
6289 DebugHelper.TraceWriteLine ("XUnmapWindow");
6290 return _XUnmapWindow(display, window);
6292 [DllImport ("libX11", EntryPoint="XMapSubwindows")]
6293 internal extern static int _XMapSubindows(IntPtr display, IntPtr window);
6294 internal static int XMapSubindows(IntPtr display, IntPtr window) {
6295 DebugHelper.TraceWriteLine ("XMapSubindows");
6296 return _XMapSubindows(display, window);
6298 [DllImport ("libX11", EntryPoint="XUnmapSubwindows")]
6299 internal extern static int _XUnmapSubwindows(IntPtr display, IntPtr window);
6300 internal static int XUnmapSubwindows(IntPtr display, IntPtr window) {
6301 DebugHelper.TraceWriteLine ("XUnmapSubwindows");
6302 return _XUnmapSubwindows(display, window);
6304 [DllImport ("libX11", EntryPoint="XRootWindow")]
6305 internal extern static IntPtr _XRootWindow(IntPtr display, int screen_number);
6306 internal static IntPtr XRootWindow(IntPtr display, int screen_number) {
6307 DebugHelper.TraceWriteLine ("XRootWindow");
6308 return _XRootWindow(display, screen_number);
6310 [DllImport ("libX11", EntryPoint="XNextEvent")]
6311 internal extern static IntPtr _XNextEvent(IntPtr display, ref XEvent xevent);
6312 internal static IntPtr XNextEvent(IntPtr display, ref XEvent xevent) {
6313 DebugHelper.TraceWriteLine ("XNextEvent");
6314 return _XNextEvent(display, ref xevent);
6316 [DllImport ("libX11", EntryPoint="XConnectionNumber")]
6317 internal extern static int _XConnectionNumber (IntPtr display);
6318 internal static int XConnectionNumber (IntPtr display) {
6319 DebugHelper.TraceWriteLine ("XConnectionNumber");
6320 return _XConnectionNumber (display);
6322 [DllImport ("libX11", EntryPoint="XPending")]
6323 internal extern static int _XPending (IntPtr display);
6324 internal static int XPending (IntPtr display) {
6325 DebugHelper.TraceWriteLine ("XPending");
6326 DebugHelper.DumpCallers (3);
6327 return _XPending (display);
6329 [DllImport ("libX11", EntryPoint="XSelectInput")]
6330 internal extern static IntPtr _XSelectInput(IntPtr display, IntPtr window, IntPtr mask);
6331 internal static IntPtr XSelectInput(IntPtr display, IntPtr window, IntPtr mask) {
6332 DebugHelper.TraceWriteLine ("XSelectInput");
6333 return _XSelectInput(display, window, mask);
6336 [DllImport ("libX11", EntryPoint="XDestroyWindow")]
6337 internal extern static int _XDestroyWindow(IntPtr display, IntPtr window);
6338 internal static int XDestroyWindow(IntPtr display, IntPtr window) {
6339 DebugHelper.TraceWriteLine ("XDestroyWindow 0x{0:x}", window.ToInt32());
6340 return _XDestroyWindow(display, window);
6343 [DllImport ("libX11", EntryPoint="XReparentWindow")]
6344 internal extern static int _XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y);
6345 internal static int XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y) {
6346 DebugHelper.TraceWriteLine ("XReparentWindow");
6347 return _XReparentWindow(display, window, parent, x, y);
6350 [DllImport ("libX11", EntryPoint="XMoveResizeWindow")]
6351 private extern static int _XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height);
6352 private static int XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height) {
6353 DebugHelper.TraceWriteLine ("XMoveResizeWindow");
6354 return _XMoveResizeWindow(display, window, x, y, width, height);
6357 internal static int MoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height)
6359 int ret = XMoveResizeWindow (display, window, x, y, width, height);
6360 Keyboard.MoveCurrentCaretPos ();
6364 [DllImport ("libX11", EntryPoint="XResizeWindow")]
6365 internal extern static int _XResizeWindow(IntPtr display, IntPtr window, int width, int height);
6366 internal static int XResizeWindow(IntPtr display, IntPtr window, int width, int height) {
6367 DebugHelper.TraceWriteLine ("XResizeWindow");
6368 return _XResizeWindow(display, window, width, height);
6371 [DllImport ("libX11", EntryPoint="XGetWindowAttributes")]
6372 internal extern static int _XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes);
6373 internal static int XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes) {
6374 DebugHelper.TraceWriteLine ("XGetWindowAttributes");
6375 return _XGetWindowAttributes(display, window, ref attributes);
6378 [DllImport ("libX11", EntryPoint="XFlush")]
6379 internal extern static int _XFlush(IntPtr display);
6380 internal static int XFlush(IntPtr display) {
6381 DebugHelper.TraceWriteLine ("XFlush");
6382 return _XFlush(display);
6385 [DllImport ("libX11", EntryPoint="XSetWMName")]
6386 internal extern static int _XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop);
6387 internal static int XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop) {
6388 DebugHelper.TraceWriteLine ("XSetWMName");
6389 return _XSetWMName(display, window, ref text_prop);
6392 [DllImport ("libX11", EntryPoint="XStoreName")]
6393 internal extern static int _XStoreName(IntPtr display, IntPtr window, string window_name);
6394 internal static int XStoreName(IntPtr display, IntPtr window, string window_name) {
6395 DebugHelper.TraceWriteLine ("XStoreName");
6396 return _XStoreName(display, window, window_name);
6399 [DllImport ("libX11", EntryPoint="XFetchName")]
6400 internal extern static int _XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name);
6401 internal static int XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name) {
6402 DebugHelper.TraceWriteLine ("XFetchName");
6403 return _XFetchName(display, window, ref window_name);
6406 [DllImport ("libX11", EntryPoint="XSendEvent")]
6407 internal extern static int _XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event);
6408 internal static int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event) {
6409 DebugHelper.TraceWriteLine ("XSendEvent");
6410 return _XSendEvent(display, window, propagate, event_mask, ref send_event);
6413 [DllImport ("libX11", EntryPoint="XQueryTree")]
6414 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);
6415 internal static int XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return) {
6416 DebugHelper.TraceWriteLine ("XQueryTree");
6417 return _XQueryTree(display, window, out root_return, out parent_return, out children_return, out nchildren_return);
6420 [DllImport ("libX11", EntryPoint="XFree")]
6421 internal extern static int _XFree(IntPtr data);
6422 internal static int XFree(IntPtr data) {
6423 DebugHelper.TraceWriteLine ("XFree");
6424 return _XFree(data);
6427 [DllImport ("libX11", EntryPoint="XRaiseWindow")]
6428 internal extern static int _XRaiseWindow(IntPtr display, IntPtr window);
6429 internal static int XRaiseWindow(IntPtr display, IntPtr window) {
6430 DebugHelper.TraceWriteLine ("XRaiseWindow");
6431 return _XRaiseWindow(display, window);
6434 [DllImport ("libX11", EntryPoint="XLowerWindow")]
6435 internal extern static uint _XLowerWindow(IntPtr display, IntPtr window);
6436 internal static uint XLowerWindow(IntPtr display, IntPtr window) {
6437 DebugHelper.TraceWriteLine ("XLowerWindow");
6438 return _XLowerWindow(display, window);
6441 [DllImport ("libX11", EntryPoint="XConfigureWindow")]
6442 internal extern static uint _XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values);
6443 internal static uint XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values) {
6444 DebugHelper.TraceWriteLine ("XConfigureWindow");
6445 return _XConfigureWindow(display, window, value_mask, ref values);
6448 [DllImport ("libX11", EntryPoint="XInternAtom")]
6449 internal extern static IntPtr _XInternAtom(IntPtr display, string atom_name, bool only_if_exists);
6450 internal static IntPtr XInternAtom(IntPtr display, string atom_name, bool only_if_exists) {
6451 DebugHelper.TraceWriteLine ("XInternAtom");
6452 return _XInternAtom(display, atom_name, only_if_exists);
6455 [DllImport ("libX11", EntryPoint="XInternAtoms")]
6456 internal extern static int _XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms);
6457 internal static int XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms) {
6458 DebugHelper.TraceWriteLine ("XInternAtoms");
6459 return _XInternAtoms(display, atom_names, atom_count, only_if_exists, atoms);
6462 [DllImport ("libX11", EntryPoint="XSetWMProtocols")]
6463 internal extern static int _XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count);
6464 internal static int XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count) {
6465 DebugHelper.TraceWriteLine ("XSetWMProtocols");
6466 return _XSetWMProtocols(display, window, protocols, count);
6469 [DllImport ("libX11", EntryPoint="XGrabPointer")]
6470 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);
6471 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) {
6472 DebugHelper.TraceWriteLine ("XGrabPointer");
6473 return _XGrabPointer(display, window, owner_events, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, timestamp);
6476 [DllImport ("libX11", EntryPoint="XUngrabPointer")]
6477 internal extern static int _XUngrabPointer(IntPtr display, IntPtr timestamp);
6478 internal static int XUngrabPointer(IntPtr display, IntPtr timestamp) {
6479 DebugHelper.TraceWriteLine ("XUngrabPointer");
6480 return _XUngrabPointer(display, timestamp);
6483 [DllImport ("libX11", EntryPoint="XQueryPointer")]
6484 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);
6485 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) {
6486 DebugHelper.TraceWriteLine ("XQueryPointer");
6487 return _XQueryPointer(display, window, out root, out child, out root_x, out root_y, out win_x, out win_y, out keys_buttons);
6490 [DllImport ("libX11", EntryPoint="XTranslateCoordinates")]
6491 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);
6492 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) {
6493 DebugHelper.TraceWriteLine ("XTranslateCoordinates");
6494 return _XTranslateCoordinates (display, src_w, dest_w, src_x, src_y, out intdest_x_return, out dest_y_return, out child_return);
6497 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6498 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);
6499 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) {
6500 DebugHelper.TraceWriteLine ("XGetGeometry");
6501 return _XGetGeometry(display, window, out root, out x, out y, out width, out height, out border_width, out depth);
6504 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6505 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);
6506 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) {
6507 DebugHelper.TraceWriteLine ("XGetGeometry");
6508 return _XGetGeometry(display, window, root, out x, out y, out width, out height, border_width, depth);
6511 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6512 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);
6513 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) {
6514 DebugHelper.TraceWriteLine ("XGetGeometry");
6515 return _XGetGeometry(display, window, root, out x, out y, width, height, border_width, depth);
6518 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6519 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);
6520 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) {
6521 DebugHelper.TraceWriteLine ("XGetGeometry");
6522 return _XGetGeometry(display, window, root, x, y, out width, out height, border_width, depth);
6525 [DllImport ("libX11", EntryPoint="XWarpPointer")]
6526 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);
6527 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) {
6528 DebugHelper.TraceWriteLine ("XWarpPointer");
6529 return _XWarpPointer(display, src_w, dest_w, src_x, src_y, src_width, src_height, dest_x, dest_y);
6532 [DllImport ("libX11", EntryPoint="XClearWindow")]
6533 internal extern static int _XClearWindow(IntPtr display, IntPtr window);
6534 internal static int XClearWindow(IntPtr display, IntPtr window) {
6535 DebugHelper.TraceWriteLine ("XClearWindow");
6536 return _XClearWindow(display, window);
6539 [DllImport ("libX11", EntryPoint="XClearArea")]
6540 internal extern static int _XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures);
6541 internal static int XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures) {
6542 DebugHelper.TraceWriteLine ("XClearArea");
6543 return _XClearArea(display, window, x, y, width, height, exposures);
6547 [DllImport ("libX11", EntryPoint="XDefaultScreenOfDisplay")]
6548 internal extern static IntPtr _XDefaultScreenOfDisplay(IntPtr display);
6549 internal static IntPtr XDefaultScreenOfDisplay(IntPtr display) {
6550 DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay");
6551 return _XDefaultScreenOfDisplay(display);
6554 [DllImport ("libX11", EntryPoint="XScreenNumberOfScreen")]
6555 internal extern static int _XScreenNumberOfScreen(IntPtr display, IntPtr Screen);
6556 internal static int XDefaultScreenOfDisplay(IntPtr display, IntPtr Screen) {
6557 DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay");
6558 return _XScreenNumberOfScreen(display, Screen);
6561 [DllImport ("libX11", EntryPoint="XDefaultVisual")]
6562 internal extern static IntPtr _XDefaultVisual(IntPtr display, int screen_number);
6563 internal static IntPtr XDefaultScreenOfDisplay(IntPtr display, int screen_number) {
6564 DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay");
6565 return _XDefaultVisual(display, screen_number);
6568 [DllImport ("libX11", EntryPoint="XDefaultDepth")]
6569 internal extern static uint _XDefaultDepth(IntPtr display, int screen_number);
6570 internal static uint XDefaultDepth(IntPtr display, int screen_number) {
6571 DebugHelper.TraceWriteLine ("XDefaultDepth");
6572 return _XDefaultDepth(display, screen_number);
6575 [DllImport ("libX11", EntryPoint="XDefaultScreen")]
6576 internal extern static int _XDefaultScreen(IntPtr display);
6577 internal static int XDefaultScreen(IntPtr display) {
6578 DebugHelper.TraceWriteLine ("XDefaultScreen");
6579 return _XDefaultScreen(display);
6582 [DllImport ("libX11", EntryPoint="XDefaultColormap")]
6583 internal extern static IntPtr _XDefaultColormap(IntPtr display, int screen_number);
6584 internal static IntPtr XDefaultColormap(IntPtr display, int screen_number) {
6585 DebugHelper.TraceWriteLine ("XDefaultColormap");
6586 return _XDefaultColormap(display, screen_number);
6589 [DllImport ("libX11", EntryPoint="XLookupColor")]
6590 internal extern static int _XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color);
6591 internal static int XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color) {
6592 DebugHelper.TraceWriteLine ("XLookupColor");
6593 return _XLookupColor(display, Colormap, Coloranem, ref exact_def_color, ref screen_def_color);
6596 [DllImport ("libX11", EntryPoint="XAllocColor")]
6597 internal extern static int _XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def);
6598 internal static int XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def) {
6599 DebugHelper.TraceWriteLine ("XAllocColor");
6600 return _XAllocColor(display, Colormap, ref colorcell_def);
6603 [DllImport ("libX11", EntryPoint="XSetTransientForHint")]
6604 internal extern static int _XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window);
6605 internal static int XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window) {
6606 DebugHelper.TraceWriteLine ("XSetTransientForHint");
6607 return _XSetTransientForHint(display, window, prop_window);
6610 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6611 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements);
6612 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements) {
6613 DebugHelper.TraceWriteLine ("XChangeProperty");
6614 return _XChangeProperty(display, window, property, type, format, mode, ref data, nelements);
6617 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6618 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements);
6619 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements) {
6620 DebugHelper.TraceWriteLine ("XChangeProperty");
6621 return _XChangeProperty(display, window, property, type, format, mode, ref value, nelements);
6624 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6625 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements);
6626 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements) {
6627 DebugHelper.TraceWriteLine ("XChangeProperty");
6628 return _XChangeProperty(display, window, property, type, format, mode, ref value, nelements);
6631 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6632 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements);
6633 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements) {
6634 DebugHelper.TraceWriteLine ("XChangeProperty");
6635 return _XChangeProperty(display, window, property, type, format, mode, data, nelements);
6638 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6639 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements);
6640 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements) {
6641 DebugHelper.TraceWriteLine ("XChangeProperty");
6642 return _XChangeProperty(display, window, property, type, format, mode, data, nelements);
6645 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6646 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements);
6647 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements) {
6648 DebugHelper.TraceWriteLine ("XChangeProperty");
6649 return _XChangeProperty(display, window, property, type, format, mode, data, nelements);
6652 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6653 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements);
6654 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements) {
6655 DebugHelper.TraceWriteLine ("XChangeProperty");
6656 return _XChangeProperty(display, window, property, type, format, mode, atoms, nelements);
6659 [DllImport ("libX11", EntryPoint="XChangeProperty", CharSet=CharSet.Ansi)]
6660 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length);
6661 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length) {
6662 DebugHelper.TraceWriteLine ("XChangeProperty");
6663 return _XChangeProperty(display, window, property, type, format, mode, text, text_length);
6666 [DllImport ("libX11", EntryPoint="XDeleteProperty")]
6667 internal extern static int _XDeleteProperty(IntPtr display, IntPtr window, IntPtr property);
6668 internal static int XDeleteProperty(IntPtr display, IntPtr window, IntPtr property) {
6669 DebugHelper.TraceWriteLine ("XDeleteProperty");
6670 return _XDeleteProperty(display, window, property);
6674 [DllImport ("libX11", EntryPoint="XCreateGC")]
6675 internal extern static IntPtr _XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values);
6676 internal static IntPtr XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values) {
6677 DebugHelper.TraceWriteLine ("XCreateGC");
6678 return _XCreateGC(display, window, valuemask, ref values);
6681 [DllImport ("libX11", EntryPoint="XFreeGC")]
6682 internal extern static int _XFreeGC(IntPtr display, IntPtr gc);
6683 internal static int XFreeGC(IntPtr display, IntPtr gc) {
6684 DebugHelper.TraceWriteLine ("XFreeGC");
6685 return _XFreeGC(display, gc);
6688 [DllImport ("libX11", EntryPoint="XSetFunction")]
6689 internal extern static int _XSetFunction(IntPtr display, IntPtr gc, GXFunction function);
6690 internal static int XSetFunction(IntPtr display, IntPtr gc, GXFunction function) {
6691 DebugHelper.TraceWriteLine ("XSetFunction");
6692 return _XSetFunction(display, gc, function);
6695 [DllImport ("libX11", EntryPoint="XSetLineAttributes")]
6696 internal extern static int _XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style);
6697 internal static int XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style) {
6698 DebugHelper.TraceWriteLine ("XSetLineAttributes");
6699 return _XSetLineAttributes(display, gc, line_width, line_style, cap_style, join_style);
6702 [DllImport ("libX11", EntryPoint="XDrawLine")]
6703 internal extern static int _XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2);
6704 internal static int XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2) {
6705 DebugHelper.TraceWriteLine ("XDrawLine");
6706 return _XDrawLine(display, drawable, gc, x1, y1, x2, y2);
6709 [DllImport ("libX11", EntryPoint="XDrawRectangle")]
6710 internal extern static int _XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
6711 internal static int XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height) {
6712 DebugHelper.TraceWriteLine ("XDrawRectangle");
6713 return _XDrawRectangle(display, drawable, gc, x1, y1, width, height);
6716 [DllImport ("libX11", EntryPoint="XFillRectangle")]
6717 internal extern static int _XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
6718 internal static int XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height) {
6719 DebugHelper.TraceWriteLine ("XFillRectangle");
6720 return _XFillRectangle(display, drawable, gc, x1, y1, width, height);
6723 [DllImport ("libX11", EntryPoint="XSetWindowBackground")]
6724 internal extern static int _XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background);
6725 internal static int XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background) {
6726 DebugHelper.TraceWriteLine ("XSetWindowBackground");
6727 return _XSetWindowBackground(display, window, background);
6730 [DllImport ("libX11", EntryPoint="XCopyArea")]
6731 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);
6732 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) {
6733 DebugHelper.TraceWriteLine ("XCopyArea");
6734 return _XCopyArea(display, src, dest, gc, src_x, src_y, width, height, dest_x, dest_y);
6737 [DllImport ("libX11", EntryPoint="XGetWindowProperty")]
6738 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);
6739 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) {
6740 DebugHelper.TraceWriteLine ("XGetWindowProperty");
6741 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);
6744 [DllImport ("libX11", EntryPoint="XSetInputFocus")]
6745 internal extern static int _XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time);
6746 internal static int XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time) {
6747 DebugHelper.TraceWriteLine ("XSetInputFocus");
6748 return _XSetInputFocus(display, window, revert_to, time);
6751 [DllImport ("libX11", EntryPoint="XIconifyWindow")]
6752 internal extern static int _XIconifyWindow(IntPtr display, IntPtr window, int screen_number);
6753 internal static int XIconifyWindow(IntPtr display, IntPtr window, int screen_number) {
6754 DebugHelper.TraceWriteLine ("XIconifyWindow");
6755 return _XIconifyWindow(display, window, screen_number);
6758 [DllImport ("libX11", EntryPoint="XDefineCursor")]
6759 internal extern static int _XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor);
6760 internal static int XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor) {
6761 DebugHelper.TraceWriteLine ("XDefineCursor");
6762 return _XDefineCursor(display, window, cursor);
6765 [DllImport ("libX11", EntryPoint="XUndefineCursor")]
6766 internal extern static int _XUndefineCursor(IntPtr display, IntPtr window);
6767 internal static int XUndefineCursor(IntPtr display, IntPtr window) {
6768 DebugHelper.TraceWriteLine ("XUndefineCursor");
6769 return _XUndefineCursor(display, window);
6772 [DllImport ("libX11", EntryPoint="XFreeCursor")]
6773 internal extern static int _XFreeCursor(IntPtr display, IntPtr cursor);
6774 internal static int XFreeCursor(IntPtr display, IntPtr cursor) {
6775 DebugHelper.TraceWriteLine ("XFreeCursor");
6776 return _XFreeCursor(display, cursor);
6779 [DllImport ("libX11", EntryPoint="XCreateFontCursor")]
6780 internal extern static IntPtr _XCreateFontCursor(IntPtr display, CursorFontShape shape);
6781 internal static IntPtr XCreateFontCursor(IntPtr display, CursorFontShape shape) {
6782 DebugHelper.TraceWriteLine ("XCreateFontCursor");
6783 return _XCreateFontCursor(display, shape);
6786 [DllImport ("libX11", EntryPoint="XCreatePixmapCursor")]
6787 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);
6788 internal static IntPtr XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot) {
6789 DebugHelper.TraceWriteLine ("XCreatePixmapCursor");
6790 return _XCreatePixmapCursor(display, source, mask, ref foreground_color, ref background_color, x_hot, y_hot);
6793 [DllImport ("libX11", EntryPoint="XCreatePixmapFromBitmapData")]
6794 internal extern static IntPtr _XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth);
6795 internal static IntPtr XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth) {
6796 DebugHelper.TraceWriteLine ("XCreatePixmapFromBitmapData");
6797 return _XCreatePixmapFromBitmapData(display, drawable, data, width, height, fg, bg, depth);
6800 [DllImport ("libX11", EntryPoint="XCreatePixmap")]
6801 internal extern static IntPtr _XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth);
6802 internal static IntPtr XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth) {
6803 DebugHelper.TraceWriteLine ("XCreatePixmap");
6804 return _XCreatePixmap(display, d, width, height, depth);
6807 [DllImport ("libX11", EntryPoint="XFreePixmap")]
6808 internal extern static IntPtr _XFreePixmap(IntPtr display, IntPtr pixmap);
6809 internal static IntPtr XFreePixmap(IntPtr display, IntPtr pixmap) {
6810 DebugHelper.TraceWriteLine ("XFreePixmap");
6811 return _XFreePixmap(display, pixmap);
6814 [DllImport ("libX11", EntryPoint="XQueryBestCursor")]
6815 internal extern static int _XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height);
6816 internal static int XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height) {
6817 DebugHelper.TraceWriteLine ("XQueryBestCursor");
6818 return _XQueryBestCursor(display, drawable, width, height, out best_width, out best_height);
6821 [DllImport ("libX11", EntryPoint="XQueryExtension")]
6822 internal extern static int _XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error);
6823 internal static int XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error) {
6824 DebugHelper.TraceWriteLine ("XQueryExtension");
6825 return _XQueryExtension(display, extension_name, ref major, ref first_event, ref first_error);
6828 [DllImport ("libX11", EntryPoint="XWhitePixel")]
6829 internal extern static IntPtr _XWhitePixel(IntPtr display, int screen_no);
6830 internal static IntPtr XWhitePixel(IntPtr display, int screen_no) {
6831 DebugHelper.TraceWriteLine ("XWhitePixel");
6832 return _XWhitePixel(display, screen_no);
6835 [DllImport ("libX11", EntryPoint="XBlackPixel")]
6836 internal extern static IntPtr _XBlackPixel(IntPtr display, int screen_no);
6837 internal static IntPtr XBlackPixel(IntPtr display, int screen_no) {
6838 DebugHelper.TraceWriteLine ("XBlackPixel");
6839 return _XBlackPixel(display, screen_no);
6842 [DllImport ("libX11", EntryPoint="XGrabServer")]
6843 internal extern static void _XGrabServer(IntPtr display);
6844 internal static void XGrabServer(IntPtr display) {
6845 DebugHelper.TraceWriteLine ("XGrabServer");
6846 _XGrabServer(display);
6849 [DllImport ("libX11", EntryPoint="XUngrabServer")]
6850 internal extern static void _XUngrabServer(IntPtr display);
6851 internal static void XUngrabServer(IntPtr display) {
6852 DebugHelper.TraceWriteLine ("XUngrabServer");
6853 _XUngrabServer(display);
6856 [DllImport ("libX11", EntryPoint="XGetWMNormalHints")]
6857 internal extern static void _XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return);
6858 internal static void XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return) {
6859 DebugHelper.TraceWriteLine ("XGetWMNormalHints");
6860 _XGetWMNormalHints(display, window, ref hints, out supplied_return);
6863 [DllImport ("libX11", EntryPoint="XSetWMNormalHints")]
6864 internal extern static void _XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints);
6865 internal static void XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints) {
6866 DebugHelper.TraceWriteLine ("XSetWMNormalHints");
6867 _XSetWMNormalHints(display, window, ref hints);
6870 [DllImport ("libX11", EntryPoint="XSetZoomHints")]
6871 internal extern static void _XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints);
6872 internal static void XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints) {
6873 DebugHelper.TraceWriteLine ("XSetZoomHints");
6874 _XSetZoomHints(display, window, ref hints);
6877 [DllImport ("libX11", EntryPoint="XSetWMHints")]
6878 internal extern static void _XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints);
6879 internal static void XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints) {
6880 DebugHelper.TraceWriteLine ("XSetWMHints");
6881 _XSetWMHints(display, window, ref wmhints);
6884 [DllImport ("libX11", EntryPoint="XGetIconSizes")]
6885 internal extern static int _XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count);
6886 internal static int XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count) {
6887 DebugHelper.TraceWriteLine ("XGetIconSizes");
6888 return _XGetIconSizes(display, window, out size_list, out count);
6891 [DllImport ("libX11", EntryPoint="XSetErrorHandler")]
6892 internal extern static IntPtr _XSetErrorHandler(XErrorHandler error_handler);
6893 internal static IntPtr XSetErrorHandler(XErrorHandler error_handler) {
6894 DebugHelper.TraceWriteLine ("XSetErrorHandler");
6895 return _XSetErrorHandler(error_handler);
6898 [DllImport ("libX11", EntryPoint="XGetErrorText")]
6899 internal extern static IntPtr _XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length);
6900 internal static IntPtr XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length) {
6901 DebugHelper.TraceWriteLine ("XGetErrorText");
6902 return _XGetErrorText(display, code, buffer, length);
6905 [DllImport ("libX11", EntryPoint="XInitThreads")]
6906 internal extern static int _XInitThreads();
6907 internal static int XInitThreads() {
6908 DebugHelper.TraceWriteLine ("XInitThreads");
6909 return _XInitThreads();
6912 [DllImport ("libX11", EntryPoint="XConvertSelection")]
6913 internal extern static int _XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time);
6914 internal static int XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time) {
6915 DebugHelper.TraceWriteLine ("XConvertSelection");
6916 return _XConvertSelection(display, selection, target, property, requestor, time);
6919 [DllImport ("libX11", EntryPoint="XGetSelectionOwner")]
6920 internal extern static IntPtr _XGetSelectionOwner(IntPtr display, IntPtr selection);
6921 internal static IntPtr XGetSelectionOwner(IntPtr display, IntPtr selection) {
6922 DebugHelper.TraceWriteLine ("XGetSelectionOwner");
6923 return _XGetSelectionOwner(display, selection);
6926 [DllImport ("libX11", EntryPoint="XSetSelectionOwner")]
6927 internal extern static int _XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time);
6928 internal static int XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time) {
6929 DebugHelper.TraceWriteLine ("XSetSelectionOwner");
6930 return _XSetSelectionOwner(display, selection, owner, time);
6933 [DllImport ("libX11", EntryPoint="XSetPlaneMask")]
6934 internal extern static int _XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask);
6935 internal static int XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask) {
6936 DebugHelper.TraceWriteLine ("XSetPlaneMask");
6937 return _XSetPlaneMask(display, gc, mask);
6940 [DllImport ("libX11", EntryPoint="XSetForeground")]
6941 internal extern static int _XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground);
6942 internal static int XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground) {
6943 DebugHelper.TraceWriteLine ("XSetForeground");
6944 return _XSetForeground(display, gc, foreground);
6947 [DllImport ("libX11", EntryPoint="XSetBackground")]
6948 internal extern static int _XSetBackground(IntPtr display, IntPtr gc, UIntPtr background);
6949 internal static int XSetBackground(IntPtr display, IntPtr gc, UIntPtr background) {
6950 DebugHelper.TraceWriteLine ("XSetBackground");
6951 return _XSetBackground(display, gc, background);
6954 [DllImport ("libX11", EntryPoint="XBell")]
6955 internal extern static int _XBell(IntPtr display, int percent);
6956 internal static int XBell(IntPtr display, int percent) {
6957 DebugHelper.TraceWriteLine ("XBell");
6958 return _XBell(display, percent);
6961 [DllImport ("libX11", EntryPoint="XChangeActivePointerGrab")]
6962 internal extern static int _XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time);
6963 internal static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time) {
6964 DebugHelper.TraceWriteLine ("XChangeActivePointerGrab");
6965 return _XChangeActivePointerGrab (display, event_mask, cursor, time);
6968 [DllImport ("libX11", EntryPoint="XFilterEvent")]
6969 internal extern static bool _XFilterEvent(ref XEvent xevent, IntPtr window);
6970 internal static bool XFilterEvent(ref XEvent xevent, IntPtr window) {
6971 DebugHelper.TraceWriteLine ("XFilterEvent");
6972 return _XFilterEvent(ref xevent, window);
6975 [DllImport ("libX11", EntryPoint="XkbSetDetectableAutoRepeat")]
6976 internal extern static void _XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported);
6977 internal static void XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported) {
6978 DebugHelper.TraceWriteLine ("XkbSetDetectableAutoRepeat");
6979 _XkbSetDetectableAutoRepeat (display, detectable, supported);
6982 [DllImport ("libX11", EntryPoint="XPeekEvent")]
6983 internal extern static void _XPeekEvent (IntPtr display, ref XEvent xevent);
6984 internal static void XPeekEvent (IntPtr display, ref XEvent xevent) {
6985 DebugHelper.TraceWriteLine ("XPeekEvent");
6986 _XPeekEvent (display, ref xevent);
6989 [DllImport ("libX11", EntryPoint="XIfEvent")]
6990 internal extern static void _XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg);
6991 internal static void XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg) {
6992 DebugHelper.TraceWriteLine ("XIfEvent");
6993 _XIfEvent (display, ref xevent, event_predicate, arg);
6998 #else //no TRACE defined
7000 #region Xcursor imports
7001 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadCursor")]
7002 internal extern static IntPtr XcursorLibraryLoadCursor (IntPtr display, [MarshalAs (UnmanagedType.LPStr)] string name);
7004 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadImages")]
7005 internal extern static IntPtr XcursorLibraryLoadImages ([MarshalAs (UnmanagedType.LPStr)] string file, IntPtr theme, int size);
7007 [DllImport ("libXcursor", EntryPoint = "XcursorImagesDestroy")]
7008 internal extern static void XcursorImagesDestroy (IntPtr images);
7010 [DllImport ("libXcursor", EntryPoint = "XcursorGetDefaultSize")]
7011 internal extern static int XcursorGetDefaultSize (IntPtr display);
7013 [DllImport ("libXcursor", EntryPoint = "XcursorImageLoadCursor")]
7014 internal extern static IntPtr XcursorImageLoadCursor (IntPtr display, IntPtr image);
7016 [DllImport ("libXcursor", EntryPoint = "XcursorGetTheme")]
7017 internal extern static IntPtr XcursorGetTheme (IntPtr display);
7020 [DllImport ("libX11", EntryPoint="XOpenDisplay")]
7021 internal extern static IntPtr XOpenDisplay(IntPtr display);
7022 [DllImport ("libX11", EntryPoint="XCloseDisplay")]
7023 internal extern static int XCloseDisplay(IntPtr display);
7024 [DllImport ("libX11", EntryPoint="XSynchronize")]
7025 internal extern static IntPtr XSynchronize(IntPtr display, bool onoff);
7027 [DllImport ("libX11", EntryPoint="XCreateWindow")]
7028 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);
7030 [DllImport ("libX11", EntryPoint="XCreateSimpleWindow")]
7031 internal extern static IntPtr XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background);
7033 [DllImport ("libX11", EntryPoint="XMapWindow")]
7034 internal extern static int XMapWindow(IntPtr display, IntPtr window);
7036 [DllImport ("libX11", EntryPoint="XUnmapWindow")]
7037 internal extern static int XUnmapWindow(IntPtr display, IntPtr window);
7039 [DllImport ("libX11", EntryPoint="XMapSubwindows")]
7040 internal extern static int XMapSubindows(IntPtr display, IntPtr window);
7042 [DllImport ("libX11", EntryPoint="XUnmapSubwindows")]
7043 internal extern static int XUnmapSubwindows(IntPtr display, IntPtr window);
7045 [DllImport ("libX11", EntryPoint="XRootWindow")]
7046 internal extern static IntPtr XRootWindow(IntPtr display, int screen_number);
7048 [DllImport ("libX11", EntryPoint="XNextEvent")]
7049 internal extern static IntPtr XNextEvent(IntPtr display, ref XEvent xevent);
7051 [DllImport ("libX11", EntryPoint="XConnectionNumber")]
7052 internal extern static int XConnectionNumber (IntPtr display);
7054 [DllImport ("libX11", EntryPoint="XPending")]
7055 internal extern static int XPending (IntPtr display);
7057 [DllImport ("libX11", EntryPoint="XSelectInput")]
7058 internal extern static IntPtr XSelectInput(IntPtr display, IntPtr window, IntPtr mask);
7060 [DllImport ("libX11", EntryPoint="XDestroyWindow")]
7061 internal extern static int XDestroyWindow(IntPtr display, IntPtr window);
7063 [DllImport ("libX11", EntryPoint="XReparentWindow")]
7064 internal extern static int XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y);
7066 [DllImport ("libX11", EntryPoint="XMoveResizeWindow")]
7067 private extern static int XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height);
7068 internal static int MoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height)
7070 int ret = XMoveResizeWindow (display, window, x, y, width, height);
7071 Keyboard.MoveCurrentCaretPos ();
7075 [DllImport ("libX11", EntryPoint="XResizeWindow")]
7076 internal extern static int XResizeWindow(IntPtr display, IntPtr window, int width, int height);
7078 [DllImport ("libX11", EntryPoint="XGetWindowAttributes")]
7079 internal extern static int XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes);
7081 [DllImport ("libX11", EntryPoint="XFlush")]
7082 internal extern static int XFlush(IntPtr display);
7084 [DllImport ("libX11", EntryPoint="XSetWMName")]
7085 internal extern static int XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop);
7087 [DllImport ("libX11", EntryPoint="XStoreName")]
7088 internal extern static int XStoreName(IntPtr display, IntPtr window, string window_name);
7090 [DllImport ("libX11", EntryPoint="XFetchName")]
7091 internal extern static int XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name);
7093 [DllImport ("libX11", EntryPoint="XSendEvent")]
7094 internal extern static int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event);
7096 [DllImport ("libX11", EntryPoint="XQueryTree")]
7097 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);
7099 [DllImport ("libX11", EntryPoint="XFree")]
7100 internal extern static int XFree(IntPtr data);
7102 [DllImport ("libX11", EntryPoint="XRaiseWindow")]
7103 internal extern static int XRaiseWindow(IntPtr display, IntPtr window);
7105 [DllImport ("libX11", EntryPoint="XLowerWindow")]
7106 internal extern static uint XLowerWindow(IntPtr display, IntPtr window);
7108 [DllImport ("libX11", EntryPoint="XConfigureWindow")]
7109 internal extern static uint XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values);
7111 [DllImport ("libX11", EntryPoint="XInternAtom")]
7112 internal extern static IntPtr XInternAtom(IntPtr display, string atom_name, bool only_if_exists);
7114 [DllImport ("libX11", EntryPoint="XInternAtoms")]
7115 internal extern static int XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms);
7117 [DllImport ("libX11", EntryPoint="XSetWMProtocols")]
7118 internal extern static int XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count);
7120 [DllImport ("libX11", EntryPoint="XGrabPointer")]
7121 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);
7123 [DllImport ("libX11", EntryPoint="XUngrabPointer")]
7124 internal extern static int XUngrabPointer(IntPtr display, IntPtr timestamp);
7126 [DllImport ("libX11", EntryPoint="XQueryPointer")]
7127 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);
7129 [DllImport ("libX11", EntryPoint="XTranslateCoordinates")]
7130 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);
7132 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7133 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);
7135 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7136 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);
7138 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7139 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);
7141 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7142 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);
7144 [DllImport ("libX11", EntryPoint="XWarpPointer")]
7145 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);
7147 [DllImport ("libX11", EntryPoint="XClearWindow")]
7148 internal extern static int XClearWindow(IntPtr display, IntPtr window);
7150 [DllImport ("libX11", EntryPoint="XClearArea")]
7151 internal extern static int XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures);
7154 [DllImport ("libX11", EntryPoint="XDefaultScreenOfDisplay")]
7155 internal extern static IntPtr XDefaultScreenOfDisplay(IntPtr display);
7157 [DllImport ("libX11", EntryPoint="XScreenNumberOfScreen")]
7158 internal extern static int XScreenNumberOfScreen(IntPtr display, IntPtr Screen);
7160 [DllImport ("libX11", EntryPoint="XDefaultVisual")]
7161 internal extern static IntPtr XDefaultVisual(IntPtr display, int screen_number);
7163 [DllImport ("libX11", EntryPoint="XDefaultDepth")]
7164 internal extern static uint XDefaultDepth(IntPtr display, int screen_number);
7166 [DllImport ("libX11", EntryPoint="XDefaultScreen")]
7167 internal extern static int XDefaultScreen(IntPtr display);
7169 [DllImport ("libX11", EntryPoint="XDefaultColormap")]
7170 internal extern static IntPtr XDefaultColormap(IntPtr display, int screen_number);
7172 [DllImport ("libX11", EntryPoint="XLookupColor")]
7173 internal extern static int XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color);
7175 [DllImport ("libX11", EntryPoint="XAllocColor")]
7176 internal extern static int XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def);
7178 [DllImport ("libX11", EntryPoint="XSetTransientForHint")]
7179 internal extern static int XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window);
7181 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7182 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements);
7184 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7185 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements);
7187 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7188 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements);
7190 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7191 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements);
7193 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7194 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements);
7196 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7197 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements);
7199 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7200 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements);
7202 [DllImport ("libX11", EntryPoint="XChangeProperty", CharSet=CharSet.Ansi)]
7203 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length);
7205 [DllImport ("libX11", EntryPoint="XDeleteProperty")]
7206 internal extern static int XDeleteProperty(IntPtr display, IntPtr window, IntPtr property);
7209 [DllImport ("libX11", EntryPoint="XCreateGC")]
7210 internal extern static IntPtr XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values);
7212 [DllImport ("libX11", EntryPoint="XFreeGC")]
7213 internal extern static int XFreeGC(IntPtr display, IntPtr gc);
7215 [DllImport ("libX11", EntryPoint="XSetFunction")]
7216 internal extern static int XSetFunction(IntPtr display, IntPtr gc, GXFunction function);
7218 [DllImport ("libX11", EntryPoint="XSetLineAttributes")]
7219 internal extern static int XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style);
7221 [DllImport ("libX11", EntryPoint="XDrawLine")]
7222 internal extern static int XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2);
7224 [DllImport ("libX11", EntryPoint="XDrawRectangle")]
7225 internal extern static int XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
7227 [DllImport ("libX11", EntryPoint="XFillRectangle")]
7228 internal extern static int XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
7230 [DllImport ("libX11", EntryPoint="XSetWindowBackground")]
7231 internal extern static int XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background);
7233 [DllImport ("libX11", EntryPoint="XCopyArea")]
7234 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);
7236 [DllImport ("libX11", EntryPoint="XGetWindowProperty")]
7237 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);
7239 [DllImport ("libX11", EntryPoint="XSetInputFocus")]
7240 internal extern static int XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time);
7242 [DllImport ("libX11", EntryPoint="XIconifyWindow")]
7243 internal extern static int XIconifyWindow(IntPtr display, IntPtr window, int screen_number);
7245 [DllImport ("libX11", EntryPoint="XDefineCursor")]
7246 internal extern static int XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor);
7248 [DllImport ("libX11", EntryPoint="XUndefineCursor")]
7249 internal extern static int XUndefineCursor(IntPtr display, IntPtr window);
7251 [DllImport ("libX11", EntryPoint="XFreeCursor")]
7252 internal extern static int XFreeCursor(IntPtr display, IntPtr cursor);
7254 [DllImport ("libX11", EntryPoint="XCreateFontCursor")]
7255 internal extern static IntPtr XCreateFontCursor(IntPtr display, CursorFontShape shape);
7257 [DllImport ("libX11", EntryPoint="XCreatePixmapCursor")]
7258 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);
7260 [DllImport ("libX11", EntryPoint="XCreatePixmapFromBitmapData")]
7261 internal extern static IntPtr XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth);
7263 [DllImport ("libX11", EntryPoint="XCreatePixmap")]
7264 internal extern static IntPtr XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth);
7266 [DllImport ("libX11", EntryPoint="XFreePixmap")]
7267 internal extern static IntPtr XFreePixmap(IntPtr display, IntPtr pixmap);
7269 [DllImport ("libX11", EntryPoint="XQueryBestCursor")]
7270 internal extern static int XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height);
7272 [DllImport ("libX11", EntryPoint="XQueryExtension")]
7273 internal extern static int XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error);
7275 [DllImport ("libX11", EntryPoint="XWhitePixel")]
7276 internal extern static IntPtr XWhitePixel(IntPtr display, int screen_no);
7278 [DllImport ("libX11", EntryPoint="XBlackPixel")]
7279 internal extern static IntPtr XBlackPixel(IntPtr display, int screen_no);
7281 [DllImport ("libX11", EntryPoint="XGrabServer")]
7282 internal extern static void XGrabServer(IntPtr display);
7284 [DllImport ("libX11", EntryPoint="XUngrabServer")]
7285 internal extern static void XUngrabServer(IntPtr display);
7287 [DllImport ("libX11", EntryPoint="XGetWMNormalHints")]
7288 internal extern static void XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return);
7290 [DllImport ("libX11", EntryPoint="XSetWMNormalHints")]
7291 internal extern static void XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints);
7293 [DllImport ("libX11", EntryPoint="XSetZoomHints")]
7294 internal extern static void XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints);
7296 [DllImport ("libX11", EntryPoint="XSetWMHints")]
7297 internal extern static void XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints);
7299 [DllImport ("libX11", EntryPoint="XGetIconSizes")]
7300 internal extern static int XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count);
7302 [DllImport ("libX11", EntryPoint="XSetErrorHandler")]
7303 internal extern static IntPtr XSetErrorHandler(XErrorHandler error_handler);
7305 [DllImport ("libX11", EntryPoint="XGetErrorText")]
7306 internal extern static IntPtr XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length);
7308 [DllImport ("libX11", EntryPoint="XInitThreads")]
7309 internal extern static int XInitThreads();
7311 [DllImport ("libX11", EntryPoint="XConvertSelection")]
7312 internal extern static int XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time);
7314 [DllImport ("libX11", EntryPoint="XGetSelectionOwner")]
7315 internal extern static IntPtr XGetSelectionOwner(IntPtr display, IntPtr selection);
7317 [DllImport ("libX11", EntryPoint="XSetSelectionOwner")]
7318 internal extern static int XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time);
7320 [DllImport ("libX11", EntryPoint="XSetPlaneMask")]
7321 internal extern static int XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask);
7323 [DllImport ("libX11", EntryPoint="XSetForeground")]
7324 internal extern static int XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground);
7326 [DllImport ("libX11", EntryPoint="XSetBackground")]
7327 internal extern static int XSetBackground(IntPtr display, IntPtr gc, UIntPtr background);
7329 [DllImport ("libX11", EntryPoint="XBell")]
7330 internal extern static int XBell(IntPtr display, int percent);
7332 [DllImport ("libX11", EntryPoint="XChangeActivePointerGrab")]
7333 internal extern static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time);
7335 [DllImport ("libX11", EntryPoint="XFilterEvent")]
7336 internal extern static bool XFilterEvent(ref XEvent xevent, IntPtr window);
7338 [DllImport ("libX11", EntryPoint="XkbSetDetectableAutoRepeat")]
7339 internal extern static void XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported);
7341 [DllImport ("libX11", EntryPoint="XPeekEvent")]
7342 internal extern static void XPeekEvent (IntPtr display, ref XEvent xevent);
7344 [DllImport ("libX11", EntryPoint="XIfEvent")]
7345 internal extern static void XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg);