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;
82 static object XlibLock; // Our locking object
83 static bool themes_enabled;
86 static IntPtr DisplayHandle; // X11 handle to display
87 static int ScreenNo; // Screen number used
88 static IntPtr DefaultColormap; // Colormap for screen
89 static IntPtr CustomVisual; // Visual for window creation
90 static IntPtr CustomColormap; // Colormap for window creation
91 static IntPtr RootWindow; // Handle of the root window for the screen/display
92 static IntPtr FosterParent; // Container to hold child windows until their parent exists
93 static XErrorHandler ErrorHandler; // Error handler delegate
94 static bool ErrorExceptions; // Throw exceptions on X errors
95 int render_major_opcode;
96 int render_first_event;
97 int render_first_error;
100 static IntPtr ClipMagic;
101 static ClipboardData Clipboard; // Our clipboard
104 static IntPtr PostAtom; // PostMessage atom
105 static IntPtr AsyncAtom; // Support for async messages
108 static Hashtable MessageQueues; // Holds our thread-specific XEventQueues
109 static ArrayList unattached_timer_list; // holds timers that are enabled but not attached to a window.
111 static Pollfd[] pollfds; // For watching the X11 socket
112 static bool wake_waiting;
113 static object wake_waiting_lock = new object ();
115 static X11Keyboard Keyboard; //
117 static Socket listen; //
118 static Socket wake; //
119 static Socket wake_receive; //
120 static byte[] network_buffer; //
121 static bool detectable_key_auto_repeat;
124 static IntPtr ActiveWindow; // Handle of the active window
125 static IntPtr FocusWindow; // Handle of the window with keyboard focus (if any)
128 static Stack ModalWindows; // Stack of our modal windows
131 static IntPtr SystrayMgrWindow; // Handle of the Systray Manager window
134 static IntPtr LastCursorWindow; // The last window we set the cursor on
135 static IntPtr LastCursorHandle; // The handle that was last set on LastCursorWindow
136 static IntPtr OverrideCursorHandle; // The cursor that is set to override any other cursors
139 static CaretStruct Caret; //
141 // Last window containing the pointer
142 static IntPtr LastPointerWindow; // The last window containing the pointer
145 static IntPtr WM_PROTOCOLS;
146 static IntPtr WM_DELETE_WINDOW;
147 static IntPtr WM_TAKE_FOCUS;
148 //static IntPtr _NET_SUPPORTED;
149 //static IntPtr _NET_CLIENT_LIST;
150 //static IntPtr _NET_NUMBER_OF_DESKTOPS;
151 static IntPtr _NET_DESKTOP_GEOMETRY;
152 //static IntPtr _NET_DESKTOP_VIEWPORT;
153 static IntPtr _NET_CURRENT_DESKTOP;
154 //static IntPtr _NET_DESKTOP_NAMES;
155 static IntPtr _NET_ACTIVE_WINDOW;
156 static IntPtr _NET_WORKAREA;
157 //static IntPtr _NET_SUPPORTING_WM_CHECK;
158 //static IntPtr _NET_VIRTUAL_ROOTS;
159 //static IntPtr _NET_DESKTOP_LAYOUT;
160 //static IntPtr _NET_SHOWING_DESKTOP;
161 //static IntPtr _NET_CLOSE_WINDOW;
162 //static IntPtr _NET_MOVERESIZE_WINDOW;
163 static IntPtr _NET_WM_MOVERESIZE;
164 //static IntPtr _NET_RESTACK_WINDOW;
165 //static IntPtr _NET_REQUEST_FRAME_EXTENTS;
166 static IntPtr _NET_WM_NAME;
167 //static IntPtr _NET_WM_VISIBLE_NAME;
168 //static IntPtr _NET_WM_ICON_NAME;
169 //static IntPtr _NET_WM_VISIBLE_ICON_NAME;
170 //static IntPtr _NET_WM_DESKTOP;
171 static IntPtr _NET_WM_WINDOW_TYPE;
172 static IntPtr _NET_WM_STATE;
173 //static IntPtr _NET_WM_ALLOWED_ACTIONS;
174 //static IntPtr _NET_WM_STRUT;
175 //static IntPtr _NET_WM_STRUT_PARTIAL;
176 //static IntPtr _NET_WM_ICON_GEOMETRY;
177 static IntPtr _NET_WM_ICON;
178 //static IntPtr _NET_WM_PID;
179 //static IntPtr _NET_WM_HANDLED_ICONS;
180 static IntPtr _NET_WM_USER_TIME;
181 static IntPtr _NET_FRAME_EXTENTS;
182 //static IntPtr _NET_WM_PING;
183 //static IntPtr _NET_WM_SYNC_REQUEST;
184 static IntPtr _NET_SYSTEM_TRAY_S;
185 //static IntPtr _NET_SYSTEM_TRAY_ORIENTATION;
186 static IntPtr _NET_SYSTEM_TRAY_OPCODE;
187 static IntPtr _NET_WM_STATE_MAXIMIZED_HORZ;
188 static IntPtr _NET_WM_STATE_MAXIMIZED_VERT;
189 static IntPtr _XEMBED;
190 static IntPtr _XEMBED_INFO;
191 static IntPtr _MOTIF_WM_HINTS;
192 static IntPtr _NET_WM_STATE_SKIP_TASKBAR;
193 static IntPtr _NET_WM_STATE_ABOVE;
194 static IntPtr _NET_WM_STATE_MODAL;
195 static IntPtr _NET_WM_STATE_HIDDEN;
196 static IntPtr _NET_WM_CONTEXT_HELP;
197 static IntPtr _NET_WM_WINDOW_OPACITY;
198 //static IntPtr _NET_WM_WINDOW_TYPE_DESKTOP;
199 //static IntPtr _NET_WM_WINDOW_TYPE_DOCK;
200 //static IntPtr _NET_WM_WINDOW_TYPE_TOOLBAR;
201 //static IntPtr _NET_WM_WINDOW_TYPE_MENU;
202 static IntPtr _NET_WM_WINDOW_TYPE_UTILITY;
203 //static IntPtr _NET_WM_WINDOW_TYPE_SPLASH;
204 // static IntPtr _NET_WM_WINDOW_TYPE_DIALOG;
205 static IntPtr _NET_WM_WINDOW_TYPE_NORMAL;
206 static IntPtr CLIPBOARD;
207 static IntPtr PRIMARY;
209 static IntPtr OEMTEXT;
210 static IntPtr UTF8_STRING;
211 static IntPtr UTF16_STRING;
212 static IntPtr RICHTEXTFORMAT;
213 static IntPtr TARGETS;
215 // mouse hover message generation
216 static HoverStruct HoverState; //
218 // double click message generation
219 static ClickStruct ClickPending; //
221 // Support for mouse grab
222 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 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
252 // Handle singleton stuff first
256 // Now regular initialization
257 XlibLock = new object ();
258 X11Keyboard.XlibLock = XlibLock;
259 MessageQueues = Hashtable.Synchronized (new Hashtable(7));
260 unattached_timer_list = ArrayList.Synchronized (new ArrayList (3));
261 messageHold = Hashtable.Synchronized (new Hashtable(3));
262 Clipboard = new ClipboardData ();
265 ErrorExceptions = false;
267 // X11 Initialization
268 SetDisplay(XOpenDisplay(IntPtr.Zero));
269 X11DesktopColors.Initialize();
272 // Disable keyboard autorepeat
274 XkbSetDetectableAutoRepeat (DisplayHandle, true, IntPtr.Zero);
275 detectable_key_auto_repeat = true;
277 Console.Error.WriteLine ("Could not disable keyboard auto repeat, will attempt to disable manually.");
278 detectable_key_auto_repeat = false;
281 // Handle any upcoming errors; we re-set it here, X11DesktopColor stuff might have stolen it (gtk does)
282 ErrorHandler = new XErrorHandler(HandleError);
283 XSetErrorHandler(ErrorHandler);
287 // Remove our display handle from S.D
288 Graphics.FromHdcInternal (IntPtr.Zero);
291 #endregion // Constructors
293 #region Singleton Specific Code
294 public static XplatUIX11 GetInstance() {
296 if (Instance == null) {
297 Instance=new XplatUIX11();
304 public int Reference {
311 #region Internal Properties
312 internal static IntPtr Display {
314 return DisplayHandle;
318 XplatUIX11.GetInstance().SetDisplay(value);
322 internal static int Screen {
332 internal static IntPtr RootWindowHandle {
342 internal static IntPtr Visual {
348 CustomVisual = value;
352 internal static IntPtr ColorMap {
354 return CustomColormap;
358 CustomColormap = value;
363 internal static IntPtr DefaultColorMap {
365 return DefaultColormap;
371 #region XExceptionClass
372 internal class XException : ApplicationException {
376 XRequest RequestCode;
380 public XException(IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) {
381 this.Display = Display;
382 this.ResourceID = ResourceID;
383 this.Serial = Serial;
384 this.RequestCode = RequestCode;
385 this.ErrorCode = ErrorCode;
386 this.MinorCode = MinorCode;
389 public override string Message {
391 return GetMessage(Display, ResourceID, Serial, ErrorCode, RequestCode, MinorCode);
395 public static string GetMessage(IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) {
404 sb = new StringBuilder(160);
405 XGetErrorText(Display, ErrorCode, sb, sb.Capacity);
406 x_error_text = sb.ToString();
407 hwnd = Hwnd.ObjectFromHandle(ResourceID);
409 hwnd_text = hwnd.ToString();
410 c = Control.FromHandle(hwnd.Handle);
412 control_text = c.ToString();
414 control_text = String.Format("<handle {0:X} non-existant>", hwnd.Handle.ToInt32());
417 hwnd_text = "<null>";
418 control_text = "<null>";
422 error = String.Format("\n Error: {0}\n Request: {1:D} ({2})\n Resource ID: 0x{3:X}\n Serial: {4}\n Hwnd: {5}\n Control: {6}", x_error_text, RequestCode, MinorCode, ResourceID.ToInt32(), Serial, hwnd_text, control_text);
426 #endregion // XExceptionClass
428 #region Internal Methods
429 internal void SetDisplay(IntPtr display_handle)
431 if (display_handle != IntPtr.Zero) {
434 if ((DisplayHandle != IntPtr.Zero) && (FosterParent != IntPtr.Zero)) {
435 hwnd = Hwnd.ObjectFromHandle(FosterParent);
436 XDestroyWindow(DisplayHandle, FosterParent);
440 if (DisplayHandle != IntPtr.Zero) {
441 XCloseDisplay(DisplayHandle);
444 DisplayHandle=display_handle;
446 // We need to tell System.Drawing our DisplayHandle. FromHdcInternal has
447 // been hacked to do this for us.
448 Graphics.FromHdcInternal (DisplayHandle);
450 // query for the render extension so
451 // we can ignore the spurious
452 // BadPicture errors that are
453 // generated by cairo/render.
454 XQueryExtension (DisplayHandle, "RENDER",
455 ref render_major_opcode, ref render_first_event, ref render_first_error);
458 if (Environment.GetEnvironmentVariable ("MONO_XSYNC") != null) {
459 XSynchronize(DisplayHandle, true);
462 if (Environment.GetEnvironmentVariable ("MONO_XEXCEPTIONS") != null) {
463 ErrorExceptions = true;
467 ScreenNo = XDefaultScreen(DisplayHandle);
468 RootWindow = XRootWindow(DisplayHandle, ScreenNo);
469 DefaultColormap = XDefaultColormap(DisplayHandle, ScreenNo);
471 // Create the foster parent
472 // it is important that border_width is kept in synch with the other XCreateWindow calls
473 FosterParent=XCreateSimpleWindow(DisplayHandle, RootWindow, 0, 0, 1, 1, 0, UIntPtr.Zero, UIntPtr.Zero);
474 if (FosterParent==IntPtr.Zero) {
475 Console.WriteLine("XplatUIX11 Constructor failed to create FosterParent");
478 DebugHelper.WriteLine ("FosterParent created 0x{0:x}", FosterParent.ToInt32());
481 hwnd.Queue = ThreadQueue(Thread.CurrentThread);
482 hwnd.WholeWindow = FosterParent;
483 hwnd.ClientWindow = FosterParent;
485 // Create a HWND for RootWIndow as well, so our queue doesn't eat the events
487 hwnd.Queue = ThreadQueue(Thread.CurrentThread);
488 hwnd.whole_window = RootWindow;
489 hwnd.ClientWindow = RootWindow;
491 // For sleeping on the X11 socket
492 listen = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
493 IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, 0);
497 // To wake up when a timer is ready
498 network_buffer = new byte[10];
500 wake = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
501 wake.Connect(listen.LocalEndPoint);
503 // Make this non-blocking, so it doesn't
504 // deadlock if too many wakes are sent
505 // before the wake_receive end is polled
506 wake.Blocking = false;
508 wake_receive = listen.Accept();
511 pollfds = new Pollfd [2];
512 pollfds [0] = new Pollfd ();
513 pollfds [0].fd = XConnectionNumber (DisplayHandle);
514 pollfds [0].events = PollEvents.POLLIN;
516 pollfds [1] = new Pollfd ();
517 pollfds [1].fd = wake_receive.Handle.ToInt32 ();
518 pollfds [1].events = PollEvents.POLLIN;
521 Keyboard = new X11Keyboard(DisplayHandle, FosterParent);
522 Dnd = new X11Dnd (DisplayHandle, Keyboard);
524 DoubleClickInterval = 500;
526 HoverState.Interval = 500;
527 HoverState.Timer = new Timer();
528 HoverState.Timer.Enabled = false;
529 HoverState.Timer.Interval = HoverState.Interval;
530 HoverState.Timer.Tick += new EventHandler(MouseHover);
531 HoverState.Size = new Size(4, 4);
535 ActiveWindow = IntPtr.Zero;
536 FocusWindow = IntPtr.Zero;
537 ModalWindows = new Stack(3);
539 MouseState = MouseButtons.None;
540 mouse_position = new Point(0, 0);
542 Caret.Timer = new Timer();
543 Caret.Timer.Interval = 500; // FIXME - where should this number come from?
544 Caret.Timer.Tick += new EventHandler(CaretCallback);
548 // Grab atom changes off the root window to catch certain WM events
549 XSelectInput(DisplayHandle, RootWindow, new IntPtr ((int) (EventMask.PropertyChangeMask | Keyboard.KeyEventMask)));
551 // Handle any upcoming errors
552 ErrorHandler = new XErrorHandler(HandleError);
553 XSetErrorHandler(ErrorHandler);
555 throw new ArgumentNullException("Display", "Could not open display (X-Server required. Check you DISPLAY environment variable)");
558 #endregion // Internal Methods
561 [Conditional ("DriverDebug")]
562 static void DriverDebug (string format, params object [] args)
564 Console.WriteLine (String.Format (format, args));
568 TimeSpan t = (DateTime.UtcNow - new DateTime(1970, 1, 1));
570 return (int) t.TotalSeconds;
573 static void SetupAtoms() {
574 // make sure this array stays in sync with the statements below
575 string [] atom_names = new string[] {
580 //"_NET_CLIENT_LIST",
581 //"_NET_NUMBER_OF_DESKTOPS",
582 "_NET_DESKTOP_GEOMETRY",
583 //"_NET_DESKTOP_VIEWPORT",
584 "_NET_CURRENT_DESKTOP",
585 //"_NET_DESKTOP_NAMES",
586 "_NET_ACTIVE_WINDOW",
588 //"_NET_SUPPORTING_WM_CHECK",
589 //"_NET_VIRTUAL_ROOTS",
590 //"_NET_DESKTOP_LAYOUT",
591 //"_NET_SHOWING_DESKTOP",
592 //"_NET_CLOSE_WINDOW",
593 //"_NET_MOVERESIZE_WINDOW",
594 "_NET_WM_MOVERESIZE",
595 //"_NET_RESTACK_WINDOW",
596 //"_NET_REQUEST_FRAME_EXTENTS",
598 //"_NET_WM_VISIBLE_NAME",
599 //"_NET_WM_ICON_NAME",
600 //"_NET_WM_VISIBLE_ICON_NAME",
602 "_NET_WM_WINDOW_TYPE",
604 //"_NET_WM_ALLOWED_ACTIONS",
606 //"_NET_WM_STRUT_PARTIAL",
607 //"_NET_WM_ICON_GEOMETRY",
610 //"_NET_WM_HANDLED_ICONS",
612 "_NET_FRAME_EXTENTS",
614 //"_NET_WM_SYNC_REQUEST",
615 "_NET_SYSTEM_TRAY_OPCODE",
616 //"_NET_SYSTEM_TRAY_ORIENTATION",
617 "_NET_WM_STATE_MAXIMIZED_HORZ",
618 "_NET_WM_STATE_MAXIMIZED_VERT",
619 "_NET_WM_STATE_HIDDEN",
623 "_NET_WM_STATE_SKIP_TASKBAR",
624 "_NET_WM_STATE_ABOVE",
625 "_NET_WM_STATE_MODAL",
626 "_NET_WM_CONTEXT_HELP",
627 "_NET_WM_WINDOW_OPACITY",
628 //"_NET_WM_WINDOW_TYPE_DESKTOP",
629 //"_NET_WM_WINDOW_TYPE_DOCK",
630 //"_NET_WM_WINDOW_TYPE_TOOLBAR",
631 //"_NET_WM_WINDOW_TYPE_MENU",
632 "_NET_WM_WINDOW_TYPE_UTILITY",
633 // "_NET_WM_WINDOW_TYPE_DIALOG",
634 //"_NET_WM_WINDOW_TYPE_SPLASH",
635 "_NET_WM_WINDOW_TYPE_NORMAL",
644 "_SWF_PostMessageAtom",
647 IntPtr[] atoms = new IntPtr [atom_names.Length];;
649 XInternAtoms (DisplayHandle, atom_names, atom_names.Length, false, atoms);
652 WM_PROTOCOLS = atoms [off++];
653 WM_DELETE_WINDOW = atoms [off++];
654 WM_TAKE_FOCUS = atoms [off++];
655 //_NET_SUPPORTED = atoms [off++];
656 //_NET_CLIENT_LIST = atoms [off++];
657 //_NET_NUMBER_OF_DESKTOPS = atoms [off++];
658 _NET_DESKTOP_GEOMETRY = atoms [off++];
659 //_NET_DESKTOP_VIEWPORT = atoms [off++];
660 _NET_CURRENT_DESKTOP = atoms [off++];
661 //_NET_DESKTOP_NAMES = atoms [off++];
662 _NET_ACTIVE_WINDOW = atoms [off++];
663 _NET_WORKAREA = atoms [off++];
664 //_NET_SUPPORTING_WM_CHECK = atoms [off++];
665 //_NET_VIRTUAL_ROOTS = atoms [off++];
666 //_NET_DESKTOP_LAYOUT = atoms [off++];
667 //_NET_SHOWING_DESKTOP = atoms [off++];
668 //_NET_CLOSE_WINDOW = atoms [off++];
669 //_NET_MOVERESIZE_WINDOW = atoms [off++];
670 _NET_WM_MOVERESIZE = atoms [off++];
671 //_NET_RESTACK_WINDOW = atoms [off++];
672 //_NET_REQUEST_FRAME_EXTENTS = atoms [off++];
673 _NET_WM_NAME = atoms [off++];
674 //_NET_WM_VISIBLE_NAME = atoms [off++];
675 //_NET_WM_ICON_NAME = atoms [off++];
676 //_NET_WM_VISIBLE_ICON_NAME = atoms [off++];
677 //_NET_WM_DESKTOP = atoms [off++];
678 _NET_WM_WINDOW_TYPE = atoms [off++];
679 _NET_WM_STATE = atoms [off++];
680 //_NET_WM_ALLOWED_ACTIONS = atoms [off++];
681 //_NET_WM_STRUT = atoms [off++];
682 //_NET_WM_STRUT_PARTIAL = atoms [off++];
683 //_NET_WM_ICON_GEOMETRY = atoms [off++];
684 _NET_WM_ICON = atoms [off++];
685 //_NET_WM_PID = atoms [off++];
686 //_NET_WM_HANDLED_ICONS = atoms [off++];
687 _NET_WM_USER_TIME = atoms [off++];
688 _NET_FRAME_EXTENTS = atoms [off++];
689 //_NET_WM_PING = atoms [off++];
690 //_NET_WM_SYNC_REQUEST = atoms [off++];
691 _NET_SYSTEM_TRAY_OPCODE = atoms [off++];
692 //_NET_SYSTEM_TRAY_ORIENTATION = atoms [off++];
693 _NET_WM_STATE_MAXIMIZED_HORZ = atoms [off++];
694 _NET_WM_STATE_MAXIMIZED_VERT = atoms [off++];
695 _NET_WM_STATE_HIDDEN = atoms [off++];
696 _XEMBED = atoms [off++];
697 _XEMBED_INFO = atoms [off++];
698 _MOTIF_WM_HINTS = atoms [off++];
699 _NET_WM_STATE_SKIP_TASKBAR = atoms [off++];
700 _NET_WM_STATE_ABOVE = atoms [off++];
701 _NET_WM_STATE_MODAL = atoms [off++];
702 _NET_WM_CONTEXT_HELP = atoms [off++];
703 _NET_WM_WINDOW_OPACITY = atoms [off++];
704 //_NET_WM_WINDOW_TYPE_DESKTOP = atoms [off++];
705 //_NET_WM_WINDOW_TYPE_DOCK = atoms [off++];
706 //_NET_WM_WINDOW_TYPE_TOOLBAR = atoms [off++];
707 //_NET_WM_WINDOW_TYPE_MENU = atoms [off++];
708 _NET_WM_WINDOW_TYPE_UTILITY = atoms [off++];
709 // _NET_WM_WINDOW_TYPE_DIALOG = atoms [off++];
710 //_NET_WM_WINDOW_TYPE_SPLASH = atoms [off++];
711 _NET_WM_WINDOW_TYPE_NORMAL = atoms [off++];
712 CLIPBOARD = atoms [off++];
713 PRIMARY = atoms [off++];
714 OEMTEXT = atoms [off++];
715 UTF8_STRING = atoms [off++];
716 UTF16_STRING = atoms [off++];
717 RICHTEXTFORMAT = atoms [off++];
718 TARGETS = atoms [off++];
719 AsyncAtom = atoms [off++];
720 PostAtom = atoms [off++];
721 HoverState.Atom = atoms [off++];
723 //DIB = (IntPtr)Atom.XA_PIXMAP;
724 _NET_SYSTEM_TRAY_S = XInternAtom (DisplayHandle, "_NET_SYSTEM_TRAY_S" + ScreenNo.ToString(), false);
727 void GetSystrayManagerWindow() {
728 XGrabServer(DisplayHandle);
729 SystrayMgrWindow = XGetSelectionOwner(DisplayHandle, _NET_SYSTEM_TRAY_S);
730 XUngrabServer(DisplayHandle);
731 XFlush(DisplayHandle);
734 void SendNetWMMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) {
735 SendNetWMMessage (window, message_type, l0, l1, l2, IntPtr.Zero);
738 void SendNetWMMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2, IntPtr l3) {
742 xev.ClientMessageEvent.type = XEventName.ClientMessage;
743 xev.ClientMessageEvent.send_event = true;
744 xev.ClientMessageEvent.window = window;
745 xev.ClientMessageEvent.message_type = message_type;
746 xev.ClientMessageEvent.format = 32;
747 xev.ClientMessageEvent.ptr1 = l0;
748 xev.ClientMessageEvent.ptr2 = l1;
749 xev.ClientMessageEvent.ptr3 = l2;
750 xev.ClientMessageEvent.ptr4 = l3;
751 XSendEvent(DisplayHandle, RootWindow, false, new IntPtr ((int) (EventMask.SubstructureRedirectMask | EventMask.SubstructureNotifyMask)), ref xev);
754 void SendNetClientMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) {
758 xev.ClientMessageEvent.type = XEventName.ClientMessage;
759 xev.ClientMessageEvent.send_event = true;
760 xev.ClientMessageEvent.window = window;
761 xev.ClientMessageEvent.message_type = message_type;
762 xev.ClientMessageEvent.format = 32;
763 xev.ClientMessageEvent.ptr1 = l0;
764 xev.ClientMessageEvent.ptr2 = l1;
765 xev.ClientMessageEvent.ptr3 = l2;
766 XSendEvent(DisplayHandle, window, false, new IntPtr ((int)EventMask.NoEventMask), ref xev);
769 // For WM_LBUTTONDOWN, WM_MBUTTONDOWN, WM_RBUTTONDOWN, WM_XBUTTONDOWN
770 // WM_CREATE and WM_DESTROY causes
771 void SendParentNotify(IntPtr child, Msg cause, int x, int y)
775 if (child == IntPtr.Zero) {
779 hwnd = Hwnd.GetObjectFromWindow (child);
785 if (hwnd.Handle == IntPtr.Zero) {
789 if (ExStyleSet ((int) hwnd.initial_ex_style, WindowExStyles.WS_EX_NOPARENTNOTIFY)) {
793 if (hwnd.Parent == null) {
797 if (hwnd.Parent.Handle == IntPtr.Zero) {
801 if (cause == Msg.WM_CREATE || cause == Msg.WM_DESTROY) {
802 SendMessage(hwnd.Parent.Handle, Msg.WM_PARENTNOTIFY, Control.MakeParam((int)cause, 0), child);
804 SendMessage(hwnd.Parent.Handle, Msg.WM_PARENTNOTIFY, Control.MakeParam((int)cause, 0), Control.MakeParam(x, y));
807 SendParentNotify (hwnd.Parent.Handle, cause, x, y);
810 bool StyleSet (int s, WindowStyles ws)
812 return (s & (int)ws) == (int)ws;
815 bool ExStyleSet (int ex, WindowExStyles exws)
817 return (ex & (int)exws) == (int)exws;
820 internal static Rectangle TranslateClientRectangleToXClientRectangle (Hwnd hwnd)
822 return TranslateClientRectangleToXClientRectangle (hwnd, Control.FromHandle (hwnd.Handle));
825 internal static Rectangle TranslateClientRectangleToXClientRectangle (Hwnd hwnd, Control ctrl)
828 * If this is a form with no window manager, X is handling all the border and caption painting
829 * so remove that from the area (since the area we set of the window here is the part of the window
830 * we're painting in only)
832 Rectangle rect = hwnd.ClientRect;
833 Form form = ctrl as Form;
834 CreateParams cp = null;
837 cp = form.GetCreateParams ();
839 if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) {
840 Hwnd.Borders borders = Hwnd.GetBorders (cp, null);
841 Rectangle xrect = rect;
843 xrect.Y -= borders.top;
844 xrect.X -= borders.left;
845 xrect.Width += borders.left + borders.right;
846 xrect.Height += borders.top + borders.bottom;
851 if (rect.Width < 1 || rect.Height < 1) {
861 internal static Size TranslateWindowSizeToXWindowSize (CreateParams cp)
863 return TranslateWindowSizeToXWindowSize (cp, new Size (cp.Width, cp.Height));
866 internal static Size TranslateWindowSizeToXWindowSize (CreateParams cp, Size size)
869 * If this is a form with no window manager, X is handling all the border and caption painting
870 * so remove that from the area (since the area we set of the window here is the part of the window
871 * we're painting in only)
873 Form form = cp.control as Form;
874 if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) {
875 Hwnd.Borders borders = Hwnd.GetBorders (cp, null);
878 xrect.Width -= borders.left + borders.right;
879 xrect.Height -= borders.top + borders.bottom;
883 if (size.Height == 0)
890 internal static Size TranslateXWindowSizeToWindowSize (CreateParams cp, int xWidth, int xHeight)
893 * If this is a form with no window manager, X is handling all the border and caption painting
894 * so remove that from the area (since the area we set of the window here is the part of the window
895 * we're painting in only)
897 Size rect = new Size (xWidth, xHeight);
898 Form form = cp.control as Form;
899 if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) {
900 Hwnd.Borders borders = Hwnd.GetBorders (cp, null);
903 xrect.Width += borders.left + borders.right;
904 xrect.Height += borders.top + borders.bottom;
911 internal static Point GetTopLevelWindowLocation (Hwnd hwnd)
917 XTranslateCoordinates (DisplayHandle, hwnd.whole_window, RootWindow, 0, 0, out x, out y, out dummy);
918 frame = FrameExtents (hwnd.whole_window);
923 return new Point (x, y);
926 void DeriveStyles(int Style, int ExStyle, out FormBorderStyle border_style, out bool border_static, out TitleStyle title_style, out int caption_height, out int tool_caption_height) {
929 tool_caption_height = 19;
930 border_static = false;
932 if (StyleSet (Style, WindowStyles.WS_CHILD)) {
933 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) {
934 border_style = FormBorderStyle.Fixed3D;
935 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) {
936 border_style = FormBorderStyle.Fixed3D;
937 border_static = true;
938 } else if (!StyleSet (Style, WindowStyles.WS_BORDER)) {
939 border_style = FormBorderStyle.None;
941 border_style = FormBorderStyle.FixedSingle;
943 title_style = TitleStyle.None;
945 if (StyleSet (Style, WindowStyles.WS_CAPTION)) {
947 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
948 title_style = TitleStyle.Tool;
950 title_style = TitleStyle.Normal;
954 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_MDICHILD)) {
957 if (StyleSet (Style, WindowStyles.WS_OVERLAPPEDWINDOW) ||
958 ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
959 border_style = (FormBorderStyle) 0xFFFF;
961 border_style = FormBorderStyle.None;
966 title_style = TitleStyle.None;
967 if (StyleSet (Style, WindowStyles.WS_CAPTION)) {
968 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
969 title_style = TitleStyle.Tool;
971 title_style = TitleStyle.Normal;
975 border_style = FormBorderStyle.None;
977 if (StyleSet (Style, WindowStyles.WS_THICKFRAME)) {
978 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
979 border_style = FormBorderStyle.SizableToolWindow;
981 border_style = FormBorderStyle.Sizable;
984 if (StyleSet (Style, WindowStyles.WS_CAPTION)) {
985 if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) {
986 border_style = FormBorderStyle.Fixed3D;
987 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) {
988 border_style = FormBorderStyle.Fixed3D;
989 border_static = true;
990 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) {
991 border_style = FormBorderStyle.FixedDialog;
992 } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
993 border_style = FormBorderStyle.FixedToolWindow;
994 } else if (StyleSet (Style, WindowStyles.WS_BORDER)) {
995 border_style = FormBorderStyle.FixedSingle;
998 if (StyleSet (Style, WindowStyles.WS_BORDER)) {
999 border_style = FormBorderStyle.FixedSingle;
1006 void SetHwndStyles(Hwnd hwnd, CreateParams cp) {
1007 DeriveStyles(cp.Style, cp.ExStyle, out hwnd.border_style, out hwnd.border_static, out hwnd.title_style, out hwnd.caption_height, out hwnd.tool_caption_height);
1010 void SetWMStyles(Hwnd hwnd, CreateParams cp) {
1011 MotifWmHints mwmHints;
1012 MotifFunctions functions;
1013 MotifDecorations decorations;
1016 Rectangle client_rect;
1019 bool hide_from_taskbar;
1020 IntPtr transient_for_parent;
1022 // Windows we manage ourselves don't need WM window styles.
1023 if (cp.HasWindowManager && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) {
1028 mwmHints = new MotifWmHints();
1031 window_type = _NET_WM_WINDOW_TYPE_NORMAL;
1032 transient_for_parent = IntPtr.Zero;
1034 mwmHints.flags = (IntPtr)(MotifFlags.Functions | MotifFlags.Decorations);
1035 mwmHints.functions = (IntPtr)0;
1036 mwmHints.decorations = (IntPtr)0;
1038 form = cp.control as Form;
1040 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
1041 /* tool windows get no window manager
1045 /* just because the window doesn't get any decorations doesn't
1046 mean we should disable the functions. for instance, without
1047 MotifFunctions.Maximize, changing the windowstate to Maximized
1048 is ignored by metacity. */
1049 functions |= MotifFunctions.Move | MotifFunctions.Resize | MotifFunctions.Minimize | MotifFunctions.Maximize;
1050 } else if (form != null && form.FormBorderStyle == FormBorderStyle.None) {
1051 /* allow borderless window to be maximized */
1052 functions |= MotifFunctions.All | MotifFunctions.Resize;
1054 if (StyleSet (cp.Style, WindowStyles.WS_CAPTION)) {
1055 functions |= MotifFunctions.Move;
1056 decorations |= MotifDecorations.Title | MotifDecorations.Menu;
1059 if (StyleSet (cp.Style, WindowStyles.WS_THICKFRAME)) {
1060 functions |= MotifFunctions.Move | MotifFunctions.Resize;
1061 decorations |= MotifDecorations.Border | MotifDecorations.ResizeH;
1064 if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZEBOX)) {
1065 functions |= MotifFunctions.Minimize;
1066 decorations |= MotifDecorations.Minimize;
1069 if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZEBOX)) {
1070 functions |= MotifFunctions.Maximize;
1071 decorations |= MotifDecorations.Maximize;
1074 if (StyleSet (cp.Style, WindowStyles.WS_SIZEBOX)) {
1075 functions |= MotifFunctions.Resize;
1076 decorations |= MotifDecorations.ResizeH;
1079 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) {
1080 decorations |= MotifDecorations.Border;
1083 if (StyleSet (cp.Style, WindowStyles.WS_BORDER)) {
1084 decorations |= MotifDecorations.Border;
1087 if (StyleSet (cp.Style, WindowStyles.WS_DLGFRAME)) {
1088 decorations |= MotifDecorations.Border;
1091 if (StyleSet (cp.Style, WindowStyles.WS_SYSMENU)) {
1092 functions |= MotifFunctions.Close;
1095 functions &= ~(MotifFunctions.Maximize | MotifFunctions.Minimize | MotifFunctions.Close);
1096 decorations &= ~(MotifDecorations.Menu | MotifDecorations.Maximize | MotifDecorations.Minimize);
1097 if (cp.Caption == "") {
1098 functions &= ~MotifFunctions.Move;
1099 decorations &= ~(MotifDecorations.Title | MotifDecorations.ResizeH);
1104 if ((functions & MotifFunctions.Resize) == 0) {
1105 hwnd.fixed_size = true;
1106 Rectangle fixed_rectangle = new Rectangle (cp.X, cp.Y, cp.Width, cp.Height);
1107 SetWindowMinMax(hwnd.Handle, fixed_rectangle, fixed_rectangle.Size, fixed_rectangle.Size, cp);
1109 hwnd.fixed_size = false;
1112 mwmHints.functions = (IntPtr)functions;
1113 mwmHints.decorations = (IntPtr)decorations;
1115 DriverDebug ("SetWMStyles ({0}, {1}) functions = {2}, decorations = {3}", hwnd, cp, functions, decorations);
1117 if (cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) {
1118 // needed! map toolwindows to _NET_WM_WINDOW_TYPE_UTILITY to make newer metacity versions happy
1119 // and get those windows in front of their parents
1120 window_type = _NET_WM_WINDOW_TYPE_UTILITY;
1122 window_type = _NET_WM_WINDOW_TYPE_NORMAL;
1125 if (!cp.IsSet (WindowExStyles.WS_EX_APPWINDOW)) {
1126 hide_from_taskbar = true;
1127 } else if (cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW) && form != null && form.Parent != null && !form.ShowInTaskbar) {
1128 hide_from_taskbar = true;
1130 hide_from_taskbar = false;
1133 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
1134 if (form != null && !hwnd.reparented) {
1135 if (form.Owner != null && form.Owner.Handle != IntPtr.Zero) {
1136 Hwnd owner_hwnd = Hwnd.ObjectFromHandle (form.Owner.Handle);
1137 if (owner_hwnd != null)
1138 transient_for_parent = owner_hwnd.whole_window;
1142 if (StyleSet (cp.Style, WindowStyles.WS_POPUP) && (hwnd.parent != null) && (hwnd.parent.whole_window != IntPtr.Zero)) {
1143 transient_for_parent = hwnd.parent.whole_window;
1146 FormWindowState current_state = GetWindowState (hwnd.Handle);
1147 if (current_state == (FormWindowState)(-1))
1148 current_state = FormWindowState.Normal;
1150 client_rect = TranslateClientRectangleToXClientRectangle (hwnd);
1155 atoms [0] = window_type.ToInt32 ();
1156 XChangeProperty (DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
1158 XChangeProperty(DisplayHandle, hwnd.whole_window, _MOTIF_WM_HINTS, _MOTIF_WM_HINTS, 32, PropertyMode.Replace, ref mwmHints, 5);
1160 if (transient_for_parent != IntPtr.Zero) {
1161 XSetTransientForHint (DisplayHandle, hwnd.whole_window, transient_for_parent);
1164 MoveResizeWindow(DisplayHandle, hwnd.client_window, client_rect.X, client_rect.Y, client_rect.Width, client_rect.Height);
1166 if (hide_from_taskbar) {
1167 /* this line keeps the window from showing up in gnome's taskbar */
1168 atoms[atom_count++] = _NET_WM_STATE_SKIP_TASKBAR.ToInt32();
1170 /* we need to add these atoms in the
1171 * event we're maximized, since we're
1172 * replacing the existing
1173 * _NET_WM_STATE here. If we don't
1174 * add them, future calls to
1175 * GetWindowState will return Normal
1176 * for a window which is maximized. */
1177 if (current_state == FormWindowState.Maximized) {
1178 atoms[atom_count++] = _NET_WM_STATE_MAXIMIZED_HORZ.ToInt32();
1179 atoms[atom_count++] = _NET_WM_STATE_MAXIMIZED_VERT.ToInt32();
1182 if (form != null && form.Modal) {
1183 atoms[atom_count++] = _NET_WM_STATE_MODAL.ToInt32 ();
1186 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, atom_count);
1189 IntPtr[] atom_ptrs = new IntPtr[2];
1190 atom_ptrs[atom_count++] = WM_DELETE_WINDOW;
1191 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_CONTEXTHELP)) {
1192 atom_ptrs[atom_count++] = _NET_WM_CONTEXT_HELP;
1195 XSetWMProtocols(DisplayHandle, hwnd.whole_window, atom_ptrs, atom_count);
1199 void SetIcon(Hwnd hwnd, Icon icon)
1204 // This really needs to do whatever it
1205 // takes to remove the window manager
1206 // menu, not just delete the ICON
1207 // property. This will cause metacity
1208 // to use the "no icon set" icon, and
1209 // we'll still have an icon.
1210 XDeleteProperty (DisplayHandle, hwnd.whole_window, _NET_WM_ICON);
1218 bitmap = icon.ToBitmap();
1220 size = bitmap.Width * bitmap.Height + 2;
1221 data = new IntPtr[size];
1223 data[index++] = (IntPtr)bitmap.Width;
1224 data[index++] = (IntPtr)bitmap.Height;
1226 for (int y = 0; y < bitmap.Height; y++) {
1227 for (int x = 0; x < bitmap.Width; x++) {
1228 data[index++] = (IntPtr)bitmap.GetPixel (x, y).ToArgb ();
1232 XChangeProperty (DisplayHandle, hwnd.whole_window,
1233 _NET_WM_ICON, (IntPtr)Atom.XA_CARDINAL, 32,
1234 PropertyMode.Replace, data, size);
1238 void WakeupMain () {
1240 wake.Send (new byte [] { 0xFF });
1241 } catch (SocketException ex) {
1242 if (ex.SocketErrorCode != SocketError.WouldBlock) {
1248 XEventQueue ThreadQueue(Thread thread) {
1251 queue = (XEventQueue)MessageQueues[thread];
1252 if (queue == null) {
1253 queue = new XEventQueue(thread);
1254 MessageQueues[thread] = queue;
1260 void TranslatePropertyToClipboard(IntPtr property) {
1265 IntPtr prop = IntPtr.Zero;
1267 Clipboard.Item = null;
1269 XGetWindowProperty(DisplayHandle, FosterParent, property, IntPtr.Zero, new IntPtr (0x7fffffff), true, (IntPtr)Atom.AnyPropertyType, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
1271 if ((long)nitems > 0) {
1272 if (property == (IntPtr)Atom.XA_STRING) {
1273 // Some X managers/apps pass unicode chars as escaped strings, so
1274 // we may need to unescape them.
1275 Clipboard.Item = UnescapeUnicodeFromAnsi (Marshal.PtrToStringAnsi(prop));
1276 } else if (property == (IntPtr)Atom.XA_BITMAP) {
1277 // FIXME - convert bitmap to image
1278 } else if (property == (IntPtr)Atom.XA_PIXMAP) {
1279 // FIXME - convert pixmap to image
1280 } else if (property == OEMTEXT) {
1281 Clipboard.Item = UnescapeUnicodeFromAnsi (Marshal.PtrToStringAnsi(prop));
1282 } else if (property == UTF8_STRING) {
1283 byte [] buffer = new byte [(int)nitems];
1284 for (int i = 0; i < (int)nitems; i++)
1285 buffer [i] = Marshal.ReadByte (prop, i);
1286 Clipboard.Item = Encoding.UTF8.GetString (buffer);
1287 } else if (property == UTF16_STRING) {
1288 Clipboard.Item = Marshal.PtrToStringUni (prop, Encoding.Unicode.GetMaxCharCount ((int)nitems));
1289 } else if (property == RICHTEXTFORMAT)
1290 Clipboard.Item = Marshal.PtrToStringAnsi(prop);
1291 else if (DataFormats.ContainsFormat (property.ToInt32 ())) {
1292 if (DataFormats.GetFormat (property.ToInt32 ()).is_serializable) {
1293 MemoryStream memory_stream = new MemoryStream ((int)nitems);
1294 for (int i = 0; i < (int)nitems; i++)
1295 memory_stream.WriteByte (Marshal.ReadByte (prop, i));
1297 memory_stream.Position = 0;
1298 BinaryFormatter formatter = new BinaryFormatter ();
1299 Clipboard.Item = formatter.Deserialize (memory_stream);
1300 memory_stream.Close ();
1308 string UnescapeUnicodeFromAnsi (string value)
1310 if (value == null || value.IndexOf ("\\u") == -1)
1313 StringBuilder sb = new StringBuilder (value.Length);
1317 while (start < value.Length) {
1318 pos = value.IndexOf ("\\u", start);
1322 sb.Append (value, start, pos - start);
1327 while (pos < value.Length) {
1328 if (!Char.IsLetterOrDigit (value [pos]))
1335 if (!Int32.TryParse (value.Substring (start, length), System.Globalization.NumberStyles.HexNumber,
1337 return value; // Error, return the unescaped original value.
1339 sb.Append ((char)res);
1343 // Append any remaining data.
1344 if (start < value.Length)
1345 sb.Append (value, start, value.Length - start);
1347 return sb.ToString ();
1350 void AddExpose (Hwnd hwnd, bool client, int x, int y, int width, int height) {
1352 if ((hwnd == null) || (x > hwnd.Width) || (y > hwnd.Height) || ((x + width) < 0) || ((y + height) < 0)) {
1356 // Keep the invalid area as small as needed
1357 if ((x + width) > hwnd.width) {
1358 width = hwnd.width - x;
1361 if ((y + height) > hwnd.height) {
1362 height = hwnd.height - y;
1366 hwnd.AddInvalidArea(x, y, width, height);
1367 if (!hwnd.expose_pending) {
1368 if (!hwnd.nc_expose_pending) {
1369 hwnd.Queue.Paint.Enqueue(hwnd);
1371 hwnd.expose_pending = true;
1374 hwnd.AddNcInvalidArea (x, y, width, height);
1376 if (!hwnd.nc_expose_pending) {
1377 if (!hwnd.expose_pending) {
1378 hwnd.Queue.Paint.Enqueue(hwnd);
1380 hwnd.nc_expose_pending = true;
1385 static Hwnd.Borders FrameExtents (IntPtr window)
1391 IntPtr prop = IntPtr.Zero;
1392 Hwnd.Borders rect = new Hwnd.Borders ();
1394 XGetWindowProperty (DisplayHandle, window, _NET_FRAME_EXTENTS, IntPtr.Zero, new IntPtr (16), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
1395 if (prop != IntPtr.Zero) {
1396 if (nitems.ToInt32 () == 4) {
1397 rect.left = Marshal.ReadInt32 (prop, 0);
1398 rect.right = Marshal.ReadInt32 (prop, IntPtr.Size);
1399 rect.top = Marshal.ReadInt32 (prop, 2 * IntPtr.Size);
1400 rect.bottom = Marshal.ReadInt32 (prop, 3 * IntPtr.Size);
1408 void AddConfigureNotify (XEvent xevent) {
1411 hwnd = Hwnd.GetObjectFromWindow(xevent.ConfigureEvent.window);
1414 if (hwnd == null || hwnd.zombie) {
1417 if ((xevent.ConfigureEvent.window == hwnd.whole_window)/* && (xevent.ConfigureEvent.window == xevent.ConfigureEvent.xevent)*/) {
1418 if (hwnd.parent == null) {
1419 // The location given by the event is not reliable between different wm's,
1420 // so use an alternative way of getting it.
1421 Point location = GetTopLevelWindowLocation (hwnd);
1422 hwnd.x = location.X;
1423 hwnd.y = location.Y;
1426 // XXX this sucks. this isn't thread safe
1427 Control ctrl = Control.FromHandle (hwnd.Handle);
1428 Size TranslatedSize;
1430 TranslatedSize = TranslateXWindowSizeToWindowSize (ctrl.GetCreateParams (), xevent.ConfigureEvent.width, xevent.ConfigureEvent.height);
1432 TranslatedSize = new Size (xevent.ConfigureEvent.width, xevent.ConfigureEvent.height);
1434 hwnd.width = TranslatedSize.Width;
1435 hwnd.height = TranslatedSize.Height;
1436 hwnd.ClientRect = Rectangle.Empty;
1438 DriverDebug ("AddConfigureNotify (hwnd.Handle = {1}, final hwnd.rect = {0}, reported rect={2})",
1439 new Rectangle (hwnd.x, hwnd.y, hwnd.width, hwnd.height), hwnd.Handle,
1440 new Rectangle (xevent.ConfigureEvent.x, xevent.ConfigureEvent.y, xevent.ConfigureEvent.width, xevent.ConfigureEvent.width));
1441 lock (hwnd.configure_lock) {
1442 if (!hwnd.configure_pending) {
1443 hwnd.Queue.EnqueueLocked (xevent);
1444 hwnd.configure_pending = true;
1448 // We drop configure events for Client windows
1452 if ((Caret.gc == IntPtr.Zero) || Caret.On) {
1458 XDrawLine(DisplayHandle, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height);
1463 if ((Caret.gc == IntPtr.Zero) || !Caret.On) {
1469 XDrawLine(DisplayHandle, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height);
1473 int NextTimeout (ArrayList timers, DateTime now) {
1476 foreach (Timer timer in timers) {
1477 int next = (int) (timer.Expires - now).TotalMilliseconds;
1479 return 0; // Have a timer that has already expired
1482 if (next < timeout) {
1486 if (timeout < Timer.Minimum) {
1487 timeout = Timer.Minimum;
1495 void CheckTimers (ArrayList timers, DateTime now) {
1498 count = timers.Count;
1503 for (int i = 0; i < timers.Count; i++) {
1506 timer = (Timer) timers [i];
1508 if (timer.Enabled && timer.Expires <= now && !timer.Busy) {
1510 // - Before MainForm.OnLoad if DoEvents () is called.
1511 // - After MainForm.OnLoad if not.
1514 (Application.MWFThread.Current.Context != null &&
1515 (Application.MWFThread.Current.Context.MainForm == null ||
1516 Application.MWFThread.Current.Context.MainForm.IsLoaded))) {
1526 void WaitForHwndMessage (Hwnd hwnd, Msg message) {
1527 WaitForHwndMessage (hwnd, message, false);
1531 void WaitForHwndMessage (Hwnd hwnd, Msg message, bool process) {
1532 MSG msg = new MSG ();
1535 queue = ThreadQueue(Thread.CurrentThread);
1537 queue.DispatchIdle = false;
1540 string key = hwnd.Handle + ":" + message;
1541 if (!messageHold.ContainsKey (key))
1542 messageHold.Add (key, 1);
1544 messageHold[key] = ((int)messageHold[key]) + 1;
1549 DebugHelper.WriteLine ("Waiting for message " + message + " on hwnd " + String.Format("0x{0:x}", hwnd.Handle.ToInt32 ()));
1550 DebugHelper.Indent ();
1552 if (PeekMessage(queue, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) {
1553 if ((Msg)msg.message == Msg.WM_QUIT) {
1554 PostQuitMessage (0);
1559 DebugHelper.WriteLine ("PeekMessage got " + msg);
1561 if (msg.hwnd == hwnd.Handle) {
1562 if ((Msg)msg.message == message) {
1564 TranslateMessage (ref msg);
1565 DispatchMessage (ref msg);
1569 else if ((Msg)msg.message == Msg.WM_DESTROY)
1573 TranslateMessage (ref msg);
1574 DispatchMessage (ref msg);
1578 done = !messageHold.ContainsKey (key) || ((int)messageHold[key] < 1) || done;
1581 messageHold.Remove (key);
1583 DebugHelper.Unindent ();
1584 DebugHelper.WriteLine ("Finished waiting for " + key);
1586 queue.DispatchIdle = true;
1590 void MapWindow(Hwnd hwnd, WindowType windows) {
1592 Form f = Control.FromHandle(hwnd.Handle) as Form;
1594 if (f.WindowState == FormWindowState.Normal) {
1595 f.waiting_showwindow = true;
1596 SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero);
1600 // it's possible that our Hwnd is no
1601 // longer valid after making that
1602 // SendMessage call, so check here.
1606 if ((windows & WindowType.Whole) != 0) {
1607 XMapWindow(DisplayHandle, hwnd.whole_window);
1609 if ((windows & WindowType.Client) != 0) {
1610 XMapWindow(DisplayHandle, hwnd.client_window);
1616 if (f.waiting_showwindow) {
1617 WaitForHwndMessage (hwnd, Msg.WM_SHOWWINDOW);
1618 CreateParams cp = f.GetCreateParams();
1619 if (!ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_MDICHILD) &&
1620 !StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
1621 WaitForHwndMessage (hwnd, Msg.WM_ACTIVATE, true);
1628 void UnmapWindow(Hwnd hwnd, WindowType windows) {
1631 if (Control.FromHandle(hwnd.Handle) is Form) {
1632 f = Control.FromHandle(hwnd.Handle) as Form;
1633 if (f.WindowState == FormWindowState.Normal) {
1634 f.waiting_showwindow = true;
1635 SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, IntPtr.Zero, IntPtr.Zero);
1639 // it's possible that our Hwnd is no
1640 // longer valid after making that
1641 // SendMessage call, so check here.
1642 // FIXME: it is likely wrong, as it has already sent WM_SHOWWINDOW
1646 if ((windows & WindowType.Client) != 0) {
1647 XUnmapWindow(DisplayHandle, hwnd.client_window);
1649 if ((windows & WindowType.Whole) != 0) {
1650 XUnmapWindow(DisplayHandle, hwnd.whole_window);
1653 hwnd.mapped = false;
1656 if (f.waiting_showwindow) {
1657 WaitForHwndMessage (hwnd, Msg.WM_SHOWWINDOW);
1658 CreateParams cp = f.GetCreateParams();
1659 if (!ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_MDICHILD) &&
1660 !StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
1661 WaitForHwndMessage (hwnd, Msg.WM_ACTIVATE, true);
1668 void UpdateMessageQueue (XEventQueue queue) {
1669 UpdateMessageQueue(queue, true);
1672 void UpdateMessageQueue (XEventQueue queue, bool allowIdle) {
1677 now = DateTime.UtcNow;
1680 pending = XPending (DisplayHandle);
1683 if (pending == 0 && allowIdle) {
1684 if ((queue == null || queue.DispatchIdle) && Idle != null) {
1685 Idle (this, EventArgs.Empty);
1689 pending = XPending (DisplayHandle);
1696 if (queue != null) {
1697 if (queue.Paint.Count > 0)
1700 timeout = NextTimeout (queue.timer_list, now);
1705 int length = pollfds.Length - 1;
1706 lock (wake_waiting_lock) {
1707 if (wake_waiting == false) {
1709 wake_waiting = true;
1713 Syscall.poll (pollfds, (uint)length, timeout);
1714 // Clean out buffer, so we're not busy-looping on the same data
1715 if (length == pollfds.Length) {
1716 if (pollfds[1].revents != 0)
1717 wake_receive.Receive(network_buffer, 0, 1, SocketFlags.None);
1718 lock (wake_waiting_lock) {
1719 wake_waiting = false;
1724 pending = XPending (DisplayHandle);
1730 CheckTimers (queue.timer_list, now);
1733 XEvent xevent = new XEvent ();
1736 if (XPending (DisplayHandle) == 0)
1739 XNextEvent (DisplayHandle, ref xevent);
1741 if (xevent.AnyEvent.type == XEventName.KeyPress ||
1742 xevent.AnyEvent.type == XEventName.KeyRelease) {
1743 // PreFilter() handles "shift key state updates.
1744 Keyboard.PreFilter (xevent);
1745 if (XFilterEvent (ref xevent, Keyboard.ClientWindow)) {
1746 // probably here we could raise WM_IME_KEYDOWN and
1747 // WM_IME_KEYUP, but I'm not sure it is worthy.
1751 else if (XFilterEvent (ref xevent, IntPtr.Zero))
1755 hwnd = Hwnd.GetObjectFromWindow(xevent.AnyEvent.window);
1759 DebugHelper.WriteLine ("UpdateMessageQueue got Event: " + xevent.ToString ());
1761 switch (xevent.type) {
1762 case XEventName.Expose:
1763 AddExpose (hwnd, xevent.ExposeEvent.window == hwnd.ClientWindow, xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height);
1766 case XEventName.SelectionClear: {
1767 // Should we do something?
1771 case XEventName.SelectionRequest: {
1772 if (Dnd.HandleSelectionRequestEvent (ref xevent))
1776 sel_event = new XEvent();
1777 sel_event.SelectionEvent.type = XEventName.SelectionNotify;
1778 sel_event.SelectionEvent.send_event = true;
1779 sel_event.SelectionEvent.display = DisplayHandle;
1780 sel_event.SelectionEvent.selection = xevent.SelectionRequestEvent.selection;
1781 sel_event.SelectionEvent.target = xevent.SelectionRequestEvent.target;
1782 sel_event.SelectionEvent.requestor = xevent.SelectionRequestEvent.requestor;
1783 sel_event.SelectionEvent.time = xevent.SelectionRequestEvent.time;
1784 sel_event.SelectionEvent.property = IntPtr.Zero;
1786 IntPtr format_atom = xevent.SelectionRequestEvent.target;
1788 // Seems that some apps support asking for supported types
1789 if (format_atom == TARGETS) {
1796 if (Clipboard.IsSourceText) {
1797 atoms[atom_count++] = (int)Atom.XA_STRING;
1798 atoms[atom_count++] = (int)OEMTEXT;
1799 atoms[atom_count++] = (int)UTF8_STRING;
1800 atoms[atom_count++] = (int)UTF16_STRING;
1801 atoms[atom_count++] = (int)RICHTEXTFORMAT;
1802 } else if (Clipboard.IsSourceImage) {
1803 atoms[atom_count++] = (int)Atom.XA_PIXMAP;
1804 atoms[atom_count++] = (int)Atom.XA_BITMAP;
1806 // FIXME - handle other types
1809 XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property,
1810 (IntPtr)xevent.SelectionRequestEvent.target, 32, PropertyMode.Replace, atoms, atom_count);
1811 sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1812 } else if (format_atom == (IntPtr)RICHTEXTFORMAT) {
1813 string rtf_text = Clipboard.GetRtfText ();
1814 if (rtf_text != null) {
1815 // The RTF spec mentions that ascii is enough to contain it
1816 Byte [] bytes = Encoding.ASCII.GetBytes (rtf_text);
1817 int buflen = bytes.Length;
1818 IntPtr buffer = Marshal.AllocHGlobal (buflen);
1820 for (int i = 0; i < buflen; i++)
1821 Marshal.WriteByte (buffer, i, bytes[i]);
1823 XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property,
1824 (IntPtr)xevent.SelectionRequestEvent.target, 8, PropertyMode.Replace, buffer, buflen);
1825 sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1826 Marshal.FreeHGlobal(buffer);
1828 } else if (Clipboard.IsSourceText &&
1829 (format_atom == (IntPtr)Atom.XA_STRING
1830 || format_atom == OEMTEXT
1831 || format_atom == UTF16_STRING
1832 || format_atom == UTF8_STRING)) {
1833 IntPtr buffer = IntPtr.Zero;
1835 Encoding encoding = null;
1839 // Select an encoding depending on the target
1840 IntPtr target_atom = xevent.SelectionRequestEvent.target;
1841 if (target_atom == (IntPtr)Atom.XA_STRING || target_atom == OEMTEXT)
1842 // FIXME - EOMTEXT should encode into ISO2022
1843 encoding = Encoding.ASCII;
1844 else if (target_atom == UTF16_STRING)
1845 encoding = Encoding.Unicode;
1846 else if (target_atom == UTF8_STRING)
1847 encoding = Encoding.UTF8;
1851 bytes = encoding.GetBytes (Clipboard.GetPlainText ());
1852 buffer = Marshal.AllocHGlobal (bytes.Length);
1853 buflen = bytes.Length;
1855 for (int i = 0; i < buflen; i++)
1856 Marshal.WriteByte (buffer, i, bytes [i]);
1858 if (buffer != IntPtr.Zero) {
1859 XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, (IntPtr)xevent.SelectionRequestEvent.target, 8, PropertyMode.Replace, buffer, buflen);
1860 sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1861 Marshal.FreeHGlobal(buffer);
1863 } else if (Clipboard.GetSource (format_atom.ToInt32 ()) != null) { // check if we have an available value of this format
1864 if (DataFormats.GetFormat (format_atom.ToInt32 ()).is_serializable) {
1865 object serializable = Clipboard.GetSource (format_atom.ToInt32 ());
1867 BinaryFormatter formatter = new BinaryFormatter ();
1868 MemoryStream memory_stream = new MemoryStream ();
1869 formatter.Serialize (memory_stream, serializable);
1871 int buflen = (int)memory_stream.Length;
1872 IntPtr buffer = Marshal.AllocHGlobal (buflen);
1873 memory_stream.Position = 0;
1874 for (int i = 0; i < buflen; i++)
1875 Marshal.WriteByte (buffer, i, (byte)memory_stream.ReadByte ());
1876 memory_stream.Close ();
1878 XChangeProperty (DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, (IntPtr)xevent.SelectionRequestEvent.target,
1879 8, PropertyMode.Replace, buffer, buflen);
1880 sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property;
1881 Marshal.FreeHGlobal (buffer);
1884 } else if (Clipboard.IsSourceImage) {
1885 if (xevent.SelectionEvent.target == (IntPtr)Atom.XA_PIXMAP) {
1886 // FIXME - convert image and store as property
1887 } else if (xevent.SelectionEvent.target == (IntPtr)Atom.XA_PIXMAP) {
1888 // FIXME - convert image and store as property
1892 XSendEvent(DisplayHandle, xevent.SelectionRequestEvent.requestor, false, new IntPtr ((int)EventMask.NoEventMask), ref sel_event);
1896 case XEventName.SelectionNotify: {
1897 if (Clipboard.Enumerating) {
1898 Clipboard.Enumerating = false;
1899 if (xevent.SelectionEvent.property != IntPtr.Zero) {
1900 XDeleteProperty(DisplayHandle, FosterParent, (IntPtr)xevent.SelectionEvent.property);
1901 if (!Clipboard.Formats.Contains(xevent.SelectionEvent.property)) {
1902 Clipboard.Formats.Add(xevent.SelectionEvent.property);
1903 DriverDebug("Got supported clipboard atom format: {0}", xevent.SelectionEvent.property);
1906 } else if (Clipboard.Retrieving) {
1907 Clipboard.Retrieving = false;
1908 if (xevent.SelectionEvent.property != IntPtr.Zero) {
1909 TranslatePropertyToClipboard(xevent.SelectionEvent.property);
1911 Clipboard.ClearSources ();
1912 Clipboard.Item = null;
1915 Dnd.HandleSelectionNotifyEvent (ref xevent);
1920 case XEventName.KeyRelease:
1921 if (!detectable_key_auto_repeat && XPending (DisplayHandle) != 0) {
1922 XEvent nextevent = new XEvent ();
1924 XPeekEvent (DisplayHandle, ref nextevent);
1926 if (nextevent.type == XEventName.KeyPress &&
1927 nextevent.KeyEvent.keycode == xevent.KeyEvent.keycode &&
1928 nextevent.KeyEvent.time == xevent.KeyEvent.time) {
1932 goto case XEventName.KeyPress;
1934 case XEventName.MotionNotify: {
1937 /* we can't do motion compression across threads, so just punt if we don't match up */
1938 if (Thread.CurrentThread == hwnd.Queue.Thread && hwnd.Queue.Count > 0) {
1939 peek = hwnd.Queue.Peek();
1940 if (peek.AnyEvent.type == XEventName.MotionNotify) {
1944 goto case XEventName.KeyPress;
1947 case XEventName.KeyPress:
1948 hwnd.Queue.EnqueueLocked (xevent);
1949 /* Process KeyPresses immediately. Otherwise multiple Compose messages as a result of a
1950 * single physical keypress are not processed correctly */
1952 case XEventName.ButtonPress:
1953 case XEventName.ButtonRelease:
1954 case XEventName.EnterNotify:
1955 case XEventName.LeaveNotify:
1956 case XEventName.CreateNotify:
1957 case XEventName.DestroyNotify:
1958 case XEventName.FocusIn:
1959 case XEventName.FocusOut:
1960 case XEventName.ClientMessage:
1961 case XEventName.ReparentNotify:
1962 case XEventName.MapNotify:
1963 case XEventName.UnmapNotify:
1964 hwnd.Queue.EnqueueLocked (xevent);
1967 case XEventName.ConfigureNotify:
1968 AddConfigureNotify(xevent);
1971 case XEventName.PropertyNotify:
1972 DriverDebug ("UpdateMessageQueue (), got Event: {0}", xevent.ToString ());
1973 if (xevent.PropertyEvent.atom == _NET_ACTIVE_WINDOW) {
1978 IntPtr prop = IntPtr.Zero;
1981 prev_active = ActiveWindow;
1982 XGetWindowProperty(DisplayHandle, RootWindow, _NET_ACTIVE_WINDOW, IntPtr.Zero, new IntPtr (1), false, (IntPtr)Atom.XA_WINDOW, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
1983 if (((long)nitems > 0) && (prop != IntPtr.Zero)) {
1984 ActiveWindow = Hwnd.GetHandleFromWindow((IntPtr)Marshal.ReadInt32(prop));
1987 DebugHelper.WriteLine ("PropertyNotify: _NET_ACTIVE_WINDOW: previous = 0x{0:x}, new = 0x{1:x}", prev_active.ToInt32 (), ActiveWindow.ToInt32 ());
1989 if (prev_active != ActiveWindow) {
1990 if (prev_active != IntPtr.Zero) {
1991 PostMessage(prev_active, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero);
1993 if (ActiveWindow != IntPtr.Zero) {
1994 PostMessage(ActiveWindow, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_ACTIVE, IntPtr.Zero);
1997 if (ModalWindows.Count == 0) {
2000 // Modality Handling
2002 // If there is a modal window on the stack and the new active
2003 // window is MWF window, but not the modal one and not a non-modal
2004 // child of the modal one, switch back to the modal window.
2006 // To identify if a non-modal form is child of a modal form
2007 // we match their ApplicationContexts, which will be the same.
2008 // This is because each modal form runs the loop with a
2009 // new ApplicationContext, which is inherited by the non-modal
2012 Form activeForm = Control.FromHandle (ActiveWindow) as Form;
2013 if (activeForm != null) {
2014 Form modalForm = Control.FromHandle ((IntPtr)ModalWindows.Peek()) as Form;
2015 if (ActiveWindow != (IntPtr)ModalWindows.Peek() &&
2016 (modalForm == null || activeForm.context == modalForm.context)) {
2017 Activate((IntPtr)ModalWindows.Peek());
2024 else if (xevent.PropertyEvent.atom == _NET_WM_STATE) {
2025 // invalidate our cache - we'll query again the next time someone does GetWindowState.
2026 hwnd.cached_window_state = (FormWindowState)(-1);
2027 PostMessage (hwnd.Handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
2035 IntPtr GetMousewParam(int Delta) {
2038 if ((MouseState & MouseButtons.Left) != 0) {
2039 result |= (int)MsgButtons.MK_LBUTTON;
2042 if ((MouseState & MouseButtons.Middle) != 0) {
2043 result |= (int)MsgButtons.MK_MBUTTON;
2046 if ((MouseState & MouseButtons.Right) != 0) {
2047 result |= (int)MsgButtons.MK_RBUTTON;
2050 Keys mods = ModifierKeys;
2051 if ((mods & Keys.Control) != 0) {
2052 result |= (int)MsgButtons.MK_CONTROL;
2055 if ((mods & Keys.Shift) != 0) {
2056 result |= (int)MsgButtons.MK_SHIFT;
2059 result |= Delta << 16;
2061 return (IntPtr)result;
2063 IntPtr XGetParent(IntPtr handle) {
2070 XQueryTree(DisplayHandle, handle, out Root, out Parent, out Children, out ChildCount);
2073 if (Children!=IntPtr.Zero) {
2081 int HandleError (IntPtr display, ref XErrorEvent error_event)
2083 // we need to workaround a problem with the
2084 // ordering of destruction of Drawables and
2085 // Pictures that exists between cairo and
2086 // RENDER on the server.
2087 if (error_event.request_code == (XRequest)render_major_opcode
2088 && error_event.minor_code == 7 /* X_RenderFreePicture from render.h */
2089 && error_event.error_code == render_first_error + 1 /* BadPicture from render.h */) {
2093 if (ErrorExceptions) {
2094 XUngrabPointer (display, IntPtr.Zero);
2095 throw new XException (error_event.display, error_event.resourceid,
2096 error_event.serial, error_event.error_code,
2097 error_event.request_code, error_event.minor_code);
2099 Console.WriteLine("X11 Error encountered: {0}{1}\n",
2100 XException.GetMessage (error_event.display, error_event.resourceid,
2101 error_event.serial, error_event.error_code,
2102 error_event.request_code, error_event.minor_code),
2103 Environment.StackTrace);
2108 void AccumulateDestroyedHandles (Control c, ArrayList list)
2110 DebugHelper.Enter ();
2113 Control[] controls = c.Controls.GetAllControls ();
2115 DebugHelper.WriteLine ("Checking control:0x{0:x}", c.IsHandleCreated ? c.Handle.ToInt32() : 0);
2117 if (c.IsHandleCreated && !c.IsDisposed) {
2118 Hwnd hwnd = Hwnd.ObjectFromHandle(c.Handle);
2120 DriverDebug (" + adding {0} to the list of zombie windows", XplatUI.Window (hwnd.Handle));
2121 DriverDebug (" + parent X window is {0:X}", XGetParent (hwnd.whole_window).ToInt32());
2124 CleanupCachedWindows (hwnd);
2127 for (int i = 0; i < controls.Length; i ++) {
2128 AccumulateDestroyedHandles (controls[i], list);
2131 DebugHelper.Leave ();
2134 void CleanupCachedWindows (Hwnd hwnd)
2136 if (ActiveWindow == hwnd.Handle) {
2137 SendMessage(hwnd.client_window, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero);
2138 ActiveWindow = IntPtr.Zero;
2141 if (FocusWindow == hwnd.Handle) {
2142 SendMessage(hwnd.client_window, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero);
2143 FocusWindow = IntPtr.Zero;
2146 if (Grab.Hwnd == hwnd.Handle) {
2147 Grab.Hwnd = IntPtr.Zero;
2148 Grab.Confined = false;
2151 DestroyCaret (hwnd.Handle);
2154 void PerformNCCalc(Hwnd hwnd) {
2155 XplatUIWin32.NCCALCSIZE_PARAMS ncp;
2159 rect = new Rectangle (0, 0, hwnd.Width, hwnd.Height);
2161 ncp = new XplatUIWin32.NCCALCSIZE_PARAMS();
2162 ptr = Marshal.AllocHGlobal(Marshal.SizeOf(ncp));
2164 ncp.rgrc1.left = rect.Left;
2165 ncp.rgrc1.top = rect.Top;
2166 ncp.rgrc1.right = rect.Right;
2167 ncp.rgrc1.bottom = rect.Bottom;
2169 Marshal.StructureToPtr(ncp, ptr, true);
2170 NativeWindow.WndProc(hwnd.client_window, Msg.WM_NCCALCSIZE, (IntPtr)1, ptr);
2171 ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure(ptr, typeof(XplatUIWin32.NCCALCSIZE_PARAMS));
2172 Marshal.FreeHGlobal(ptr);
2175 rect = new Rectangle(ncp.rgrc1.left, ncp.rgrc1.top, ncp.rgrc1.right - ncp.rgrc1.left, ncp.rgrc1.bottom - ncp.rgrc1.top);
2176 hwnd.ClientRect = rect;
2178 rect = TranslateClientRectangleToXClientRectangle (hwnd);
2181 MoveResizeWindow (DisplayHandle, hwnd.client_window, rect.X, rect.Y, rect.Width, rect.Height);
2184 AddExpose (hwnd, hwnd.WholeWindow == hwnd.ClientWindow, 0, 0, hwnd.Width, hwnd.Height);
2186 #endregion // Methods
2189 void MouseHover(object sender, EventArgs e) {
2193 HoverState.Timer.Enabled = false;
2195 if (HoverState.Window != IntPtr.Zero) {
2196 hwnd = Hwnd.GetObjectFromWindow(HoverState.Window);
2198 xevent = new XEvent ();
2200 xevent.type = XEventName.ClientMessage;
2201 xevent.ClientMessageEvent.display = DisplayHandle;
2202 xevent.ClientMessageEvent.window = HoverState.Window;
2203 xevent.ClientMessageEvent.message_type = HoverState.Atom;
2204 xevent.ClientMessageEvent.format = 32;
2205 xevent.ClientMessageEvent.ptr1 = (IntPtr) (HoverState.Y << 16 | HoverState.X);
2207 hwnd.Queue.EnqueueLocked (xevent);
2214 void CaretCallback(object sender, EventArgs e) {
2218 Caret.On = !Caret.On;
2220 XDrawLine(DisplayHandle, Caret.Hwnd, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height);
2222 #endregion // Callbacks
2224 #region Public Properties
2226 internal override int CaptionHeight {
2232 internal override Size CursorSize {
2237 if (XQueryBestCursor(DisplayHandle, RootWindow, 32, 32, out x, out y) != 0) {
2238 return new Size(x, y);
2240 return new Size(16, 16);
2245 internal override bool DragFullWindows {
2251 internal override Size DragSize {
2253 return new Size(4, 4);
2257 internal override Size FrameBorderSize {
2259 return new Size (4, 4);
2263 internal override Size IconSize {
2269 if (XGetIconSizes(DisplayHandle, RootWindow, out list, out count) != 0) {
2273 current = (long)list;
2276 size = new XIconSize();
2278 for (int i = 0; i < count; i++) {
2279 size = (XIconSize)Marshal.PtrToStructure((IntPtr)current, size.GetType());
2280 current += Marshal.SizeOf(size);
2282 // Look for our preferred size
2283 if (size.min_width == 32) {
2285 return new Size(32, 32);
2288 if (size.max_width == 32) {
2290 return new Size(32, 32);
2293 if (size.min_width < 32 && size.max_width > 32) {
2296 // check if we can fit one
2298 while (x < size.max_width) {
2299 x += size.width_inc;
2302 return new Size(32, 32);
2307 if (largest < size.max_width) {
2308 largest = size.max_width;
2312 // We didn't find a match or we wouldn't be here
2313 return new Size(largest, largest);
2316 return new Size(32, 32);
2321 internal override int KeyboardSpeed {
2324 // A lot harder: need to do:
2325 // XkbQueryExtension(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58) = 1
2326 // XkbAllocKeyboard(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58) = 0x080517a8
2327 // XkbGetControls(0x08051008, 1, 0x080517a8, 0xbfffdf54, 0xbfffdf58) = 0
2329 // And from that we can tell the repetition rate
2331 // Notice, the values must map to:
2332 // [0, 31] which maps to 2.5 to 30 repetitions per second.
2338 internal override int KeyboardDelay {
2341 // Return values must range from 0 to 4, 0 meaning 250ms,
2342 // and 4 meaning 1000 ms.
2344 return 1; // ie, 500 ms
2348 internal override Size MaxWindowTrackSize {
2350 return new Size (WorkingArea.Width, WorkingArea.Height);
2354 internal override bool MenuAccessKeysUnderlined {
2360 internal override Size MinimizedWindowSpacingSize {
2362 return new Size(1, 1);
2366 internal override Size MinimumWindowSize {
2368 return new Size(110, 22);
2372 internal override Size MinimumFixedToolWindowSize {
2373 get { return new Size (27, 22); }
2376 internal override Size MinimumSizeableToolWindowSize {
2377 get { return new Size (37, 22); }
2380 internal override Size MinimumNoBorderWindowSize {
2381 get { return new Size (2, 2); }
2384 internal override Keys ModifierKeys {
2386 return Keyboard.ModifierKeys;
2390 internal override Size SmallIconSize {
2396 if (XGetIconSizes(DisplayHandle, RootWindow, out list, out count) != 0) {
2400 current = (long)list;
2403 size = new XIconSize();
2405 for (int i = 0; i < count; i++) {
2406 size = (XIconSize)Marshal.PtrToStructure((IntPtr)current, size.GetType());
2407 current += Marshal.SizeOf(size);
2409 // Look for our preferred size
2410 if (size.min_width == 16) {
2412 return new Size(16, 16);
2415 if (size.max_width == 16) {
2417 return new Size(16, 16);
2420 if (size.min_width < 16 && size.max_width > 16) {
2423 // check if we can fit one
2425 while (x < size.max_width) {
2426 x += size.width_inc;
2429 return new Size(16, 16);
2434 if (smallest == 0 || smallest > size.min_width) {
2435 smallest = size.min_width;
2439 // We didn't find a match or we wouldn't be here
2440 return new Size(smallest, smallest);
2443 return new Size(16, 16);
2448 internal override int MouseButtonCount {
2454 internal override bool MouseButtonsSwapped {
2456 return false; // FIXME - how to detect?
2460 internal override Point MousePosition {
2462 return mouse_position;
2466 internal override Size MouseHoverSize {
2468 return new Size (1, 1);
2472 internal override int MouseHoverTime {
2474 return HoverState.Interval;
2480 internal override bool MouseWheelPresent {
2482 return true; // FIXME - how to detect?
2486 internal override MouseButtons MouseButtons {
2492 internal override Rectangle VirtualScreen {
2498 IntPtr prop = IntPtr.Zero;
2502 XGetWindowProperty(DisplayHandle, RootWindow, _NET_DESKTOP_GEOMETRY, IntPtr.Zero, new IntPtr (256), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
2503 if ((long)nitems < 2)
2506 width = Marshal.ReadIntPtr(prop, 0).ToInt32();
2507 height = Marshal.ReadIntPtr(prop, IntPtr.Size).ToInt32();
2511 return new Rectangle(0, 0, width, height);
2514 XWindowAttributes attributes=new XWindowAttributes();
2517 XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes);
2520 return new Rectangle(0, 0, attributes.width, attributes.height);
2524 internal override Rectangle WorkingArea {
2530 IntPtr prop = IntPtr.Zero;
2533 int current_desktop;
2537 XGetWindowProperty(DisplayHandle, RootWindow, _NET_CURRENT_DESKTOP, IntPtr.Zero, new IntPtr(1), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
2538 if ((long)nitems < 1) {
2542 current_desktop = Marshal.ReadIntPtr(prop, 0).ToInt32();
2545 XGetWindowProperty(DisplayHandle, RootWindow, _NET_WORKAREA, IntPtr.Zero, new IntPtr (256), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
2546 if ((long)nitems < 4 * (current_desktop + 1)) {
2550 x = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop).ToInt32();
2551 y = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size).ToInt32();
2552 width = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size * 2).ToInt32();
2553 height = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size * 3).ToInt32();
2556 return new Rectangle(x, y, width, height);
2559 XWindowAttributes attributes=new XWindowAttributes();
2562 XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes);
2565 return new Rectangle(0, 0, attributes.width, attributes.height);
2569 internal override bool ThemesEnabled {
2571 return XplatUIX11.themes_enabled;
2576 #endregion // Public properties
2578 #region Public Static Methods
2579 internal override void RaiseIdle (EventArgs e)
2585 internal override IntPtr InitializeDriver()
2588 if (DisplayHandle==IntPtr.Zero) {
2589 SetDisplay(XOpenDisplay(IntPtr.Zero));
2595 internal override void ShutdownDriver(IntPtr token)
2598 if (DisplayHandle!=IntPtr.Zero) {
2599 XCloseDisplay(DisplayHandle);
2600 DisplayHandle=IntPtr.Zero;
2605 internal override void EnableThemes()
2607 themes_enabled = true;
2611 internal override void Activate(IntPtr handle)
2615 hwnd = Hwnd.ObjectFromHandle(handle);
2619 if (true /* the window manager supports NET_ACTIVE_WINDOW */) {
2620 SendNetWMMessage(hwnd.whole_window, _NET_ACTIVE_WINDOW, (IntPtr)1, IntPtr.Zero, IntPtr.Zero);
2621 XEventQueue q = null;
2622 lock (unattached_timer_list) {
2623 foreach (Timer t in unattached_timer_list) {
2625 q= (XEventQueue) MessageQueues [Thread.CurrentThread];
2626 t.thread = q.Thread;
2627 q.timer_list.Add (t);
2629 unattached_timer_list.Clear ();
2633 // XRaiseWindow(DisplayHandle, handle);
2639 internal override void AudibleAlert(AlertType alert)
2641 XBell(DisplayHandle, 0);
2646 internal override void CaretVisible(IntPtr handle, bool visible)
2648 if (Caret.Hwnd == handle) {
2650 if (!Caret.Visible) {
2651 Caret.Visible = true;
2653 Caret.Timer.Start();
2656 Caret.Visible = false;
2663 internal override bool CalculateWindowRect(ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect)
2665 WindowRect = Hwnd.GetWindowRectangle (cp, menu, ClientRect);
2669 internal override void ClientToScreen(IntPtr handle, ref int x, ref int y)
2676 hwnd = Hwnd.ObjectFromHandle(handle);
2679 XTranslateCoordinates(DisplayHandle, hwnd.client_window, RootWindow, x, y, out dest_x_return, out dest_y_return, out child);
2686 internal override int[] ClipboardAvailableFormats(IntPtr handle)
2688 DataFormats.Format f;
2691 f = DataFormats.Format.List;
2693 if (XGetSelectionOwner(DisplayHandle, CLIPBOARD) == IntPtr.Zero) {
2697 Clipboard.Formats = new ArrayList();
2700 XConvertSelection(DisplayHandle, CLIPBOARD, (IntPtr)f.Id, (IntPtr)f.Id, FosterParent, IntPtr.Zero);
2702 Clipboard.Enumerating = true;
2703 while (Clipboard.Enumerating) {
2704 UpdateMessageQueue(null, false);
2709 result = new int[Clipboard.Formats.Count];
2711 for (int i = 0; i < Clipboard.Formats.Count; i++) {
2712 result[i] = ((IntPtr)Clipboard.Formats[i]).ToInt32 ();
2715 Clipboard.Formats = null;
2719 internal override void ClipboardClose(IntPtr handle)
2721 if (handle != ClipMagic) {
2722 throw new ArgumentException("handle is not a valid clipboard handle");
2727 internal override int ClipboardGetID(IntPtr handle, string format)
2729 if (handle != ClipMagic) {
2730 throw new ArgumentException("handle is not a valid clipboard handle");
2733 if (format == "Text" ) return (int)Atom.XA_STRING;
2734 else if (format == "Bitmap" ) return (int)Atom.XA_BITMAP;
2735 //else if (format == "MetaFilePict" ) return 3;
2736 //else if (format == "SymbolicLink" ) return 4;
2737 //else if (format == "DataInterchangeFormat" ) return 5;
2738 //else if (format == "Tiff" ) return 6;
2739 else if (format == "OEMText" ) return OEMTEXT.ToInt32();
2740 else if (format == "DeviceIndependentBitmap" ) return (int)Atom.XA_PIXMAP;
2741 else if (format == "Palette" ) return (int)Atom.XA_COLORMAP; // Useless
2742 //else if (format == "PenData" ) return 10;
2743 //else if (format == "RiffAudio" ) return 11;
2744 //else if (format == "WaveAudio" ) return 12;
2745 else if (format == "UnicodeText" ) return UTF16_STRING.ToInt32();
2746 //else if (format == "EnhancedMetafile" ) return 14;
2747 //else if (format == "FileDrop" ) return 15;
2748 //else if (format == "Locale" ) return 16;
2749 else if (format == "Rich Text Format") return RICHTEXTFORMAT.ToInt32 ();
2751 return XInternAtom(DisplayHandle, format, false).ToInt32();
2754 internal override IntPtr ClipboardOpen(bool primary_selection)
2756 if (!primary_selection)
2757 ClipMagic = CLIPBOARD;
2759 ClipMagic = PRIMARY;
2763 internal override object ClipboardRetrieve(IntPtr handle, int type, XplatUI.ClipboardToObject converter)
2765 XConvertSelection(DisplayHandle, handle, (IntPtr)type, (IntPtr)type, FosterParent, IntPtr.Zero);
2767 Clipboard.Retrieving = true;
2768 while (Clipboard.Retrieving) {
2769 UpdateMessageQueue(null, false);
2772 return Clipboard.Item;
2775 internal override void ClipboardStore(IntPtr handle, object obj, int type, XplatUI.ObjectToClipboard converter)
2777 Clipboard.Converter = converter;
2780 Clipboard.AddSource (type, obj);
2781 XSetSelectionOwner(DisplayHandle, CLIPBOARD, FosterParent, IntPtr.Zero);
2783 // Clearing the selection
2784 Clipboard.ClearSources ();
2785 XSetSelectionOwner(DisplayHandle, CLIPBOARD, IntPtr.Zero, IntPtr.Zero);
2789 internal override void CreateCaret (IntPtr handle, int width, int height)
2791 XGCValues gc_values;
2794 hwnd = Hwnd.ObjectFromHandle(handle);
2796 if (Caret.Hwnd != IntPtr.Zero) {
2797 DestroyCaret(Caret.Hwnd);
2800 Caret.Hwnd = handle;
2801 Caret.Window = hwnd.client_window;
2802 Caret.Width = width;
2803 Caret.Height = height;
2804 Caret.Visible = false;
2807 gc_values = new XGCValues();
2808 gc_values.line_width = width;
2810 Caret.gc = XCreateGC(DisplayHandle, Caret.Window, new IntPtr ((int)GCFunction.GCLineWidth), ref gc_values);
2811 if (Caret.gc == IntPtr.Zero) {
2812 Caret.Hwnd = IntPtr.Zero;
2816 XSetFunction(DisplayHandle, Caret.gc, GXFunction.GXinvert);
2819 internal override IntPtr CreateWindow (CreateParams cp)
2821 XSetWindowAttributes Attributes;
2823 Hwnd parent_hwnd = null;
2828 IntPtr ParentHandle;
2830 IntPtr ClientWindow;
2831 SetWindowValuemask ValueMask;
2836 Attributes = new XSetWindowAttributes();
2842 if (Width<1) Width=1;
2843 if (Height<1) Height=1;
2845 if (cp.Parent != IntPtr.Zero) {
2846 parent_hwnd = Hwnd.ObjectFromHandle(cp.Parent);
2847 ParentHandle = parent_hwnd.client_window;
2849 if (StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
2850 // We need to use our foster parent window until this poor child gets it's parent assigned
2851 ParentHandle=FosterParent;
2853 ParentHandle=RootWindow;
2857 // Set the default location location for forms.
2859 if (cp.control is Form) {
2860 next = Hwnd.GetNextStackedFormLocation (cp, parent_hwnd);
2864 ValueMask = SetWindowValuemask.BitGravity | SetWindowValuemask.WinGravity;
2866 Attributes.bit_gravity = Gravity.NorthWestGravity;
2867 Attributes.win_gravity = Gravity.NorthWestGravity;
2869 // Save what's under the toolwindow
2870 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) {
2871 Attributes.save_under = true;
2872 ValueMask |= SetWindowValuemask.SaveUnder;
2876 // If we're a popup without caption we override the WM
2877 if (StyleSet (cp.Style, WindowStyles.WS_POPUP) && !StyleSet (cp.Style, WindowStyles.WS_CAPTION)) {
2878 Attributes.override_redirect = true;
2879 ValueMask |= SetWindowValuemask.OverrideRedirect;
2885 hwnd.height = Height;
2886 hwnd.parent = Hwnd.ObjectFromHandle(cp.Parent);
2887 hwnd.initial_style = cp.WindowStyle;
2888 hwnd.initial_ex_style = cp.WindowExStyle;
2890 if (StyleSet (cp.Style, WindowStyles.WS_DISABLED)) {
2891 hwnd.enabled = false;
2894 ClientWindow = IntPtr.Zero;
2896 Size XWindowSize = TranslateWindowSizeToXWindowSize (cp);
2897 Rectangle XClientRect = TranslateClientRectangleToXClientRectangle (hwnd, cp.control);
2900 WholeWindow = XCreateWindow(DisplayHandle, ParentHandle, X, Y, XWindowSize.Width, XWindowSize.Height, 0, (int)CreateWindowArgs.CopyFromParent, (int)CreateWindowArgs.InputOutput, IntPtr.Zero, new UIntPtr ((uint)ValueMask), ref Attributes);
2901 if (WholeWindow != IntPtr.Zero) {
2902 ValueMask &= ~(SetWindowValuemask.OverrideRedirect | SetWindowValuemask.SaveUnder);
2904 if (CustomVisual != IntPtr.Zero && CustomColormap != IntPtr.Zero) {
2905 ValueMask = SetWindowValuemask.ColorMap;
2906 Attributes.colormap = CustomColormap;
2908 ClientWindow = XCreateWindow(DisplayHandle, WholeWindow, XClientRect.X, XClientRect.Y, XClientRect.Width, XClientRect.Height, 0, (int)CreateWindowArgs.CopyFromParent, (int)CreateWindowArgs.InputOutput, CustomVisual, new UIntPtr ((uint)ValueMask), ref Attributes);
2912 if ((WholeWindow == IntPtr.Zero) || (ClientWindow == IntPtr.Zero)) {
2913 throw new Exception("Could not create X11 windows");
2916 hwnd.Queue = ThreadQueue(Thread.CurrentThread);
2917 hwnd.WholeWindow = WholeWindow;
2918 hwnd.ClientWindow = ClientWindow;
2920 DriverDebug("Created window {0:X} / {1:X} parent {2:X}, Style {3}, ExStyle {4}", ClientWindow.ToInt32(), WholeWindow.ToInt32(), hwnd.parent != null ? hwnd.parent.Handle.ToInt32() : 0, (WindowStyles)cp.Style, (WindowExStyles)cp.ExStyle);
2922 if (!StyleSet (cp.Style, WindowStyles.WS_CHILD)) {
2923 if ((X != unchecked((int)0x80000000)) && (Y != unchecked((int)0x80000000))) {
2926 hints = new XSizeHints();
2929 hints.flags = (IntPtr)(XSizeHintsFlags.USPosition | XSizeHintsFlags.PPosition);
2930 XSetWMNormalHints(DisplayHandle, WholeWindow, ref hints);
2935 XSelectInput(DisplayHandle, hwnd.whole_window, new IntPtr ((int)(SelectInputMask | EventMask.StructureNotifyMask | EventMask.PropertyChangeMask | Keyboard.KeyEventMask)));
2936 if (hwnd.whole_window != hwnd.client_window)
2937 XSelectInput(DisplayHandle, hwnd.client_window, new IntPtr ((int)(SelectInputMask | EventMask.StructureNotifyMask | Keyboard.KeyEventMask)));
2940 if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOPMOST)) {
2942 atoms[0] = _NET_WM_WINDOW_TYPE_NORMAL.ToInt32();
2943 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
2945 XSetTransientForHint (DisplayHandle, hwnd.whole_window, RootWindow);
2948 SetWMStyles(hwnd, cp);
2950 // set the group leader
2951 XWMHints wm_hints = new XWMHints ();
2953 wm_hints.flags = (IntPtr)(XWMHintsFlags.InputHint | XWMHintsFlags.StateHint | XWMHintsFlags.WindowGroupHint);
2954 wm_hints.input = !StyleSet (cp.Style, WindowStyles.WS_DISABLED);
2955 wm_hints.initial_state = StyleSet (cp.Style, WindowStyles.WS_MINIMIZE) ? XInitialState.IconicState : XInitialState.NormalState;
2957 if (ParentHandle != RootWindow) {
2958 wm_hints.window_group = hwnd.whole_window;
2960 wm_hints.window_group = ParentHandle;
2964 XSetWMHints(DisplayHandle, hwnd.whole_window, ref wm_hints );
2967 if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZE)) {
2968 SetWindowState(hwnd.Handle, FormWindowState.Minimized);
2969 } else if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZE)) {
2970 SetWindowState(hwnd.Handle, FormWindowState.Maximized);
2973 // for now make all windows dnd enabled
2974 Dnd.SetAllowDrop (hwnd, true);
2976 // Set caption/window title
2977 Text(hwnd.Handle, cp.Caption);
2979 SendMessage (hwnd.Handle, Msg.WM_CREATE, (IntPtr)1, IntPtr.Zero /* XXX unused */);
2980 SendParentNotify (hwnd.Handle, Msg.WM_CREATE, int.MaxValue, int.MaxValue);
2982 if (StyleSet (cp.Style, WindowStyles.WS_VISIBLE)) {
2983 hwnd.visible = true;
2984 MapWindow(hwnd, WindowType.Both);
2985 if (!(Control.FromHandle(hwnd.Handle) is Form))
2986 SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero);
2992 internal override IntPtr CreateWindow(IntPtr Parent, int X, int Y, int Width, int Height)
2994 CreateParams create_params = new CreateParams();
2996 create_params.Caption = "";
2997 create_params.X = X;
2998 create_params.Y = Y;
2999 create_params.Width = Width;
3000 create_params.Height = Height;
3002 create_params.ClassName=XplatUI.GetDefaultClassName (GetType ());
3003 create_params.ClassStyle = 0;
3004 create_params.ExStyle=0;
3005 create_params.Parent=IntPtr.Zero;
3006 create_params.Param=0;
3008 return CreateWindow(create_params);
3011 internal override IntPtr DefineCursor(Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot)
3014 Bitmap cursor_bitmap;
3022 IntPtr cursor_pixmap;
3029 if (XQueryBestCursor(DisplayHandle, RootWindow, bitmap.Width, bitmap.Height, out width, out height) == 0) {
3033 // Win32 only allows creation cursors of a certain size
3034 if ((bitmap.Width != width) || (bitmap.Width != height)) {
3035 cursor_bitmap = new Bitmap(bitmap, new Size(width, height));
3036 cursor_mask = new Bitmap(mask, new Size(width, height));
3038 cursor_bitmap = bitmap;
3042 width = cursor_bitmap.Width;
3043 height = cursor_bitmap.Height;
3045 cursor_bits = new Byte[(width / 8) * height];
3046 mask_bits = new Byte[(width / 8) * height];
3048 for (int y = 0; y < height; y++) {
3049 for (int x = 0; x < width; x++) {
3050 c_pixel = cursor_bitmap.GetPixel(x, y);
3051 m_pixel = cursor_mask.GetPixel(x, y);
3053 and = c_pixel == cursor_pixel;
3054 xor = m_pixel == mask_pixel;
3058 // cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8))); // The bit already is 0
3059 mask_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8));
3060 } else if (and && !xor) {
3062 cursor_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8));
3063 mask_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8));
3065 } else if (and && !xor) {
3067 } else if (and && xor) {
3070 // X11 doesn't know the 'reverse screen' concept, so we'll treat them the same
3071 // we want both to be 0 so nothing to be done
3072 //cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8)));
3073 //mask_bits[y * width / 8 + x / 8] |= (byte)(01 << (x % 8));
3079 cursor_pixmap = XCreatePixmapFromBitmapData(DisplayHandle, RootWindow, cursor_bits, width, height, (IntPtr)1, (IntPtr)0, 1);
3080 mask_pixmap = XCreatePixmapFromBitmapData(DisplayHandle, RootWindow, mask_bits, width, height, (IntPtr)1, (IntPtr)0, 1);
3084 fg.pixel = XWhitePixel(DisplayHandle, ScreenNo);
3085 fg.red = (ushort)65535;
3086 fg.green = (ushort)65535;
3087 fg.blue = (ushort)65535;
3089 bg.pixel = XBlackPixel(DisplayHandle, ScreenNo);
3091 cursor = XCreatePixmapCursor(DisplayHandle, cursor_pixmap, mask_pixmap, ref fg, ref bg, xHotSpot, yHotSpot);
3093 XFreePixmap(DisplayHandle, cursor_pixmap);
3094 XFreePixmap(DisplayHandle, mask_pixmap);
3099 internal override Bitmap DefineStdCursorBitmap (StdCursor id)
3101 CursorFontShape shape;
3108 shape = StdCursorToFontShape (id);
3109 name = shape.ToString ().Replace ("XC_", string.Empty);
3110 size = XcursorGetDefaultSize (DisplayHandle);
3111 theme = XcursorGetTheme (DisplayHandle);
3112 IntPtr images_ptr = XcursorLibraryLoadImages (name, theme, size);
3113 DriverDebug ("DefineStdCursorBitmap, id={0}, #id={1}, name{2}, size={3}, theme: {4}, images_ptr={5}", id, (int) id, name, size, Marshal.PtrToStringAnsi (theme), images_ptr);
3115 if (images_ptr == IntPtr.Zero) {
3119 XcursorImages images = (XcursorImages) Marshal.PtrToStructure (images_ptr, typeof (XcursorImages));
3120 DriverDebug ("DefineStdCursorBitmap, cursor has {0} images", images.nimage);
3122 if (images.nimage > 0) {
3123 // We only care about the first image.
3124 XcursorImage image = (XcursorImage)Marshal.PtrToStructure (Marshal.ReadIntPtr (images.images), typeof (XcursorImage));
3126 DriverDebug ("DefineStdCursorBitmap, loaded image <size={0}, height={1}, width={2}, xhot={3}, yhot={4}, pixels={5}", image.size, image.height, image.width, image.xhot, image.yhot, image.pixels);
3128 if (image.width <= short.MaxValue && image.height <= short.MaxValue) {
3129 int [] pixels = new int [image.width * image.height];
3130 Marshal.Copy (image.pixels, pixels, 0, pixels.Length);
3131 bmp = new Bitmap (image.width, image.height);
3132 for (int w = 0; w < image.width; w++) {
3133 for (int h = 0; h < image.height; h++) {
3134 bmp.SetPixel (w, h, Color.FromArgb (pixels [h * image.width + w]));
3140 XcursorImagesDestroy (images_ptr);
3142 } catch (DllNotFoundException ex) {
3143 Console.WriteLine ("Could not load libXcursor: " + ex.Message + " (" + ex.GetType ().Name + ")");
3151 internal override IntPtr DefineStdCursor(StdCursor id)
3153 CursorFontShape shape;
3156 shape = StdCursorToFontShape (id);
3159 cursor = XCreateFontCursor(DisplayHandle, shape);
3164 internal static CursorFontShape StdCursorToFontShape (StdCursor id)
3166 CursorFontShape shape;
3167 // FIXME - define missing shapes
3170 case StdCursor.AppStarting: {
3171 shape = CursorFontShape.XC_watch;
3175 case StdCursor.Arrow: {
3176 shape = CursorFontShape.XC_top_left_arrow;
3180 case StdCursor.Cross: {
3181 shape = CursorFontShape.XC_crosshair;
3185 case StdCursor.Default: {
3186 shape = CursorFontShape.XC_top_left_arrow;
3190 case StdCursor.Hand: {
3191 shape = CursorFontShape.XC_hand1;
3195 case StdCursor.Help: {
3196 shape = CursorFontShape.XC_question_arrow;
3200 case StdCursor.HSplit: {
3201 shape = CursorFontShape.XC_sb_v_double_arrow;
3205 case StdCursor.IBeam: {
3206 shape = CursorFontShape.XC_xterm;
3210 case StdCursor.No: {
3211 shape = CursorFontShape.XC_circle;
3215 case StdCursor.NoMove2D: {
3216 shape = CursorFontShape.XC_fleur;
3220 case StdCursor.NoMoveHoriz: {
3221 shape = CursorFontShape.XC_fleur;
3225 case StdCursor.NoMoveVert: {
3226 shape = CursorFontShape.XC_fleur;
3230 case StdCursor.PanEast: {
3231 shape = CursorFontShape.XC_fleur;
3235 case StdCursor.PanNE: {
3236 shape = CursorFontShape.XC_fleur;
3240 case StdCursor.PanNorth: {
3241 shape = CursorFontShape.XC_fleur;
3245 case StdCursor.PanNW: {
3246 shape = CursorFontShape.XC_fleur;
3250 case StdCursor.PanSE: {
3251 shape = CursorFontShape.XC_fleur;
3255 case StdCursor.PanSouth: {
3256 shape = CursorFontShape.XC_fleur;
3260 case StdCursor.PanSW: {
3261 shape = CursorFontShape.XC_fleur;
3265 case StdCursor.PanWest: {
3266 shape = CursorFontShape.XC_sizing;
3270 case StdCursor.SizeAll: {
3271 shape = CursorFontShape.XC_fleur;
3275 case StdCursor.SizeNESW: {
3276 shape = CursorFontShape.XC_top_right_corner;
3280 case StdCursor.SizeNS: {
3281 shape = CursorFontShape.XC_sb_v_double_arrow;
3285 case StdCursor.SizeNWSE: {
3286 shape = CursorFontShape.XC_top_left_corner;
3290 case StdCursor.SizeWE: {
3291 shape = CursorFontShape.XC_sb_h_double_arrow;
3295 case StdCursor.UpArrow: {
3296 shape = CursorFontShape.XC_center_ptr;
3300 case StdCursor.VSplit: {
3301 shape = CursorFontShape.XC_sb_h_double_arrow;
3305 case StdCursor.WaitCursor: {
3306 shape = CursorFontShape.XC_watch;
3311 shape = (CursorFontShape) 0;
3319 internal override IntPtr DefWndProc(ref Message msg)
3321 switch ((Msg)msg.Msg) {
3323 case Msg.WM_IME_COMPOSITION:
3324 string s = Keyboard.GetCompositionString ();
3325 foreach (char c in s)
3326 SendMessage (msg.HWnd, Msg.WM_IME_CHAR, (IntPtr) c, msg.LParam);
3329 case Msg.WM_IME_CHAR:
3330 // On Windows API it sends two WM_CHAR messages for each byte, but
3331 // I wonder if it is worthy to emulate it (also no idea how to
3332 // reconstruct those bytes into chars).
3333 SendMessage (msg.HWnd, Msg.WM_CHAR, msg.WParam, msg.LParam);
3336 case Msg.WM_PAINT: {
3339 hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3341 hwnd.expose_pending = false;
3347 case Msg.WM_NCPAINT: {
3350 hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3352 hwnd.nc_expose_pending = false;
3358 case Msg.WM_NCCALCSIZE: {
3361 if (msg.WParam == (IntPtr)1) {
3362 hwnd = Hwnd.GetObjectFromWindow (msg.HWnd);
3364 XplatUIWin32.NCCALCSIZE_PARAMS ncp;
3365 ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure (msg.LParam, typeof (XplatUIWin32.NCCALCSIZE_PARAMS));
3367 // Add all the stuff X is supposed to draw.
3368 Control ctrl = Control.FromHandle (hwnd.Handle);
3371 Hwnd.Borders rect = Hwnd.GetBorders (ctrl.GetCreateParams (), null);
3373 ncp.rgrc1.top += rect.top;
3374 ncp.rgrc1.bottom -= rect.bottom;
3375 ncp.rgrc1.left += rect.left;
3376 ncp.rgrc1.right -= rect.right;
3378 Marshal.StructureToPtr (ncp, msg.LParam, true);
3385 case Msg.WM_CONTEXTMENU: {
3388 hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3390 if ((hwnd != null) && (hwnd.parent != null)) {
3391 SendMessage(hwnd.parent.client_window, Msg.WM_CONTEXTMENU, msg.WParam, msg.LParam);
3396 case Msg.WM_MOUSEWHEEL: {
3399 hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3401 if ((hwnd != null) && (hwnd.parent != null)) {
3402 SendMessage(hwnd.parent.client_window, Msg.WM_MOUSEWHEEL, msg.WParam, msg.LParam);
3403 if (msg.Result == IntPtr.Zero) {
3410 case Msg.WM_SETCURSOR: {
3413 hwnd = Hwnd.GetObjectFromWindow(msg.HWnd);
3415 break; // not sure how this happens, but it does
3417 // Pass to parent window first
3418 while ((hwnd.parent != null) && (msg.Result == IntPtr.Zero)) {
3420 msg.Result = NativeWindow.WndProc(hwnd.Handle, Msg.WM_SETCURSOR, msg.HWnd, msg.LParam);
3423 if (msg.Result == IntPtr.Zero) {
3426 switch((HitTest)(msg.LParam.ToInt32() & 0xffff)) {
3427 case HitTest.HTBOTTOM: handle = Cursors.SizeNS.handle; break;
3428 case HitTest.HTBORDER: handle = Cursors.SizeNS.handle; break;
3429 case HitTest.HTBOTTOMLEFT: handle = Cursors.SizeNESW.handle; break;
3430 case HitTest.HTBOTTOMRIGHT: handle = Cursors.SizeNWSE.handle; break;
3431 case HitTest.HTERROR: if ((msg.LParam.ToInt32() >> 16) == (int)Msg.WM_LBUTTONDOWN) {
3432 AudibleAlert(AlertType.Default);
3434 handle = Cursors.Default.handle;
3437 case HitTest.HTHELP: handle = Cursors.Help.handle; break;
3438 case HitTest.HTLEFT: handle = Cursors.SizeWE.handle; break;
3439 case HitTest.HTRIGHT: handle = Cursors.SizeWE.handle; break;
3440 case HitTest.HTTOP: handle = Cursors.SizeNS.handle; break;
3441 case HitTest.HTTOPLEFT: handle = Cursors.SizeNWSE.handle; break;
3442 case HitTest.HTTOPRIGHT: handle = Cursors.SizeNESW.handle; break;
3445 case HitTest.HTGROWBOX:
3446 case HitTest.HTSIZE:
3447 case HitTest.HTZOOM:
3448 case HitTest.HTVSCROLL:
3449 case HitTest.HTSYSMENU:
3450 case HitTest.HTREDUCE:
3451 case HitTest.HTNOWHERE:
3452 case HitTest.HTMAXBUTTON:
3453 case HitTest.HTMINBUTTON:
3454 case HitTest.HTMENU:
3455 case HitTest.HSCROLL:
3456 case HitTest.HTBOTTOM:
3457 case HitTest.HTCAPTION:
3458 case HitTest.HTCLIENT:
3459 case HitTest.HTCLOSE:
3461 default: handle = Cursors.Default.handle; break;
3463 SetCursor(msg.HWnd, handle);
3471 internal override void DestroyCaret(IntPtr handle)
3473 if (Caret.Hwnd == handle) {
3474 if (Caret.Visible) {
3478 if (Caret.gc != IntPtr.Zero) {
3479 XFreeGC(DisplayHandle, Caret.gc);
3480 Caret.gc = IntPtr.Zero;
3482 Caret.Hwnd = IntPtr.Zero;
3483 Caret.Visible = false;
3488 internal override void DestroyCursor(IntPtr cursor)
3491 XFreeCursor(DisplayHandle, cursor);
3495 internal override void DestroyWindow(IntPtr handle)
3498 hwnd = Hwnd.ObjectFromHandle(handle);
3500 // The window should never ever be a zombie here, since we should
3501 // wait until it's completely dead before returning from
3502 // "destroying" calls, but just in case....
3503 if (hwnd == null || hwnd.zombie) {
3504 DriverDebug ("window {0:X} already destroyed", handle.ToInt32());
3508 DriverDebug ("Destroying window {0}", XplatUI.Window(hwnd.client_window));
3510 SendParentNotify (hwnd.Handle, Msg.WM_DESTROY, int.MaxValue, int.MaxValue);
3512 CleanupCachedWindows (hwnd);
3514 ArrayList windows = new ArrayList ();
3516 AccumulateDestroyedHandles (Control.ControlNativeWindow.ControlFromHandle(hwnd.Handle), windows);
3519 foreach (Hwnd h in windows) {
3520 SendMessage (h.Handle, Msg.WM_DESTROY, IntPtr.Zero, IntPtr.Zero);
3525 if (hwnd.whole_window != IntPtr.Zero) {
3526 DriverDebug ("XDestroyWindow (whole_window = {0:X})", hwnd.whole_window.ToInt32());
3527 Keyboard.DestroyICForWindow (hwnd.whole_window);
3528 XDestroyWindow(DisplayHandle, hwnd.whole_window);
3530 else if (hwnd.client_window != IntPtr.Zero) {
3531 DriverDebug ("XDestroyWindow (client_window = {0:X})", hwnd.client_window.ToInt32());
3532 Keyboard.DestroyICForWindow (hwnd.client_window);
3533 XDestroyWindow(DisplayHandle, hwnd.client_window);
3539 internal override IntPtr DispatchMessage(ref MSG msg)
3541 return NativeWindow.WndProc(msg.hwnd, msg.message, msg.wParam, msg.lParam);
3544 IntPtr GetReversibleScreenGC (Color backColor)
3546 XGCValues gc_values;
3550 XColor xcolor = new XColor();
3551 xcolor.red = (ushort)(backColor.R * 257);
3552 xcolor.green = (ushort)(backColor.G * 257);
3553 xcolor.blue = (ushort)(backColor.B * 257);
3554 XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
3555 pixel = (uint)xcolor.pixel.ToInt32();
3558 gc_values = new XGCValues();
3560 gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors;
3561 gc_values.foreground = (IntPtr)pixel;
3563 gc = XCreateGC(DisplayHandle, RootWindow, new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCForeground)), ref gc_values);
3564 XSetForeground(DisplayHandle, gc, (UIntPtr)pixel);
3565 XSetFunction(DisplayHandle, gc, GXFunction.GXxor);
3570 IntPtr GetReversibleControlGC (Control control, int line_width)
3572 XGCValues gc_values;
3575 gc_values = new XGCValues();
3577 gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors;
3578 gc_values.line_width = line_width;
3579 gc_values.foreground = XBlackPixel(DisplayHandle, ScreenNo);
3581 // This logic will give us true rubber bands: (libsx, SANE_XOR)
3582 //mask = foreground ^ background;
3583 //XSetForeground(DisplayHandle, gc, 0xffffffff);
3584 //XSetBackground(DisplayHandle, gc, background);
3585 //XSetFunction(DisplayHandle, gc, GXxor);
3586 //XSetPlaneMask(DisplayHandle, gc, mask);
3589 gc = XCreateGC(DisplayHandle, control.Handle, new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCLineWidth | GCFunction.GCForeground)), ref gc_values);
3593 XColor xcolor = new XColor();
3595 xcolor.red = (ushort)(control.ForeColor.R * 257);
3596 xcolor.green = (ushort)(control.ForeColor.G * 257);
3597 xcolor.blue = (ushort)(control.ForeColor.B * 257);
3598 XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
3599 foreground = (uint)xcolor.pixel.ToInt32();
3601 xcolor.red = (ushort)(control.BackColor.R * 257);
3602 xcolor.green = (ushort)(control.BackColor.G * 257);
3603 xcolor.blue = (ushort)(control.BackColor.B * 257);
3604 XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
3605 background = (uint)xcolor.pixel.ToInt32();
3607 uint mask = foreground ^ background;
3609 XSetForeground(DisplayHandle, gc, (UIntPtr)0xffffffff);
3610 XSetBackground(DisplayHandle, gc, (UIntPtr)background);
3611 XSetFunction(DisplayHandle, gc, GXFunction.GXxor);
3612 XSetPlaneMask(DisplayHandle, gc, (IntPtr)mask);
3617 internal override void DrawReversibleLine(Point start, Point end, Color backColor)
3619 if (backColor.GetBrightness() < 0.5)
3620 backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B);
3622 IntPtr gc = GetReversibleScreenGC (backColor);
3624 XDrawLine (DisplayHandle, RootWindow, gc, start.X, start.Y, end.X, end.Y);
3626 XFreeGC(DisplayHandle, gc);
3629 internal override void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style)
3631 if (backColor.GetBrightness() < 0.5)
3632 backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B);
3634 IntPtr gc = GetReversibleScreenGC (backColor);
3636 if (rectangle.Width < 0) {
3637 rectangle.X += rectangle.Width;
3638 rectangle.Width = -rectangle.Width;
3640 if (rectangle.Height < 0) {
3641 rectangle.Y += rectangle.Height;
3642 rectangle.Height = -rectangle.Height;
3646 GCLineStyle line_style = GCLineStyle.LineSolid;
3647 GCCapStyle cap_style = GCCapStyle.CapButt;
3648 GCJoinStyle join_style = GCJoinStyle.JoinMiter;
3651 case FrameStyle.Dashed:
3652 line_style = GCLineStyle.LineOnOffDash;
3654 case FrameStyle.Thick:
3659 XSetLineAttributes (DisplayHandle, gc, line_width, line_style, cap_style, join_style);
3661 XDrawRectangle(DisplayHandle, RootWindow, gc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height);
3663 XFreeGC(DisplayHandle, gc);
3666 internal override void FillReversibleRectangle (Rectangle rectangle, Color backColor)
3668 if (backColor.GetBrightness() < 0.5)
3669 backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B);
3671 IntPtr gc = GetReversibleScreenGC (backColor);
3673 if (rectangle.Width < 0) {
3674 rectangle.X += rectangle.Width;
3675 rectangle.Width = -rectangle.Width;
3677 if (rectangle.Height < 0) {
3678 rectangle.Y += rectangle.Height;
3679 rectangle.Height = -rectangle.Height;
3681 XFillRectangle(DisplayHandle, RootWindow, gc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height);
3683 XFreeGC(DisplayHandle, gc);
3686 internal override void DrawReversibleRectangle(IntPtr handle, Rectangle rect, int line_width)
3689 Control control = Control.FromHandle(handle);
3691 gc = GetReversibleControlGC (control, line_width);
3693 if ((rect.Width > 0) && (rect.Height > 0)) {
3694 XDrawRectangle(DisplayHandle, control.Handle, gc, rect.Left, rect.Top, rect.Width, rect.Height);
3696 if (rect.Width > 0) {
3697 XDrawLine(DisplayHandle, control.Handle, gc, rect.X, rect.Y, rect.Right, rect.Y);
3699 XDrawLine(DisplayHandle, control.Handle, gc, rect.X, rect.Y, rect.X, rect.Bottom);
3702 XFreeGC(DisplayHandle, gc);
3705 internal override void DoEvents()
3707 DebugHelper.Enter ();
3709 MSG msg = new MSG ();
3712 if (OverrideCursorHandle != IntPtr.Zero) {
3713 OverrideCursorHandle = IntPtr.Zero;
3716 queue = ThreadQueue(Thread.CurrentThread);
3718 queue.DispatchIdle = false;
3721 while (PeekMessage(queue, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) {
3722 Message m = Message.Create (msg.hwnd, (int)msg.message, msg.wParam, msg.lParam);
3724 if (Application.FilterMessage (ref m))
3727 TranslateMessage (ref msg);
3728 DispatchMessage (ref msg);
3730 string key = msg.hwnd + ":" + msg.message;
3731 if (messageHold[key] != null) {
3732 messageHold[key] = ((int)messageHold[key]) - 1;
3733 DebugHelper.WriteLine ("Got " + msg + " for " + key);
3737 in_doevents = false;
3738 queue.DispatchIdle = true;
3740 DebugHelper.Leave ();
3743 internal override void EnableWindow(IntPtr handle, bool Enable)
3747 hwnd = Hwnd.ObjectFromHandle(handle);
3749 hwnd.Enabled = Enable;
3753 internal override void EndLoop(Thread thread)
3755 // This is where we one day will shut down the loop for the thread
3758 internal override IntPtr GetActive()
3764 IntPtr prop = IntPtr.Zero;
3765 IntPtr active = IntPtr.Zero;
3767 XGetWindowProperty(DisplayHandle, RootWindow, _NET_ACTIVE_WINDOW, IntPtr.Zero, new IntPtr (1), false, (IntPtr)Atom.XA_WINDOW, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
3768 if (((long)nitems > 0) && (prop != IntPtr.Zero)) {
3769 active = (IntPtr)Marshal.ReadInt32(prop);
3772 // The window manager does not support _NET_ACTIVE_WINDOW. Fall back to XGetInputFocus.
3773 IntPtr revert_to = IntPtr.Zero;
3774 XGetInputFocus(DisplayHandle, out active, out revert_to);
3777 if (active != IntPtr.Zero) {
3780 hwnd = Hwnd.GetObjectFromWindow(active);
3782 active = hwnd.Handle;
3784 active = IntPtr.Zero;
3790 internal override Region GetClipRegion(IntPtr handle)
3794 hwnd = Hwnd.ObjectFromHandle(handle);
3796 return hwnd.UserClip;
3802 internal override void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y)
3810 internal override void GetDisplaySize(out Size size)
3812 XWindowAttributes attributes=new XWindowAttributes();
3815 // FIXME - use _NET_WM messages instead?
3816 XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes);
3819 size = new Size(attributes.width, attributes.height);
3822 internal override SizeF GetAutoScaleSize(Font font)
3826 string magic_string = "The quick brown fox jumped over the lazy dog.";
3827 double magic_number = 44.549996948242189;
3829 g = Graphics.FromHwnd(FosterParent);
3831 width = (float) (g.MeasureString (magic_string, font).Width / magic_number);
3832 return new SizeF(width, font.Height);
3835 internal override IntPtr GetParent(IntPtr handle)
3839 hwnd = Hwnd.ObjectFromHandle(handle);
3840 if (hwnd != null && hwnd.parent != null) {
3841 return hwnd.parent.Handle;
3846 // This is a nop on win32 and x11
3847 internal override IntPtr GetPreviousWindow(IntPtr handle)
3852 internal override void GetCursorPos(IntPtr handle, out int x, out int y)
3863 if (handle != IntPtr.Zero) {
3864 use_handle = Hwnd.ObjectFromHandle(handle).client_window;
3866 use_handle = RootWindow;
3870 QueryPointer (DisplayHandle, use_handle, out root, out child, out root_x, out root_y, out win_x, out win_y, out keys_buttons);
3873 if (handle != IntPtr.Zero) {
3882 internal override IntPtr GetFocus()
3888 internal override bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent)
3890 FontFamily ff = font.FontFamily;
3891 ascent = ff.GetCellAscent (font.Style);
3892 descent = ff.GetCellDescent (font.Style);
3896 internal override Point GetMenuOrigin(IntPtr handle)
3900 hwnd = Hwnd.ObjectFromHandle(handle);
3903 return hwnd.MenuOrigin;
3908 [MonoTODO("Implement filtering")]
3909 internal override bool GetMessage(Object queue_id, ref MSG msg, IntPtr handle, int wFilterMin, int wFilterMax)
3917 if (((XEventQueue)queue_id).Count > 0) {
3918 xevent = (XEvent) ((XEventQueue)queue_id).Dequeue ();
3920 UpdateMessageQueue ((XEventQueue)queue_id);
3922 if (((XEventQueue)queue_id).Count > 0) {
3923 xevent = (XEvent) ((XEventQueue)queue_id).Dequeue ();
3924 } else if (((XEventQueue)queue_id).Paint.Count > 0) {
3925 xevent = ((XEventQueue)queue_id).Paint.Dequeue();
3927 msg.hwnd= IntPtr.Zero;
3928 msg.message = Msg.WM_ENTERIDLE;
3933 hwnd = Hwnd.GetObjectFromWindow(xevent.AnyEvent.window);
3935 #if DriverDebugDestroy
3938 Console.WriteLine ( "GetMessage zombie, got Event: " + xevent.ToString () + " for 0x{0:x}", hwnd.Handle.ToInt32());
3940 Console.WriteLine ( "GetMessage, got Event: " + xevent.ToString () + " for 0x{0:x}", hwnd.Handle.ToInt32());
3942 // Handle messages for windows that are already or are about to be destroyed.
3944 // we need a special block for this because unless we remove the hwnd from the paint
3945 // queue it will always stay there (since we don't handle the expose), and we'll
3946 // effectively loop infinitely trying to repaint a non-existant window.
3947 if (hwnd != null && hwnd.zombie && xevent.type == XEventName.Expose) {
3948 hwnd.expose_pending = hwnd.nc_expose_pending = false;
3949 hwnd.Queue.Paint.Remove (hwnd);
3950 goto ProcessNextMessage;
3953 // We need to make sure we only allow DestroyNotify events through for zombie
3954 // hwnds, since much of the event handling code makes requests using the hwnd's
3955 // client_window, and that'll result in BadWindow errors if there's some lag
3956 // between the XDestroyWindow call and the DestroyNotify event.
3957 if (hwnd == null || hwnd.zombie && xevent.AnyEvent.type != XEventName.ClientMessage) {
3958 DriverDebug("GetMessage(): Got message {0} for non-existent or already destroyed window {1:X}", xevent.type, xevent.AnyEvent.window.ToInt32());
3959 goto ProcessNextMessage;
3963 // If we get here, that means the window is no more but there are Client Messages
3964 // to be processed, probably a Posted message (for instance, an WM_ACTIVATE message)
3965 // We don't want anything else to run but the ClientMessage block, so reset all hwnd
3966 // properties that might cause other processing to occur.
3968 hwnd.resizing_or_moving = false;
3971 if (hwnd.client_window == xevent.AnyEvent.window) {
3973 //Console.WriteLine("Client message {1}, sending to window {0:X}", msg.hwnd.ToInt32(), xevent.type);
3976 //Console.WriteLine("Non-Client message, sending to window {0:X}", msg.hwnd.ToInt32());
3979 msg.hwnd = hwnd.Handle;
3981 // Windows sends WM_ENTERSIZEMOVE when a form resize/move operation starts and WM_EXITSIZEMOVE
3982 // when it is done. The problem in X11 is that there is no concept of start-end of a moving/sizing.
3983 // Configure events ("this window has resized/moved") are sent for each step of the resize. We send a
3984 // WM_ENTERSIZEMOVE when we get the first Configure event. The problem is the WM_EXITSIZEMOVE.
3986 // - There is no way for us to know which is the last Configure event. We can't traverse the events
3987 // queue, because the next configure event might not be pending yet.
3988 // - We can't get ButtonPress/Release events for the window decorations, because they are not part
3989 // of the window(s) we manage.
3990 // - We can't rely on the mouse state to change to "up" before the last Configure event. It doesn't.
3992 // We are almost 100% guaranteed to get another event (e.g Expose or other), but we can't know for sure
3993 // which, so we have here to check if the mouse buttons state is "up" and send the WM_EXITSIZEMOVE
3995 if (hwnd.resizing_or_moving) {
3996 int root_x, root_y, win_x, win_y, keys_buttons;
3998 XQueryPointer (DisplayHandle, hwnd.Handle, out root, out child, out root_x, out root_y,
3999 out win_x, out win_y, out keys_buttons);
4000 if ((keys_buttons & (int)MouseKeyMasks.Button1Mask) == 0 &&
4001 (keys_buttons & (int)MouseKeyMasks.Button2Mask) == 0 &&
4002 (keys_buttons & (int)MouseKeyMasks.Button3Mask) == 0) {
4003 hwnd.resizing_or_moving = false;
4004 SendMessage (hwnd.Handle, Msg.WM_EXITSIZEMOVE, IntPtr.Zero, IntPtr.Zero);
4009 // If you add a new event to this switch make sure to add it in
4010 // UpdateMessage also unless it is not coming through the X event system.
4012 switch(xevent.type) {
4013 case XEventName.KeyPress: {
4014 Keyboard.KeyEvent (FocusWindow, xevent, ref msg);
4016 // F1 key special case - WM_HELP sending
4017 if (msg.wParam == (IntPtr)VirtualKeys.VK_F1 || msg.wParam == (IntPtr)VirtualKeys.VK_HELP) {
4018 // Send wM_HELP and then return it as a keypress message in
4019 // case it needs to be preproccessed.
4020 HELPINFO helpInfo = new HELPINFO ();
4021 GetCursorPos (IntPtr.Zero, out helpInfo.MousePos.x, out helpInfo.MousePos.y);
4022 IntPtr helpInfoPtr = Marshal.AllocHGlobal (Marshal.SizeOf (helpInfo));
4023 Marshal.StructureToPtr (helpInfo, helpInfoPtr, true);
4024 NativeWindow.WndProc (FocusWindow, Msg.WM_HELP, IntPtr.Zero, helpInfoPtr);
4025 Marshal.FreeHGlobal (helpInfoPtr);
4030 case XEventName.KeyRelease: {
4031 Keyboard.KeyEvent (FocusWindow, xevent, ref msg);
4035 case XEventName.ButtonPress: {
4036 switch(xevent.ButtonEvent.button) {
4038 MouseState |= MouseButtons.Left;
4040 msg.message = Msg.WM_LBUTTONDOWN;
4041 msg.wParam = GetMousewParam (0);
4043 msg.message = Msg.WM_NCLBUTTONDOWN;
4044 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4045 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4051 MouseState |= MouseButtons.Middle;
4053 msg.message = Msg.WM_MBUTTONDOWN;
4054 msg.wParam = GetMousewParam (0);
4056 msg.message = Msg.WM_NCMBUTTONDOWN;
4057 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4058 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4064 MouseState |= MouseButtons.Right;
4066 msg.message = Msg.WM_RBUTTONDOWN;
4067 msg.wParam = GetMousewParam (0);
4069 msg.message = Msg.WM_NCRBUTTONDOWN;
4070 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4071 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4077 msg.hwnd = FocusWindow;
4078 msg.message=Msg.WM_MOUSEWHEEL;
4079 msg.wParam=GetMousewParam(120);
4084 msg.hwnd = FocusWindow;
4085 msg.message=Msg.WM_MOUSEWHEEL;
4086 msg.wParam=GetMousewParam(-120);
4092 msg.lParam=(IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x);
4093 mouse_position.X = xevent.ButtonEvent.x;
4094 mouse_position.Y = xevent.ButtonEvent.y;
4096 if (!hwnd.Enabled) {
4099 msg.hwnd = hwnd.EnabledHwnd;
4100 XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.ButtonEvent.x, xevent.ButtonEvent.y, out xevent.ButtonEvent.x, out xevent.ButtonEvent.y, out dummy);
4101 msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4104 if (Grab.Hwnd != IntPtr.Zero) {
4105 msg.hwnd = Grab.Hwnd;
4108 if (ClickPending.Pending && ((((long)xevent.ButtonEvent.time - ClickPending.Time) < DoubleClickInterval) && (msg.wParam == ClickPending.wParam) && (msg.lParam == ClickPending.lParam) && (msg.message == ClickPending.Message))) {
4109 // Looks like a genuine double click, clicked twice on the same spot with the same keys
4110 switch(xevent.ButtonEvent.button) {
4112 msg.message = client ? Msg.WM_LBUTTONDBLCLK : Msg.WM_NCLBUTTONDBLCLK;
4117 msg.message = client ? Msg.WM_MBUTTONDBLCLK : Msg.WM_NCMBUTTONDBLCLK;
4122 msg.message = client ? Msg.WM_RBUTTONDBLCLK : Msg.WM_NCRBUTTONDBLCLK;
4126 ClickPending.Pending = false;
4128 ClickPending.Pending = true;
4129 ClickPending.Hwnd = msg.hwnd;
4130 ClickPending.Message = msg.message;
4131 ClickPending.wParam = msg.wParam;
4132 ClickPending.lParam = msg.lParam;
4133 ClickPending.Time = (long)xevent.ButtonEvent.time;
4136 if (msg.message == Msg.WM_LBUTTONDOWN || msg.message == Msg.WM_MBUTTONDOWN || msg.message == Msg.WM_RBUTTONDOWN) {
4137 SendParentNotify(msg.hwnd, msg.message, mouse_position.X, mouse_position.Y);
4143 case XEventName.ButtonRelease: {
4144 switch(xevent.ButtonEvent.button) {
4147 msg.message = Msg.WM_LBUTTONUP;
4149 msg.message = Msg.WM_NCLBUTTONUP;
4150 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4151 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4153 MouseState &= ~MouseButtons.Left;
4154 msg.wParam = GetMousewParam (0);
4160 msg.message = Msg.WM_MBUTTONUP;
4162 msg.message = Msg.WM_NCMBUTTONUP;
4163 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4164 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4166 MouseState &= ~MouseButtons.Middle;
4167 msg.wParam = GetMousewParam (0);
4173 msg.message = Msg.WM_RBUTTONUP;
4175 msg.message = Msg.WM_NCRBUTTONUP;
4176 msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4177 MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y);
4179 MouseState &= ~MouseButtons.Right;
4180 msg.wParam = GetMousewParam (0);
4185 goto ProcessNextMessage;
4189 goto ProcessNextMessage;
4193 if (!hwnd.Enabled) {
4196 msg.hwnd = hwnd.EnabledHwnd;
4197 XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.ButtonEvent.x, xevent.ButtonEvent.y, out xevent.ButtonEvent.x, out xevent.ButtonEvent.y, out dummy);
4198 msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4201 if (Grab.Hwnd != IntPtr.Zero) {
4202 msg.hwnd = Grab.Hwnd;
4205 msg.lParam=(IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x);
4206 mouse_position.X = xevent.ButtonEvent.x;
4207 mouse_position.Y = xevent.ButtonEvent.y;
4209 // Win32 splurts MouseMove events all over the place, regardless of whether the mouse is actually moving or
4210 // not, especially after mousedown and mouseup. To support apps relying on mousemove events between and after
4211 // mouse clicks to repaint or whatever, we generate a mousemove event here. *sigh*
4212 if (msg.message == Msg.WM_LBUTTONUP || msg.message == Msg.WM_MBUTTONUP || msg.message == Msg.WM_RBUTTONUP) {
4213 XEvent motionEvent = new XEvent ();
4214 motionEvent.type = XEventName.MotionNotify;
4215 motionEvent.MotionEvent.display = DisplayHandle;
4216 motionEvent.MotionEvent.window = xevent.ButtonEvent.window;
4217 motionEvent.MotionEvent.x = xevent.ButtonEvent.x;
4218 motionEvent.MotionEvent.y = xevent.ButtonEvent.y;
4219 hwnd.Queue.EnqueueLocked (motionEvent);
4224 case XEventName.MotionNotify: {
4226 DriverDebug("GetMessage(): Window {0:X} MotionNotify x={1} y={2}",
4227 client ? hwnd.client_window.ToInt32() : hwnd.whole_window.ToInt32(),
4228 xevent.MotionEvent.x, xevent.MotionEvent.y);
4230 if (Grab.Hwnd != IntPtr.Zero) {
4231 msg.hwnd = Grab.Hwnd;
4234 NativeWindow.WndProc(msg.hwnd, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)HitTest.HTCLIENT);
4238 if (xevent.MotionEvent.is_hint != 0)
4242 XQueryPointer (DisplayHandle, xevent.AnyEvent.window,
4243 out root, out child,
4244 out xevent.MotionEvent.x_root,
4245 out xevent.MotionEvent.y_root,
4246 out xevent.MotionEvent.x,
4247 out xevent.MotionEvent.y, out mask);
4250 msg.message = Msg.WM_MOUSEMOVE;
4251 msg.wParam = GetMousewParam(0);
4252 msg.lParam = (IntPtr) (xevent.MotionEvent.y << 16 | xevent.MotionEvent.x & 0xFFFF);
4254 if (!hwnd.Enabled) {
4257 msg.hwnd = hwnd.EnabledHwnd;
4258 XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.MotionEvent.x, xevent.MotionEvent.y, out xevent.MotionEvent.x, out xevent.MotionEvent.y, out dummy);
4259 msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4262 mouse_position.X = xevent.MotionEvent.x;
4263 mouse_position.Y = xevent.MotionEvent.y;
4265 if ((HoverState.Timer.Enabled) &&
4266 (((mouse_position.X + HoverState.Size.Width) < HoverState.X) ||
4267 ((mouse_position.X - HoverState.Size.Width) > HoverState.X) ||
4268 ((mouse_position.Y + HoverState.Size.Height) < HoverState.Y) ||
4269 ((mouse_position.Y - HoverState.Size.Height) > HoverState.Y))) {
4270 HoverState.Timer.Stop();
4271 HoverState.Timer.Start();
4272 HoverState.X = mouse_position.X;
4273 HoverState.Y = mouse_position.Y;
4281 DriverDebug("GetMessage(): non-client area {0:X} MotionNotify x={1} y={2}",
4282 client ? hwnd.client_window.ToInt32() : hwnd.whole_window.ToInt32(),
4283 xevent.MotionEvent.x, xevent.MotionEvent.y);
4284 msg.message = Msg.WM_NCMOUSEMOVE;
4286 if (!hwnd.Enabled) {
4287 msg.hwnd = hwnd.EnabledHwnd;
4288 XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.MotionEvent.x, xevent.MotionEvent.y, out xevent.MotionEvent.x, out xevent.MotionEvent.y, out dummy);
4289 msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X);
4292 ht = NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y);
4293 NativeWindow.WndProc(hwnd.client_window, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)ht);
4295 mouse_position.X = xevent.MotionEvent.x;
4296 mouse_position.Y = xevent.MotionEvent.y;
4302 case XEventName.EnterNotify: {
4303 if (!hwnd.Enabled) {
4304 goto ProcessNextMessage;
4306 if (xevent.CrossingEvent.mode == NotifyMode.NotifyGrab || xevent.AnyEvent.window != hwnd.client_window) {
4307 goto ProcessNextMessage;
4309 if (xevent.CrossingEvent.mode == NotifyMode.NotifyUngrab) { // Pseudo motion caused by grabbing
4310 if (LastPointerWindow == xevent.AnyEvent.window)
4311 goto ProcessNextMessage;
4313 if (LastPointerWindow != IntPtr.Zero) {
4314 Point enter_loc = new Point (xevent.ButtonEvent.x, xevent.ButtonEvent.y);
4316 // We need this due to EnterNotify being fired on all the parent controls
4317 // of the Control being grabbed, and obviously in that scenario we are not
4318 // actuallty entering them
4319 Control ctrl = Control.FromHandle (hwnd.client_window);
4320 foreach (Control child_control in ctrl.Controls.GetAllControls ())
4321 if (child_control.Bounds.Contains (enter_loc))
4322 goto ProcessNextMessage;
4324 // A MouseLeave/LeaveNotify event is sent to the previous window
4325 // until the mouse is ungrabbed, not when actually leaving its bounds
4326 int x = xevent.CrossingEvent.x_root;
4327 int y = xevent.CrossingEvent.y_root;
4328 ScreenToClient (LastPointerWindow, ref x, ref y);
4330 XEvent leaveEvent = new XEvent ();
4331 leaveEvent.type = XEventName.LeaveNotify;
4332 leaveEvent.CrossingEvent.display = DisplayHandle;
4333 leaveEvent.CrossingEvent.window = LastPointerWindow;
4334 leaveEvent.CrossingEvent.x = x;
4335 leaveEvent.CrossingEvent.y = y;
4336 leaveEvent.CrossingEvent.mode = NotifyMode.NotifyNormal;
4337 Hwnd last_pointer_hwnd = Hwnd.ObjectFromHandle (LastPointerWindow);
4338 last_pointer_hwnd.Queue.EnqueueLocked (leaveEvent);
4342 LastPointerWindow = xevent.AnyEvent.window;
4344 msg.message = Msg.WM_MOUSE_ENTER;
4345 HoverState.X = xevent.CrossingEvent.x;
4346 HoverState.Y = xevent.CrossingEvent.y;
4347 HoverState.Timer.Enabled = true;
4348 HoverState.Window = xevent.CrossingEvent.window;
4350 // Win32 sends a WM_MOUSEMOVE after mouse enter
4351 XEvent motionEvent = new XEvent ();
4352 motionEvent.type = XEventName.MotionNotify;
4353 motionEvent.MotionEvent.display = DisplayHandle;
4354 motionEvent.MotionEvent.window = xevent.ButtonEvent.window;
4355 motionEvent.MotionEvent.x = xevent.ButtonEvent.x;
4356 motionEvent.MotionEvent.y = xevent.ButtonEvent.y;
4357 hwnd.Queue.EnqueueLocked (motionEvent);
4361 case XEventName.LeaveNotify: {
4362 if (xevent.CrossingEvent.mode == NotifyMode.NotifyUngrab) {
4363 WindowUngrabbed (hwnd.Handle);
4364 goto ProcessNextMessage;
4366 if (!hwnd.Enabled) {
4367 goto ProcessNextMessage;
4369 if ((xevent.CrossingEvent.mode != NotifyMode.NotifyNormal) || (xevent.CrossingEvent.window != hwnd.client_window)) {
4370 goto ProcessNextMessage;
4372 // If a grab is taking place, ignore it - we handle it in EnterNotify
4373 if (Grab.Hwnd != IntPtr.Zero)
4374 goto ProcessNextMessage;
4376 // Reset the cursor explicitly on X11.
4377 // X11 remembers the last set cursor for the window and in cases where
4378 // the control won't get a WM_SETCURSOR X11 will restore the last
4379 // known cursor, which we don't want.
4381 SetCursor (hwnd.client_window, IntPtr.Zero);
4383 msg.message=Msg.WM_MOUSELEAVE;
4384 HoverState.Timer.Enabled = false;
4385 HoverState.Window = IntPtr.Zero;
4390 case XEventName.CreateNotify: {
4391 if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) {
4392 msg.message = WM_CREATE;
4393 // Set up CreateStruct
4395 goto ProcessNextMessage;
4402 case XEventName.ReparentNotify: {
4403 if (hwnd.parent == null) { // Toplevel
4404 if ((xevent.ReparentEvent.parent != IntPtr.Zero) && (xevent.ReparentEvent.window == hwnd.whole_window)) {
4405 hwnd.Reparented = true;
4407 // The location given by the event is not reliable between different wm's,
4408 // so use an alternative way of getting it.
4409 Point location = GetTopLevelWindowLocation (hwnd);
4410 hwnd.X = location.X;
4411 hwnd.Y = location.Y;
4413 if (hwnd.opacity != 0xffffffff) {
4416 opacity = (IntPtr)(Int32)hwnd.opacity;
4417 XChangeProperty(DisplayHandle, XGetParent(hwnd.whole_window), _NET_WM_WINDOW_OPACITY, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, ref opacity, 1);
4419 SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, msg.wParam, msg.lParam);
4420 goto ProcessNextMessage;
4422 hwnd.Reparented = false;
4423 goto ProcessNextMessage;
4426 goto ProcessNextMessage;
4429 case XEventName.ConfigureNotify: {
4430 if (!client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas
4431 DriverDebug("GetMessage(): Window {0:X} ConfigureNotify x={1} y={2} width={3} height={4}",
4432 hwnd.client_window.ToInt32(), xevent.ConfigureEvent.x,
4433 xevent.ConfigureEvent.y, xevent.ConfigureEvent.width, xevent.ConfigureEvent.height);
4435 lock (hwnd.configure_lock) {
4436 Form form = Control.FromHandle (hwnd.client_window) as Form;
4437 if (form != null && !hwnd.resizing_or_moving) {
4438 if (hwnd.x != form.Bounds.X || hwnd.y != form.Bounds.Y) {
4439 SendMessage (form.Handle, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_MOVE, IntPtr.Zero);
4440 hwnd.resizing_or_moving = true;
4441 } else if (hwnd.width != form.Bounds.Width || hwnd.height != form.Bounds.Height) {
4442 SendMessage (form.Handle, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_SIZE, IntPtr.Zero);
4443 hwnd.resizing_or_moving = true;
4445 if (hwnd.resizing_or_moving)
4446 SendMessage (form.Handle, Msg.WM_ENTERSIZEMOVE, IntPtr.Zero, IntPtr.Zero);
4449 SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
4450 hwnd.configure_pending = false;
4452 // We need to adjust our client window to track the resize of whole_window
4453 if (hwnd.whole_window != hwnd.client_window)
4454 PerformNCCalc(hwnd);
4457 goto ProcessNextMessage;
4460 case XEventName.FocusIn: {
4461 // We received focus. We use X11 focus only to know if the app window does or does not have focus
4462 // We do not track the actual focussed window via it. Instead, this is done via FocusWindow internally
4463 // Receiving focus means we've gotten activated and therefore we need to let the actual FocusWindow know
4464 // about it having focus again
4465 if (xevent.FocusChangeEvent.detail != NotifyDetail.NotifyNonlinear) {
4466 goto ProcessNextMessage;
4470 if (FocusWindow == IntPtr.Zero) {
4471 Control c = Control.FromHandle (hwnd.client_window);
4474 goto ProcessNextMessage;
4475 Form form = c.FindForm ();
4477 goto ProcessNextMessage;
4479 if (ActiveWindow != form.Handle) {
4480 ActiveWindow = form.Handle;
4481 SendMessage (ActiveWindow, Msg.WM_ACTIVATE, (IntPtr) WindowActiveFlags.WA_ACTIVE, IntPtr.Zero);
4483 goto ProcessNextMessage;
4485 Keyboard.FocusIn (FocusWindow);
4486 SendMessage(FocusWindow, Msg.WM_SETFOCUS, IntPtr.Zero, IntPtr.Zero);
4487 goto ProcessNextMessage;
4490 case XEventName.FocusOut: {
4491 // Se the comment for our FocusIn handler
4492 if (xevent.FocusChangeEvent.detail != NotifyDetail.NotifyNonlinear) {
4493 goto ProcessNextMessage;
4496 while (Keyboard.ResetKeyState(FocusWindow, ref msg)) {
4497 SendMessage(FocusWindow, msg.message, msg.wParam, msg.lParam);
4500 Keyboard.FocusOut(hwnd.client_window);
4501 SendMessage(FocusWindow, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero);
4502 goto ProcessNextMessage;
4505 // We are already firing WM_SHOWWINDOW messages in the proper places, but I'm leaving this code
4506 // in case we break a scenario not taken into account in the tests
4507 case XEventName.MapNotify: {
4508 /*if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas
4510 msg.message = Msg.WM_SHOWWINDOW;
4511 msg.wParam = (IntPtr) 1;
4512 // XXX we're missing the lParam..
4515 goto ProcessNextMessage;
4518 case XEventName.UnmapNotify: {
4519 /*if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas
4520 hwnd.mapped = false;
4521 msg.message = Msg.WM_SHOWWINDOW;
4522 msg.wParam = (IntPtr) 0;
4523 // XXX we're missing the lParam..
4526 goto ProcessNextMessage;
4529 case XEventName.Expose: {
4532 hwnd.expose_pending = false;
4534 hwnd.nc_expose_pending = false;
4536 goto ProcessNextMessage;
4540 if (!hwnd.expose_pending) {
4541 goto ProcessNextMessage;
4544 if (!hwnd.nc_expose_pending) {
4545 goto ProcessNextMessage;
4548 switch (hwnd.border_style) {
4549 case FormBorderStyle.Fixed3D: {
4552 g = Graphics.FromHwnd(hwnd.whole_window);
4553 if (hwnd.border_static)
4554 ControlPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Border3DStyle.SunkenOuter);
4556 ControlPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Border3DStyle.Sunken);
4561 case FormBorderStyle.FixedSingle: {
4564 g = Graphics.FromHwnd(hwnd.whole_window);
4565 ControlPaint.DrawBorder(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Color.Black, ButtonBorderStyle.Solid);
4570 DriverDebug("GetMessage(): Window {0:X} Exposed non-client area {1},{2} {3}x{4}",
4571 hwnd.client_window.ToInt32(), xevent.ExposeEvent.x, xevent.ExposeEvent.y,
4572 xevent.ExposeEvent.width, xevent.ExposeEvent.height);
4574 Rectangle rect = new Rectangle (xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height);
4575 Region region = new Region (rect);
4576 IntPtr hrgn = region.GetHrgn (null); // Graphics object isn't needed
4577 msg.message = Msg.WM_NCPAINT;
4578 msg.wParam = hrgn == IntPtr.Zero ? (IntPtr)1 : hrgn;
4579 msg.refobject = region;
4582 DriverDebug("GetMessage(): Window {0:X} Exposed area {1},{2} {3}x{4}",
4583 hwnd.client_window.ToInt32(), xevent.ExposeEvent.x, xevent.ExposeEvent.y,
4584 xevent.ExposeEvent.width, xevent.ExposeEvent.height);
4585 if (Caret.Visible == true) {
4586 Caret.Paused = true;
4590 if (Caret.Visible == true) {
4592 Caret.Paused = false;
4594 msg.message = Msg.WM_PAINT;
4598 case XEventName.DestroyNotify: {
4600 // This is a bit tricky, we don't receive our own DestroyNotify, we only get those for our children
4601 hwnd = Hwnd.ObjectFromHandle(xevent.DestroyWindowEvent.window);
4603 // We may get multiple for the same window, act only one the first (when Hwnd still knows about it)
4604 if ((hwnd != null) && (hwnd.client_window == xevent.DestroyWindowEvent.window)) {
4605 CleanupCachedWindows (hwnd);
4607 DriverDebug("Received X11 Destroy Notification for {0}", XplatUI.Window(hwnd.client_window));
4609 msg.hwnd = hwnd.client_window;
4610 msg.message=Msg.WM_DESTROY;
4613 goto ProcessNextMessage;
4619 case XEventName.ClientMessage: {
4620 if (Dnd.HandleClientMessage (ref xevent)) {
4621 goto ProcessNextMessage;
4624 if (xevent.ClientMessageEvent.message_type == AsyncAtom) {
4625 XplatUIDriverSupport.ExecuteClientMessage((GCHandle)xevent.ClientMessageEvent.ptr1);
4626 goto ProcessNextMessage;
4629 if (xevent.ClientMessageEvent.message_type == HoverState.Atom) {
4630 msg.message = Msg.WM_MOUSEHOVER;
4631 msg.wParam = GetMousewParam(0);
4632 msg.lParam = (IntPtr) (xevent.ClientMessageEvent.ptr1);
4636 if (xevent.ClientMessageEvent.message_type == (IntPtr)PostAtom) {
4637 DebugHelper.Indent ();
4638 DebugHelper.WriteLine (String.Format ("Posted message:" + (Msg) xevent.ClientMessageEvent.ptr2.ToInt32 () + " for 0x{0:x}", xevent.ClientMessageEvent.ptr1.ToInt32 ()));
4639 DebugHelper.Unindent ();
4640 msg.hwnd = xevent.ClientMessageEvent.ptr1;
4641 msg.message = (Msg) xevent.ClientMessageEvent.ptr2.ToInt32 ();
4642 msg.wParam = xevent.ClientMessageEvent.ptr3;
4643 msg.lParam = xevent.ClientMessageEvent.ptr4;
4644 if (msg.message == (Msg)Msg.WM_QUIT)
4650 if (xevent.ClientMessageEvent.message_type == _XEMBED) {
4651 #if DriverDebugXEmbed
4652 Console.WriteLine("GOT EMBED MESSAGE {0:X}, detail {1:X}", xevent.ClientMessageEvent.ptr2.ToInt32(), xevent.ClientMessageEvent.ptr3.ToInt32());
4655 if (xevent.ClientMessageEvent.ptr2.ToInt32() == (int)XEmbedMessage.EmbeddedNotify) {
4656 XSizeHints hints = new XSizeHints();
4659 XGetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints, out dummy);
4661 hwnd.width = hints.max_width;
4662 hwnd.height = hints.max_height;
4663 hwnd.ClientRect = Rectangle.Empty;
4664 SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
4668 if (xevent.ClientMessageEvent.message_type == WM_PROTOCOLS) {
4669 if (xevent.ClientMessageEvent.ptr1 == WM_DELETE_WINDOW) {
4670 SendMessage (msg.hwnd, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_CLOSE, IntPtr.Zero);
4671 msg.message = Msg.WM_CLOSE;
4675 // We should not get this, but I'll leave the code in case we need it in the future
4676 if (xevent.ClientMessageEvent.ptr1 == WM_TAKE_FOCUS) {
4677 goto ProcessNextMessage;
4680 goto ProcessNextMessage;
4684 goto ProcessNextMessage;
4691 HitTest NCHitTest (Hwnd hwnd, int x, int y)
4693 // The hit test is sent in screen coordinates
4695 int screen_x, screen_y;
4696 XTranslateCoordinates (DisplayHandle, hwnd.WholeWindow, RootWindow, x, y, out screen_x, out screen_y, out dummy);
4697 return (HitTest) NativeWindow.WndProc (hwnd.client_window, Msg.WM_NCHITTEST, IntPtr.Zero,
4698 (IntPtr) (screen_y << 16 | screen_x & 0xFFFF));
4701 // Our very basic implementation of MoveResize - we can extend it later
4703 internal override void BeginMoveResize (IntPtr handle)
4705 // We *need* to ungrab the pointer in the current display
4706 XplatUI.UngrabWindow (Grab.Hwnd);
4709 GetCursorPos (IntPtr.Zero, out x_root, out y_root);
4711 Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
4712 SendNetWMMessage (hwnd.whole_window, _NET_WM_MOVERESIZE, (IntPtr) x_root, (IntPtr) y_root,
4713 (IntPtr) NetWmMoveResize._NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT,
4714 (IntPtr) 1); // left button
4717 internal override bool GetText(IntPtr handle, out string text)
4725 IntPtr prop = IntPtr.Zero;
4727 XGetWindowProperty(DisplayHandle, handle,
4728 _NET_WM_NAME, IntPtr.Zero, new IntPtr (1), false,
4729 UTF8_STRING, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
4731 if ((long)nitems > 0 && prop != IntPtr.Zero) {
4732 text = Marshal.PtrToStringUni (prop, (int)nitems);
4737 // fallback on the non-_NET property
4740 textptr = IntPtr.Zero;
4742 XFetchName(DisplayHandle, Hwnd.ObjectFromHandle(handle).whole_window, ref textptr);
4743 if (textptr != IntPtr.Zero) {
4744 text = Marshal.PtrToStringAnsi(textptr);
4755 internal override void GetWindowPos(IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height)
4759 hwnd = Hwnd.ObjectFromHandle(handle);
4765 height = hwnd.height;
4767 PerformNCCalc(hwnd);
4769 client_width = hwnd.ClientRect.Width;
4770 client_height = hwnd.ClientRect.Height;
4775 // Should we throw an exception or fail silently?
4776 // throw new ArgumentException("Called with an invalid window handle", "handle");
4786 internal override FormWindowState GetWindowState(IntPtr handle)
4790 hwnd = Hwnd.ObjectFromHandle(handle);
4792 if (hwnd.cached_window_state == (FormWindowState)(-1))
4793 hwnd.cached_window_state = UpdateWindowState (handle);
4795 return hwnd.cached_window_state;
4798 FormWindowState UpdateWindowState (IntPtr handle) {
4803 IntPtr prop = IntPtr.Zero;
4807 XWindowAttributes attributes;
4810 hwnd = Hwnd.ObjectFromHandle(handle);
4814 XGetWindowProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, IntPtr.Zero, new IntPtr (256), false, (IntPtr)Atom.XA_ATOM, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop);
4815 if (((long)nitems > 0) && (prop != IntPtr.Zero)) {
4816 for (int i = 0; i < (long)nitems; i++) {
4817 atom = (IntPtr)Marshal.ReadInt32(prop, i * 4);
4818 if ((atom == _NET_WM_STATE_MAXIMIZED_HORZ) || (atom == _NET_WM_STATE_MAXIMIZED_VERT)) {
4820 } else if (atom == _NET_WM_STATE_HIDDEN) {
4828 return FormWindowState.Minimized;
4829 } else if (maximized == 2) {
4830 return FormWindowState.Maximized;
4833 attributes = new XWindowAttributes();
4834 XGetWindowAttributes(DisplayHandle, hwnd.client_window, ref attributes);
4835 if (attributes.map_state == MapState.IsUnmapped) {
4836 return (FormWindowState)(-1);
4840 return FormWindowState.Normal;
4843 internal override void GrabInfo(out IntPtr handle, out bool GrabConfined, out Rectangle GrabArea)
4846 GrabConfined = Grab.Confined;
4847 GrabArea = Grab.Area;
4850 internal override void GrabWindow(IntPtr handle, IntPtr confine_to_handle)
4853 IntPtr confine_to_window;
4855 confine_to_window = IntPtr.Zero;
4857 if (confine_to_handle != IntPtr.Zero) {
4858 XWindowAttributes attributes = new XWindowAttributes();
4860 hwnd = Hwnd.ObjectFromHandle(confine_to_handle);
4863 XGetWindowAttributes(DisplayHandle, hwnd.client_window, ref attributes);
4865 Grab.Area.X = attributes.x;
4866 Grab.Area.Y = attributes.y;
4867 Grab.Area.Width = attributes.width;
4868 Grab.Area.Height = attributes.height;
4869 Grab.Confined = true;
4870 confine_to_window = hwnd.client_window;
4875 hwnd = Hwnd.ObjectFromHandle(handle);
4878 XGrabPointer(DisplayHandle, hwnd.client_window, false,
4879 EventMask.ButtonPressMask | EventMask.ButtonMotionMask |
4880 EventMask.ButtonReleaseMask | EventMask.PointerMotionMask |
4881 EventMask.PointerMotionHintMask | EventMask.LeaveWindowMask,
4882 GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, confine_to_window, IntPtr.Zero, IntPtr.Zero);
4886 internal override void UngrabWindow(IntPtr hwnd)
4889 XUngrabPointer(DisplayHandle, IntPtr.Zero);
4890 XFlush(DisplayHandle);
4892 WindowUngrabbed (hwnd);
4895 void WindowUngrabbed (IntPtr hwnd) {
4896 bool was_grabbed = Grab.Hwnd != IntPtr.Zero;
4898 Grab.Hwnd = IntPtr.Zero;
4899 Grab.Confined = false;
4902 // lparam should be the handle to the window gaining the mouse capture,
4903 // but X doesn't seem to give us that information.
4904 // Also only generate WM_CAPTURECHANGED if the window actually was grabbed.
4905 // X will send a NotifyUngrab, but since it comes late sometimes we're
4906 // calling WindowUngrabbed directly from UngrabWindow in order to send
4907 // this WM right away.
4908 SendMessage (hwnd, Msg.WM_CAPTURECHANGED, IntPtr.Zero, IntPtr.Zero);
4912 internal override void HandleException(Exception e)
4914 StackTrace st = new StackTrace(e, true);
4915 Console.WriteLine("Exception '{0}'", e.Message+st.ToString());
4916 Console.WriteLine("{0}{1}", e.Message, st.ToString());
4919 internal override void Invalidate(IntPtr handle, Rectangle rc, bool clear)
4923 hwnd = Hwnd.ObjectFromHandle(handle);
4926 AddExpose (hwnd, true, hwnd.X, hwnd.Y, hwnd.Width, hwnd.Height);
4928 AddExpose (hwnd, true, rc.X, rc.Y, rc.Width, rc.Height);
4932 internal override void InvalidateNC (IntPtr handle)
4936 hwnd = Hwnd.ObjectFromHandle(handle);
4938 AddExpose (hwnd, hwnd.WholeWindow == hwnd.ClientWindow, 0, 0, hwnd.Width, hwnd.Height);
4941 internal override bool IsEnabled(IntPtr handle)
4943 Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
4944 return (hwnd != null && hwnd.Enabled);
4947 internal override bool IsVisible(IntPtr handle)
4949 Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
4950 return (hwnd != null && hwnd.visible);
4953 internal override void KillTimer(Timer timer)
4955 XEventQueue queue = (XEventQueue) MessageQueues [timer.thread];
4957 if (queue == null) {
4958 // This isn't really an error, MS doesn't start the timer if
4959 // it has no assosciated queue. In this case, remove the timer
4960 // from the list of unattached timers (if it was enabled).
4961 lock (unattached_timer_list) {
4962 if (unattached_timer_list.Contains (timer))
4963 unattached_timer_list.Remove (timer);
4967 queue.timer_list.Remove (timer);
4970 internal override void MenuToScreen(IntPtr handle, ref int x, ref int y)
4977 hwnd = Hwnd.ObjectFromHandle(handle);
4980 XTranslateCoordinates(DisplayHandle, hwnd.whole_window, RootWindow, x, y, out dest_x_return, out dest_y_return, out child);
4987 internal override void OverrideCursor(IntPtr cursor)
4989 if (Grab.Hwnd != IntPtr.Zero) {
4990 XChangeActivePointerGrab (DisplayHandle,
4991 EventMask.ButtonMotionMask |
4992 EventMask.PointerMotionMask |
4993 EventMask.PointerMotionHintMask |
4994 EventMask.ButtonPressMask |
4995 EventMask.ButtonReleaseMask,
4996 cursor, IntPtr.Zero);
5000 OverrideCursorHandle = cursor;
5003 internal override PaintEventArgs PaintEventStart(ref Message msg, IntPtr handle, bool client)
5005 PaintEventArgs paint_event;
5010 // handle (and paint_hwnd) refers to the window that is should be painted.
5011 // msg.HWnd (and hwnd) refers to the window that got the paint message.
5014 hwnd = Hwnd.ObjectFromHandle(msg.HWnd);
5015 if (msg.HWnd == handle) {
5018 paint_hwnd = Hwnd.ObjectFromHandle (handle);
5021 if (Caret.Visible == true) {
5022 Caret.Paused = true;
5029 dc = Graphics.FromHwnd (paint_hwnd.client_window);
5031 Region clip_region = new Region ();
5032 clip_region.MakeEmpty();
5034 foreach (Rectangle r in hwnd.ClipRectangles) {
5035 /* Expand the region slightly.
5038 Rectangle r2 = Rectangle.FromLTRB (r.Left, r.Top, r.Right, r.Bottom + 1);
5039 clip_region.Union (r2);
5042 if (hwnd.UserClip != null) {
5043 clip_region.Intersect(hwnd.UserClip);
5046 dc.Clip = clip_region;
5047 paint_event = new PaintEventArgs(dc, hwnd.Invalid);
5048 hwnd.expose_pending = false;
5050 hwnd.ClearInvalidArea();
5052 hwnd.drawing_stack.Push (paint_event);
5053 hwnd.drawing_stack.Push (dc);
5057 dc = Graphics.FromHwnd (paint_hwnd.whole_window);
5059 if (!hwnd.nc_invalid.IsEmpty) {
5060 dc.SetClip (hwnd.nc_invalid);
5061 paint_event = new PaintEventArgs(dc, hwnd.nc_invalid);
5063 paint_event = new PaintEventArgs(dc, new Rectangle(0, 0, hwnd.width, hwnd.height));
5065 hwnd.nc_expose_pending = false;
5067 hwnd.ClearNcInvalidArea ();
5069 hwnd.drawing_stack.Push (paint_event);
5070 hwnd.drawing_stack.Push (dc);
5076 internal override void PaintEventEnd(ref Message msg, IntPtr handle, bool client)
5080 hwnd = Hwnd.ObjectFromHandle (msg.HWnd);
5082 Graphics dc = (Graphics)hwnd.drawing_stack.Pop ();
5086 PaintEventArgs pe = (PaintEventArgs)hwnd.drawing_stack.Pop();
5087 pe.SetGraphics (null);
5090 if (Caret.Visible == true) {
5092 Caret.Paused = false;
5096 [MonoTODO("Implement filtering and PM_NOREMOVE")]
5097 internal override bool PeekMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags)
5099 XEventQueue queue = (XEventQueue) queue_id;
5102 if ((flags & (uint)PeekMessageFlags.PM_REMOVE) == 0) {
5103 throw new NotImplementedException("PeekMessage PM_NOREMOVE is not implemented yet"); // FIXME - Implement PM_NOREMOVE flag
5107 if (queue.Count > 0) {
5110 // Only call UpdateMessageQueue if real events are pending
5111 // otherwise we go to sleep on the socket
5112 if (XPending(DisplayHandle) != 0) {
5113 UpdateMessageQueue((XEventQueue)queue_id);
5115 } else if (((XEventQueue)queue_id).Paint.Count > 0) {
5120 CheckTimers(queue.timer_list, DateTime.UtcNow);
5125 return GetMessage(queue_id, ref msg, hWnd, wFilterMin, wFilterMax);
5128 internal override bool PostMessage (IntPtr handle, Msg message, IntPtr wparam, IntPtr lparam)
5130 XEvent xevent = new XEvent ();
5131 Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
5133 xevent.type = XEventName.ClientMessage;
5134 xevent.ClientMessageEvent.display = DisplayHandle;
5137 xevent.ClientMessageEvent.window = hwnd.whole_window;
5139 xevent.ClientMessageEvent.window = IntPtr.Zero;
5142 xevent.ClientMessageEvent.message_type = (IntPtr) PostAtom;
5143 xevent.ClientMessageEvent.format = 32;
5144 xevent.ClientMessageEvent.ptr1 = handle;
5145 xevent.ClientMessageEvent.ptr2 = (IntPtr) message;
5146 xevent.ClientMessageEvent.ptr3 = wparam;
5147 xevent.ClientMessageEvent.ptr4 = lparam;
5150 hwnd.Queue.EnqueueLocked (xevent);
5152 ThreadQueue(Thread.CurrentThread).EnqueueLocked (xevent);
5157 internal override void PostQuitMessage(int exitCode)
5159 ApplicationContext ctx = Application.MWFThread.Current.Context;
5160 Form f = ctx != null ? ctx.MainForm : null;
5162 PostMessage (Application.MWFThread.Current.Context.MainForm.window.Handle, Msg.WM_QUIT, IntPtr.Zero, IntPtr.Zero);
5164 PostMessage (FosterParent, Msg.WM_QUIT, IntPtr.Zero, IntPtr.Zero);
5165 XFlush(DisplayHandle);
5168 internal override void RequestAdditionalWM_NCMessages(IntPtr hwnd, bool hover, bool leave)
5173 internal override void RequestNCRecalc(IntPtr handle)
5177 hwnd = Hwnd.ObjectFromHandle(handle);
5183 PerformNCCalc(hwnd);
5184 SendMessage(handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
5185 InvalidateNC(handle);
5188 internal override void ResetMouseHover(IntPtr handle)
5192 hwnd = Hwnd.ObjectFromHandle(handle);
5197 HoverState.Timer.Enabled = true;
5198 HoverState.X = mouse_position.X;
5199 HoverState.Y = mouse_position.Y;
5200 HoverState.Window = handle;
5204 internal override void ScreenToClient(IntPtr handle, ref int x, ref int y)
5211 hwnd = Hwnd.ObjectFromHandle(handle);
5214 XTranslateCoordinates (DisplayHandle, RootWindow, hwnd.client_window, x, y, out dest_x_return, out dest_y_return, out child);
5221 internal override void ScreenToMenu(IntPtr handle, ref int x, ref int y)
5228 hwnd = Hwnd.ObjectFromHandle(handle);
5231 XTranslateCoordinates (DisplayHandle, RootWindow, hwnd.whole_window, x, y, out dest_x_return, out dest_y_return, out child);
5234 Form form = Control.FromHandle (handle) as Form;
5235 if (form != null && form.window_manager != null) {
5236 dest_y_return -= form.window_manager.TitleBarHeight;
5243 bool GraphicsExposePredicate (IntPtr display, ref XEvent xevent, IntPtr arg)
5245 return (xevent.type == XEventName.GraphicsExpose || xevent.type == XEventName.NoExpose) &&
5246 arg == xevent.GraphicsExposeEvent.drawable;
5249 delegate bool EventPredicate (IntPtr display, ref XEvent xevent, IntPtr arg);
5251 void ProcessGraphicsExpose (Hwnd hwnd)
5253 XEvent xevent = new XEvent ();
5254 IntPtr handle = Hwnd.HandleFromObject (hwnd);
5255 EventPredicate predicate = GraphicsExposePredicate;
5258 XIfEvent (Display, ref xevent, predicate, handle);
5259 if (xevent.type != XEventName.GraphicsExpose)
5262 AddExpose (hwnd, xevent.ExposeEvent.window == hwnd.ClientWindow, xevent.GraphicsExposeEvent.x, xevent.GraphicsExposeEvent.y,
5263 xevent.GraphicsExposeEvent.width, xevent.GraphicsExposeEvent.height);
5265 if (xevent.GraphicsExposeEvent.count == 0)
5270 internal override void ScrollWindow(IntPtr handle, Rectangle area, int XAmount, int YAmount, bool with_children)
5274 XGCValues gc_values;
5276 hwnd = Hwnd.ObjectFromHandle(handle);
5278 Rectangle r = Rectangle.Intersect (hwnd.Invalid, area);
5280 /* We have an invalid area in the window we're scrolling.
5281 Adjust our stored invalid rectangle to to match the scrolled amount */
5296 if (area.Contains (hwnd.Invalid))
5297 hwnd.ClearInvalidArea ();
5298 hwnd.AddInvalidArea(r);
5301 gc_values = new XGCValues();
5303 if (with_children) {
5304 gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors;
5307 gc = XCreateGC(DisplayHandle, hwnd.client_window, IntPtr.Zero, ref gc_values);
5309 Rectangle visible_rect = GetTotalVisibleArea (hwnd.client_window);
5310 visible_rect.Intersect (area);
5312 Rectangle dest_rect = visible_rect;
5313 dest_rect.Y += YAmount;
5314 dest_rect.X += XAmount;
5315 dest_rect.Intersect (area);
5317 Point src = new Point (dest_rect.X - XAmount, dest_rect.Y - YAmount);
5318 XCopyArea (DisplayHandle, hwnd.client_window, hwnd.client_window, gc, src.X, src.Y,
5319 dest_rect.Width, dest_rect.Height, dest_rect.X, dest_rect.Y);
5321 Rectangle dirty_area = GetDirtyArea (area, dest_rect, XAmount, YAmount);
5322 AddExpose (hwnd, true, dirty_area.X, dirty_area.Y, dirty_area.Width, dirty_area.Height);
5324 ProcessGraphicsExpose (hwnd);
5326 XFreeGC(DisplayHandle, gc);
5329 internal override void ScrollWindow(IntPtr handle, int XAmount, int YAmount, bool with_children)
5334 hwnd = Hwnd.GetObjectFromWindow(handle);
5336 rect = hwnd.ClientRect;
5339 ScrollWindow(handle, rect, XAmount, YAmount, with_children);
5342 Rectangle GetDirtyArea (Rectangle total_area, Rectangle valid_area, int XAmount, int YAmount)
5344 Rectangle dirty_area = total_area;
5347 dirty_area.Height -= valid_area.Height;
5348 else if (YAmount < 0) {
5349 dirty_area.Height -= valid_area.Height;
5350 dirty_area.Y += valid_area.Height;
5354 dirty_area.Width -= valid_area.Width;
5355 else if (XAmount < 0) {
5356 dirty_area.Width -= valid_area.Width;
5357 dirty_area.X += valid_area.Width;
5363 Rectangle GetTotalVisibleArea (IntPtr handle)
5365 Control c = Control.FromHandle (handle);
5367 Rectangle visible_area = c.ClientRectangle;
5368 visible_area.Location = c.PointToScreen (Point.Empty);
5370 for (Control parent = c.Parent; parent != null; parent = parent.Parent) {
5371 if (!parent.IsHandleCreated || !parent.Visible)
5372 return visible_area; // Non visible, not need to finish computations
5374 Rectangle r = parent.ClientRectangle;
5375 r.Location = parent.PointToScreen (Point.Empty);
5377 visible_area.Intersect (r);
5380 visible_area.Location = c.PointToClient (visible_area.Location);
5381 return visible_area;
5384 internal override void SendAsyncMethod (AsyncMethodData method)
5387 XEvent xevent = new XEvent ();
5389 hwnd = Hwnd.ObjectFromHandle(method.Handle);
5391 xevent.type = XEventName.ClientMessage;
5392 xevent.ClientMessageEvent.display = DisplayHandle;
5393 xevent.ClientMessageEvent.window = method.Handle;
5394 xevent.ClientMessageEvent.message_type = (IntPtr)AsyncAtom;
5395 xevent.ClientMessageEvent.format = 32;
5396 xevent.ClientMessageEvent.ptr1 = (IntPtr) GCHandle.Alloc (method);
5398 hwnd.Queue.EnqueueLocked (xevent);
5403 delegate IntPtr WndProcDelegate (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam);
5405 internal override IntPtr SendMessage (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam)
5408 h = Hwnd.ObjectFromHandle(hwnd);
5410 if (h != null && h.queue != ThreadQueue (Thread.CurrentThread)) {
5411 AsyncMethodResult result;
5412 AsyncMethodData data;
5414 result = new AsyncMethodResult ();
5415 data = new AsyncMethodData ();
5418 data.Method = new WndProcDelegate (NativeWindow.WndProc);
5419 data.Args = new object[] { hwnd, message, wParam, lParam };
5420 data.Result = result;
5422 SendAsyncMethod (data);
5423 DriverDebug("Sending {0} message across.", message);
5427 string key = hwnd + ":" + message;
5428 if (messageHold[key] != null)
5429 messageHold[key] = ((int)messageHold[key]) - 1;
5430 return NativeWindow.WndProc(hwnd, message, wParam, lParam);
5433 internal override int SendInput(IntPtr handle, Queue keys)
5435 if (handle == IntPtr.Zero)
5438 int count = keys.Count;
5439 Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
5441 while (keys.Count > 0) {
5443 MSG msg = (MSG)keys.Dequeue();
5445 XEvent xevent = new XEvent ();
5447 xevent.type = (msg.message == Msg.WM_KEYUP ? XEventName.KeyRelease : XEventName.KeyPress);
5448 xevent.KeyEvent.display = DisplayHandle;
5451 xevent.KeyEvent.window = hwnd.whole_window;
5453 xevent.KeyEvent.window = IntPtr.Zero;
5456 xevent.KeyEvent.keycode = Keyboard.ToKeycode((int)msg.wParam);
5458 hwnd.Queue.EnqueueLocked (xevent);
5463 internal override void SetAllowDrop (IntPtr handle, bool value)
5465 // We allow drop on all windows
5468 internal override DragDropEffects StartDrag (IntPtr handle, object data,
5469 DragDropEffects allowed_effects)
5471 Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
5474 throw new ArgumentException ("Attempt to begin drag from invalid window handle (" + handle.ToInt32 () + ").");
5476 return Dnd.StartDrag (hwnd.client_window, data, allowed_effects);
5479 internal override void SetBorderStyle(IntPtr handle, FormBorderStyle border_style)
5481 Form form = Control.FromHandle (handle) as Form;
5482 if (form != null && form.window_manager == null) {
5483 CreateParams cp = form.GetCreateParams ();
5484 if (border_style == FormBorderStyle.FixedToolWindow ||
5485 border_style == FormBorderStyle.SizableToolWindow ||
5486 cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) {
5487 form.window_manager = new ToolWindowManager (form);
5491 RequestNCRecalc(handle);
5494 internal override void SetCaretPos(IntPtr handle, int x, int y)
5496 if (Caret.Hwnd == handle) {
5503 Keyboard.SetCaretPos (Caret, handle, x, y);
5505 if (Caret.Visible == true) {
5507 Caret.Timer.Start();
5512 internal override void SetClipRegion(IntPtr handle, Region region)
5516 hwnd = Hwnd.ObjectFromHandle(handle);
5521 hwnd.UserClip = region;
5524 internal override void SetCursor(IntPtr handle, IntPtr cursor)
5528 if (OverrideCursorHandle == IntPtr.Zero) {
5529 if ((LastCursorWindow == handle) && (LastCursorHandle == cursor)) {
5533 LastCursorHandle = cursor;
5534 LastCursorWindow = handle;
5536 hwnd = Hwnd.ObjectFromHandle(handle);
5538 if (cursor != IntPtr.Zero) {
5539 XDefineCursor(DisplayHandle, hwnd.whole_window, cursor);
5541 XUndefineCursor(DisplayHandle, hwnd.whole_window);
5543 XFlush(DisplayHandle);
5548 hwnd = Hwnd.ObjectFromHandle(handle);
5550 XDefineCursor(DisplayHandle, hwnd.whole_window, OverrideCursorHandle);
5554 void QueryPointer (IntPtr display, IntPtr w, out IntPtr root, out IntPtr child,
5555 out int root_x, out int root_y, out int child_x, out int child_y,
5558 /* this code was written with the help of
5559 glance at gdk. I never would have realized we
5560 needed a loop in order to traverse down in the
5561 hierarchy. I would have assumed you'd get the
5562 most deeply nested child and have to do
5563 XQueryTree to move back up the hierarchy..
5564 stupid me, of course. */
5567 XGrabServer (display);
5569 XQueryPointer(display, w, out root, out c,
5570 out root_x, out root_y, out child_x, out child_y,
5576 IntPtr child_last = IntPtr.Zero;
5577 while (c != IntPtr.Zero) {
5579 XQueryPointer(display, c, out root, out c,
5580 out root_x, out root_y, out child_x, out child_y,
5583 XUngrabServer (display);
5589 internal override void SetCursorPos(IntPtr handle, int x, int y)
5591 if (handle == IntPtr.Zero) {
5594 int root_x, root_y, child_x, child_y, mask;
5597 * QueryPointer before warping
5598 * because if the warp is on
5599 * the RootWindow, the x/y are
5600 * relative to the current
5603 QueryPointer (DisplayHandle, RootWindow,
5606 out root_x, out root_y,
5607 out child_x, out child_y,
5610 XWarpPointer(DisplayHandle, IntPtr.Zero, IntPtr.Zero, 0, 0, 0, 0, x - root_x, y - root_y);
5612 XFlush (DisplayHandle);
5614 /* then we need to a
5615 * QueryPointer after warping
5616 * to manually generate a
5617 * motion event for the window
5620 QueryPointer (DisplayHandle, RootWindow,
5623 out root_x, out root_y,
5624 out child_x, out child_y,
5627 Hwnd child_hwnd = Hwnd.ObjectFromHandle(child);
5628 if (child_hwnd == null) {
5632 XEvent xevent = new XEvent ();
5634 xevent.type = XEventName.MotionNotify;
5635 xevent.MotionEvent.display = DisplayHandle;
5636 xevent.MotionEvent.window = child_hwnd.client_window;
5637 xevent.MotionEvent.root = RootWindow;
5638 xevent.MotionEvent.x = child_x;
5639 xevent.MotionEvent.y = child_y;
5640 xevent.MotionEvent.x_root = root_x;
5641 xevent.MotionEvent.y_root = root_y;
5642 xevent.MotionEvent.state = mask;
5644 child_hwnd.Queue.EnqueueLocked (xevent);
5649 hwnd = Hwnd.ObjectFromHandle(handle);
5651 XWarpPointer(DisplayHandle, IntPtr.Zero, hwnd.client_window, 0, 0, 0, 0, x, y);
5656 internal override void SetFocus(IntPtr handle)
5659 IntPtr prev_focus_window;
5661 hwnd = Hwnd.ObjectFromHandle(handle);
5663 if (hwnd.client_window == FocusWindow) {
5667 // Win32 doesn't do anything if disabled
5671 prev_focus_window = FocusWindow;
5672 FocusWindow = hwnd.client_window;
5674 if (prev_focus_window != IntPtr.Zero) {
5675 SendMessage(prev_focus_window, Msg.WM_KILLFOCUS, FocusWindow, IntPtr.Zero);
5677 Keyboard.FocusIn (FocusWindow);
5678 SendMessage(FocusWindow, Msg.WM_SETFOCUS, prev_focus_window, IntPtr.Zero);
5680 //XSetInputFocus(DisplayHandle, Hwnd.ObjectFromHandle(handle).client_window, RevertTo.None, IntPtr.Zero);
5683 internal override void SetIcon(IntPtr handle, Icon icon)
5687 hwnd = Hwnd.ObjectFromHandle(handle);
5689 SetIcon(hwnd, icon);
5693 internal override void SetMenu(IntPtr handle, Menu menu)
5697 hwnd = Hwnd.ObjectFromHandle(handle);
5700 RequestNCRecalc(handle);
5703 internal override void SetModal(IntPtr handle, bool Modal)
5706 ModalWindows.Push(handle);
5708 if (ModalWindows.Contains(handle)) {
5711 if (ModalWindows.Count > 0) {
5712 Activate((IntPtr)ModalWindows.Peek());
5716 Hwnd hwnd = Hwnd.ObjectFromHandle (handle);
5717 Control ctrl = Control.FromHandle (handle);
5718 SetWMStyles (hwnd, ctrl.GetCreateParams ());
5721 internal override IntPtr SetParent(IntPtr handle, IntPtr parent)
5725 hwnd = Hwnd.ObjectFromHandle(handle);
5726 hwnd.parent = Hwnd.ObjectFromHandle(parent);
5729 DriverDebug("Parent for window {0} = {1}", XplatUI.Window(hwnd.Handle), XplatUI.Window(hwnd.parent != null ? hwnd.parent.Handle : IntPtr.Zero));
5730 XReparentWindow(DisplayHandle, hwnd.whole_window, hwnd.parent == null ? FosterParent : hwnd.parent.client_window, hwnd.x, hwnd.y);
5736 internal override void SetTimer (Timer timer)
5738 XEventQueue queue = (XEventQueue) MessageQueues [timer.thread];
5740 if (queue == null) {
5741 // This isn't really an error, MS doesn't start the timer if
5742 // it has no assosciated queue at this stage (it will be
5743 // enabled when a window is activated).
5744 unattached_timer_list.Add (timer);
5747 queue.timer_list.Add (timer);
5751 internal override bool SetTopmost(IntPtr handle, bool enabled)
5754 Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
5759 SendNetWMMessage(hwnd.WholeWindow, _NET_WM_STATE, (IntPtr) NetWmStateRequest._NET_WM_STATE_ADD, _NET_WM_STATE_ABOVE, IntPtr.Zero);
5761 int[] atoms = new int[8];
5762 atoms[0] = _NET_WM_STATE_ABOVE.ToInt32();
5763 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
5769 SendNetWMMessage(hwnd.WholeWindow, _NET_WM_STATE, (IntPtr) NetWmStateRequest._NET_WM_STATE_REMOVE, _NET_WM_STATE_ABOVE, IntPtr.Zero);
5771 XDeleteProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE);
5777 internal override bool SetOwner(IntPtr handle, IntPtr handle_owner)
5782 hwnd = Hwnd.ObjectFromHandle(handle);
5784 if (handle_owner != IntPtr.Zero) {
5785 hwnd_owner = Hwnd.ObjectFromHandle(handle_owner);
5791 atoms[0] = _NET_WM_WINDOW_TYPE_NORMAL.ToInt32();
5792 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1);
5794 if (hwnd_owner != null) {
5795 XSetTransientForHint(DisplayHandle, hwnd.whole_window, hwnd_owner.whole_window);
5797 XSetTransientForHint(DisplayHandle, hwnd.whole_window, RootWindow);
5802 XDeleteProperty(DisplayHandle, hwnd.whole_window, (IntPtr)Atom.XA_WM_TRANSIENT_FOR);
5808 internal override bool SetVisible (IntPtr handle, bool visible, bool activate)
5812 hwnd = Hwnd.ObjectFromHandle(handle);
5813 hwnd.visible = visible;
5817 MapWindow(hwnd, WindowType.Both);
5819 if (Control.FromHandle(handle) is Form) {
5822 s = ((Form)Control.FromHandle(handle)).WindowState;
5825 case FormWindowState.Minimized: SetWindowState(handle, FormWindowState.Minimized); break;
5826 case FormWindowState.Maximized: SetWindowState(handle, FormWindowState.Maximized); break;
5830 SendMessage(handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
5833 UnmapWindow(hwnd, WindowType.Both);
5839 internal override void SetWindowMinMax(IntPtr handle, Rectangle maximized, Size min, Size max)
5841 Control ctrl = Control.FromHandle (handle);
5842 SetWindowMinMax (handle, maximized, min, max, ctrl != null ? ctrl.GetCreateParams () : null);
5845 internal void SetWindowMinMax (IntPtr handle, Rectangle maximized, Size min, Size max, CreateParams cp)
5851 hwnd = Hwnd.ObjectFromHandle(handle);
5856 min.Width = Math.Max (min.Width, SystemInformation.MinimumWindowSize.Width);
5857 min.Height = Math.Max (min.Height, SystemInformation.MinimumWindowSize.Height);
5859 hints = new XSizeHints();
5861 XGetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints, out dummy);
5862 if ((min != Size.Empty) && (min.Width > 0) && (min.Height > 0)) {
5864 min = TranslateWindowSizeToXWindowSize (cp, min);
5865 hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMinSize);
5866 hints.min_width = min.Width;
5867 hints.min_height = min.Height;
5870 if ((max != Size.Empty) && (max.Width > 0) && (max.Height > 0)) {
5872 max = TranslateWindowSizeToXWindowSize (cp, max);
5873 hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMaxSize);
5874 hints.max_width = max.Width;
5875 hints.max_height = max.Height;
5878 if (hints.flags != IntPtr.Zero) {
5879 // The Metacity team has decided that they won't care about this when clicking the maximize icon,
5880 // they will maximize the window to fill the screen/parent no matter what.
5881 // http://bugzilla.ximian.com/show_bug.cgi?id=80021
5882 XSetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints);
5885 if ((maximized != Rectangle.Empty) && (maximized.Width > 0) && (maximized.Height > 0)) {
5887 maximized.Size = TranslateWindowSizeToXWindowSize (cp);
5888 hints.flags = (IntPtr)XSizeHintsFlags.PPosition;
5889 hints.x = maximized.X;
5890 hints.y = maximized.Y;
5891 hints.width = maximized.Width;
5892 hints.height = maximized.Height;
5894 // Metacity does not seem to follow this constraint for maximized (zoomed) windows
5895 XSetZoomHints(DisplayHandle, hwnd.whole_window, ref hints);
5900 internal override void SetWindowPos(IntPtr handle, int x, int y, int width, int height)
5904 hwnd = Hwnd.ObjectFromHandle(handle);
5910 // Win32 automatically changes negative width/height to 0.
5916 // X requires a sanity check for width & height; otherwise it dies
5917 if (hwnd.zero_sized && width > 0 && height > 0) {
5919 MapWindow(hwnd, WindowType.Whole);
5921 hwnd.zero_sized = false;
5924 if ((width < 1) || (height < 1)) {
5925 hwnd.zero_sized = true;
5926 UnmapWindow(hwnd, WindowType.Whole);
5929 // Save a server roundtrip (and prevent a feedback loop)
5930 if ((hwnd.x == x) && (hwnd.y == y) &&
5931 (hwnd.width == width) && (hwnd.height == height)) {
5935 if (!hwnd.zero_sized) {
5940 hwnd.height = height;
5941 SendMessage(hwnd.client_window, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero);
5943 if (hwnd.fixed_size) {
5944 SetWindowMinMax(handle, Rectangle.Empty, new Size(width, height), new Size(width, height));
5948 Control ctrl = Control.FromHandle (handle);
5949 Size TranslatedSize = TranslateWindowSizeToXWindowSize (ctrl.GetCreateParams (), new Size (width, height));
5950 MoveResizeWindow (DisplayHandle, hwnd.whole_window, x, y, TranslatedSize.Width, TranslatedSize.Height);
5951 PerformNCCalc(hwnd);
5955 // Update our position/size immediately, so
5956 // that future calls to SetWindowPos aren't
5957 // kept from calling XMoveResizeWindow (by the
5958 // "Save a server roundtrip" block above).
5962 hwnd.height = height;
5963 hwnd.ClientRect = Rectangle.Empty;
5966 internal override void SetWindowState(IntPtr handle, FormWindowState state)
5968 FormWindowState current_state;
5971 hwnd = Hwnd.ObjectFromHandle(handle);
5973 current_state = GetWindowState(handle);
5975 if (current_state == state) {
5980 case FormWindowState.Normal: {
5982 if (current_state == FormWindowState.Minimized) {
5983 MapWindow(hwnd, WindowType.Both);
5984 } else if (current_state == FormWindowState.Maximized) {
5985 SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)2 /* toggle */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT);
5992 case FormWindowState.Minimized: {
5994 if (current_state == FormWindowState.Maximized) {
5995 SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)2 /* toggle */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT);
5997 XIconifyWindow(DisplayHandle, hwnd.whole_window, ScreenNo);
6002 case FormWindowState.Maximized: {
6004 if (current_state == FormWindowState.Minimized) {
6005 MapWindow(hwnd, WindowType.Both);
6008 SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)1 /* Add */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT);
6016 internal override void SetWindowStyle(IntPtr handle, CreateParams cp)
6020 hwnd = Hwnd.ObjectFromHandle(handle);
6021 SetHwndStyles(hwnd, cp);
6022 SetWMStyles(hwnd, cp);
6025 internal override double GetWindowTransparency(IntPtr handle)
6030 internal override void SetWindowTransparency(IntPtr handle, double transparency, Color key)
6035 hwnd = Hwnd.ObjectFromHandle(handle);
6041 hwnd.opacity = (uint)(0xffffffff * transparency);
6042 opacity = (IntPtr)((int)hwnd.opacity);
6044 IntPtr w = hwnd.whole_window;
6045 if (hwnd.reparented)
6046 w = XGetParent (hwnd.whole_window);
6047 XChangeProperty(DisplayHandle, w, _NET_WM_WINDOW_OPACITY, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, ref opacity, 1);
6050 internal override bool SetZOrder(IntPtr handle, IntPtr after_handle, bool top, bool bottom)
6052 Hwnd hwnd = Hwnd.ObjectFromHandle(handle);
6060 XRaiseWindow(DisplayHandle, hwnd.whole_window);
6063 } else if (!bottom) {
6064 Hwnd after_hwnd = null;
6066 if (after_handle != IntPtr.Zero) {
6067 after_hwnd = Hwnd.ObjectFromHandle(after_handle);
6070 XWindowChanges values = new XWindowChanges();
6072 if (after_hwnd == null) {
6073 // Work around metacity 'issues'
6077 atoms[0] = unixtime();
6078 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_USER_TIME, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, atoms, 1);
6080 XRaiseWindow(DisplayHandle, hwnd.whole_window);
6081 SendNetWMMessage(hwnd.whole_window, _NET_ACTIVE_WINDOW, (IntPtr)1, IntPtr.Zero, IntPtr.Zero);
6083 //throw new ArgumentNullException("after_handle", "Need sibling to adjust z-order");
6086 values.sibling = after_hwnd.whole_window;
6087 values.stack_mode = StackMode.Below;
6090 XConfigureWindow(DisplayHandle, hwnd.whole_window, ChangeWindowFlags.CWStackMode | ChangeWindowFlags.CWSibling, ref values);
6095 XLowerWindow(DisplayHandle, hwnd.whole_window);
6102 internal override void ShowCursor(bool show)
6104 ; // FIXME - X11 doesn't 'hide' the cursor. we could create an empty cursor
6107 internal override object StartLoop(Thread thread)
6109 XEventQueue q = ThreadQueue(thread);
6113 internal override TransparencySupport SupportsTransparency()
6115 // We need to check if the x compositing manager is running
6116 return TransparencySupport.Set;
6119 internal override bool SystrayAdd(IntPtr handle, string tip, Icon icon, out ToolTip tt)
6121 GetSystrayManagerWindow();
6123 if (SystrayMgrWindow != IntPtr.Zero) {
6124 XSizeHints size_hints;
6127 hwnd = Hwnd.ObjectFromHandle(handle);
6128 DriverDebug("Adding Systray Whole:{0:X}, Client:{1:X}", hwnd.whole_window.ToInt32(), hwnd.client_window.ToInt32());
6131 if (hwnd.client_window != hwnd.whole_window) {
6132 Keyboard.DestroyICForWindow (hwnd.client_window);
6133 XDestroyWindow(DisplayHandle, hwnd.client_window);
6134 hwnd.client_window = hwnd.whole_window;
6137 /* by virtue of the way the tests are ordered when determining if it's PAINT
6138 or NCPAINT, client_window == whole_window will always be PAINT. So, if we're
6139 waiting on an nc_expose, drop it and remove the hwnd from the list (unless
6140 there's a pending expose). */
6141 if (hwnd.nc_expose_pending) {
6142 hwnd.nc_expose_pending = false;
6143 if (!hwnd.expose_pending)
6144 hwnd.Queue.Paint.Remove (hwnd);
6147 // We are going to be directly mapped by the system tray, so mark as mapped
6148 // so we can later properly unmap it.
6151 size_hints = new XSizeHints();
6153 size_hints.flags = (IntPtr)(XSizeHintsFlags.PMinSize | XSizeHintsFlags.PMaxSize | XSizeHintsFlags.PBaseSize);
6155 size_hints.min_width = 24;
6156 size_hints.min_height = 24;
6157 size_hints.max_width = 24;
6158 size_hints.max_height = 24;
6159 size_hints.base_width = 24;
6160 size_hints.base_height = 24;
6162 XSetWMNormalHints(DisplayHandle, hwnd.whole_window, ref size_hints);
6164 int[] atoms = new int[2];
6165 atoms [0] = 1; // Version 1
6166 atoms [1] = 1; // we want to be mapped
6168 // This line cost me 3 days...
6169 XChangeProperty(DisplayHandle, hwnd.whole_window, _XEMBED_INFO, _XEMBED_INFO, 32, PropertyMode.Replace, atoms, 2);
6171 // Need to pick some reasonable defaults
6173 tt.AutomaticDelay = 350;
6174 tt.InitialDelay = 250;
6175 tt.ReshowDelay = 250;
6176 tt.ShowAlways = true;
6178 if ((tip != null) && (tip != string.Empty)) {
6179 tt.SetToolTip(Control.FromHandle(handle), tip);
6185 SendNetClientMessage(SystrayMgrWindow, _NET_SYSTEM_TRAY_OPCODE, IntPtr.Zero, (IntPtr)SystrayRequest.SYSTEM_TRAY_REQUEST_DOCK, hwnd.whole_window);
6193 internal override bool SystrayChange(IntPtr handle, string tip, Icon icon, ref ToolTip tt)
6197 control = Control.FromHandle(handle);
6198 if (control != null && tt != null) {
6199 tt.SetToolTip(control, tip);
6201 SendMessage(handle, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero);
6208 internal override void SystrayRemove(IntPtr handle, ref ToolTip tt)
6211 SetVisible (handle, false, false);
6213 // The caller can now re-dock it later...
6218 // Close any balloon window *we* fired.
6219 ThemeEngine.Current.HideBalloonWindow (handle);
6222 internal override void SystrayBalloon(IntPtr handle, int timeout, string title, string text, ToolTipIcon icon)
6224 ThemeEngine.Current.ShowBalloonWindow (handle, timeout, title, text, icon);
6225 SendMessage(handle, Msg.WM_USER, IntPtr.Zero, (IntPtr) Msg.NIN_BALLOONSHOW);
6228 internal override bool Text(IntPtr handle, string text)
6232 hwnd = Hwnd.ObjectFromHandle(handle);
6235 XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_NAME, UTF8_STRING, 8,
6236 PropertyMode.Replace, text, Encoding.UTF8.GetByteCount (text));
6238 // XXX this has problems with UTF8.
6239 // we need to either use the actual
6240 // text if it's latin-1, or convert it
6241 // to compound text if it's in a
6242 // different charset.
6243 XStoreName(DisplayHandle, Hwnd.ObjectFromHandle(handle).whole_window, text);
6248 internal override bool TranslateMessage(ref MSG msg)
6250 return Keyboard.TranslateMessage (ref msg);
6253 internal override void UpdateWindow(IntPtr handle)
6257 hwnd = Hwnd.ObjectFromHandle(handle);
6259 if (!hwnd.visible || !hwnd.expose_pending || !hwnd.Mapped) {
6263 SendMessage(handle, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero);
6264 hwnd.Queue.Paint.Remove(hwnd);
6267 internal override void CreateOffscreenDrawable (IntPtr handle,
6268 int width, int height,
6269 out object offscreen_drawable)
6272 int x_out, y_out, width_out, height_out, border_width_out, depth_out;
6274 XGetGeometry (DisplayHandle, handle,
6276 out x_out, out y_out,
6277 out width_out, out height_out,
6278 out border_width_out, out depth_out);
6280 IntPtr pixmap = XCreatePixmap (DisplayHandle, handle, width, height, depth_out);
6282 offscreen_drawable = pixmap;
6286 internal override void DestroyOffscreenDrawable (object offscreen_drawable)
6288 XFreePixmap (DisplayHandle, (IntPtr)offscreen_drawable);
6291 internal override Graphics GetOffscreenGraphics (object offscreen_drawable)
6293 return Graphics.FromHwnd ((IntPtr) offscreen_drawable);
6296 internal override void BlitFromOffscreen (IntPtr dest_handle,
6298 object offscreen_drawable,
6299 Graphics offscreen_dc,
6302 XGCValues gc_values;
6305 gc_values = new XGCValues();
6307 gc = XCreateGC (DisplayHandle, dest_handle, IntPtr.Zero, ref gc_values);
6309 XCopyArea (DisplayHandle, (IntPtr)offscreen_drawable, dest_handle,
6310 gc, r.X, r.Y, r.Width, r.Height, r.X, r.Y);
6312 XFreeGC (DisplayHandle, gc);
6315 #endregion // Public Static Methods
6318 internal override event EventHandler Idle;
6319 #endregion // Events
6324 #region Xcursor imports
6325 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadCursor")]
6326 internal extern static IntPtr XcursorLibraryLoadCursor (IntPtr display, [MarshalAs (UnmanagedType.LPStr)] string name);
6328 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadImages")]
6329 internal extern static IntPtr XcursorLibraryLoadImages ([MarshalAs (UnmanagedType.LPStr)] string file, IntPtr theme, int size);
6331 [DllImport ("libXcursor", EntryPoint = "XcursorImagesDestroy")]
6332 internal extern static void XcursorImagesDestroy (IntPtr images);
6334 [DllImport ("libXcursor", EntryPoint = "XcursorGetDefaultSize")]
6335 internal extern static int XcursorGetDefaultSize (IntPtr display);
6337 [DllImport ("libXcursor", EntryPoint = "XcursorImageLoadCursor")]
6338 internal extern static IntPtr XcursorImageLoadCursor (IntPtr display, IntPtr image);
6340 [DllImport ("libXcursor", EntryPoint = "XcursorGetTheme")]
6341 internal extern static IntPtr XcursorGetTheme (IntPtr display);
6344 [DllImport ("libX11", EntryPoint="XOpenDisplay")]
6345 internal extern static IntPtr XOpenDisplay(IntPtr display);
6346 [DllImport ("libX11", EntryPoint="XCloseDisplay")]
6347 internal extern static int XCloseDisplay(IntPtr display);
6348 [DllImport ("libX11", EntryPoint="XSynchronize")]
6349 internal extern static IntPtr XSynchronize(IntPtr display, bool onoff);
6351 [DllImport ("libX11", EntryPoint="XCreateWindow")]
6352 internal extern static IntPtr _XCreateWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, UIntPtr valuemask, ref XSetWindowAttributes attributes);
6353 internal static IntPtr XCreateWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, UIntPtr valuemask, ref XSetWindowAttributes attributes)
6355 DebugHelper.TraceWriteLine ("XCreateWindow");
6356 return _XCreateWindow(display, parent, x, y, width, height,
6357 border_width, depth, xclass, visual, valuemask, ref attributes);
6359 [DllImport ("libX11", EntryPoint="XCreateSimpleWindow")]
6360 internal extern static IntPtr _XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background);
6361 internal static IntPtr XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background)
6363 DebugHelper.TraceWriteLine ("XCreateSimpleWindow");
6364 return _XCreateSimpleWindow(display, parent, x, y, width, height, border_width, border, background);
6366 [DllImport ("libX11", EntryPoint="XMapWindow")]
6367 internal extern static int _XMapWindow(IntPtr display, IntPtr window);
6368 internal static int XMapWindow(IntPtr display, IntPtr window)
6370 DebugHelper.TraceWriteLine ("XMapWindow");
6371 return _XMapWindow(display, window);
6373 [DllImport ("libX11", EntryPoint="XUnmapWindow")]
6374 internal extern static int _XUnmapWindow(IntPtr display, IntPtr window);
6375 internal static int XUnmapWindow(IntPtr display, IntPtr window)
6377 DebugHelper.TraceWriteLine ("XUnmapWindow");
6378 return _XUnmapWindow(display, window);
6380 [DllImport ("libX11", EntryPoint="XMapSubwindows")]
6381 internal extern static int _XMapSubindows(IntPtr display, IntPtr window);
6382 internal static int XMapSubindows(IntPtr display, IntPtr window)
6384 DebugHelper.TraceWriteLine ("XMapSubindows");
6385 return _XMapSubindows(display, window);
6387 [DllImport ("libX11", EntryPoint="XUnmapSubwindows")]
6388 internal extern static int _XUnmapSubwindows(IntPtr display, IntPtr window);
6389 internal static int XUnmapSubwindows(IntPtr display, IntPtr window)
6391 DebugHelper.TraceWriteLine ("XUnmapSubwindows");
6392 return _XUnmapSubwindows(display, window);
6394 [DllImport ("libX11", EntryPoint="XRootWindow")]
6395 internal extern static IntPtr _XRootWindow(IntPtr display, int screen_number);
6396 internal static IntPtr XRootWindow(IntPtr display, int screen_number)
6398 DebugHelper.TraceWriteLine ("XRootWindow");
6399 return _XRootWindow(display, screen_number);
6401 [DllImport ("libX11", EntryPoint="XNextEvent")]
6402 internal extern static IntPtr _XNextEvent(IntPtr display, ref XEvent xevent);
6403 internal static IntPtr XNextEvent(IntPtr display, ref XEvent xevent)
6405 DebugHelper.TraceWriteLine ("XNextEvent");
6406 return _XNextEvent(display, ref xevent);
6408 [DllImport ("libX11", EntryPoint="XConnectionNumber")]
6409 internal extern static int _XConnectionNumber (IntPtr display);
6410 internal static int XConnectionNumber (IntPtr display)
6412 DebugHelper.TraceWriteLine ("XConnectionNumber");
6413 return _XConnectionNumber (display);
6415 [DllImport ("libX11", EntryPoint="XPending")]
6416 internal extern static int _XPending (IntPtr display);
6417 internal static int XPending (IntPtr display)
6419 DebugHelper.TraceWriteLine ("XPending");
6420 DebugHelper.DumpCallers (3);
6421 return _XPending (display);
6423 [DllImport ("libX11", EntryPoint="XSelectInput")]
6424 internal extern static IntPtr _XSelectInput(IntPtr display, IntPtr window, IntPtr mask);
6425 internal static IntPtr XSelectInput(IntPtr display, IntPtr window, IntPtr mask)
6427 DebugHelper.TraceWriteLine ("XSelectInput");
6428 return _XSelectInput(display, window, mask);
6431 [DllImport ("libX11", EntryPoint="XDestroyWindow")]
6432 internal extern static int _XDestroyWindow(IntPtr display, IntPtr window);
6433 internal static int XDestroyWindow(IntPtr display, IntPtr window)
6435 DebugHelper.TraceWriteLine ("XDestroyWindow 0x{0:x}", window.ToInt32());
6436 return _XDestroyWindow(display, window);
6439 [DllImport ("libX11", EntryPoint="XReparentWindow")]
6440 internal extern static int _XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y);
6441 internal static int XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y)
6443 DebugHelper.TraceWriteLine ("XReparentWindow");
6444 return _XReparentWindow(display, window, parent, x, y);
6447 [DllImport ("libX11", EntryPoint="XMoveResizeWindow")]
6448 extern static int _XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height);
6449 static int XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height) {
6450 DebugHelper.TraceWriteLine ("XMoveResizeWindow");
6451 return _XMoveResizeWindow(display, window, x, y, width, height);
6454 internal static int MoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height)
6456 int ret = XMoveResizeWindow (display, window, x, y, width, height);
6457 Keyboard.MoveCurrentCaretPos ();
6461 [DllImport ("libX11", EntryPoint="XResizeWindow")]
6462 internal extern static int _XResizeWindow(IntPtr display, IntPtr window, int width, int height);
6463 internal static int XResizeWindow(IntPtr display, IntPtr window, int width, int height)
6465 DebugHelper.TraceWriteLine ("XResizeWindow");
6466 return _XResizeWindow(display, window, width, height);
6469 [DllImport ("libX11", EntryPoint="XGetWindowAttributes")]
6470 internal extern static int _XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes);
6471 internal static int XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes)
6473 DebugHelper.TraceWriteLine ("XGetWindowAttributes");
6474 return _XGetWindowAttributes(display, window, ref attributes);
6477 [DllImport ("libX11", EntryPoint="XFlush")]
6478 internal extern static int _XFlush(IntPtr display);
6479 internal static int XFlush(IntPtr display)
6481 DebugHelper.TraceWriteLine ("XFlush");
6482 return _XFlush(display);
6485 [DllImport ("libX11", EntryPoint="XSetWMName")]
6486 internal extern static int _XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop);
6487 internal static int XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop)
6489 DebugHelper.TraceWriteLine ("XSetWMName");
6490 return _XSetWMName(display, window, ref text_prop);
6493 [DllImport ("libX11", EntryPoint="XStoreName")]
6494 internal extern static int _XStoreName(IntPtr display, IntPtr window, string window_name);
6495 internal static int XStoreName(IntPtr display, IntPtr window, string window_name)
6497 DebugHelper.TraceWriteLine ("XStoreName");
6498 return _XStoreName(display, window, window_name);
6501 [DllImport ("libX11", EntryPoint="XFetchName")]
6502 internal extern static int _XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name);
6503 internal static int XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name)
6505 DebugHelper.TraceWriteLine ("XFetchName");
6506 return _XFetchName(display, window, ref window_name);
6509 [DllImport ("libX11", EntryPoint="XSendEvent")]
6510 internal extern static int _XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event);
6511 internal static int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event)
6513 DebugHelper.TraceWriteLine ("XSendEvent");
6514 return _XSendEvent(display, window, propagate, event_mask, ref send_event);
6517 [DllImport ("libX11", EntryPoint="XQueryTree")]
6518 internal extern static int _XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return);
6519 internal static int XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return)
6521 DebugHelper.TraceWriteLine ("XQueryTree");
6522 return _XQueryTree(display, window, out root_return, out parent_return, out children_return, out nchildren_return);
6525 [DllImport ("libX11", EntryPoint="XFree")]
6526 internal extern static int _XFree(IntPtr data);
6527 internal static int XFree(IntPtr data)
6529 DebugHelper.TraceWriteLine ("XFree");
6530 return _XFree(data);
6533 [DllImport ("libX11", EntryPoint="XRaiseWindow")]
6534 internal extern static int _XRaiseWindow(IntPtr display, IntPtr window);
6535 internal static int XRaiseWindow(IntPtr display, IntPtr window)
6537 DebugHelper.TraceWriteLine ("XRaiseWindow");
6538 return _XRaiseWindow(display, window);
6541 [DllImport ("libX11", EntryPoint="XLowerWindow")]
6542 internal extern static uint _XLowerWindow(IntPtr display, IntPtr window);
6543 internal static uint XLowerWindow(IntPtr display, IntPtr window)
6545 DebugHelper.TraceWriteLine ("XLowerWindow");
6546 return _XLowerWindow(display, window);
6549 [DllImport ("libX11", EntryPoint="XConfigureWindow")]
6550 internal extern static uint _XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values);
6551 internal static uint XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values)
6553 DebugHelper.TraceWriteLine ("XConfigureWindow");
6554 return _XConfigureWindow(display, window, value_mask, ref values);
6557 [DllImport ("libX11", EntryPoint="XInternAtom")]
6558 internal extern static IntPtr _XInternAtom(IntPtr display, string atom_name, bool only_if_exists);
6559 internal static IntPtr XInternAtom(IntPtr display, string atom_name, bool only_if_exists)
6561 DebugHelper.TraceWriteLine ("XInternAtom");
6562 return _XInternAtom(display, atom_name, only_if_exists);
6565 [DllImport ("libX11", EntryPoint="XInternAtoms")]
6566 internal extern static int _XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms);
6567 internal static int XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms)
6569 DebugHelper.TraceWriteLine ("XInternAtoms");
6570 return _XInternAtoms(display, atom_names, atom_count, only_if_exists, atoms);
6573 [DllImport ("libX11", EntryPoint="XSetWMProtocols")]
6574 internal extern static int _XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count);
6575 internal static int XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count)
6577 DebugHelper.TraceWriteLine ("XSetWMProtocols");
6578 return _XSetWMProtocols(display, window, protocols, count);
6581 [DllImport ("libX11", EntryPoint="XGrabPointer")]
6582 internal extern static int _XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp);
6583 internal static int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp)
6585 DebugHelper.TraceWriteLine ("XGrabPointer");
6586 return _XGrabPointer(display, window, owner_events, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, timestamp);
6589 [DllImport ("libX11", EntryPoint="XUngrabPointer")]
6590 internal extern static int _XUngrabPointer(IntPtr display, IntPtr timestamp);
6591 internal static int XUngrabPointer(IntPtr display, IntPtr timestamp)
6593 DebugHelper.TraceWriteLine ("XUngrabPointer");
6594 return _XUngrabPointer(display, timestamp);
6597 [DllImport ("libX11", EntryPoint="XQueryPointer")]
6598 internal extern static bool _XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons);
6599 internal static bool XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons)
6601 DebugHelper.TraceWriteLine ("XQueryPointer");
6602 return _XQueryPointer(display, window, out root, out child, out root_x, out root_y, out win_x, out win_y, out keys_buttons);
6605 [DllImport ("libX11", EntryPoint="XTranslateCoordinates")]
6606 internal extern static bool _XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return);
6607 internal static bool XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return)
6609 DebugHelper.TraceWriteLine ("XTranslateCoordinates");
6610 return _XTranslateCoordinates (display, src_w, dest_w, src_x, src_y, out intdest_x_return, out dest_y_return, out child_return);
6613 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6614 internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth);
6615 internal static bool XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth)
6617 DebugHelper.TraceWriteLine ("XGetGeometry");
6618 return _XGetGeometry(display, window, out root, out x, out y, out width, out height, out border_width, out depth);
6621 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6622 internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, out int width, out int height, IntPtr border_width, IntPtr depth);
6623 internal static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, out int width, out int height, IntPtr border_width, IntPtr depth)
6625 DebugHelper.TraceWriteLine ("XGetGeometry");
6626 return _XGetGeometry(display, window, root, out x, out y, out width, out height, border_width, depth);
6629 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6630 internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, IntPtr width, IntPtr height, IntPtr border_width, IntPtr depth);
6631 internal static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, IntPtr width, IntPtr height, IntPtr border_width, IntPtr depth)
6633 DebugHelper.TraceWriteLine ("XGetGeometry");
6634 return _XGetGeometry(display, window, root, out x, out y, width, height, border_width, depth);
6637 [DllImport ("libX11", EntryPoint="XGetGeometry")]
6638 internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, IntPtr root, IntPtr x, IntPtr y, out int width, out int height, IntPtr border_width, IntPtr depth);
6639 internal static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, IntPtr x, IntPtr y, out int width, out int height, IntPtr border_width, IntPtr depth)
6641 DebugHelper.TraceWriteLine ("XGetGeometry");
6642 return _XGetGeometry(display, window, root, x, y, out width, out height, border_width, depth);
6645 [DllImport ("libX11", EntryPoint="XWarpPointer")]
6646 internal extern static uint _XWarpPointer(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y);
6647 internal static uint XWarpPointer(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y)
6649 DebugHelper.TraceWriteLine ("XWarpPointer");
6650 return _XWarpPointer(display, src_w, dest_w, src_x, src_y, src_width, src_height, dest_x, dest_y);
6653 [DllImport ("libX11", EntryPoint="XClearWindow")]
6654 internal extern static int _XClearWindow(IntPtr display, IntPtr window);
6655 internal static int XClearWindow(IntPtr display, IntPtr window)
6657 DebugHelper.TraceWriteLine ("XClearWindow");
6658 return _XClearWindow(display, window);
6661 [DllImport ("libX11", EntryPoint="XClearArea")]
6662 internal extern static int _XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures);
6663 internal static int XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures)
6665 DebugHelper.TraceWriteLine ("XClearArea");
6666 return _XClearArea(display, window, x, y, width, height, exposures);
6670 [DllImport ("libX11", EntryPoint="XDefaultScreenOfDisplay")]
6671 internal extern static IntPtr _XDefaultScreenOfDisplay(IntPtr display);
6672 internal static IntPtr XDefaultScreenOfDisplay(IntPtr display)
6674 DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay");
6675 return _XDefaultScreenOfDisplay(display);
6678 [DllImport ("libX11", EntryPoint="XScreenNumberOfScreen")]
6679 internal extern static int _XScreenNumberOfScreen(IntPtr display, IntPtr Screen);
6680 internal static int XDefaultScreenOfDisplay(IntPtr display, IntPtr Screen)
6682 DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay");
6683 return _XScreenNumberOfScreen(display, Screen);
6686 [DllImport ("libX11", EntryPoint="XDefaultVisual")]
6687 internal extern static IntPtr _XDefaultVisual(IntPtr display, int screen_number);
6688 internal static IntPtr XDefaultScreenOfDisplay(IntPtr display, int screen_number)
6690 DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay");
6691 return _XDefaultVisual(display, screen_number);
6694 [DllImport ("libX11", EntryPoint="XDefaultDepth")]
6695 internal extern static uint _XDefaultDepth(IntPtr display, int screen_number);
6696 internal static uint XDefaultDepth(IntPtr display, int screen_number)
6698 DebugHelper.TraceWriteLine ("XDefaultDepth");
6699 return _XDefaultDepth(display, screen_number);
6702 [DllImport ("libX11", EntryPoint="XDefaultScreen")]
6703 internal extern static int _XDefaultScreen(IntPtr display);
6704 internal static int XDefaultScreen(IntPtr display)
6706 DebugHelper.TraceWriteLine ("XDefaultScreen");
6707 return _XDefaultScreen(display);
6710 [DllImport ("libX11", EntryPoint="XDefaultColormap")]
6711 internal extern static IntPtr _XDefaultColormap(IntPtr display, int screen_number);
6712 internal static IntPtr XDefaultColormap(IntPtr display, int screen_number)
6714 DebugHelper.TraceWriteLine ("XDefaultColormap");
6715 return _XDefaultColormap(display, screen_number);
6718 [DllImport ("libX11", EntryPoint="XLookupColor")]
6719 internal extern static int _XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color);
6720 internal static int XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color)
6722 DebugHelper.TraceWriteLine ("XLookupColor");
6723 return _XLookupColor(display, Colormap, Coloranem, ref exact_def_color, ref screen_def_color);
6726 [DllImport ("libX11", EntryPoint="XAllocColor")]
6727 internal extern static int _XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def);
6728 internal static int XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def)
6730 DebugHelper.TraceWriteLine ("XAllocColor");
6731 return _XAllocColor(display, Colormap, ref colorcell_def);
6734 [DllImport ("libX11", EntryPoint="XSetTransientForHint")]
6735 internal extern static int _XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window);
6736 internal static int XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window)
6738 DebugHelper.TraceWriteLine ("XSetTransientForHint");
6739 return _XSetTransientForHint(display, window, prop_window);
6742 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6743 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements);
6744 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements)
6746 DebugHelper.TraceWriteLine ("XChangeProperty");
6747 return _XChangeProperty(display, window, property, type, format, mode, ref data, nelements);
6750 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6751 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements);
6752 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements)
6754 DebugHelper.TraceWriteLine ("XChangeProperty");
6755 return _XChangeProperty(display, window, property, type, format, mode, ref value, nelements);
6758 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6759 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements);
6760 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements)
6762 DebugHelper.TraceWriteLine ("XChangeProperty");
6763 return _XChangeProperty(display, window, property, type, format, mode, ref value, nelements);
6766 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6767 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements);
6768 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements)
6770 DebugHelper.TraceWriteLine ("XChangeProperty");
6771 return _XChangeProperty(display, window, property, type, format, mode, data, nelements);
6774 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6775 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements);
6776 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements)
6778 DebugHelper.TraceWriteLine ("XChangeProperty");
6779 return _XChangeProperty(display, window, property, type, format, mode, data, nelements);
6782 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6783 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements);
6784 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements)
6786 DebugHelper.TraceWriteLine ("XChangeProperty");
6787 return _XChangeProperty(display, window, property, type, format, mode, data, nelements);
6790 [DllImport ("libX11", EntryPoint="XChangeProperty")]
6791 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements);
6792 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements)
6794 DebugHelper.TraceWriteLine ("XChangeProperty");
6795 return _XChangeProperty(display, window, property, type, format, mode, atoms, nelements);
6798 [DllImport ("libX11", EntryPoint="XChangeProperty", CharSet=CharSet.Ansi)]
6799 internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length);
6800 internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length)
6802 DebugHelper.TraceWriteLine ("XChangeProperty");
6803 return _XChangeProperty(display, window, property, type, format, mode, text, text_length);
6806 [DllImport ("libX11", EntryPoint="XDeleteProperty")]
6807 internal extern static int _XDeleteProperty(IntPtr display, IntPtr window, IntPtr property);
6808 internal static int XDeleteProperty(IntPtr display, IntPtr window, IntPtr property)
6810 DebugHelper.TraceWriteLine ("XDeleteProperty");
6811 return _XDeleteProperty(display, window, property);
6815 [DllImport ("libX11", EntryPoint="XCreateGC")]
6816 internal extern static IntPtr _XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values);
6817 internal static IntPtr XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values)
6819 DebugHelper.TraceWriteLine ("XCreateGC");
6820 return _XCreateGC(display, window, valuemask, ref values);
6823 [DllImport ("libX11", EntryPoint="XFreeGC")]
6824 internal extern static int _XFreeGC(IntPtr display, IntPtr gc);
6825 internal static int XFreeGC(IntPtr display, IntPtr gc)
6827 DebugHelper.TraceWriteLine ("XFreeGC");
6828 return _XFreeGC(display, gc);
6831 [DllImport ("libX11", EntryPoint="XSetFunction")]
6832 internal extern static int _XSetFunction(IntPtr display, IntPtr gc, GXFunction function);
6833 internal static int XSetFunction(IntPtr display, IntPtr gc, GXFunction function)
6835 DebugHelper.TraceWriteLine ("XSetFunction");
6836 return _XSetFunction(display, gc, function);
6839 [DllImport ("libX11", EntryPoint="XSetLineAttributes")]
6840 internal extern static int _XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style);
6841 internal static int XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style)
6843 DebugHelper.TraceWriteLine ("XSetLineAttributes");
6844 return _XSetLineAttributes(display, gc, line_width, line_style, cap_style, join_style);
6847 [DllImport ("libX11", EntryPoint="XDrawLine")]
6848 internal extern static int _XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2);
6849 internal static int XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2)
6851 DebugHelper.TraceWriteLine ("XDrawLine");
6852 return _XDrawLine(display, drawable, gc, x1, y1, x2, y2);
6855 [DllImport ("libX11", EntryPoint="XDrawRectangle")]
6856 internal extern static int _XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
6857 internal static int XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height)
6859 DebugHelper.TraceWriteLine ("XDrawRectangle");
6860 return _XDrawRectangle(display, drawable, gc, x1, y1, width, height);
6863 [DllImport ("libX11", EntryPoint="XFillRectangle")]
6864 internal extern static int _XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
6865 internal static int XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height)
6867 DebugHelper.TraceWriteLine ("XFillRectangle");
6868 return _XFillRectangle(display, drawable, gc, x1, y1, width, height);
6871 [DllImport ("libX11", EntryPoint="XSetWindowBackground")]
6872 internal extern static int _XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background);
6873 internal static int XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background)
6875 DebugHelper.TraceWriteLine ("XSetWindowBackground");
6876 return _XSetWindowBackground(display, window, background);
6879 [DllImport ("libX11", EntryPoint="XCopyArea")]
6880 internal extern static int _XCopyArea(IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y);
6881 internal static int XCopyArea(IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y)
6883 DebugHelper.TraceWriteLine ("XCopyArea");
6884 return _XCopyArea(display, src, dest, gc, src_x, src_y, width, height, dest_x, dest_y);
6887 [DllImport ("libX11", EntryPoint="XGetWindowProperty")]
6888 internal extern static int _XGetWindowProperty(IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, out int actual_format, out IntPtr nitems, out IntPtr bytes_after, ref IntPtr prop);
6889 internal static int XGetWindowProperty(IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, out int actual_format, out IntPtr nitems, out IntPtr bytes_after, ref IntPtr prop)
6891 DebugHelper.TraceWriteLine ("XGetWindowProperty");
6892 return _XGetWindowProperty(display, window, atom, long_offset, long_length, delete, req_type, out actual_type, out actual_format, out nitems, out bytes_after, ref prop);
6895 [DllImport ("libX11", EntryPoint="XSetInputFocus")]
6896 internal extern static int _XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time);
6897 internal static int XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time)
6899 DebugHelper.TraceWriteLine ("XSetInputFocus");
6900 return _XSetInputFocus(display, window, revert_to, time);
6903 [DllImport ("libX11", EntryPoint="XIconifyWindow")]
6904 internal extern static int _XIconifyWindow(IntPtr display, IntPtr window, int screen_number);
6905 internal static int XIconifyWindow(IntPtr display, IntPtr window, int screen_number)
6907 DebugHelper.TraceWriteLine ("XIconifyWindow");
6908 return _XIconifyWindow(display, window, screen_number);
6911 [DllImport ("libX11", EntryPoint="XDefineCursor")]
6912 internal extern static int _XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor);
6913 internal static int XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor)
6915 DebugHelper.TraceWriteLine ("XDefineCursor");
6916 return _XDefineCursor(display, window, cursor);
6919 [DllImport ("libX11", EntryPoint="XUndefineCursor")]
6920 internal extern static int _XUndefineCursor(IntPtr display, IntPtr window);
6921 internal static int XUndefineCursor(IntPtr display, IntPtr window)
6923 DebugHelper.TraceWriteLine ("XUndefineCursor");
6924 return _XUndefineCursor(display, window);
6927 [DllImport ("libX11", EntryPoint="XFreeCursor")]
6928 internal extern static int _XFreeCursor(IntPtr display, IntPtr cursor);
6929 internal static int XFreeCursor(IntPtr display, IntPtr cursor)
6931 DebugHelper.TraceWriteLine ("XFreeCursor");
6932 return _XFreeCursor(display, cursor);
6935 [DllImport ("libX11", EntryPoint="XCreateFontCursor")]
6936 internal extern static IntPtr _XCreateFontCursor(IntPtr display, CursorFontShape shape);
6937 internal static IntPtr XCreateFontCursor(IntPtr display, CursorFontShape shape)
6939 DebugHelper.TraceWriteLine ("XCreateFontCursor");
6940 return _XCreateFontCursor(display, shape);
6943 [DllImport ("libX11", EntryPoint="XCreatePixmapCursor")]
6944 internal extern static IntPtr _XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot);
6945 internal static IntPtr XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot)
6947 DebugHelper.TraceWriteLine ("XCreatePixmapCursor");
6948 return _XCreatePixmapCursor(display, source, mask, ref foreground_color, ref background_color, x_hot, y_hot);
6951 [DllImport ("libX11", EntryPoint="XCreatePixmapFromBitmapData")]
6952 internal extern static IntPtr _XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth);
6953 internal static IntPtr XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth)
6955 DebugHelper.TraceWriteLine ("XCreatePixmapFromBitmapData");
6956 return _XCreatePixmapFromBitmapData(display, drawable, data, width, height, fg, bg, depth);
6959 [DllImport ("libX11", EntryPoint="XCreatePixmap")]
6960 internal extern static IntPtr _XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth);
6961 internal static IntPtr XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth)
6963 DebugHelper.TraceWriteLine ("XCreatePixmap");
6964 return _XCreatePixmap(display, d, width, height, depth);
6967 [DllImport ("libX11", EntryPoint="XFreePixmap")]
6968 internal extern static IntPtr _XFreePixmap(IntPtr display, IntPtr pixmap);
6969 internal static IntPtr XFreePixmap(IntPtr display, IntPtr pixmap)
6971 DebugHelper.TraceWriteLine ("XFreePixmap");
6972 return _XFreePixmap(display, pixmap);
6975 [DllImport ("libX11", EntryPoint="XQueryBestCursor")]
6976 internal extern static int _XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height);
6977 internal static int XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height)
6979 DebugHelper.TraceWriteLine ("XQueryBestCursor");
6980 return _XQueryBestCursor(display, drawable, width, height, out best_width, out best_height);
6983 [DllImport ("libX11", EntryPoint="XQueryExtension")]
6984 internal extern static int _XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error);
6985 internal static int XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error)
6987 DebugHelper.TraceWriteLine ("XQueryExtension");
6988 return _XQueryExtension(display, extension_name, ref major, ref first_event, ref first_error);
6991 [DllImport ("libX11", EntryPoint="XWhitePixel")]
6992 internal extern static IntPtr _XWhitePixel(IntPtr display, int screen_no);
6993 internal static IntPtr XWhitePixel(IntPtr display, int screen_no)
6995 DebugHelper.TraceWriteLine ("XWhitePixel");
6996 return _XWhitePixel(display, screen_no);
6999 [DllImport ("libX11", EntryPoint="XBlackPixel")]
7000 internal extern static IntPtr _XBlackPixel(IntPtr display, int screen_no);
7001 internal static IntPtr XBlackPixel(IntPtr display, int screen_no)
7003 DebugHelper.TraceWriteLine ("XBlackPixel");
7004 return _XBlackPixel(display, screen_no);
7007 [DllImport ("libX11", EntryPoint="XGrabServer")]
7008 internal extern static void _XGrabServer(IntPtr display);
7009 internal static void XGrabServer(IntPtr display)
7011 DebugHelper.TraceWriteLine ("XGrabServer");
7012 _XGrabServer(display);
7015 [DllImport ("libX11", EntryPoint="XUngrabServer")]
7016 internal extern static void _XUngrabServer(IntPtr display);
7017 internal static void XUngrabServer(IntPtr display)
7019 DebugHelper.TraceWriteLine ("XUngrabServer");
7020 _XUngrabServer(display);
7023 [DllImport ("libX11", EntryPoint="XGetWMNormalHints")]
7024 internal extern static void _XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return);
7025 internal static void XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return)
7027 DebugHelper.TraceWriteLine ("XGetWMNormalHints");
7028 _XGetWMNormalHints(display, window, ref hints, out supplied_return);
7031 [DllImport ("libX11", EntryPoint="XSetWMNormalHints")]
7032 internal extern static void _XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints);
7033 internal static void XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints)
7035 DebugHelper.TraceWriteLine ("XSetWMNormalHints");
7036 _XSetWMNormalHints(display, window, ref hints);
7039 [DllImport ("libX11", EntryPoint="XSetZoomHints")]
7040 internal extern static void _XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints);
7041 internal static void XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints)
7043 DebugHelper.TraceWriteLine ("XSetZoomHints");
7044 _XSetZoomHints(display, window, ref hints);
7047 [DllImport ("libX11", EntryPoint="XSetWMHints")]
7048 internal extern static void _XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints);
7049 internal static void XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints)
7051 DebugHelper.TraceWriteLine ("XSetWMHints");
7052 _XSetWMHints(display, window, ref wmhints);
7055 [DllImport ("libX11", EntryPoint="XGetIconSizes")]
7056 internal extern static int _XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count);
7057 internal static int XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count)
7059 DebugHelper.TraceWriteLine ("XGetIconSizes");
7060 return _XGetIconSizes(display, window, out size_list, out count);
7063 [DllImport ("libX11", EntryPoint="XSetErrorHandler")]
7064 internal extern static IntPtr _XSetErrorHandler(XErrorHandler error_handler);
7065 internal static IntPtr XSetErrorHandler(XErrorHandler error_handler)
7067 DebugHelper.TraceWriteLine ("XSetErrorHandler");
7068 return _XSetErrorHandler(error_handler);
7071 [DllImport ("libX11", EntryPoint="XGetErrorText")]
7072 internal extern static IntPtr _XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length);
7073 internal static IntPtr XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length)
7075 DebugHelper.TraceWriteLine ("XGetErrorText");
7076 return _XGetErrorText(display, code, buffer, length);
7079 [DllImport ("libX11", EntryPoint="XInitThreads")]
7080 internal extern static int _XInitThreads();
7081 internal static int XInitThreads()
7083 DebugHelper.TraceWriteLine ("XInitThreads");
7084 return _XInitThreads();
7087 [DllImport ("libX11", EntryPoint="XConvertSelection")]
7088 internal extern static int _XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time);
7089 internal static int XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time)
7091 DebugHelper.TraceWriteLine ("XConvertSelection");
7092 return _XConvertSelection(display, selection, target, property, requestor, time);
7095 [DllImport ("libX11", EntryPoint="XGetSelectionOwner")]
7096 internal extern static IntPtr _XGetSelectionOwner(IntPtr display, IntPtr selection);
7097 internal static IntPtr XGetSelectionOwner(IntPtr display, IntPtr selection)
7099 DebugHelper.TraceWriteLine ("XGetSelectionOwner");
7100 return _XGetSelectionOwner(display, selection);
7103 [DllImport ("libX11", EntryPoint="XSetSelectionOwner")]
7104 internal extern static int _XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time);
7105 internal static int XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time)
7107 DebugHelper.TraceWriteLine ("XSetSelectionOwner");
7108 return _XSetSelectionOwner(display, selection, owner, time);
7111 [DllImport ("libX11", EntryPoint="XSetPlaneMask")]
7112 internal extern static int _XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask);
7113 internal static int XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask)
7115 DebugHelper.TraceWriteLine ("XSetPlaneMask");
7116 return _XSetPlaneMask(display, gc, mask);
7119 [DllImport ("libX11", EntryPoint="XSetForeground")]
7120 internal extern static int _XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground);
7121 internal static int XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground)
7123 DebugHelper.TraceWriteLine ("XSetForeground");
7124 return _XSetForeground(display, gc, foreground);
7127 [DllImport ("libX11", EntryPoint="XSetBackground")]
7128 internal extern static int _XSetBackground(IntPtr display, IntPtr gc, UIntPtr background);
7129 internal static int XSetBackground(IntPtr display, IntPtr gc, UIntPtr background)
7131 DebugHelper.TraceWriteLine ("XSetBackground");
7132 return _XSetBackground(display, gc, background);
7135 [DllImport ("libX11", EntryPoint="XBell")]
7136 internal extern static int _XBell(IntPtr display, int percent);
7137 internal static int XBell(IntPtr display, int percent)
7139 DebugHelper.TraceWriteLine ("XBell");
7140 return _XBell(display, percent);
7143 [DllImport ("libX11", EntryPoint="XChangeActivePointerGrab")]
7144 internal extern static int _XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time);
7145 internal static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time)
7147 DebugHelper.TraceWriteLine ("XChangeActivePointerGrab");
7148 return _XChangeActivePointerGrab (display, event_mask, cursor, time);
7151 [DllImport ("libX11", EntryPoint="XFilterEvent")]
7152 internal extern static bool _XFilterEvent(ref XEvent xevent, IntPtr window);
7153 internal static bool XFilterEvent(ref XEvent xevent, IntPtr window)
7155 DebugHelper.TraceWriteLine ("XFilterEvent");
7156 return _XFilterEvent(ref xevent, window);
7159 [DllImport ("libX11", EntryPoint="XkbSetDetectableAutoRepeat")]
7160 internal extern static void _XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported);
7161 internal static void XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported)
7163 DebugHelper.TraceWriteLine ("XkbSetDetectableAutoRepeat");
7164 _XkbSetDetectableAutoRepeat (display, detectable, supported);
7167 [DllImport ("libX11", EntryPoint="XPeekEvent")]
7168 internal extern static void _XPeekEvent (IntPtr display, ref XEvent xevent);
7169 internal static void XPeekEvent (IntPtr display, ref XEvent xevent)
7171 DebugHelper.TraceWriteLine ("XPeekEvent");
7172 _XPeekEvent (display, ref xevent);
7175 [DllImport ("libX11", EntryPoint="XIfEvent")]
7176 internal extern static void _XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg);
7177 internal static void XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg)
7179 DebugHelper.TraceWriteLine ("XIfEvent");
7180 _XIfEvent (display, ref xevent, event_predicate, arg);
7185 #else //no TRACE defined
7187 #region Xcursor imports
7188 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadCursor")]
7189 internal extern static IntPtr XcursorLibraryLoadCursor (IntPtr display, [MarshalAs (UnmanagedType.LPStr)] string name);
7191 [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadImages")]
7192 internal extern static IntPtr XcursorLibraryLoadImages ([MarshalAs (UnmanagedType.LPStr)] string file, IntPtr theme, int size);
7194 [DllImport ("libXcursor", EntryPoint = "XcursorImagesDestroy")]
7195 internal extern static void XcursorImagesDestroy (IntPtr images);
7197 [DllImport ("libXcursor", EntryPoint = "XcursorGetDefaultSize")]
7198 internal extern static int XcursorGetDefaultSize (IntPtr display);
7200 [DllImport ("libXcursor", EntryPoint = "XcursorImageLoadCursor")]
7201 internal extern static IntPtr XcursorImageLoadCursor (IntPtr display, IntPtr image);
7203 [DllImport ("libXcursor", EntryPoint = "XcursorGetTheme")]
7204 internal extern static IntPtr XcursorGetTheme (IntPtr display);
7207 [DllImport ("libX11", EntryPoint="XOpenDisplay")]
7208 internal extern static IntPtr XOpenDisplay(IntPtr display);
7209 [DllImport ("libX11", EntryPoint="XCloseDisplay")]
7210 internal extern static int XCloseDisplay(IntPtr display);
7211 [DllImport ("libX11", EntryPoint="XSynchronize")]
7212 internal extern static IntPtr XSynchronize(IntPtr display, bool onoff);
7214 [DllImport ("libX11", EntryPoint="XCreateWindow")]
7215 internal extern static IntPtr XCreateWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, UIntPtr valuemask, ref XSetWindowAttributes attributes);
7217 [DllImport ("libX11", EntryPoint="XCreateSimpleWindow")]
7218 internal extern static IntPtr XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background);
7220 [DllImport ("libX11", EntryPoint="XMapWindow")]
7221 internal extern static int XMapWindow(IntPtr display, IntPtr window);
7223 [DllImport ("libX11", EntryPoint="XUnmapWindow")]
7224 internal extern static int XUnmapWindow(IntPtr display, IntPtr window);
7226 [DllImport ("libX11", EntryPoint="XMapSubwindows")]
7227 internal extern static int XMapSubindows(IntPtr display, IntPtr window);
7229 [DllImport ("libX11", EntryPoint="XUnmapSubwindows")]
7230 internal extern static int XUnmapSubwindows(IntPtr display, IntPtr window);
7232 [DllImport ("libX11", EntryPoint="XRootWindow")]
7233 internal extern static IntPtr XRootWindow(IntPtr display, int screen_number);
7235 [DllImport ("libX11", EntryPoint="XNextEvent")]
7236 internal extern static IntPtr XNextEvent(IntPtr display, ref XEvent xevent);
7238 [DllImport ("libX11", EntryPoint="XConnectionNumber")]
7239 internal extern static int XConnectionNumber (IntPtr display);
7241 [DllImport ("libX11", EntryPoint="XPending")]
7242 internal extern static int XPending (IntPtr display);
7244 [DllImport ("libX11", EntryPoint="XSelectInput")]
7245 internal extern static IntPtr XSelectInput(IntPtr display, IntPtr window, IntPtr mask);
7247 [DllImport ("libX11", EntryPoint="XDestroyWindow")]
7248 internal extern static int XDestroyWindow(IntPtr display, IntPtr window);
7250 [DllImport ("libX11", EntryPoint="XReparentWindow")]
7251 internal extern static int XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y);
7253 [DllImport ("libX11", EntryPoint="XMoveResizeWindow")]
7254 extern static int XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height);
7255 internal static int MoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height)
7257 int ret = XMoveResizeWindow (display, window, x, y, width, height);
7258 Keyboard.MoveCurrentCaretPos ();
7262 [DllImport ("libX11", EntryPoint="XResizeWindow")]
7263 internal extern static int XResizeWindow(IntPtr display, IntPtr window, int width, int height);
7265 [DllImport ("libX11", EntryPoint="XGetWindowAttributes")]
7266 internal extern static int XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes);
7268 [DllImport ("libX11", EntryPoint="XFlush")]
7269 internal extern static int XFlush(IntPtr display);
7271 [DllImport ("libX11", EntryPoint="XSetWMName")]
7272 internal extern static int XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop);
7274 [DllImport ("libX11", EntryPoint="XStoreName")]
7275 internal extern static int XStoreName(IntPtr display, IntPtr window, string window_name);
7277 [DllImport ("libX11", EntryPoint="XFetchName")]
7278 internal extern static int XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name);
7280 [DllImport ("libX11", EntryPoint="XSendEvent")]
7281 internal extern static int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event);
7283 [DllImport ("libX11", EntryPoint="XQueryTree")]
7284 internal extern static int XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return);
7286 [DllImport ("libX11", EntryPoint="XFree")]
7287 internal extern static int XFree(IntPtr data);
7289 [DllImport ("libX11", EntryPoint="XRaiseWindow")]
7290 internal extern static int XRaiseWindow(IntPtr display, IntPtr window);
7292 [DllImport ("libX11", EntryPoint="XLowerWindow")]
7293 internal extern static uint XLowerWindow(IntPtr display, IntPtr window);
7295 [DllImport ("libX11", EntryPoint="XConfigureWindow")]
7296 internal extern static uint XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values);
7298 [DllImport ("libX11", EntryPoint="XInternAtom")]
7299 internal extern static IntPtr XInternAtom(IntPtr display, string atom_name, bool only_if_exists);
7301 [DllImport ("libX11", EntryPoint="XInternAtoms")]
7302 internal extern static int XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms);
7304 [DllImport ("libX11", EntryPoint="XSetWMProtocols")]
7305 internal extern static int XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count);
7307 [DllImport ("libX11", EntryPoint="XGrabPointer")]
7308 internal extern static int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp);
7310 [DllImport ("libX11", EntryPoint="XUngrabPointer")]
7311 internal extern static int XUngrabPointer(IntPtr display, IntPtr timestamp);
7313 [DllImport ("libX11", EntryPoint="XQueryPointer")]
7314 internal extern static bool XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons);
7316 [DllImport ("libX11", EntryPoint="XTranslateCoordinates")]
7317 internal extern static bool XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return);
7319 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7320 internal extern static bool XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth);
7322 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7323 internal extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, out int width, out int height, IntPtr border_width, IntPtr depth);
7325 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7326 internal extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, IntPtr width, IntPtr height, IntPtr border_width, IntPtr depth);
7328 [DllImport ("libX11", EntryPoint="XGetGeometry")]
7329 internal extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, IntPtr x, IntPtr y, out int width, out int height, IntPtr border_width, IntPtr depth);
7331 [DllImport ("libX11", EntryPoint="XWarpPointer")]
7332 internal extern static uint XWarpPointer(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y);
7334 [DllImport ("libX11", EntryPoint="XClearWindow")]
7335 internal extern static int XClearWindow(IntPtr display, IntPtr window);
7337 [DllImport ("libX11", EntryPoint="XClearArea")]
7338 internal extern static int XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures);
7341 [DllImport ("libX11", EntryPoint="XDefaultScreenOfDisplay")]
7342 internal extern static IntPtr XDefaultScreenOfDisplay(IntPtr display);
7344 [DllImport ("libX11", EntryPoint="XScreenNumberOfScreen")]
7345 internal extern static int XScreenNumberOfScreen(IntPtr display, IntPtr Screen);
7347 [DllImport ("libX11", EntryPoint="XDefaultVisual")]
7348 internal extern static IntPtr XDefaultVisual(IntPtr display, int screen_number);
7350 [DllImport ("libX11", EntryPoint="XDefaultDepth")]
7351 internal extern static uint XDefaultDepth(IntPtr display, int screen_number);
7353 [DllImport ("libX11", EntryPoint="XDefaultScreen")]
7354 internal extern static int XDefaultScreen(IntPtr display);
7356 [DllImport ("libX11", EntryPoint="XDefaultColormap")]
7357 internal extern static IntPtr XDefaultColormap(IntPtr display, int screen_number);
7359 [DllImport ("libX11", EntryPoint="XLookupColor")]
7360 internal extern static int XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color);
7362 [DllImport ("libX11", EntryPoint="XAllocColor")]
7363 internal extern static int XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def);
7365 [DllImport ("libX11", EntryPoint="XSetTransientForHint")]
7366 internal extern static int XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window);
7368 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7369 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements);
7371 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7372 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements);
7374 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7375 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements);
7377 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7378 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements);
7380 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7381 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements);
7383 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7384 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements);
7386 [DllImport ("libX11", EntryPoint="XChangeProperty")]
7387 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements);
7389 [DllImport ("libX11", EntryPoint="XChangeProperty", CharSet=CharSet.Ansi)]
7390 internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length);
7392 [DllImport ("libX11", EntryPoint="XDeleteProperty")]
7393 internal extern static int XDeleteProperty(IntPtr display, IntPtr window, IntPtr property);
7396 [DllImport ("libX11", EntryPoint="XCreateGC")]
7397 internal extern static IntPtr XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values);
7399 [DllImport ("libX11", EntryPoint="XFreeGC")]
7400 internal extern static int XFreeGC(IntPtr display, IntPtr gc);
7402 [DllImport ("libX11", EntryPoint="XSetFunction")]
7403 internal extern static int XSetFunction(IntPtr display, IntPtr gc, GXFunction function);
7405 [DllImport ("libX11", EntryPoint="XSetLineAttributes")]
7406 internal extern static int XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style);
7408 [DllImport ("libX11", EntryPoint="XDrawLine")]
7409 internal extern static int XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2);
7411 [DllImport ("libX11", EntryPoint="XDrawRectangle")]
7412 internal extern static int XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
7414 [DllImport ("libX11", EntryPoint="XFillRectangle")]
7415 internal extern static int XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height);
7417 [DllImport ("libX11", EntryPoint="XSetWindowBackground")]
7418 internal extern static int XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background);
7420 [DllImport ("libX11", EntryPoint="XCopyArea")]
7421 internal extern static int XCopyArea(IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y);
7423 [DllImport ("libX11", EntryPoint="XGetWindowProperty")]
7424 internal extern static int XGetWindowProperty(IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, out int actual_format, out IntPtr nitems, out IntPtr bytes_after, ref IntPtr prop);
7426 [DllImport ("libX11", EntryPoint="XSetInputFocus")]
7427 internal extern static int XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time);
7429 [DllImport ("libX11", EntryPoint="XIconifyWindow")]
7430 internal extern static int XIconifyWindow(IntPtr display, IntPtr window, int screen_number);
7432 [DllImport ("libX11", EntryPoint="XDefineCursor")]
7433 internal extern static int XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor);
7435 [DllImport ("libX11", EntryPoint="XUndefineCursor")]
7436 internal extern static int XUndefineCursor(IntPtr display, IntPtr window);
7438 [DllImport ("libX11", EntryPoint="XFreeCursor")]
7439 internal extern static int XFreeCursor(IntPtr display, IntPtr cursor);
7441 [DllImport ("libX11", EntryPoint="XCreateFontCursor")]
7442 internal extern static IntPtr XCreateFontCursor(IntPtr display, CursorFontShape shape);
7444 [DllImport ("libX11", EntryPoint="XCreatePixmapCursor")]
7445 internal extern static IntPtr XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot);
7447 [DllImport ("libX11", EntryPoint="XCreatePixmapFromBitmapData")]
7448 internal extern static IntPtr XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth);
7450 [DllImport ("libX11", EntryPoint="XCreatePixmap")]
7451 internal extern static IntPtr XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth);
7453 [DllImport ("libX11", EntryPoint="XFreePixmap")]
7454 internal extern static IntPtr XFreePixmap(IntPtr display, IntPtr pixmap);
7456 [DllImport ("libX11", EntryPoint="XQueryBestCursor")]
7457 internal extern static int XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height);
7459 [DllImport ("libX11", EntryPoint="XQueryExtension")]
7460 internal extern static int XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error);
7462 [DllImport ("libX11", EntryPoint="XWhitePixel")]
7463 internal extern static IntPtr XWhitePixel(IntPtr display, int screen_no);
7465 [DllImport ("libX11", EntryPoint="XBlackPixel")]
7466 internal extern static IntPtr XBlackPixel(IntPtr display, int screen_no);
7468 [DllImport ("libX11", EntryPoint="XGrabServer")]
7469 internal extern static void XGrabServer(IntPtr display);
7471 [DllImport ("libX11", EntryPoint="XUngrabServer")]
7472 internal extern static void XUngrabServer(IntPtr display);
7474 [DllImport ("libX11", EntryPoint="XGetWMNormalHints")]
7475 internal extern static void XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return);
7477 [DllImport ("libX11", EntryPoint="XSetWMNormalHints")]
7478 internal extern static void XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints);
7480 [DllImport ("libX11", EntryPoint="XSetZoomHints")]
7481 internal extern static void XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints);
7483 [DllImport ("libX11", EntryPoint="XSetWMHints")]
7484 internal extern static void XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints);
7486 [DllImport ("libX11", EntryPoint="XGetIconSizes")]
7487 internal extern static int XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count);
7489 [DllImport ("libX11", EntryPoint="XSetErrorHandler")]
7490 internal extern static IntPtr XSetErrorHandler(XErrorHandler error_handler);
7492 [DllImport ("libX11", EntryPoint="XGetErrorText")]
7493 internal extern static IntPtr XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length);
7495 [DllImport ("libX11", EntryPoint="XInitThreads")]
7496 internal extern static int XInitThreads();
7498 [DllImport ("libX11", EntryPoint="XConvertSelection")]
7499 internal extern static int XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time);
7501 [DllImport ("libX11", EntryPoint="XGetSelectionOwner")]
7502 internal extern static IntPtr XGetSelectionOwner(IntPtr display, IntPtr selection);
7504 [DllImport ("libX11", EntryPoint="XSetSelectionOwner")]
7505 internal extern static int XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time);
7507 [DllImport ("libX11", EntryPoint="XSetPlaneMask")]
7508 internal extern static int XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask);
7510 [DllImport ("libX11", EntryPoint="XSetForeground")]
7511 internal extern static int XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground);
7513 [DllImport ("libX11", EntryPoint="XSetBackground")]
7514 internal extern static int XSetBackground(IntPtr display, IntPtr gc, UIntPtr background);
7516 [DllImport ("libX11", EntryPoint="XBell")]
7517 internal extern static int XBell(IntPtr display, int percent);
7519 [DllImport ("libX11", EntryPoint="XChangeActivePointerGrab")]
7520 internal extern static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time);
7522 [DllImport ("libX11", EntryPoint="XFilterEvent")]
7523 internal extern static bool XFilterEvent(ref XEvent xevent, IntPtr window);
7525 [DllImport ("libX11", EntryPoint="XkbSetDetectableAutoRepeat")]
7526 internal extern static void XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported);
7528 [DllImport ("libX11", EntryPoint="XPeekEvent")]
7529 internal extern static void XPeekEvent (IntPtr display, ref XEvent xevent);
7531 [DllImport ("libX11", EntryPoint="XIfEvent")]
7532 internal extern static void XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg);
7534 [DllImport ("libX11", EntryPoint="XGetInputFocus")]
7535 internal extern static void XGetInputFocus (IntPtr display, out IntPtr focus, out IntPtr revert_to);