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

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software",, to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2004 Novell, Inc.
  21 //
  22 // Authors:
  23 //      Peter Bartok    pbartok@novell.com
  24 //
  25
  26
  27 // NOT COMPLETE
  28
  29 using System;
  30 using System.ComponentModel;
  31 using System.Collections;
  32 using System.Drawing;
  33 using System.Diagnostics;
  34 using System.Runtime.InteropServices;
  35
  36 /// X11 Version
  37 namespace System.Windows.Forms {
  38         //
  39         // In the structures below, fields of type long are mapped to IntPtr.
  40         // This will work on all platforms where sizeof(long)==sizeof(void*), which
  41         // is almost all platforms except WIN64.
  42         //
  43
  44         [StructLayout(LayoutKind.Sequential)]
  45         internal struct XAnyEvent {
  46                 internal XEventName     type;
  47                 internal IntPtr         serial;
  48                 internal bool           send_event;
  49                 internal IntPtr         display;
  50                 internal IntPtr         window;
  51         }
  52
  53         [StructLayout(LayoutKind.Sequential)]
  54         internal struct XKeyEvent {
  55                 internal XEventName     type;
  56                 internal IntPtr         serial;
  57                 internal bool           send_event;
  58                 internal IntPtr         display;
  59                 internal IntPtr         window;
  60                 internal IntPtr         root;
  61                 internal IntPtr         subwindow;
  62                 internal IntPtr         time;
  63                 internal int            x;
  64                 internal int            y;
  65                 internal int            x_root;
  66                 internal int            y_root;
  67                 internal int            state;
  68                 internal int            keycode;
  69                 internal bool           same_screen;
  70         }
  71
  72         [StructLayout(LayoutKind.Sequential)]
  73         internal struct XButtonEvent {
  74                 internal XEventName     type;
  75                 internal IntPtr         serial;
  76                 internal bool           send_event;
  77                 internal IntPtr         display;
  78                 internal IntPtr         window;
  79                 internal IntPtr         root;
  80                 internal IntPtr         subwindow;
  81                 internal IntPtr         time;
  82                 internal int            x;
  83                 internal int            y;
  84                 internal int            x_root;
  85                 internal int            y_root;
  86                 internal int            state;
  87                 internal int            button;
  88                 internal bool           same_screen;
  89         }
  90
  91         [StructLayout(LayoutKind.Sequential)]
  92         internal struct XMotionEvent {
  93                 internal XEventName     type;
  94                 internal IntPtr         serial;
  95                 internal bool           send_event;
  96                 internal IntPtr         display;
  97                 internal IntPtr         window;
  98                 internal IntPtr         root;
  99                 internal IntPtr         subwindow;
 100                 internal IntPtr         time;
 101                 internal int            x;
 102                 internal int            y;
 103                 internal int            x_root;
 104                 internal int            y_root;
 105                 internal int            state;
 106                 internal byte           is_hint;
 107                 internal bool           same_screen;
 108         }
 109
 110         [StructLayout(LayoutKind.Sequential)]
 111         internal struct XCrossingEvent {
 112                 internal XEventName     type;
 113                 internal IntPtr         serial;
 114                 internal bool           send_event;
 115                 internal IntPtr         display;
 116                 internal IntPtr         window;
 117                 internal IntPtr         root;
 118                 internal IntPtr         subwindow;
 119                 internal IntPtr         time;
 120                 internal int            x;
 121                 internal int            y;
 122                 internal int            x_root;
 123                 internal int            y_root;
 124                 internal NotifyMode     mode;
 125                 internal NotifyDetail   detail;
 126                 internal bool           same_screen;
 127                 internal bool           focus;
 128                 internal int            state;
 129         }
 130
 131         [StructLayout(LayoutKind.Sequential)]
 132         internal struct XFocusChangeEvent {
 133                 internal XEventName     type;
 134                 internal IntPtr         serial;
 135                 internal bool           send_event;
 136                 internal IntPtr         display;
 137                 internal IntPtr         window;
 138                 internal int            mode;
 139                 internal NotifyDetail   detail;
 140         }
 141
 142         [StructLayout(LayoutKind.Sequential)]
 143         internal struct XKeymapEvent {
 144                 internal XEventName     type;
 145                 internal IntPtr         serial;
 146                 internal bool           send_event;
 147                 internal IntPtr         display;
 148                 internal IntPtr         window;
 149                 internal byte           key_vector0;
 150                 internal byte           key_vector1;
 151                 internal byte           key_vector2;
 152                 internal byte           key_vector3;
 153                 internal byte           key_vector4;
 154                 internal byte           key_vector5;
 155                 internal byte           key_vector6;
 156                 internal byte           key_vector7;
 157                 internal byte           key_vector8;
 158                 internal byte           key_vector9;
 159                 internal byte           key_vector10;
 160                 internal byte           key_vector11;
 161                 internal byte           key_vector12;
 162                 internal byte           key_vector13;
 163                 internal byte           key_vector14;
 164                 internal byte           key_vector15;
 165                 internal byte           key_vector16;
 166                 internal byte           key_vector17;
 167                 internal byte           key_vector18;
 168                 internal byte           key_vector19;
 169                 internal byte           key_vector20;
 170                 internal byte           key_vector21;
 171                 internal byte           key_vector22;
 172                 internal byte           key_vector23;
 173                 internal byte           key_vector24;
 174                 internal byte           key_vector25;
 175                 internal byte           key_vector26;
 176                 internal byte           key_vector27;
 177                 internal byte           key_vector28;
 178                 internal byte           key_vector29;
 179                 internal byte           key_vector30;
 180                 internal byte           key_vector31;
 181         }
 182
 183         [StructLayout(LayoutKind.Sequential)]
 184         internal struct XExposeEvent {
 185                 internal XEventName     type;
 186                 internal IntPtr         serial;
 187                 internal bool           send_event;
 188                 internal IntPtr         display;
 189                 internal IntPtr         window;
 190                 internal int            x;
 191                 internal int            y;
 192                 internal int            width;
 193                 internal int            height;
 194                 internal int            count;
 195         }
 196
 197         [StructLayout(LayoutKind.Sequential)]
 198         internal struct XGraphicsExposeEvent {
 199                 internal XEventName     type;
 200                 internal IntPtr         serial;
 201                 internal bool           send_event;
 202                 internal IntPtr         display;
 203                 internal IntPtr         drawable;
 204                 internal int            x;
 205                 internal int            y;
 206                 internal int            width;
 207                 internal int            height;
 208                 internal int            count;
 209                 internal int            major_code;
 210                 internal int            minor_code;
 211         }
 212
 213         [StructLayout(LayoutKind.Sequential)]
 214         internal struct XNoExposeEvent {
 215                 internal XEventName     type;
 216                 internal IntPtr         serial;
 217                 internal bool           send_event;
 218                 internal IntPtr         display;
 219                 internal IntPtr         drawable;
 220                 internal int            major_code;
 221                 internal int            minor_code;
 222         }
 223
 224         [StructLayout(LayoutKind.Sequential)]
 225         internal struct XVisibilityEvent {
 226                 internal XEventName     type;
 227                 internal IntPtr         serial;
 228                 internal bool           send_event;
 229                 internal IntPtr         display;
 230                 internal IntPtr         window;
 231                 internal int            state;
 232         }
 233
 234         [StructLayout(LayoutKind.Sequential)]
 235         internal struct XCreateWindowEvent {
 236                 internal XEventName     type;
 237                 internal IntPtr         serial;
 238                 internal bool           send_event;
 239                 internal IntPtr         display;
 240                 internal IntPtr         parent;
 241                 internal IntPtr         window;
 242                 internal int            x;
 243                 internal int            y;
 244                 internal int            width;
 245                 internal int            height;
 246                 internal int            border_width;
 247                 internal bool           override_redirect;
 248         }
 249
 250         [StructLayout(LayoutKind.Sequential)]
 251         internal struct XDestroyWindowEvent {
 252                 internal XEventName     type;
 253                 internal IntPtr         serial;
 254                 internal bool           send_event;
 255                 internal IntPtr         display;
 256                 internal IntPtr         xevent;
 257                 internal IntPtr         window;
 258         }
 259
 260         [StructLayout(LayoutKind.Sequential)]
 261         internal struct XUnmapEvent {
 262                 internal XEventName     type;
 263                 internal IntPtr         serial;
 264                 internal bool           send_event;
 265                 internal IntPtr         display;
 266                 internal IntPtr         xevent;
 267                 internal IntPtr         window;
 268                 internal bool           from_configure;
 269         }
 270
 271         [StructLayout(LayoutKind.Sequential)]
 272         internal struct XMapEvent {
 273                 internal XEventName     type;
 274                 internal IntPtr         serial;
 275                 internal bool           send_event;
 276                 internal IntPtr         display;
 277                 internal IntPtr         xevent;
 278                 internal IntPtr         window;
 279                 internal bool           override_redirect;
 280         }
 281
 282         [StructLayout(LayoutKind.Sequential)]
 283         internal struct XMapRequestEvent {
 284                 internal XEventName     type;
 285                 internal IntPtr         serial;
 286                 internal bool           send_event;
 287                 internal IntPtr         display;
 288                 internal IntPtr         parent;
 289                 internal IntPtr         window;
 290         }
 291
 292         [StructLayout(LayoutKind.Sequential)]
 293         internal struct XReparentEvent {
 294                 internal XEventName     type;
 295                 internal IntPtr         serial;
 296                 internal bool           send_event;
 297                 internal IntPtr         display;
 298                 internal IntPtr         xevent;
 299                 internal IntPtr         window;
 300                 internal IntPtr         parent;
 301                 internal int            x;
 302                 internal int            y;
 303                 internal bool           override_redirect;
 304         }
 305
 306         [StructLayout(LayoutKind.Sequential)]
 307         internal struct XConfigureEvent {
 308                 internal XEventName     type;
 309                 internal IntPtr         serial;
 310                 internal bool           send_event;
 311                 internal IntPtr         display;
 312                 internal IntPtr         xevent;
 313                 internal IntPtr         window;
 314                 internal int            x;
 315                 internal int            y;
 316                 internal int            width;
 317                 internal int            height;
 318                 internal int            border_width;
 319                 internal IntPtr         above;
 320                 internal bool           override_redirect;
 321         }
 322
 323         [StructLayout(LayoutKind.Sequential)]
 324         internal struct XGravityEvent {
 325                 internal XEventName     type;
 326                 internal IntPtr         serial;
 327                 internal bool           send_event;
 328                 internal IntPtr         display;
 329                 internal IntPtr         xevent;
 330                 internal IntPtr         window;
 331                 internal int            x;
 332                 internal int            y;
 333         }
 334
 335         [StructLayout(LayoutKind.Sequential)]
 336         internal struct XResizeRequestEvent {
 337                 internal XEventName     type;
 338                 internal IntPtr         serial;
 339                 internal bool           send_event;
 340                 internal IntPtr         display;
 341                 internal IntPtr         window;
 342                 internal int            width;
 343                 internal int            height;
 344         }
 345
 346         [StructLayout(LayoutKind.Sequential)]
 347         internal struct XConfigureRequestEvent {
 348                 internal XEventName     type;
 349                 internal IntPtr         serial;
 350                 internal bool           send_event;
 351                 internal IntPtr         display;
 352                 internal IntPtr         parent;
 353                 internal IntPtr         window;
 354                 internal int            x;
 355                 internal int            y;
 356                 internal int            width;
 357                 internal int            height;
 358                 internal int            border_width;
 359                 internal IntPtr         above;
 360                 internal int            detail;
 361                 internal IntPtr         value_mask;
 362         }
 363
 364         [StructLayout(LayoutKind.Sequential)]
 365         internal struct XCirculateEvent {
 366                 internal XEventName     type;
 367                 internal IntPtr         serial;
 368                 internal bool           send_event;
 369                 internal IntPtr         display;
 370                 internal IntPtr         xevent;
 371                 internal IntPtr         window;
 372                 internal int            place;
 373         }
 374
 375         [StructLayout(LayoutKind.Sequential)]
 376         internal struct XCirculateRequestEvent {
 377                 internal XEventName     type;
 378                 internal IntPtr         serial;
 379                 internal bool           send_event;
 380                 internal IntPtr         display;
 381                 internal IntPtr         parent;
 382                 internal IntPtr         window;
 383                 internal int            place;
 384         }
 385
 386         [StructLayout(LayoutKind.Sequential)]
 387         internal struct XPropertyEvent {
 388                 internal XEventName     type;
 389                 internal IntPtr         serial;
 390                 internal bool           send_event;
 391                 internal IntPtr         display;
 392                 internal IntPtr         window;
 393                 internal IntPtr         atom;
 394                 internal IntPtr         time;
 395                 internal int            state;
 396         }
 397
 398         [StructLayout(LayoutKind.Sequential)]
 399         internal struct XSelectionClearEvent {
 400                 internal XEventName     type;
 401                 internal IntPtr         serial;
 402                 internal bool           send_event;
 403                 internal IntPtr         display;
 404                 internal IntPtr         window;
 405                 internal IntPtr         selection;
 406                 internal IntPtr         time;
 407         }
 408
 409         [StructLayout(LayoutKind.Sequential)]
 410         internal struct XSelectionRequestEvent {
 411                 internal XEventName     type;
 412                 internal IntPtr         serial;
 413                 internal bool           send_event;
 414                 internal IntPtr         display;
 415                 internal IntPtr         owner;
 416                 internal IntPtr         requestor;
 417                 internal IntPtr         selection;
 418                 internal IntPtr         target;
 419                 internal IntPtr         property;
 420                 internal IntPtr         time;
 421         }
 422
 423         [StructLayout(LayoutKind.Sequential)]
 424         internal struct XSelectionEvent {
 425                 internal XEventName     type;
 426                 internal IntPtr         serial;
 427                 internal bool           send_event;
 428                 internal IntPtr         display;
 429                 internal IntPtr         requestor;
 430                 internal IntPtr         selection;
 431                 internal IntPtr         target;
 432                 internal IntPtr         property;
 433                 internal IntPtr         time;
 434         }
 435
 436         [StructLayout(LayoutKind.Sequential)]
 437         internal struct XColormapEvent {
 438                 internal XEventName     type;
 439                 internal IntPtr         serial;
 440                 internal bool           send_event;
 441                 internal IntPtr         display;
 442                 internal IntPtr         window;
 443                 internal IntPtr         colormap;
 444                 internal bool           c_new;
 445                 internal int            state;
 446         }
 447
 448         [StructLayout(LayoutKind.Sequential)]
 449         internal struct XClientMessageEvent {
 450                 internal XEventName     type;
 451                 internal IntPtr         serial;
 452                 internal bool           send_event;
 453                 internal IntPtr         display;
 454                 internal IntPtr         window;
 455                 internal IntPtr         message_type;
 456                 internal int            format;
 457                 internal IntPtr         ptr1;
 458                 internal IntPtr         ptr2;
 459                 internal IntPtr         ptr3;
 460                 internal IntPtr         ptr4;
 461                 internal IntPtr         ptr5;
 462         }
 463
 464         [StructLayout(LayoutKind.Sequential)]
 465         internal struct XMappingEvent {
 466                 internal XEventName     type;
 467                 internal IntPtr         serial;
 468                 internal bool           send_event;
 469                 internal IntPtr         display;
 470                 internal IntPtr         window;
 471                 internal int            request;
 472                 internal int            first_keycode;
 473                 internal int            count;
 474         }
 475
 476         [StructLayout(LayoutKind.Sequential)]
 477         internal struct XErrorEvent {
 478                 internal XEventName     type;
 479                 internal IntPtr         display;
 480                 internal IntPtr         resourceid;
 481                 internal IntPtr         serial;
 482                 internal byte           error_code;
 483                 internal XRequest       request_code;
 484                 internal byte           minor_code;
 485         }
 486
 487         [StructLayout(LayoutKind.Sequential)]
 488         internal struct XEventPad {
 489                 internal IntPtr pad0;
 490                 internal IntPtr pad1;
 491                 internal IntPtr pad2;
 492                 internal IntPtr pad3;
 493                 internal IntPtr pad4;
 494                 internal IntPtr pad5;
 495                 internal IntPtr pad6;
 496                 internal IntPtr pad7;
 497                 internal IntPtr pad8;
 498                 internal IntPtr pad9;
 499                 internal IntPtr pad10;
 500                 internal IntPtr pad11;
 501                 internal IntPtr pad12;
 502                 internal IntPtr pad13;
 503                 internal IntPtr pad14;
 504                 internal IntPtr pad15;
 505                 internal IntPtr pad16;
 506                 internal IntPtr pad17;
 507                 internal IntPtr pad18;
 508                 internal IntPtr pad19;
 509                 internal IntPtr pad20;
 510                 internal IntPtr pad21;
 511                 internal IntPtr pad22;
 512                 internal IntPtr pad23;
 513         }
 514
 515         [StructLayout(LayoutKind.Explicit)]
 516         internal struct XEvent {
 517                 [ FieldOffset(0) ] internal XEventName type;
 518                 [ FieldOffset(0) ] internal XAnyEvent AnyEvent;
 519                 [ FieldOffset(0) ] internal XKeyEvent KeyEvent;
 520                 [ FieldOffset(0) ] internal XButtonEvent ButtonEvent;
 521                 [ FieldOffset(0) ] internal XMotionEvent MotionEvent;
 522                 [ FieldOffset(0) ] internal XCrossingEvent CrossingEvent;
 523                 [ FieldOffset(0) ] internal XFocusChangeEvent FocusChangeEvent;
 524                 [ FieldOffset(0) ] internal XExposeEvent ExposeEvent;
 525                 [ FieldOffset(0) ] internal XGraphicsExposeEvent GraphicsExposeEvent;
 526                 [ FieldOffset(0) ] internal XNoExposeEvent NoExposeEvent;
 527                 [ FieldOffset(0) ] internal XVisibilityEvent VisibilityEvent;
 528                 [ FieldOffset(0) ] internal XCreateWindowEvent CreateWindowEvent;
 529                 [ FieldOffset(0) ] internal XDestroyWindowEvent DestroyWindowEvent;
 530                 [ FieldOffset(0) ] internal XUnmapEvent UnmapEvent;
 531                 [ FieldOffset(0) ] internal XMapEvent MapEvent;
 532                 [ FieldOffset(0) ] internal XMapRequestEvent MapRequestEvent;
 533                 [ FieldOffset(0) ] internal XReparentEvent ReparentEvent;
 534                 [ FieldOffset(0) ] internal XConfigureEvent ConfigureEvent;
 535                 [ FieldOffset(0) ] internal XGravityEvent GravityEvent;
 536                 [ FieldOffset(0) ] internal XResizeRequestEvent ResizeRequestEvent;
 537                 [ FieldOffset(0) ] internal XConfigureRequestEvent ConfigureRequestEvent;
 538                 [ FieldOffset(0) ] internal XCirculateEvent CirculateEvent;
 539                 [ FieldOffset(0) ] internal XCirculateRequestEvent CirculateRequestEvent;
 540                 [ FieldOffset(0) ] internal XPropertyEvent PropertyEvent;
 541                 [ FieldOffset(0) ] internal XSelectionClearEvent SelectionClearEvent;
 542                 [ FieldOffset(0) ] internal XSelectionRequestEvent SelectionRequestEvent;
 543                 [ FieldOffset(0) ] internal XSelectionEvent SelectionEvent;
 544                 [ FieldOffset(0) ] internal XColormapEvent ColormapEvent;
 545                 [ FieldOffset(0) ] internal XClientMessageEvent ClientMessageEvent;
 546                 [ FieldOffset(0) ] internal XMappingEvent MappingEvent;
 547                 [ FieldOffset(0) ] internal XErrorEvent ErrorEvent;
 548                 [ FieldOffset(0) ] internal XKeymapEvent KeymapEvent;
 549
 550                 //[MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=24)]
 551                 //[ FieldOffset(0) ] internal int[] pad;
 552                 [ FieldOffset(0) ] internal XEventPad Pad;
 553                 public override string ToString() {
 554                         switch (type)
 555                         {
 556                                 case XEventName.ButtonPress:
 557                                 case XEventName.ButtonRelease:
 558                                         return ToString (ButtonEvent);
 559                                 case XEventName.CirculateNotify:
 560                                 case XEventName.CirculateRequest:
 561                                         return ToString (CirculateEvent);
 562                                 case XEventName.ClientMessage:
 563                                         return ToString (ClientMessageEvent);
 564                                 case XEventName.ColormapNotify:
 565                                         return ToString (ColormapEvent);
 566                                 case XEventName.ConfigureNotify:
 567                                         return ToString (ConfigureEvent);
 568                                 case XEventName.ConfigureRequest:
 569                                         return ToString (ConfigureRequestEvent);
 570                                 case XEventName.CreateNotify:
 571                                         return ToString (CreateWindowEvent);
 572                                 case XEventName.DestroyNotify:
 573                                         return ToString (DestroyWindowEvent);
 574                                 case XEventName.Expose:
 575                                         return ToString (ExposeEvent);
 576                                 case XEventName.FocusIn:
 577                                 case XEventName.FocusOut:
 578                                         return ToString (FocusChangeEvent);
 579                                 case XEventName.GraphicsExpose:
 580                                         return ToString (GraphicsExposeEvent);
 581                                 case XEventName.GravityNotify:
 582                                         return ToString (GravityEvent);
 583                                 case XEventName.KeymapNotify:
 584                                         return ToString (KeymapEvent);
 585                                 case XEventName.MapNotify:
 586                                         return ToString (MapEvent);
 587                                 case XEventName.MappingNotify:
 588                                         return ToString (MappingEvent);
 589                                 case XEventName.MapRequest:
 590                                         return ToString (MapRequestEvent);
 591                                 case XEventName.MotionNotify:
 592                                         return ToString (MotionEvent);
 593                                 case XEventName.NoExpose:
 594                                         return ToString (NoExposeEvent);
 595                                 case XEventName.PropertyNotify:
 596                                         return ToString (PropertyEvent);
 597                                 case XEventName.ReparentNotify:
 598                                         return ToString (ReparentEvent);
 599                                 case XEventName.ResizeRequest:
 600                                         return ToString (ResizeRequestEvent);
 601                                 case XEventName.SelectionClear:
 602                                         return ToString (SelectionClearEvent);
 603                                 case XEventName.SelectionNotify:
 604                                         return ToString (SelectionEvent);
 605                                 case XEventName.SelectionRequest:
 606                                         return ToString (SelectionRequestEvent);
 607                                 case XEventName.UnmapNotify:
 608                                         return ToString (UnmapEvent);
 609                                 case XEventName.VisibilityNotify:
 610                                         return ToString (VisibilityEvent);
 611                                 case XEventName.EnterNotify:
 612                                 case XEventName.LeaveNotify:
 613                                         return ToString (CrossingEvent);
 614                                 default:
 615                                         return type.ToString ();
 616                         }
 617                 }
 618
 619                 public static string ToString (object ev)
 620                 {
 621                         string result = string.Empty;
 622                         Type type = ev.GetType ();
 623                         Reflection.FieldInfo [] fields = type.GetFields (System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Instance);
 624                         for (int i = 0; i < fields.Length; i++) {
 625                                 if (result != string.Empty) {
 626                                         result += ", ";
 627                                 }
 628                                 object value = fields [i].GetValue (ev);
 629                                 result += fields [i].Name + "=" + (value == null ? "<null>" : value.ToString ());
 630                         }
 631                         return type.Name + " (" + result + ")";
 632                 }
 633         }
 634
 635         [StructLayout(LayoutKind.Sequential)]
 636         internal struct XSetWindowAttributes {
 637                 internal IntPtr         background_pixmap;
 638                 internal IntPtr         background_pixel;
 639                 internal IntPtr         border_pixmap;
 640                 internal IntPtr         border_pixel;
 641                 internal Gravity        bit_gravity;
 642                 internal Gravity        win_gravity;
 643                 internal int            backing_store;
 644                 internal IntPtr         backing_planes;
 645                 internal IntPtr         backing_pixel;
 646                 internal bool           save_under;
 647                 internal IntPtr         event_mask;
 648                 internal IntPtr         do_not_propagate_mask;
 649                 internal bool           override_redirect;
 650                 internal IntPtr         colormap;
 651                 internal IntPtr         cursor;
 652         }
 653
 654         [StructLayout(LayoutKind.Sequential)]
 655         internal struct XWindowAttributes {
 656                 internal int            x;
 657                 internal int            y;
 658                 internal int            width;
 659                 internal int            height;
 660                 internal int            border_width;
 661                 internal int            depth;
 662                 internal IntPtr         visual;
 663                 internal IntPtr         root;
 664                 internal int            c_class;
 665                 internal Gravity        bit_gravity;
 666                 internal Gravity        win_gravity;
 667                 internal int            backing_store;
 668                 internal IntPtr         backing_planes;
 669                 internal IntPtr         backing_pixel;
 670                 internal bool           save_under;
 671                 internal IntPtr         colormap;
 672                 internal bool           map_installed;
 673                 internal MapState       map_state;
 674                 internal IntPtr         all_event_masks;
 675                 internal IntPtr         your_event_mask;
 676                 internal IntPtr         do_not_propagate_mask;
 677                 internal bool           override_direct;
 678                 internal IntPtr         screen;
 679
 680                 public override string ToString ()
 681                 {
 682                         return XEvent.ToString (this);
 683                 }
 684         }
 685
 686         [StructLayout(LayoutKind.Sequential)]
 687         internal struct XTextProperty {
 688                 internal string         value;
 689                 internal IntPtr         encoding;
 690                 internal int            format;
 691                 internal IntPtr         nitems;
 692         }
 693
 694         internal enum XWindowClass {
 695                 InputOutput     = 1,
 696                 InputOnly       = 2
 697         }
 698
 699         internal enum XEventName {
 700                 KeyPress                = 2,
 701                 KeyRelease              = 3,
 702                 ButtonPress             = 4,
 703                 ButtonRelease           = 5,
 704                 MotionNotify            = 6,
 705                 EnterNotify             = 7,
 706                 LeaveNotify             = 8,
 707                 FocusIn                 = 9,
 708                 FocusOut                = 10,
 709                 KeymapNotify            = 11,
 710                 Expose                  = 12,
 711                 GraphicsExpose          = 13,
 712                 NoExpose                = 14,
 713                 VisibilityNotify        = 15,
 714                 CreateNotify            = 16,
 715                 DestroyNotify           = 17,
 716                 UnmapNotify             = 18,
 717                 MapNotify               = 19,
 718                 MapRequest              = 20,
 719                 ReparentNotify          = 21,
 720                 ConfigureNotify         = 22,
 721                 ConfigureRequest        = 23,
 722                 GravityNotify           = 24,
 723                 ResizeRequest           = 25,
 724                 CirculateNotify         = 26,
 725                 CirculateRequest        = 27,
 726                 PropertyNotify          = 28,
 727                 SelectionClear          = 29,
 728                 SelectionRequest        = 30,
 729                 SelectionNotify         = 31,
 730                 ColormapNotify          = 32,
 731                 ClientMessage           = 33,
 732                 MappingNotify           = 34,
 733
 734                 LASTEvent
 735         }
 736
 737         [Flags]
 738         internal enum SetWindowValuemask {
 739                 Nothing         = 0,
 740                 BackPixmap      = 1,
 741                 BackPixel       = 2,
 742                 BorderPixmap    = 4,
 743                 BorderPixel     = 8,
 744                 BitGravity      = 16,
 745                 WinGravity      = 32,
 746                 BackingStore    = 64,
 747                 BackingPlanes   = 128,
 748                 BackingPixel    = 256,
 749                 OverrideRedirect = 512,
 750                 SaveUnder       = 1024,
 751                 EventMask       = 2048,
 752                 DontPropagate   = 4096,
 753                 ColorMap        = 8192,
 754                 Cursor          = 16384
 755         }
 756
 757         internal enum SendEventValues {
 758                 PointerWindow = 0,
 759                 InputFocus = 1
 760         }
 761
 762         internal enum CreateWindowArgs {
 763                 CopyFromParent  = 0,
 764                 ParentRelative  = 1,
 765                 InputOutput     = 1,
 766                 InputOnly       = 2
 767         }
 768
 769         internal enum Gravity {
 770                 ForgetGravity   = 0,
 771                 NorthWestGravity= 1,
 772                 NorthGravity    = 2,
 773                 NorthEastGravity= 3,
 774                 WestGravity     = 4,
 775                 CenterGravity   = 5,
 776                 EastGravity     = 6,
 777                 SouthWestGravity= 7,
 778                 SouthGravity    = 8,
 779                 SouthEastGravity= 9,
 780                 StaticGravity   = 10
 781         }
 782
 783         internal enum XKeySym : uint {
 784                 XK_BackSpace    = 0xFF08,
 785                 XK_Tab          = 0xFF09,
 786                 XK_Clear        = 0xFF0B,
 787                 XK_Return       = 0xFF0D,
 788                 XK_Home         = 0xFF50,
 789                 XK_Left         = 0xFF51,
 790                 XK_Up           = 0xFF52,
 791                 XK_Right        = 0xFF53,
 792                 XK_Down         = 0xFF54,
 793                 XK_Page_Up      = 0xFF55,
 794                 XK_Page_Down    = 0xFF56,
 795                 XK_End          = 0xFF57,
 796                 XK_Begin        = 0xFF58,
 797                 XK_Menu         = 0xFF67,
 798                 XK_Shift_L      = 0xFFE1,
 799                 XK_Shift_R      = 0xFFE2,
 800                 XK_Control_L    = 0xFFE3,
 801                 XK_Control_R    = 0xFFE4,
 802                 XK_Caps_Lock    = 0xFFE5,
 803                 XK_Shift_Lock   = 0xFFE6,
 804                 XK_Meta_L       = 0xFFE7,
 805                 XK_Meta_R       = 0xFFE8,
 806                 XK_Alt_L        = 0xFFE9,
 807                 XK_Alt_R        = 0xFFEA,
 808                 XK_Super_L      = 0xFFEB,
 809                 XK_Super_R      = 0xFFEC,
 810                 XK_Hyper_L      = 0xFFED,
 811                 XK_Hyper_R      = 0xFFEE,
 812         }
 813
 814         [Flags]
 815         internal enum EventMask {
 816                 NoEventMask             = 0,
 817                 KeyPressMask            = 1<<0,
 818                 KeyReleaseMask          = 1<<1,
 819                 ButtonPressMask         = 1<<2,
 820                 ButtonReleaseMask       = 1<<3,
 821                 EnterWindowMask         = 1<<4,
 822                 LeaveWindowMask         = 1<<5,
 823                 PointerMotionMask       = 1<<6,
 824                 PointerMotionHintMask   = 1<<7,
 825                 Button1MotionMask       = 1<<8,
 826                 Button2MotionMask       = 1<<9,
 827                 Button3MotionMask       = 1<<10,
 828                 Button4MotionMask       = 1<<11,
 829                 Button5MotionMask       = 1<<12,
 830                 ButtonMotionMask        = 1<<13,
 831                 KeymapStateMask         = 1<<14,
 832                 ExposureMask            = 1<<15,
 833                 VisibilityChangeMask    = 1<<16,
 834                 StructureNotifyMask     = 1<<17,
 835                 ResizeRedirectMask      = 1<<18,
 836                 SubstructureNotifyMask  = 1<<19,
 837                 SubstructureRedirectMask= 1<<20,
 838                 FocusChangeMask         = 1<<21,
 839                 PropertyChangeMask      = 1<<22,
 840                 ColormapChangeMask      = 1<<23,
 841                 OwnerGrabButtonMask     = 1<<24
 842         }
 843
 844         internal enum GrabMode {
 845                 GrabModeSync            = 0,
 846                 GrabModeAsync           = 1
 847         }
 848
 849         [StructLayout(LayoutKind.Sequential)]
 850         internal struct XStandardColormap {
 851                 internal IntPtr         colormap;
 852                 internal IntPtr         red_max;
 853                 internal IntPtr         red_mult;
 854                 internal IntPtr         green_max;
 855                 internal IntPtr         green_mult;
 856                 internal IntPtr         blue_max;
 857                 internal IntPtr         blue_mult;
 858                 internal IntPtr         base_pixel;
 859                 internal IntPtr         visualid;
 860                 internal IntPtr         killid;
 861         }
 862
 863         [StructLayout(LayoutKind.Sequential, Pack=2)]
 864         internal struct XColor {
 865                 internal IntPtr         pixel;
 866                 internal ushort         red;
 867                 internal ushort         green;
 868                 internal ushort         blue;
 869                 internal byte           flags;
 870                 internal byte           pad;
 871         }
 872
 873         internal enum Atom {
 874                 AnyPropertyType         = 0,
 875                 XA_PRIMARY              = 1,
 876                 XA_SECONDARY            = 2,
 877                 XA_ARC                  = 3,
 878                 XA_ATOM                 = 4,
 879                 XA_BITMAP               = 5,
 880                 XA_CARDINAL             = 6,
 881                 XA_COLORMAP             = 7,
 882                 XA_CURSOR               = 8,
 883                 XA_CUT_BUFFER0          = 9,
 884                 XA_CUT_BUFFER1          = 10,
 885                 XA_CUT_BUFFER2          = 11,
 886                 XA_CUT_BUFFER3          = 12,
 887                 XA_CUT_BUFFER4          = 13,
 888                 XA_CUT_BUFFER5          = 14,
 889                 XA_CUT_BUFFER6          = 15,
 890                 XA_CUT_BUFFER7          = 16,
 891                 XA_DRAWABLE             = 17,
 892                 XA_FONT                 = 18,
 893                 XA_INTEGER              = 19,
 894                 XA_PIXMAP               = 20,
 895                 XA_POINT                = 21,
 896                 XA_RECTANGLE            = 22,
 897                 XA_RESOURCE_MANAGER     = 23,
 898                 XA_RGB_COLOR_MAP        = 24,
 899                 XA_RGB_BEST_MAP         = 25,
 900                 XA_RGB_BLUE_MAP         = 26,
 901                 XA_RGB_DEFAULT_MAP      = 27,
 902                 XA_RGB_GRAY_MAP         = 28,
 903                 XA_RGB_GREEN_MAP        = 29,
 904                 XA_RGB_RED_MAP          = 30,
 905                 XA_STRING               = 31,
 906                 XA_VISUALID             = 32,
 907                 XA_WINDOW               = 33,
 908                 XA_WM_COMMAND           = 34,
 909                 XA_WM_HINTS             = 35,
 910                 XA_WM_CLIENT_MACHINE    = 36,
 911                 XA_WM_ICON_NAME         = 37,
 912                 XA_WM_ICON_SIZE         = 38,
 913                 XA_WM_NAME              = 39,
 914                 XA_WM_NORMAL_HINTS      = 40,
 915                 XA_WM_SIZE_HINTS        = 41,
 916                 XA_WM_ZOOM_HINTS        = 42,
 917                 XA_MIN_SPACE            = 43,
 918                 XA_NORM_SPACE           = 44,
 919                 XA_MAX_SPACE            = 45,
 920                 XA_END_SPACE            = 46,
 921                 XA_SUPERSCRIPT_X        = 47,
 922                 XA_SUPERSCRIPT_Y        = 48,
 923                 XA_SUBSCRIPT_X          = 49,
 924                 XA_SUBSCRIPT_Y          = 50,
 925                 XA_UNDERLINE_POSITION   = 51,
 926                 XA_UNDERLINE_THICKNESS  = 52,
 927                 XA_STRIKEOUT_ASCENT     = 53,
 928                 XA_STRIKEOUT_DESCENT    = 54,
 929                 XA_ITALIC_ANGLE         = 55,
 930                 XA_X_HEIGHT             = 56,
 931                 XA_QUAD_WIDTH           = 57,
 932                 XA_WEIGHT               = 58,
 933                 XA_POINT_SIZE           = 59,
 934                 XA_RESOLUTION           = 60,
 935                 XA_COPYRIGHT            = 61,
 936                 XA_NOTICE               = 62,
 937                 XA_FONT_NAME            = 63,
 938                 XA_FAMILY_NAME          = 64,
 939                 XA_FULL_NAME            = 65,
 940                 XA_CAP_HEIGHT           = 66,
 941                 XA_WM_CLASS             = 67,
 942                 XA_WM_TRANSIENT_FOR     = 68,
 943
 944                 XA_LAST_PREDEFINED      = 68
 945         }
 946
 947         [StructLayout(LayoutKind.Sequential)]
 948         internal struct XScreen {
 949                 internal IntPtr         ext_data;
 950                 internal IntPtr         display;
 951                 internal IntPtr         root;
 952                 internal int            width;
 953                 internal int            height;
 954                 internal int            mwidth;
 955                 internal int            mheight;
 956                 internal int            ndepths;
 957                 internal IntPtr         depths;
 958                 internal int            root_depth;
 959                 internal IntPtr         root_visual;
 960                 internal IntPtr         default_gc;
 961                 internal IntPtr         cmap;
 962                 internal IntPtr         white_pixel;
 963                 internal IntPtr         black_pixel;
 964                 internal int            max_maps;
 965                 internal int            min_maps;
 966                 internal int            backing_store;
 967                 internal bool           save_unders;
 968                 internal IntPtr     root_input_mask;
 969         }
 970
 971         [Flags]
 972         internal enum ChangeWindowFlags {
 973                 CWX                     = 1<<0,
 974                 CWY                     = 1<<1,
 975                 CWWidth                 = 1<<2,
 976                 CWHeight                = 1<<3,
 977                 CWBorderWidth           = 1<<4,
 978                 CWSibling               = 1<<5,
 979                 CWStackMode             = 1<<6
 980         }
 981
 982         internal enum StackMode {
 983                 Above                   = 0,
 984                 Below                   = 1,
 985                 TopIf                   = 2,
 986                 BottomIf                = 3,
 987                 Opposite                = 4
 988         }
 989
 990         [StructLayout(LayoutKind.Sequential)]
 991         internal struct XWindowChanges {
 992                 internal int            x;
 993                 internal int            y;
 994                 internal int            width;
 995                 internal int            height;
 996                 internal int            border_width;
 997                 internal IntPtr         sibling;
 998                 internal StackMode      stack_mode;
 999         }
1000
1001         [Flags]
1002         internal enum ColorFlags {
1003                 DoRed                   = 1<<0,
1004                 DoGreen                 = 1<<1,
1005                 DoBlue                  = 1<<2
1006         }
1007
1008         internal enum NotifyMode {
1009                 NotifyNormal            = 0,
1010                 NotifyGrab              = 1,
1011                 NotifyUngrab            = 2
1012         }
1013
1014         internal enum NotifyDetail {
1015                 NotifyAncestor          = 0,
1016                 NotifyVirtual           = 1,
1017                 NotifyInferior          = 2,
1018                 NotifyNonlinear         = 3,
1019                 NotifyNonlinearVirtual  = 4,
1020                 NotifyPointer           = 5,
1021                 NotifyPointerRoot       = 6,
1022                 NotifyDetailNone        = 7
1023         }
1024
1025         [StructLayout(LayoutKind.Sequential)]
1026         internal struct MotifWmHints {
1027                 internal IntPtr         flags;
1028                 internal IntPtr         functions;
1029                 internal IntPtr     decorations;
1030                 internal IntPtr         input_mode;
1031                 internal IntPtr         status;
1032
1033                 public override string ToString ()
1034                 {
1035                         return string.Format("MotifWmHints <flags={0}, functions={1}, decorations={2}, input_mode={3}, status={4}", (MotifFlags) flags.ToInt32 (), (MotifFunctions) functions.ToInt32 (), (MotifDecorations) decorations.ToInt32 (), (MotifInputMode) input_mode.ToInt32 (), status.ToInt32 ());
1036                 }
1037         }
1038
1039         [Flags]
1040         internal enum MotifFlags {
1041                 Functions               = 1,
1042                 Decorations             = 2,
1043                 InputMode               = 4,
1044                 Status                  = 8
1045         }
1046
1047         [Flags]
1048         internal enum MotifFunctions {
1049                 All                     = 0x01,
1050                 Resize                  = 0x02,
1051                 Move                    = 0x04,
1052                 Minimize                = 0x08,
1053                 Maximize                = 0x10,
1054                 Close                   = 0x20
1055         }
1056
1057         [Flags]
1058         internal enum MotifDecorations {
1059                 All                     = 0x01,
1060                 Border                  = 0x02,
1061                 ResizeH                 = 0x04,
1062                 Title                   = 0x08,
1063                 Menu                    = 0x10,
1064                 Minimize                = 0x20,
1065                 Maximize                = 0x40,
1066
1067         }
1068
1069         [Flags]
1070         internal enum MotifInputMode {
1071                 Modeless                = 0,
1072                 ApplicationModal        = 1,
1073                 SystemModal             = 2,
1074                 FullApplicationModal    = 3
1075         }
1076
1077         [Flags]
1078         internal enum KeyMasks {
1079                 ShiftMask               = (1 << 0),
1080                 LockMask                = (1 << 1),
1081                 ControlMask             = (1 << 2),
1082                 Mod1Mask                = (1 << 3),
1083                 Mod2Mask                = (1 << 4),
1084                 Mod3Mask                = (1 << 5),
1085                 Mod4Mask                = (1 << 6),
1086                 Mod5Mask                = (1 << 7),
1087
1088                 ModMasks                = Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask
1089         }
1090
1091         [Flags]
1092         internal enum MouseKeyMasks {
1093                 Button1Mask             = (1 << 8),
1094                 Button2Mask             = (1 << 9),
1095                 Button3Mask             = (1 << 10),
1096                 Button4Mask             = (1 << 11),
1097                 Button5Mask             = (1 << 12),
1098         }
1099
1100         [StructLayout (LayoutKind.Sequential)]
1101         internal struct XModifierKeymap {
1102                 public int max_keypermod;
1103                 public IntPtr modifiermap;
1104         }
1105
1106         internal enum PropertyMode {
1107                 Replace                 = 0,
1108                 Prepend                 = 1,
1109                 Append                  = 2
1110         }
1111
1112         [StructLayout (LayoutKind.Sequential)]
1113         internal struct XKeyBoardState {
1114                 public int key_click_percent;
1115                 public int bell_percent;
1116                 public uint bell_pitch, bell_duration;
1117                 public IntPtr led_mask;
1118                 public int global_auto_repeat;
1119                 public AutoRepeats auto_repeats;
1120
1121                 [StructLayout (LayoutKind.Explicit)]
1122                         public struct AutoRepeats {
1123                         [FieldOffset (0)]
1124                         public byte first;
1125
1126                         [FieldOffset (31)]
1127                         public byte last;
1128                 }
1129         }
1130
1131         [Flags]
1132         internal enum GCFunction {
1133                 GCFunction              = 1<<0,
1134                 GCPlaneMask             = 1<<1,
1135                 GCForeground            = 1<<2,
1136                 GCBackground            = 1<<3,
1137                 GCLineWidth             = 1<<4,
1138                 GCLineStyle             = 1<<5,
1139                 GCCapStyle              = 1<<6,
1140                 GCJoinStyle             = 1<<7,
1141                 GCFillStyle             = 1<<8,
1142                 GCFillRule              = 1<<9,
1143                 GCTile                  = 1<<10,
1144                 GCStipple               = 1<<11,
1145                 GCTileStipXOrigin       = 1<<12,
1146                 GCTileStipYOrigin       = 1<<13,
1147                 GCFont                  = 1<<14,
1148                 GCSubwindowMode         = 1<<15,
1149                 GCGraphicsExposures     = 1<<16,
1150                 GCClipXOrigin           = 1<<17,
1151                 GCClipYOrigin           = 1<<18,
1152                 GCClipMask              = 1<<19,
1153                 GCDashOffset            = 1<<20,
1154                 GCDashList              = 1<<21,
1155                 GCArcMode               = 1<<22
1156         }
1157
1158         internal enum GCJoinStyle {
1159                 JoinMiter               = 0,
1160                 JoinRound               = 1,
1161                 JoinBevel               = 2
1162         }
1163
1164         internal enum GCLineStyle {
1165                 LineSolid               = 0,
1166                 LineOnOffDash           = 1,
1167                 LineDoubleDash          = 2
1168         }
1169
1170         internal enum GCCapStyle {
1171                 CapNotLast              = 0,
1172                 CapButt                 = 1,
1173                 CapRound                = 2,
1174                 CapProjecting           = 3
1175         }
1176
1177         internal enum GCFillStyle {
1178                 FillSolid               = 0,
1179                 FillTiled               = 1,
1180                 FillStippled            = 2,
1181                 FillOpaqueStppled       = 3
1182         }
1183
1184         internal enum GCFillRule {
1185                 EvenOddRule             = 0,
1186                 WindingRule             = 1
1187         }
1188
1189         internal enum GCArcMode {
1190                 ArcChord                = 0,
1191                 ArcPieSlice             = 1
1192         }
1193
1194         internal enum GCSubwindowMode {
1195                 ClipByChildren          = 0,
1196                 IncludeInferiors        = 1
1197         }
1198
1199         [StructLayout (LayoutKind.Sequential)]
1200         internal struct XGCValues {
1201                 internal GXFunction             function;
1202                 internal IntPtr                 plane_mask;
1203                 internal IntPtr                 foreground;
1204                 internal IntPtr                 background;
1205                 internal int                    line_width;
1206                 internal GCLineStyle            line_style;
1207                 internal GCCapStyle             cap_style;
1208                 internal GCJoinStyle            join_style;
1209                 internal GCFillStyle            fill_style;
1210                 internal GCFillRule             fill_rule;
1211                 internal GCArcMode              arc_mode;
1212                 internal IntPtr                 tile;
1213                 internal IntPtr                 stipple;
1214                 internal int                    ts_x_origin;
1215                 internal int                    ts_y_origin;
1216                 internal IntPtr                 font;
1217                 internal GCSubwindowMode        subwindow_mode;
1218                 internal bool                   graphics_exposures;
1219                 internal int                    clip_x_origin;
1220                 internal int                    clib_y_origin;
1221                 internal IntPtr                 clip_mask;
1222                 internal int                    dash_offset;
1223                 internal byte                   dashes;
1224         }
1225
1226         internal enum GXFunction {
1227                 GXclear                         = 0x0,          /* 0 */
1228                 GXand                           = 0x1,          /* src AND dst */
1229                 GXandReverse                    = 0x2,          /* src AND NOT dst */
1230                 GXcopy                          = 0x3,          /* src */
1231                 GXandInverted                   = 0x4,          /* NOT src AND dst */
1232                 GXnoop                          = 0x5,          /* dst */
1233                 GXxor                           = 0x6,          /* src XOR dst */
1234                 GXor                            = 0x7,          /* src OR dst */
1235                 GXnor                           = 0x8,          /* NOT src AND NOT dst */
1236                 GXequiv                         = 0x9,          /* NOT src XOR dst */
1237                 GXinvert                        = 0xa,          /* NOT dst */
1238                 GXorReverse                     = 0xb,          /* src OR NOT dst */
1239                 GXcopyInverted                  = 0xc,          /* NOT src */
1240                 GXorInverted                    = 0xd,          /* NOT src OR dst */
1241                 GXnand                          = 0xe,          /* NOT src OR NOT dst */
1242                 GXset                           = 0xf           /* 1 */
1243         }
1244
1245         internal enum NetWindowManagerState {
1246                 Remove                          = 0,
1247                 Add                             = 1,
1248                 Toggle                          = 2
1249         }
1250
1251         internal enum RevertTo {
1252                 None                            = 0,
1253                 PointerRoot                     = 1,
1254                 Parent                          = 2
1255         }
1256
1257         internal enum MapState {
1258                 IsUnmapped                      = 0,
1259                 IsUnviewable                    = 1,
1260                 IsViewable                      = 2
1261         }
1262
1263         internal enum CursorFontShape {
1264                 XC_X_cursor                     = 0,
1265                 XC_arrow                        = 2,
1266                 XC_based_arrow_down             = 4,
1267                 XC_based_arrow_up               = 6,
1268                 XC_boat                         = 8,
1269                 XC_bogosity                     = 10,
1270                 XC_bottom_left_corner           = 12,
1271                 XC_bottom_right_corner          = 14,
1272                 XC_bottom_side                  = 16,
1273                 XC_bottom_tee                   = 18,
1274                 XC_box_spiral                   = 20,
1275                 XC_center_ptr                   = 22,
1276
1277                 XC_circle                       = 24,
1278                 XC_clock                        = 26,
1279                 XC_coffee_mug                   = 28,
1280                 XC_cross                        = 30,
1281                 XC_cross_reverse                = 32,
1282                 XC_crosshair                    = 34,
1283                 XC_diamond_cross                = 36,
1284                 XC_dot                          = 38,
1285                 XC_dotbox                       = 40,
1286                 XC_double_arrow                 = 42,
1287                 XC_draft_large                  = 44,
1288                 XC_draft_small                  = 46,
1289
1290                 XC_draped_box                   = 48,
1291                 XC_exchange                     = 50,
1292                 XC_fleur                        = 52,
1293                 XC_gobbler                      = 54,
1294                 XC_gumby                        = 56,
1295                 XC_hand1                        = 58,
1296                 XC_hand2                        = 60,
1297                 XC_heart                        = 62,
1298                 XC_icon                         = 64,
1299                 XC_iron_cross                   = 66,
1300                 XC_left_ptr                     = 68,
1301                 XC_left_side                    = 70,
1302
1303                 XC_left_tee                     = 72,
1304                 XC_left_button                  = 74,
1305                 XC_ll_angle                     = 76,
1306                 XC_lr_angle                     = 78,
1307                 XC_man                          = 80,
1308                 XC_middlebutton                 = 82,
1309                 XC_mouse                        = 84,
1310                 XC_pencil                       = 86,
1311                 XC_pirate                       = 88,
1312                 XC_plus                         = 90,
1313                 XC_question_arrow               = 92,
1314                 XC_right_ptr                    = 94,
1315
1316                 XC_right_side                   = 96,
1317                 XC_right_tee                    = 98,
1318                 XC_rightbutton                  = 100,
1319                 XC_rtl_logo                     = 102,
1320                 XC_sailboat                     = 104,
1321                 XC_sb_down_arrow                = 106,
1322                 XC_sb_h_double_arrow            = 108,
1323                 XC_sb_left_arrow                = 110,
1324                 XC_sb_right_arrow               = 112,
1325                 XC_sb_up_arrow                  = 114,
1326                 XC_sb_v_double_arrow            = 116,
1327                 XC_sb_shuttle                   = 118,
1328
1329                 XC_sizing                       = 120,
1330                 XC_spider                       = 122,
1331                 XC_spraycan                     = 124,
1332                 XC_star                         = 126,
1333                 XC_target                       = 128,
1334                 XC_tcross                       = 130,
1335                 XC_top_left_arrow               = 132,
1336                 XC_top_left_corner              = 134,
1337                 XC_top_right_corner             = 136,
1338                 XC_top_side                     = 138,
1339                 XC_top_tee                      = 140,
1340                 XC_trek                         = 142,
1341
1342                 XC_ul_angle                     = 144,
1343                 XC_umbrella                     = 146,
1344                 XC_ur_angle                     = 148,
1345                 XC_watch                        = 150,
1346                 XC_xterm                        = 152,
1347                 XC_num_glyphs                   = 154
1348         }
1349
1350         internal enum SystrayRequest {
1351                 SYSTEM_TRAY_REQUEST_DOCK        = 0,
1352                 SYSTEM_TRAY_BEGIN_MESSAGE       = 1,
1353                 SYSTEM_TRAY_CANCEL_MESSAGE      = 2
1354         }
1355
1356         internal enum NetWmStateRequest {
1357                 _NET_WM_STATE_REMOVE            = 0,
1358                 _NET_WM_STATE_ADD               = 1,
1359                 _NET_WM_STATE_TOGGLE            = 2
1360         }
1361
1362         [Flags]
1363         internal enum XSizeHintsFlags  {
1364                 USPosition                      = (1 << 0),
1365                 USSize                          = (1 << 1),
1366                 PPosition                       = (1 << 2),
1367                 PSize                           = (1 << 3),
1368                 PMinSize                        = (1 << 4),
1369                 PMaxSize                        = (1 << 5),
1370                 PResizeInc                      = (1 << 6),
1371                 PAspect                         = (1 << 7),
1372                 PAllHints                       = (PPosition | PSize | PMinSize | PMaxSize | PResizeInc | PAspect),
1373                 PBaseSize                       = (1 << 8),
1374                 PWinGravity                     = (1 << 9),
1375         }
1376
1377         [StructLayout(LayoutKind.Sequential)]
1378         internal struct XSizeHints {
1379                 internal IntPtr                 flags;
1380                 internal int                    x;
1381                 internal int                    y;
1382                 internal int                    width;
1383                 internal int                    height;
1384                 internal int                    min_width;
1385                 internal int                    min_height;
1386                 internal int                    max_width;
1387                 internal int                    max_height;
1388                 internal int                    width_inc;
1389                 internal int                    height_inc;
1390                 internal int                    min_aspect_x;
1391                 internal int                    min_aspect_y;
1392                 internal int                    max_aspect_x;
1393                 internal int                    max_aspect_y;
1394                 internal int                    base_width;
1395                 internal int                    base_height;
1396                 internal int                    win_gravity;
1397         }
1398
1399         [Flags]
1400         internal enum XWMHintsFlags {
1401                 InputHint                       = (1 << 0),
1402                 StateHint                       = (1 << 1),
1403                 IconPixmapHint                  = (1 << 2),
1404                 IconWindowHint                  = (1 << 3),
1405                 IconPositionHint                = (1 << 4),
1406                 IconMaskHint                    = (1 << 5),
1407                 WindowGroupHint                 = (1 << 6),
1408                 AllHints                        = (InputHint | StateHint | IconPixmapHint | IconWindowHint | IconPositionHint | IconMaskHint | WindowGroupHint)
1409         }
1410
1411         internal enum XInitialState {
1412                 DontCareState                   = 0,
1413                 NormalState                     = 1,
1414                 ZoomState                       = 2,
1415                 IconicState                     = 3,
1416                 InactiveState                   = 4
1417         }
1418
1419         [StructLayout(LayoutKind.Sequential)]
1420         internal struct XWMHints {
1421                 internal IntPtr                 flags;
1422                 internal bool                   input;
1423                 internal XInitialState          initial_state;
1424                 internal IntPtr                 icon_pixmap;
1425                 internal IntPtr                 icon_window;
1426                 internal int                    icon_x;
1427                 internal int                    icon_y;
1428                 internal IntPtr                 icon_mask;
1429                 internal IntPtr                 window_group;
1430         }
1431
1432         [StructLayout(LayoutKind.Sequential)]
1433         internal struct XIconSize {
1434                 internal int                    min_width;
1435                 internal int                    min_height;
1436                 internal int                    max_width;
1437                 internal int                    max_height;
1438                 internal int                    width_inc;
1439                 internal int                    height_inc;
1440         }
1441
1442         internal struct CaretStruct {
1443                 internal Timer  Timer;                          // Blink interval
1444                 internal IntPtr Hwnd;                           // Window owning the caret
1445                 internal IntPtr Window;                         // Actual X11 handle of the window
1446                 internal int    X;                              // X position of the caret
1447                 internal int    Y;                              // Y position of the caret
1448                 internal int    Width;                          // Width of the caret; if no image used
1449                 internal int    Height;                         // Height of the caret, if no image used
1450                 internal bool   Visible;                        // Is caret visible?
1451                 internal bool   On;                             // Caret blink display state: On/Off
1452                 internal IntPtr gc;                             // Graphics context
1453                 internal bool   Paused;                         // Don't update right now
1454         }
1455
1456         internal struct HoverStruct {
1457                 internal Timer  Timer;                          // for hovering
1458                 internal IntPtr Window;                         // Last window we entered; used to generate WM_MOUSEHOVER (handle is X11 handle)
1459                 internal int    X;                              // Last MouseMove X coordinate; used to generate WM_MOUSEHOVER
1460                 internal int    Y;                              // Last MouseMove Y coordinate; used to generate WM_MOUSEHOVER
1461                 internal Size   Size;                           // Size of the rectangle the mouse has to stay in to generate hover
1462                 internal int    Interval;                       // in milliseconds, how long to hold before hover is generated
1463                 internal IntPtr Atom;                           // X Atom
1464         }
1465
1466         internal struct ClickStruct {
1467                 internal IntPtr Hwnd;                           //
1468                 internal Msg    Message;                        //
1469                 internal IntPtr wParam;                         //
1470                 internal IntPtr lParam;                         //
1471                 internal long   Time;                           // Last time we received a mouse click
1472                 internal bool   Pending;                        // True if we haven't sent the last mouse click
1473         }
1474
1475         internal struct GrabStruct {
1476                 internal bool           Confined;               // Is the current grab (if any) confined to grab_area?
1477                 internal IntPtr         Hwnd;                   // The window that is grabbed
1478                 internal Rectangle      Area;                   // The area the current grab is confined to
1479         }
1480
1481         internal delegate int  XErrorHandler(IntPtr DisplayHandle, ref XErrorEvent error_event);
1482
1483         internal enum XRequest : byte {
1484                 X_CreateWindow                  = 1,
1485                 X_ChangeWindowAttributes        = 2,
1486                 X_GetWindowAttributes           = 3,
1487                 X_DestroyWindow                 = 4,
1488                 X_DestroySubwindows             = 5,
1489                 X_ChangeSaveSet                 = 6,
1490                 X_ReparentWindow                = 7,
1491                 X_MapWindow                     = 8,
1492                 X_MapSubwindows                 = 9,
1493                 X_UnmapWindow                   = 10,
1494                 X_UnmapSubwindows               = 11,
1495                 X_ConfigureWindow               = 12,
1496                 X_CirculateWindow               = 13,
1497                 X_GetGeometry                   = 14,
1498                 X_QueryTree                     = 15,
1499                 X_InternAtom                    = 16,
1500                 X_GetAtomName                   = 17,
1501                 X_ChangeProperty                = 18,
1502                 X_DeleteProperty                = 19,
1503                 X_GetProperty                   = 20,
1504                 X_ListProperties                = 21,
1505                 X_SetSelectionOwner             = 22,
1506                 X_GetSelectionOwner             = 23,
1507                 X_ConvertSelection              = 24,
1508                 X_SendEvent                     = 25,
1509                 X_GrabPointer                   = 26,
1510                 X_UngrabPointer                 = 27,
1511                 X_GrabButton                    = 28,
1512                 X_UngrabButton                  = 29,
1513                 X_ChangeActivePointerGrab       = 30,
1514                 X_GrabKeyboard                  = 31,
1515                 X_UngrabKeyboard                = 32,
1516                 X_GrabKey                       = 33,
1517                 X_UngrabKey                     = 34,
1518                 X_AllowEvents                   = 35,
1519                 X_GrabServer                    = 36,
1520                 X_UngrabServer                  = 37,
1521                 X_QueryPointer                  = 38,
1522                 X_GetMotionEvents               = 39,
1523                 X_TranslateCoords               = 40,
1524                 X_WarpPointer                   = 41,
1525                 X_SetInputFocus                 = 42,
1526                 X_GetInputFocus                 = 43,
1527                 X_QueryKeymap                   = 44,
1528                 X_OpenFont                      = 45,
1529                 X_CloseFont                     = 46,
1530                 X_QueryFont                     = 47,
1531                 X_QueryTextExtents              = 48,
1532                 X_ListFonts                     = 49,
1533                 X_ListFontsWithInfo             = 50,
1534                 X_SetFontPath                   = 51,
1535                 X_GetFontPath                   = 52,
1536                 X_CreatePixmap                  = 53,
1537                 X_FreePixmap                    = 54,
1538                 X_CreateGC                      = 55,
1539                 X_ChangeGC                      = 56,
1540                 X_CopyGC                        = 57,
1541                 X_SetDashes                     = 58,
1542                 X_SetClipRectangles             = 59,
1543                 X_FreeGC                        = 60,
1544                 X_ClearArea                     = 61,
1545                 X_CopyArea                      = 62,
1546                 X_CopyPlane                     = 63,
1547                 X_PolyPoint                     = 64,
1548                 X_PolyLine                      = 65,
1549                 X_PolySegment                   = 66,
1550                 X_PolyRectangle                 = 67,
1551                 X_PolyArc                       = 68,
1552                 X_FillPoly                      = 69,
1553                 X_PolyFillRectangle             = 70,
1554                 X_PolyFillArc                   = 71,
1555                 X_PutImage                      = 72,
1556                 X_GetImage                      = 73,
1557                 X_PolyText8                     = 74,
1558                 X_PolyText16                    = 75,
1559                 X_ImageText8                    = 76,
1560                 X_ImageText16                   = 77,
1561                 X_CreateColormap                = 78,
1562                 X_FreeColormap                  = 79,
1563                 X_CopyColormapAndFree           = 80,
1564                 X_InstallColormap               = 81,
1565                 X_UninstallColormap             = 82,
1566                 X_ListInstalledColormaps        = 83,
1567                 X_AllocColor                    = 84,
1568                 X_AllocNamedColor               = 85,
1569                 X_AllocColorCells               = 86,
1570                 X_AllocColorPlanes              = 87,
1571                 X_FreeColors                    = 88,
1572                 X_StoreColors                   = 89,
1573                 X_StoreNamedColor               = 90,
1574                 X_QueryColors                   = 91,
1575                 X_LookupColor                   = 92,
1576                 X_CreateCursor                  = 93,
1577                 X_CreateGlyphCursor             = 94,
1578                 X_FreeCursor                    = 95,
1579                 X_RecolorCursor                 = 96,
1580                 X_QueryBestSize                 = 97,
1581                 X_QueryExtension                = 98,
1582                 X_ListExtensions                = 99,
1583                 X_ChangeKeyboardMapping         = 100,
1584                 X_GetKeyboardMapping            = 101,
1585                 X_ChangeKeyboardControl         = 102,
1586                 X_GetKeyboardControl            = 103,
1587                 X_Bell                          = 104,
1588                 X_ChangePointerControl          = 105,
1589                 X_GetPointerControl             = 106,
1590                 X_SetScreenSaver                = 107,
1591                 X_GetScreenSaver                = 108,
1592                 X_ChangeHosts                   = 109,
1593                 X_ListHosts                     = 110,
1594                 X_SetAccessControl              = 111,
1595                 X_SetCloseDownMode              = 112,
1596                 X_KillClient                    = 113,
1597                 X_RotateProperties              = 114,
1598                 X_ForceScreenSaver              = 115,
1599                 X_SetPointerMapping             = 116,
1600                 X_GetPointerMapping             = 117,
1601                 X_SetModifierMapping            = 118,
1602                 X_GetModifierMapping            = 119,
1603                 X_NoOperation                   = 127
1604         }
1605
1606         [Flags]
1607         internal enum XIMProperties {
1608                 XIMPreeditArea          = 0x0001,
1609                 XIMPreeditCallbacks     = 0x0002,
1610                 XIMPreeditPosition      = 0x0004,
1611                 XIMPreeditNothing       = 0x0008,
1612                 XIMPreeditNone          = 0x0010,
1613                 XIMStatusArea           = 0x0100,
1614                 XIMStatusCallbacks      = 0x0200,
1615                 XIMStatusNothing        = 0x0400,
1616                 XIMStatusNone           = 0x0800,
1617         }
1618
1619         [Flags]
1620         internal enum WindowType {
1621                 Client                  = 1,
1622                 Whole                   = 2,
1623                 Both                    = 3
1624         }
1625
1626         internal enum XEmbedMessage {
1627                 EmbeddedNotify = 0,
1628                 WindowActivate = 1,
1629                 WindowDeactivate = 2,
1630                 RequestFocus = 3,
1631                 FocusIn = 4,
1632                 FocusOut = 5,
1633                 FocusNext = 6,
1634                 FocusPrev = 7,
1635                 /* 8-9 were used for XEMBED_GRAB_KEY/XEMBED_UNGRAB_KEY */
1636                 ModalityOn = 10,
1637                 ModalityOff = 11,
1638                 RegisterAccelerator = 12,
1639                 UnregisterAccelerator = 13,
1640                 ActivateAccelerator = 14
1641         }
1642
1643         [StructLayout (LayoutKind.Sequential)]
1644         internal struct XcursorImage
1645         {
1646                 private int version;
1647                 public int size;       /* nominal size for matching */
1648                 public int width;      /* actual width */
1649                 public int height;     /* actual height */
1650                 public int xhot;       /* hot spot x (must be inside image) */
1651                 public int yhot;       /* hot spot y (must be inside image) */
1652                 public int delay;       /* hot spot y (must be inside image) */
1653                 public IntPtr pixels;    /* pointer to pixels */
1654
1655                 public override string ToString ()
1656                 {
1657                         return string.Format ("XCursorImage (version: {0}, size: {1}, width: {2}, height: {3}, xhot: {4}, yhot: {5}, delay: {6}, pixels: {7}",
1658                                 version, size, width, height, xhot, yhot, delay, pixels);
1659                 }
1660         } ;
1661
1662         [StructLayout (LayoutKind.Sequential)]
1663         internal struct XcursorImages
1664         {
1665                 public int nimage;     /* number of images */
1666                 public IntPtr images;   /* array of XcursorImage pointers */
1667         }
1668
1669         [StructLayout (LayoutKind.Sequential)]
1670         internal struct XIMStyles
1671         {
1672                 public ushort count_styles;
1673                 public IntPtr supported_styles;
1674         }
1675
1676         [StructLayout (LayoutKind.Sequential)]
1677         [Serializable]
1678         internal class XPoint
1679         {
1680                 public short X;
1681                 public short Y;
1682         }
1683
1684         [StructLayout (LayoutKind.Sequential)]
1685         [Serializable]
1686         internal class XIMCallback
1687         {
1688                 public IntPtr client_data;
1689                 public XIMProc callback;
1690                 [NonSerialized]
1691                 GCHandle gch;
1692
1693                 public XIMCallback (IntPtr clientData, XIMProc proc)
1694                 {
1695                         this.client_data = clientData;
1696                         this.gch = GCHandle.Alloc (proc);
1697                         this.callback = proc;
1698                 }
1699
1700                 ~XIMCallback ()
1701                 {
1702                         gch.Free ();
1703                 }
1704         }
1705
1706         internal struct XIMText
1707         {
1708                 public ushort Length;
1709                 public IntPtr Feedback;
1710                 public bool EncodingIsWChar;
1711                 public IntPtr String; // it could be either char* or wchar_t*
1712         }
1713
1714         internal struct XIMPreeditDrawCallbackStruct
1715         {
1716                 public int Caret;
1717                 public int ChangeFirst;
1718                 public int ChangeLength;
1719                 public IntPtr Text; // to XIMText
1720         }
1721
1722         internal enum XIMCaretDirection
1723         {
1724                 XIMForwardChar,
1725                 XIMBackwardChar,
1726                 XIMForwardWord,
1727                 XIMBackwardWord,
1728                 XIMCaretUp,
1729                 XIMCaretDown,
1730                 XIMNextLine,
1731                 XIMPreviousLine,
1732                 XIMLineStart,
1733                 XIMLineEnd,
1734                 XIMAbsolutePosition,
1735                 XIMDontChange
1736         }
1737
1738         internal enum XIMCaretStyle
1739         {
1740                 IsInvisible,
1741                 IsPrimary,
1742                 IsSecondary
1743         }
1744
1745         internal struct XIMPreeditCaretCallbackStruct
1746         {
1747                 public int Position;
1748                 public XIMCaretDirection Direction;
1749                 public XIMCaretStyle Style;
1750         }
1751
1752         // only PreeditStartCallback requires return value though.
1753         internal delegate int XIMProc (IntPtr xim, IntPtr clientData, IntPtr callData);
1754
1755         internal static class XNames
1756         {
1757                 public const string XNVaNestedList = "XNVaNestedList";
1758                 public const string XNQueryInputStyle = "queryInputStyle";
1759                 public const string XNClientWindow = "clientWindow";
1760                 public const string XNInputStyle = "inputStyle";
1761                 public const string XNFocusWindow = "focusWindow";
1762
1763                 // XIMPreeditCallbacks delegate names.
1764                 public const string XNPreeditStartCallback = "preeditStartCallback";
1765                 public const string XNPreeditDoneCallback = "preeditDoneCallback";
1766                 public const string XNPreeditDrawCallback = "preeditDrawCallback";
1767                 public const string XNPreeditCaretCallback = "preeditCaretCallback";
1768                 public const string XNPreeditStateNotifyCallback = "preeditStateNotifyCallback";
1769                 public const string XNPreeditAttributes = "preeditAttributes";
1770                 // XIMStatusCallbacks delegate names.
1771                 public const string XNStatusStartCallback = "statusStartCallback";
1772                 public const string XNStatusDoneCallback = "statusDoneCallback";
1773                 public const string XNStatusDrawCallback = "statusDrawCallback";
1774                 public const string XNStatusAttributes = "statusAttributes";
1775
1776                 public const string XNArea = "area";
1777                 public const string XNAreaNeeded = "areaNeeded";
1778                 public const string XNSpotLocation = "spotLocation";
1779                 public const string XNFontSet = "fontSet";
1780         }
1781 }