src/gtk/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/window.cpp
   3 // Purpose:     wxWindowGTK implementation
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling, Julian Smart
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __VMS
  14 #define XWarpPointer XWARPPOINTER
  15 #endif
  16
  17 #include "wx/window.h"
  18
  19 #ifndef WX_PRECOMP
  20     #include "wx/log.h"
  21     #include "wx/app.h"
  22     #include "wx/toplevel.h"
  23     #include "wx/dcclient.h"
  24     #include "wx/menu.h"
  25     #include "wx/settings.h"
  26     #include "wx/msgdlg.h"
  27     #include "wx/math.h"
  28 #endif
  29
  30 #include "wx/dnd.h"
  31 #include "wx/tooltip.h"
  32 #include "wx/caret.h"
  33 #include "wx/fontutil.h"
  34 #include "wx/sysopt.h"
  35
  36 #include <ctype.h>
  37
  38 #include "wx/gtk/private.h"
  39 #include "wx/gtk/private/win_gtk.h"
  40 #include <gdk/gdkkeysyms.h>
  41 #include <gdk/gdkx.h>
  42
  43 #if !GTK_CHECK_VERSION(2,10,0)
  44     // GTK+ can reliably detect Meta key state only since 2.10 when
  45     // GDK_META_MASK was introduced -- there wasn't any way to detect it
  46     // in older versions. wxGTK used GDK_MOD2_MASK for this purpose, but
  47     // GDK_MOD2_MASK is documented as:
  48     //
  49     //     the fifth modifier key (it depends on the modifier mapping of the X
  50     //     server which key is interpreted as this modifier)
  51     //
  52     // In other words, it isn't guaranteed to map to Meta. This is a real
  53     // problem: it is common to map NumLock to it (in fact, it's an exception
  54     // if the X server _doesn't_ use it for NumLock).  So the old code caused
  55     // wxKeyEvent::MetaDown() to always return true as long as NumLock was on
  56     // on many systems, which broke all applications using
  57     // wxKeyEvent::GetModifiers() to check modifiers state (see e.g.  here:
  58     // http://tinyurl.com/56lsk2).
  59     //
  60     // Because of this, it's better to not detect Meta key state at all than
  61     // to detect it incorrectly. Hence the following #define, which causes
  62     // m_metaDown to be always set to false.
  63     #define GDK_META_MASK 0
  64 #endif
  65
  66 //-----------------------------------------------------------------------------
  67 // documentation on internals
  68 //-----------------------------------------------------------------------------
  69
  70 /*
  71    I have been asked several times about writing some documentation about
  72    the GTK port of wxWidgets, especially its internal structures. Obviously,
  73    you cannot understand wxGTK without knowing a little about the GTK, but
  74    some more information about what the wxWindow, which is the base class
  75    for all other window classes, does seems required as well.
  76
  77    I)
  78
  79    What does wxWindow do? It contains the common interface for the following
  80    jobs of its descendants:
  81
  82    1) Define the rudimentary behaviour common to all window classes, such as
  83    resizing, intercepting user input (so as to make it possible to use these
  84    events for special purposes in a derived class), window names etc.
  85
  86    2) Provide the possibility to contain and manage children, if the derived
  87    class is allowed to contain children, which holds true for those window
  88    classes which do not display a native GTK widget. To name them, these
  89    classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
  90    work classes are a special case and are handled a bit differently from
  91    the rest. The same holds true for the wxNotebook class.
  92
  93    3) Provide the possibility to draw into a client area of a window. This,
  94    too, only holds true for classes that do not display a native GTK widget
  95    as above.
  96
  97    4) Provide the entire mechanism for scrolling widgets. This actual inter-
  98    face for this is usually in wxScrolledWindow, but the GTK implementation
  99    is in this class.
 100
 101    5) A multitude of helper or extra methods for special purposes, such as
 102    Drag'n'Drop, managing validators etc.
 103
 104    6) Display a border (sunken, raised, simple or none).
 105
 106    Normally one might expect, that one wxWidgets window would always correspond
 107    to one GTK widget. Under GTK, there is no such all-round widget that has all
 108    the functionality. Moreover, the GTK defines a client area as a different
 109    widget from the actual widget you are handling. Last but not least some
 110    special classes (e.g. wxFrame) handle different categories of widgets and
 111    still have the possibility to draw something in the client area.
 112    It was therefore required to write a special purpose GTK widget, that would
 113    represent a client area in the sense of wxWidgets capable to do the jobs
 114    2), 3) and 4). I have written this class and it resides in win_gtk.c of
 115    this directory.
 116
 117    All windows must have a widget, with which they interact with other under-
 118    lying GTK widgets. It is this widget, e.g. that has to be resized etc and
 119    the wxWindow class has a member variable called m_widget which holds a
 120    pointer to this widget. When the window class represents a GTK native widget,
 121    this is (in most cases) the only GTK widget the class manages. E.g. the
 122    wxStaticText class handles only a GtkLabel widget a pointer to which you
 123    can find in m_widget (defined in wxWindow)
 124
 125    When the class has a client area for drawing into and for containing children
 126    it has to handle the client area widget (of the type wxPizza, defined in
 127    win_gtk.cpp), but there could be any number of widgets, handled by a class.
 128    The common rule for all windows is only, that the widget that interacts with
 129    the rest of GTK must be referenced in m_widget and all other widgets must be
 130    children of this widget on the GTK level. The top-most widget, which also
 131    represents the client area, must be in the m_wxwindow field and must be of
 132    the type wxPizza.
 133
 134    As I said, the window classes that display a GTK native widget only have
 135    one widget, so in the case of e.g. the wxButton class m_widget holds a
 136    pointer to a GtkButton widget. But windows with client areas (for drawing
 137    and children) have a m_widget field that is a pointer to a GtkScrolled-
 138    Window and a m_wxwindow field that is pointer to a wxPizza and this
 139    one is (in the GTK sense) a child of the GtkScrolledWindow.
 140
 141    If the m_wxwindow field is set, then all input to this widget is inter-
 142    cepted and sent to the wxWidgets class. If not, all input to the widget
 143    that gets pointed to by m_widget gets intercepted and sent to the class.
 144
 145    II)
 146
 147    The design of scrolling in wxWidgets is markedly different from that offered
 148    by the GTK itself and therefore we cannot simply take it as it is. In GTK,
 149    clicking on a scrollbar belonging to scrolled window will inevitably move
 150    the window. In wxWidgets, the scrollbar will only emit an event, send this
 151    to (normally) a wxScrolledWindow and that class will call ScrollWindow()
 152    which actually moves the window and its sub-windows. Note that wxPizza
 153    memorizes how much it has been scrolled but that wxWidgets forgets this
 154    so that the two coordinates systems have to be kept in synch. This is done
 155    in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
 156
 157    III)
 158
 159    Singularly the most broken code in GTK is the code that is supposed to
 160    inform subwindows (child windows) about new positions. Very often, duplicate
 161    events are sent without changes in size or position, equally often no
 162    events are sent at all (All this is due to a bug in the GtkContainer code
 163    which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
 164    GTK's own system and it simply waits for size events for toplevel windows
 165    and then iterates down the respective size events to all window. This has
 166    the disadvantage that windows might get size events before the GTK widget
 167    actually has the reported size. This doesn't normally pose any problem, but
 168    the OpenGL drawing routines rely on correct behaviour. Therefore, I have
 169    added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
 170    i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
 171    window that is used for OpenGL output really has that size (as reported by
 172    GTK).
 173
 174    IV)
 175
 176    If someone at some point of time feels the immense desire to have a look at,
 177    change or attempt to optimise the Refresh() logic, this person will need an
 178    intimate understanding of what "draw" and "expose" events are and what
 179    they are used for, in particular when used in connection with GTK's
 180    own windowless widgets. Beware.
 181
 182    V)
 183
 184    Cursors, too, have been a constant source of pleasure. The main difficulty
 185    is that a GdkWindow inherits a cursor if the programmer sets a new cursor
 186    for the parent. To prevent this from doing too much harm, I use idle time
 187    to set the cursor over and over again, starting from the toplevel windows
 188    and ending with the youngest generation (speaking of parent and child windows).
 189    Also don't forget that cursors (like much else) are connected to GdkWindows,
 190    not GtkWidgets and that the "window" field of a GtkWidget might very well
 191    point to the GdkWindow of the parent widget (-> "window-less widget") and
 192    that the two obviously have very different meanings.
 193
 194 */
 195
 196 //-----------------------------------------------------------------------------
 197 // data
 198 //-----------------------------------------------------------------------------
 199
 200 // Don't allow event propagation during drag
 201 bool g_blockEventsOnDrag;
 202 // Don't allow mouse event propagation during scroll
 203 bool g_blockEventsOnScroll;
 204 extern wxCursor   g_globalCursor;
 205
 206 // mouse capture state: the window which has it and if the mouse is currently
 207 // inside it
 208 static wxWindowGTK  *g_captureWindow = NULL;
 209 static bool g_captureWindowHasMouse = false;
 210
 211 // The window that currently has focus:
 212 static wxWindowGTK *gs_currentFocus = NULL;
 213 // The window that is scheduled to get focus in the next event loop iteration
 214 // or NULL if there's no pending focus change:
 215 static wxWindowGTK *gs_pendingFocus = NULL;
 216
 217 // the window that has deferred focus-out event pending, if any (see
 218 // GTKAddDeferredFocusOut() for details)
 219 static wxWindowGTK *gs_deferredFocusOut = NULL;
 220
 221 // global variables because GTK+ DnD want to have the
 222 // mouse event that caused it
 223 GdkEvent    *g_lastMouseEvent = NULL;
 224 int          g_lastButtonNumber = 0;
 225
 226 //-----------------------------------------------------------------------------
 227 // debug
 228 //-----------------------------------------------------------------------------
 229
 230 // the trace mask used for the focus debugging messages
 231 #define TRACE_FOCUS wxT("focus")
 232
 233 //-----------------------------------------------------------------------------
 234 // missing gdk functions
 235 //-----------------------------------------------------------------------------
 236
 237 void
 238 gdk_window_warp_pointer (GdkWindow      *window,
 239                          gint            x,
 240                          gint            y)
 241 {
 242   if (!window)
 243     window = gdk_get_default_root_window();
 244
 245   if (!GDK_WINDOW_DESTROYED(window))
 246   {
 247       XWarpPointer (GDK_WINDOW_XDISPLAY(window),
 248                     None,              /* not source window -> move from anywhere */
 249                     GDK_WINDOW_XID(window),  /* dest window */
 250                     0, 0, 0, 0,        /* not source window -> move from anywhere */
 251                     x, y );
 252   }
 253 }
 254
 255
 256 //-----------------------------------------------------------------------------
 257 // "size_request" of m_widget
 258 //-----------------------------------------------------------------------------
 259
 260 extern "C" {
 261 static void
 262 wxgtk_window_size_request_callback(GtkWidget * WXUNUSED(widget),
 263                                    GtkRequisition *requisition,
 264                                    wxWindow * win)
 265 {
 266     int w, h;
 267     win->GetSize( &w, &h );
 268     if (w < 2)
 269         w = 2;
 270     if (h < 2)
 271         h = 2;
 272
 273     requisition->height = h;
 274     requisition->width = w;
 275 }
 276 }
 277
 278 //-----------------------------------------------------------------------------
 279 // "expose_event" of m_wxwindow
 280 //-----------------------------------------------------------------------------
 281
 282 extern "C" {
 283 static gboolean
 284 gtk_window_expose_callback( GtkWidget* widget,
 285                             GdkEventExpose *gdk_event,
 286                             wxWindow *win )
 287 {
 288     if (gdk_event->window == widget->window)
 289     {
 290         win->GetUpdateRegion() = wxRegion( gdk_event->region );
 291         win->GtkSendPaintEvents();
 292     }
 293     // Let parent window draw window-less widgets
 294     return FALSE;
 295 }
 296 }
 297
 298 #ifndef __WXUNIVERSAL__
 299 //-----------------------------------------------------------------------------
 300 // "expose_event" from m_wxwindow->parent, for drawing border
 301 //-----------------------------------------------------------------------------
 302
 303 extern "C" {
 304 static gboolean
 305 expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
 306 {
 307     if (gdk_event->window != widget->window)
 308         return false;
 309
 310     const GtkAllocation& alloc = win->m_wxwindow->allocation;
 311     const int x = alloc.x;
 312     const int y = alloc.y;
 313     const int w = alloc.width;
 314     const int h = alloc.height;
 315
 316     if (w <= 0 || h <= 0)
 317         return false;
 318
 319     if (win->HasFlag(wxBORDER_SIMPLE))
 320     {
 321         gdk_draw_rectangle(gdk_event->window,
 322             widget->style->black_gc, false, x, y, w - 1, h - 1);
 323     }
 324     else
 325     {
 326         GtkShadowType shadow = GTK_SHADOW_IN;
 327         if (win->HasFlag(wxBORDER_RAISED))
 328             shadow = GTK_SHADOW_OUT;
 329
 330         // Style detail to use
 331         const char* detail;
 332         if (win->m_widget == win->m_wxwindow)
 333             // for non-scrollable wxWindows
 334             detail = "entry";
 335         else
 336             // for scrollable ones
 337             detail = "viewport";
 338
 339         gtk_paint_shadow(
 340            win->m_wxwindow->style, gdk_event->window, GTK_STATE_NORMAL,
 341            shadow, NULL, wxGTKPrivate::GetEntryWidget(), detail, x, y, w, h);
 342     }
 343     return false;
 344 }
 345 }
 346
 347 //-----------------------------------------------------------------------------
 348 // "parent_set" from m_wxwindow
 349 //-----------------------------------------------------------------------------
 350
 351 extern "C" {
 352 static void
 353 parent_set(GtkWidget* widget, GtkObject* old_parent, wxWindow* win)
 354 {
 355     if (old_parent)
 356     {
 357         g_signal_handlers_disconnect_by_func(
 358             old_parent, (void*)expose_event_border, win);
 359     }
 360     if (widget->parent)
 361     {
 362         g_signal_connect_after(widget->parent, "expose_event",
 363             G_CALLBACK(expose_event_border), win);
 364     }
 365 }
 366 }
 367 #endif // !__WXUNIVERSAL__
 368
 369 //-----------------------------------------------------------------------------
 370 // "key_press_event" from any window
 371 //-----------------------------------------------------------------------------
 372
 373 // These are used when transforming Ctrl-alpha to ascii values 1-26
 374 inline bool wxIsLowerChar(int code)
 375 {
 376     return (code >= 'a' && code <= 'z' );
 377 }
 378
 379 inline bool wxIsUpperChar(int code)
 380 {
 381     return (code >= 'A' && code <= 'Z' );
 382 }
 383
 384
 385 // set WXTRACE to this to see the key event codes on the console
 386 #define TRACE_KEYS  wxT("keyevent")
 387
 388 // translates an X key symbol to WXK_XXX value
 389 //
 390 // if isChar is true it means that the value returned will be used for EVT_CHAR
 391 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
 392 // for example, while if it is false it means that the value is going to be
 393 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
 394 // WXK_NUMPAD_DIVIDE
 395 static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
 396 {
 397     long key_code;
 398
 399     switch ( keysym )
 400     {
 401         // Shift, Control and Alt don't generate the CHAR events at all
 402         case GDK_Shift_L:
 403         case GDK_Shift_R:
 404             key_code = isChar ? 0 : WXK_SHIFT;
 405             break;
 406         case GDK_Control_L:
 407         case GDK_Control_R:
 408             key_code = isChar ? 0 : WXK_CONTROL;
 409             break;
 410         case GDK_Meta_L:
 411         case GDK_Meta_R:
 412         case GDK_Alt_L:
 413         case GDK_Alt_R:
 414         case GDK_Super_L:
 415         case GDK_Super_R:
 416             key_code = isChar ? 0 : WXK_ALT;
 417             break;
 418
 419         // neither do the toggle modifies
 420         case GDK_Scroll_Lock:
 421             key_code = isChar ? 0 : WXK_SCROLL;
 422             break;
 423
 424         case GDK_Caps_Lock:
 425             key_code = isChar ? 0 : WXK_CAPITAL;
 426             break;
 427
 428         case GDK_Num_Lock:
 429             key_code = isChar ? 0 : WXK_NUMLOCK;
 430             break;
 431
 432
 433         // various other special keys
 434         case GDK_Menu:
 435             key_code = WXK_MENU;
 436             break;
 437
 438         case GDK_Help:
 439             key_code = WXK_HELP;
 440             break;
 441
 442         case GDK_BackSpace:
 443             key_code = WXK_BACK;
 444             break;
 445
 446         case GDK_ISO_Left_Tab:
 447         case GDK_Tab:
 448             key_code = WXK_TAB;
 449             break;
 450
 451         case GDK_Linefeed:
 452         case GDK_Return:
 453             key_code = WXK_RETURN;
 454             break;
 455
 456         case GDK_Clear:
 457             key_code = WXK_CLEAR;
 458             break;
 459
 460         case GDK_Pause:
 461             key_code = WXK_PAUSE;
 462             break;
 463
 464         case GDK_Select:
 465             key_code = WXK_SELECT;
 466             break;
 467
 468         case GDK_Print:
 469             key_code = WXK_PRINT;
 470             break;
 471
 472         case GDK_Execute:
 473             key_code = WXK_EXECUTE;
 474             break;
 475
 476         case GDK_Escape:
 477             key_code = WXK_ESCAPE;
 478             break;
 479
 480         // cursor and other extended keyboard keys
 481         case GDK_Delete:
 482             key_code = WXK_DELETE;
 483             break;
 484
 485         case GDK_Home:
 486             key_code = WXK_HOME;
 487             break;
 488
 489         case GDK_Left:
 490             key_code = WXK_LEFT;
 491             break;
 492
 493         case GDK_Up:
 494             key_code = WXK_UP;
 495             break;
 496
 497         case GDK_Right:
 498             key_code = WXK_RIGHT;
 499             break;
 500
 501         case GDK_Down:
 502             key_code = WXK_DOWN;
 503             break;
 504
 505         case GDK_Prior:     // == GDK_Page_Up
 506             key_code = WXK_PAGEUP;
 507             break;
 508
 509         case GDK_Next:      // == GDK_Page_Down
 510             key_code = WXK_PAGEDOWN;
 511             break;
 512
 513         case GDK_End:
 514             key_code = WXK_END;
 515             break;
 516
 517         case GDK_Begin:
 518             key_code = WXK_HOME;
 519             break;
 520
 521         case GDK_Insert:
 522             key_code = WXK_INSERT;
 523             break;
 524
 525
 526         // numpad keys
 527         case GDK_KP_0:
 528         case GDK_KP_1:
 529         case GDK_KP_2:
 530         case GDK_KP_3:
 531         case GDK_KP_4:
 532         case GDK_KP_5:
 533         case GDK_KP_6:
 534         case GDK_KP_7:
 535         case GDK_KP_8:
 536         case GDK_KP_9:
 537             key_code = (isChar ? '0' : int(WXK_NUMPAD0)) + keysym - GDK_KP_0;
 538             break;
 539
 540         case GDK_KP_Space:
 541             key_code = isChar ? ' ' : int(WXK_NUMPAD_SPACE);
 542             break;
 543
 544         case GDK_KP_Tab:
 545             key_code = isChar ? WXK_TAB : WXK_NUMPAD_TAB;
 546             break;
 547
 548         case GDK_KP_Enter:
 549             key_code = isChar ? WXK_RETURN : WXK_NUMPAD_ENTER;
 550             break;
 551
 552         case GDK_KP_F1:
 553             key_code = isChar ? WXK_F1 : WXK_NUMPAD_F1;
 554             break;
 555
 556         case GDK_KP_F2:
 557             key_code = isChar ? WXK_F2 : WXK_NUMPAD_F2;
 558             break;
 559
 560         case GDK_KP_F3:
 561             key_code = isChar ? WXK_F3 : WXK_NUMPAD_F3;
 562             break;
 563
 564         case GDK_KP_F4:
 565             key_code = isChar ? WXK_F4 : WXK_NUMPAD_F4;
 566             break;
 567
 568         case GDK_KP_Home:
 569             key_code = isChar ? WXK_HOME : WXK_NUMPAD_HOME;
 570             break;
 571
 572         case GDK_KP_Left:
 573             key_code = isChar ? WXK_LEFT : WXK_NUMPAD_LEFT;
 574             break;
 575
 576         case GDK_KP_Up:
 577             key_code = isChar ? WXK_UP : WXK_NUMPAD_UP;
 578             break;
 579
 580         case GDK_KP_Right:
 581             key_code = isChar ? WXK_RIGHT : WXK_NUMPAD_RIGHT;
 582             break;
 583
 584         case GDK_KP_Down:
 585             key_code = isChar ? WXK_DOWN : WXK_NUMPAD_DOWN;
 586             break;
 587
 588         case GDK_KP_Prior: // == GDK_KP_Page_Up
 589             key_code = isChar ? WXK_PAGEUP : WXK_NUMPAD_PAGEUP;
 590             break;
 591
 592         case GDK_KP_Next: // == GDK_KP_Page_Down
 593             key_code = isChar ? WXK_PAGEDOWN : WXK_NUMPAD_PAGEDOWN;
 594             break;
 595
 596         case GDK_KP_End:
 597             key_code = isChar ? WXK_END : WXK_NUMPAD_END;
 598             break;
 599
 600         case GDK_KP_Begin:
 601             key_code = isChar ? WXK_HOME : WXK_NUMPAD_BEGIN;
 602             break;
 603
 604         case GDK_KP_Insert:
 605             key_code = isChar ? WXK_INSERT : WXK_NUMPAD_INSERT;
 606             break;
 607
 608         case GDK_KP_Delete:
 609             key_code = isChar ? WXK_DELETE : WXK_NUMPAD_DELETE;
 610             break;
 611
 612         case GDK_KP_Equal:
 613             key_code = isChar ? '=' : int(WXK_NUMPAD_EQUAL);
 614             break;
 615
 616         case GDK_KP_Multiply:
 617             key_code = isChar ? '*' : int(WXK_NUMPAD_MULTIPLY);
 618             break;
 619
 620         case GDK_KP_Add:
 621             key_code = isChar ? '+' : int(WXK_NUMPAD_ADD);
 622             break;
 623
 624         case GDK_KP_Separator:
 625             // FIXME: what is this?
 626             key_code = isChar ? '.' : int(WXK_NUMPAD_SEPARATOR);
 627             break;
 628
 629         case GDK_KP_Subtract:
 630             key_code = isChar ? '-' : int(WXK_NUMPAD_SUBTRACT);
 631             break;
 632
 633         case GDK_KP_Decimal:
 634             key_code = isChar ? '.' : int(WXK_NUMPAD_DECIMAL);
 635             break;
 636
 637         case GDK_KP_Divide:
 638             key_code = isChar ? '/' : int(WXK_NUMPAD_DIVIDE);
 639             break;
 640
 641
 642         // function keys
 643         case GDK_F1:
 644         case GDK_F2:
 645         case GDK_F3:
 646         case GDK_F4:
 647         case GDK_F5:
 648         case GDK_F6:
 649         case GDK_F7:
 650         case GDK_F8:
 651         case GDK_F9:
 652         case GDK_F10:
 653         case GDK_F11:
 654         case GDK_F12:
 655             key_code = WXK_F1 + keysym - GDK_F1;
 656             break;
 657
 658         default:
 659             key_code = 0;
 660     }
 661
 662     return key_code;
 663 }
 664
 665 static inline bool wxIsAsciiKeysym(KeySym ks)
 666 {
 667     return ks < 256;
 668 }
 669
 670 static void wxFillOtherKeyEventFields(wxKeyEvent& event,
 671                                       wxWindowGTK *win,
 672                                       GdkEventKey *gdk_event)
 673 {
 674     int x = 0;
 675     int y = 0;
 676     GdkModifierType state;
 677     if (gdk_event->window)
 678         gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
 679
 680     event.SetTimestamp( gdk_event->time );
 681     event.SetId(win->GetId());
 682     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
 683     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
 684     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
 685     event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0;
 686     event.m_rawCode = (wxUint32) gdk_event->keyval;
 687     event.m_rawFlags = 0;
 688 #if wxUSE_UNICODE
 689     event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval);
 690 #endif
 691     wxGetMousePosition( &x, &y );
 692     win->ScreenToClient( &x, &y );
 693     event.m_x = x;
 694     event.m_y = y;
 695     event.SetEventObject( win );
 696 }
 697
 698
 699 static bool
 700 wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
 701                            wxWindowGTK *win,
 702                            GdkEventKey *gdk_event)
 703 {
 704     // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
 705     //     but only event->keyval which is quite useless to us, so remember
 706     //     the last character from GDK_KEY_PRESS and reuse it as last resort
 707     //
 708     // NB: should be MT-safe as we're always called from the main thread only
 709     static struct
 710     {
 711         KeySym keysym;
 712         long   keycode;
 713     } s_lastKeyPress = { 0, 0 };
 714
 715     KeySym keysym = gdk_event->keyval;
 716
 717     wxLogTrace(TRACE_KEYS, wxT("Key %s event: keysym = %ld"),
 718                event.GetEventType() == wxEVT_KEY_UP ? wxT("release")
 719                                                     : wxT("press"),
 720                keysym);
 721
 722     long key_code = wxTranslateKeySymToWXKey(keysym, false /* !isChar */);
 723
 724     if ( !key_code )
 725     {
 726         // do we have the translation or is it a plain ASCII character?
 727         if ( (gdk_event->length == 1) || wxIsAsciiKeysym(keysym) )
 728         {
 729             // we should use keysym if it is ASCII as X does some translations
 730             // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
 731             // which we don't want here (but which we do use for OnChar())
 732             if ( !wxIsAsciiKeysym(keysym) )
 733             {
 734                 keysym = (KeySym)gdk_event->string[0];
 735             }
 736
 737             // we want to always get the same key code when the same key is
 738             // pressed regardless of the state of the modifiers, i.e. on a
 739             // standard US keyboard pressing '5' or '%' ('5' key with
 740             // Shift) should result in the same key code in OnKeyDown():
 741             // '5' (although OnChar() will get either '5' or '%').
 742             //
 743             // to do it we first translate keysym to keycode (== scan code)
 744             // and then back but always using the lower register
 745             Display *dpy = (Display *)wxGetDisplay();
 746             KeyCode keycode = XKeysymToKeycode(dpy, keysym);
 747
 748             wxLogTrace(TRACE_KEYS, wxT("\t-> keycode %d"), keycode);
 749
 750             KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
 751
 752             // use the normalized, i.e. lower register, keysym if we've
 753             // got one
 754             key_code = keysymNormalized ? keysymNormalized : keysym;
 755
 756             // as explained above, we want to have lower register key codes
 757             // normally but for the letter keys we want to have the upper ones
 758             //
 759             // NB: don't use XConvertCase() here, we want to do it for letters
 760             // only
 761             key_code = toupper(key_code);
 762         }
 763         else // non ASCII key, what to do?
 764         {
 765             // by default, ignore it
 766             key_code = 0;
 767
 768             // but if we have cached information from the last KEY_PRESS
 769             if ( gdk_event->type == GDK_KEY_RELEASE )
 770             {
 771                 // then reuse it
 772                 if ( keysym == s_lastKeyPress.keysym )
 773                 {
 774                     key_code = s_lastKeyPress.keycode;
 775                 }
 776             }
 777         }
 778
 779         if ( gdk_event->type == GDK_KEY_PRESS )
 780         {
 781             // remember it to be reused for KEY_UP event later
 782             s_lastKeyPress.keysym = keysym;
 783             s_lastKeyPress.keycode = key_code;
 784         }
 785     }
 786
 787     wxLogTrace(TRACE_KEYS, wxT("\t-> wxKeyCode %ld"), key_code);
 788
 789     // sending unknown key events doesn't really make sense
 790     if ( !key_code )
 791         return false;
 792
 793     // now fill all the other fields
 794     wxFillOtherKeyEventFields(event, win, gdk_event);
 795
 796     event.m_keyCode = key_code;
 797 #if wxUSE_UNICODE
 798     if ( gdk_event->type == GDK_KEY_PRESS ||  gdk_event->type == GDK_KEY_RELEASE )
 799     {
 800         event.m_uniChar = key_code;
 801     }
 802 #endif
 803
 804     return true;
 805 }
 806
 807
 808 struct wxGtkIMData
 809 {
 810     GtkIMContext *context;
 811     GdkEventKey  *lastKeyEvent;
 812
 813     wxGtkIMData()
 814     {
 815         context = gtk_im_multicontext_new();
 816         lastKeyEvent = NULL;
 817     }
 818     ~wxGtkIMData()
 819     {
 820         g_object_unref (context);
 821     }
 822 };
 823
 824 extern "C" {
 825 static gboolean
 826 gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
 827                                GdkEventKey *gdk_event,
 828                                wxWindow *win )
 829 {
 830     if (!win->m_hasVMT)
 831         return FALSE;
 832     if (g_blockEventsOnDrag)
 833         return FALSE;
 834
 835     wxKeyEvent event( wxEVT_KEY_DOWN );
 836     bool ret = false;
 837     bool return_after_IM = false;
 838
 839     if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
 840     {
 841         // Emit KEY_DOWN event
 842         ret = win->HandleWindowEvent( event );
 843     }
 844     else
 845     {
 846         // Return after IM processing as we cannot do
 847         // anything with it anyhow.
 848         return_after_IM = true;
 849     }
 850
 851     if ((!ret) && (win->m_imData != NULL))
 852     {
 853         // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
 854         // docs, if IM filter returns true, no further processing should be done.
 855         // we should send the key_down event anyway.
 856         bool intercepted_by_IM = gtk_im_context_filter_keypress(win->m_imData->context, gdk_event);
 857         win->m_imData->lastKeyEvent = NULL;
 858         if (intercepted_by_IM)
 859         {
 860             wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM"));
 861             return TRUE;
 862         }
 863     }
 864
 865     if (return_after_IM)
 866         return FALSE;
 867
 868 #if wxUSE_ACCEL
 869     if (!ret)
 870     {
 871         wxWindowGTK *ancestor = win;
 872         while (ancestor)
 873         {
 874             int command = ancestor->GetAcceleratorTable()->GetCommand( event );
 875             if (command != -1)
 876             {
 877                 wxCommandEvent menu_event( wxEVT_COMMAND_MENU_SELECTED, command );
 878                 ret = ancestor->HandleWindowEvent( menu_event );
 879
 880                 if ( !ret )
 881                 {
 882                     // if the accelerator wasn't handled as menu event, try
 883                     // it as button click (for compatibility with other
 884                     // platforms):
 885                     wxCommandEvent button_event( wxEVT_COMMAND_BUTTON_CLICKED, command );
 886                     ret = ancestor->HandleWindowEvent( button_event );
 887                 }
 888
 889                 break;
 890             }
 891             if (ancestor->IsTopLevel())
 892                 break;
 893             ancestor = ancestor->GetParent();
 894         }
 895     }
 896 #endif // wxUSE_ACCEL
 897
 898     // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
 899     // will only be sent if it is not in an accelerator table.
 900     if (!ret)
 901     {
 902         long key_code;
 903         KeySym keysym = gdk_event->keyval;
 904         // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
 905         key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */);
 906         if ( !key_code )
 907         {
 908             if ( wxIsAsciiKeysym(keysym) )
 909             {
 910                 // ASCII key
 911                 key_code = (unsigned char)keysym;
 912             }
 913             // gdk_event->string is actually deprecated
 914             else if ( gdk_event->length == 1 )
 915             {
 916                 key_code = (unsigned char)gdk_event->string[0];
 917             }
 918         }
 919
 920         if ( key_code )
 921         {
 922             wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
 923
 924             event.m_keyCode = key_code;
 925
 926             // To conform to the docs we need to translate Ctrl-alpha
 927             // characters to values in the range 1-26.
 928             if ( event.ControlDown() &&
 929                  ( wxIsLowerChar(key_code) || wxIsUpperChar(key_code) ))
 930             {
 931                 if ( wxIsLowerChar(key_code) )
 932                     event.m_keyCode = key_code - 'a' + 1;
 933                 if ( wxIsUpperChar(key_code) )
 934                     event.m_keyCode = key_code - 'A' + 1;
 935 #if wxUSE_UNICODE
 936                 event.m_uniChar = event.m_keyCode;
 937 #endif
 938             }
 939
 940             // Implement OnCharHook by checking ancestor top level windows
 941             wxWindow *parent = win;
 942             while (parent && !parent->IsTopLevel())
 943                 parent = parent->GetParent();
 944             if (parent)
 945             {
 946                 event.SetEventType( wxEVT_CHAR_HOOK );
 947                 ret = parent->HandleWindowEvent( event );
 948             }
 949
 950             if (!ret)
 951             {
 952                 event.SetEventType(wxEVT_CHAR);
 953                 ret = win->HandleWindowEvent( event );
 954             }
 955         }
 956     }
 957
 958     return ret;
 959 }
 960 }
 961
 962 extern "C" {
 963 static void
 964 gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
 965                         const gchar  *str,
 966                         wxWindow     *window)
 967 {
 968     wxKeyEvent event( wxEVT_KEY_DOWN );
 969
 970     // take modifiers, cursor position, timestamp etc. from the last
 971     // key_press_event that was fed into Input Method:
 972     if (window->m_imData->lastKeyEvent)
 973     {
 974         wxFillOtherKeyEventFields(event,
 975                                   window, window->m_imData->lastKeyEvent);
 976     }
 977     else
 978     {
 979         event.SetEventObject( window );
 980     }
 981
 982     const wxString data(wxGTK_CONV_BACK_SYS(str));
 983     if( data.empty() )
 984         return;
 985
 986     bool ret = false;
 987
 988     // Implement OnCharHook by checking ancestor top level windows
 989     wxWindow *parent = window;
 990     while (parent && !parent->IsTopLevel())
 991         parent = parent->GetParent();
 992
 993     for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr )
 994     {
 995 #if wxUSE_UNICODE
 996         event.m_uniChar = *pstr;
 997         // Backward compatible for ISO-8859-1
 998         event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
 999         wxLogTrace(TRACE_KEYS, wxT("IM sent character '%c'"), event.m_uniChar);
1000 #else
1001         event.m_keyCode = (char)*pstr;
1002 #endif  // wxUSE_UNICODE
1003
1004         // To conform to the docs we need to translate Ctrl-alpha
1005         // characters to values in the range 1-26.
1006         if ( event.ControlDown() &&
1007              ( wxIsLowerChar(*pstr) || wxIsUpperChar(*pstr) ))
1008         {
1009             if ( wxIsLowerChar(*pstr) )
1010                 event.m_keyCode = *pstr - 'a' + 1;
1011             if ( wxIsUpperChar(*pstr) )
1012                 event.m_keyCode = *pstr - 'A' + 1;
1013
1014             event.m_keyCode = *pstr - 'a' + 1;
1015 #if wxUSE_UNICODE
1016             event.m_uniChar = event.m_keyCode;
1017 #endif
1018         }
1019
1020         if (parent)
1021         {
1022             event.SetEventType( wxEVT_CHAR_HOOK );
1023             ret = parent->HandleWindowEvent( event );
1024         }
1025
1026         if (!ret)
1027         {
1028             event.SetEventType(wxEVT_CHAR);
1029             ret = window->HandleWindowEvent( event );
1030         }
1031     }
1032 }
1033 }
1034
1035
1036 //-----------------------------------------------------------------------------
1037 // "key_release_event" from any window
1038 //-----------------------------------------------------------------------------
1039
1040 extern "C" {
1041 static gboolean
1042 gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget),
1043                                  GdkEventKey *gdk_event,
1044                                  wxWindowGTK *win )
1045 {
1046     if (!win->m_hasVMT)
1047         return FALSE;
1048
1049     if (g_blockEventsOnDrag)
1050         return FALSE;
1051
1052     wxKeyEvent event( wxEVT_KEY_UP );
1053     if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1054     {
1055         // unknown key pressed, ignore (the event would be useless anyhow)
1056         return FALSE;
1057     }
1058
1059     return win->GTKProcessEvent(event);
1060 }
1061 }
1062
1063 // ============================================================================
1064 // the mouse events
1065 // ============================================================================
1066
1067 // ----------------------------------------------------------------------------
1068 // mouse event processing helpers
1069 // ----------------------------------------------------------------------------
1070
1071 // init wxMouseEvent with the info from GdkEventXXX struct
1072 template<typename T> void InitMouseEvent(wxWindowGTK *win,
1073                                          wxMouseEvent& event,
1074                                          T *gdk_event)
1075 {
1076     event.SetTimestamp( gdk_event->time );
1077     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
1078     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
1079     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
1080     event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0;
1081     event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK) != 0;
1082     event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK) != 0;
1083     event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK) != 0;
1084     event.m_aux1Down = (gdk_event->state & GDK_BUTTON4_MASK) != 0;
1085     event.m_aux2Down = (gdk_event->state & GDK_BUTTON5_MASK) != 0;
1086
1087     wxPoint pt = win->GetClientAreaOrigin();
1088     event.m_x = (wxCoord)gdk_event->x - pt.x;
1089     event.m_y = (wxCoord)gdk_event->y - pt.y;
1090
1091     if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft))
1092     {
1093         // origin in the upper right corner
1094         int window_width = win->m_wxwindow->allocation.width;
1095         event.m_x = window_width - event.m_x;
1096     }
1097
1098     event.SetEventObject( win );
1099     event.SetId( win->GetId() );
1100     event.SetTimestamp( gdk_event->time );
1101 }
1102
1103 static void AdjustEventButtonState(wxMouseEvent& event)
1104 {
1105     // GDK reports the old state of the button for a button press event, but
1106     // for compatibility with MSW and common sense we want m_leftDown be TRUE
1107     // for a LEFT_DOWN event, not FALSE, so we will invert
1108     // left/right/middleDown for the corresponding click events
1109
1110     if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1111         (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1112         (event.GetEventType() == wxEVT_LEFT_UP))
1113     {
1114         event.m_leftDown = !event.m_leftDown;
1115         return;
1116     }
1117
1118     if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1119         (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1120         (event.GetEventType() == wxEVT_MIDDLE_UP))
1121     {
1122         event.m_middleDown = !event.m_middleDown;
1123         return;
1124     }
1125
1126     if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1127         (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1128         (event.GetEventType() == wxEVT_RIGHT_UP))
1129     {
1130         event.m_rightDown = !event.m_rightDown;
1131         return;
1132     }
1133 }
1134
1135 // find the window to send the mouse event too
1136 static
1137 wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1138 {
1139     wxCoord xx = x;
1140     wxCoord yy = y;
1141
1142     if (win->m_wxwindow)
1143     {
1144         wxPizza* pizza = WX_PIZZA(win->m_wxwindow);
1145         xx += pizza->m_scroll_x;
1146         yy += pizza->m_scroll_y;
1147     }
1148
1149     wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
1150     while (node)
1151     {
1152         wxWindowGTK *child = node->GetData();
1153
1154         node = node->GetNext();
1155         if (!child->IsShown())
1156             continue;
1157
1158         if (child->GTKIsTransparentForMouse())
1159         {
1160             // wxStaticBox is transparent in the box itself
1161             int xx1 = child->m_x;
1162             int yy1 = child->m_y;
1163             int xx2 = child->m_x + child->m_width;
1164             int yy2 = child->m_y + child->m_height;
1165
1166             // left
1167             if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
1168             // right
1169                 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
1170             // top
1171                 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
1172             // bottom
1173                 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
1174             {
1175                 win = child;
1176                 x -= child->m_x;
1177                 y -= child->m_y;
1178                 break;
1179             }
1180
1181         }
1182         else
1183         {
1184             if ((child->m_wxwindow == NULL) &&
1185                 (child->m_x <= xx) &&
1186                 (child->m_y <= yy) &&
1187                 (child->m_x+child->m_width  >= xx) &&
1188                 (child->m_y+child->m_height >= yy))
1189             {
1190                 win = child;
1191                 x -= child->m_x;
1192                 y -= child->m_y;
1193                 break;
1194             }
1195         }
1196     }
1197
1198     return win;
1199 }
1200
1201 // ----------------------------------------------------------------------------
1202 // common event handlers helpers
1203 // ----------------------------------------------------------------------------
1204
1205 bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
1206 {
1207     // nothing special at this level
1208     return HandleWindowEvent(event);
1209 }
1210
1211 bool wxWindowGTK::GTKShouldIgnoreEvent() const
1212 {
1213     return !m_hasVMT || g_blockEventsOnDrag;
1214 }
1215
1216 int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
1217 {
1218     if (!m_hasVMT)
1219         return FALSE;
1220     if (g_blockEventsOnDrag)
1221         return TRUE;
1222     if (g_blockEventsOnScroll)
1223         return TRUE;
1224
1225     if (!GTKIsOwnWindow(event->window))
1226         return FALSE;
1227
1228     return -1;
1229 }
1230
1231 // overloads for all GDK event types we use here: we need to have this as
1232 // GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1233 // derives from it in the sense that the structs have the same layout
1234 #define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T)                                  \
1235     static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win)        \
1236     {                                                                         \
1237         return win->GTKCallbackCommonPrologue((GdkEventAny *)event);          \
1238     }
1239
1240 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton)
1241 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion)
1242 wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing)
1243
1244 #undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1245
1246 #define wxCOMMON_CALLBACK_PROLOGUE(event, win)                                \
1247     const int rc = wxGtkCallbackCommonPrologue(event, win);                   \
1248     if ( rc != -1 )                                                           \
1249         return rc
1250
1251 // all event handlers must have C linkage as they're called from GTK+ C code
1252 extern "C"
1253 {
1254
1255 //-----------------------------------------------------------------------------
1256 // "button_press_event"
1257 //-----------------------------------------------------------------------------
1258
1259 static gboolean
1260 gtk_window_button_press_callback( GtkWidget *widget,
1261                                   GdkEventButton *gdk_event,
1262                                   wxWindowGTK *win )
1263 {
1264     wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1265
1266     g_lastButtonNumber = gdk_event->button;
1267
1268     // GDK sends surplus button down events
1269     // before a double click event. We
1270     // need to filter these out.
1271     if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow))
1272     {
1273         GdkEvent *peek_event = gdk_event_peek();
1274         if (peek_event)
1275         {
1276             if ((peek_event->type == GDK_2BUTTON_PRESS) ||
1277                 (peek_event->type == GDK_3BUTTON_PRESS))
1278             {
1279                 gdk_event_free( peek_event );
1280                 return TRUE;
1281             }
1282             else
1283             {
1284                 gdk_event_free( peek_event );
1285             }
1286         }
1287     }
1288
1289     wxEventType event_type = wxEVT_NULL;
1290
1291     if ( gdk_event->type == GDK_2BUTTON_PRESS &&
1292             gdk_event->button >= 1 && gdk_event->button <= 3 )
1293     {
1294         // Reset GDK internal timestamp variables in order to disable GDK
1295         // triple click events. GDK will then next time believe no button has
1296         // been clicked just before, and send a normal button click event.
1297         GdkDisplay* display = gtk_widget_get_display (widget);
1298         display->button_click_time[1] = 0;
1299         display->button_click_time[0] = 0;
1300     }
1301
1302     if (gdk_event->button == 1)
1303     {
1304         // note that GDK generates triple click events which are not supported
1305         // by wxWidgets but still have to be passed to the app as otherwise
1306         // clicks would simply go missing
1307         switch (gdk_event->type)
1308         {
1309             // we shouldn't get triple clicks at all for GTK2 because we
1310             // suppress them artificially using the code above but we still
1311             // should map them to something for GTK1 and not just ignore them
1312             // as this would lose clicks
1313             case GDK_3BUTTON_PRESS:     // we could also map this to DCLICK...
1314             case GDK_BUTTON_PRESS:
1315                 event_type = wxEVT_LEFT_DOWN;
1316                 break;
1317
1318             case GDK_2BUTTON_PRESS:
1319                 event_type = wxEVT_LEFT_DCLICK;
1320                 break;
1321
1322             default:
1323                 // just to silence gcc warnings
1324                 ;
1325         }
1326     }
1327     else if (gdk_event->button == 2)
1328     {
1329         switch (gdk_event->type)
1330         {
1331             case GDK_3BUTTON_PRESS:
1332             case GDK_BUTTON_PRESS:
1333                 event_type = wxEVT_MIDDLE_DOWN;
1334                 break;
1335
1336             case GDK_2BUTTON_PRESS:
1337                 event_type = wxEVT_MIDDLE_DCLICK;
1338                 break;
1339
1340             default:
1341                 ;
1342         }
1343     }
1344     else if (gdk_event->button == 3)
1345     {
1346         switch (gdk_event->type)
1347         {
1348             case GDK_3BUTTON_PRESS:
1349             case GDK_BUTTON_PRESS:
1350                 event_type = wxEVT_RIGHT_DOWN;
1351                 break;
1352
1353             case GDK_2BUTTON_PRESS:
1354                 event_type = wxEVT_RIGHT_DCLICK;
1355                 break;
1356
1357             default:
1358                 ;
1359         }
1360     }
1361
1362     if ( event_type == wxEVT_NULL )
1363     {
1364         // unknown mouse button or click type
1365         return FALSE;
1366     }
1367
1368     g_lastMouseEvent = (GdkEvent*) gdk_event;
1369
1370     wxMouseEvent event( event_type );
1371     InitMouseEvent( win, event, gdk_event );
1372
1373     AdjustEventButtonState(event);
1374
1375     // find the correct window to send the event to: it may be a different one
1376     // from the one which got it at GTK+ level because some controls don't have
1377     // their own X window and thus cannot get any events.
1378     if ( !g_captureWindow )
1379         win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1380
1381     // reset the event object and id in case win changed.
1382     event.SetEventObject( win );
1383     event.SetId( win->GetId() );
1384
1385     bool ret = win->GTKProcessEvent( event );
1386     g_lastMouseEvent = NULL;
1387     if ( ret )
1388         return TRUE;
1389
1390     if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
1391         (gs_currentFocus != win) /* && win->IsFocusable() */)
1392     {
1393         win->SetFocus();
1394     }
1395
1396     if (event_type == wxEVT_RIGHT_DOWN)
1397     {
1398         // generate a "context menu" event: this is similar to right mouse
1399         // click under many GUIs except that it is generated differently
1400         // (right up under MSW, ctrl-click under Mac, right down here) and
1401         //
1402         // (a) it's a command event and so is propagated to the parent
1403         // (b) under some ports it can be generated from kbd too
1404         // (c) it uses screen coords (because of (a))
1405         wxContextMenuEvent evtCtx(
1406             wxEVT_CONTEXT_MENU,
1407             win->GetId(),
1408             win->ClientToScreen(event.GetPosition()));
1409         evtCtx.SetEventObject(win);
1410         return win->GTKProcessEvent(evtCtx);
1411     }
1412
1413     return FALSE;
1414 }
1415
1416 //-----------------------------------------------------------------------------
1417 // "button_release_event"
1418 //-----------------------------------------------------------------------------
1419
1420 static gboolean
1421 gtk_window_button_release_callback( GtkWidget *WXUNUSED(widget),
1422                                     GdkEventButton *gdk_event,
1423                                     wxWindowGTK *win )
1424 {
1425     wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1426
1427     g_lastButtonNumber = 0;
1428
1429     wxEventType event_type = wxEVT_NULL;
1430
1431     switch (gdk_event->button)
1432     {
1433         case 1:
1434             event_type = wxEVT_LEFT_UP;
1435             break;
1436
1437         case 2:
1438             event_type = wxEVT_MIDDLE_UP;
1439             break;
1440
1441         case 3:
1442             event_type = wxEVT_RIGHT_UP;
1443             break;
1444
1445         default:
1446             // unknown button, don't process
1447             return FALSE;
1448     }
1449
1450     g_lastMouseEvent = (GdkEvent*) gdk_event;
1451
1452     wxMouseEvent event( event_type );
1453     InitMouseEvent( win, event, gdk_event );
1454
1455     AdjustEventButtonState(event);
1456
1457     if ( !g_captureWindow )
1458         win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1459
1460     // reset the event object and id in case win changed.
1461     event.SetEventObject( win );
1462     event.SetId( win->GetId() );
1463
1464     bool ret = win->GTKProcessEvent(event);
1465
1466     g_lastMouseEvent = NULL;
1467
1468     return ret;
1469 }
1470
1471 //-----------------------------------------------------------------------------
1472 // "motion_notify_event"
1473 //-----------------------------------------------------------------------------
1474
1475 static gboolean
1476 gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget),
1477                                    GdkEventMotion *gdk_event,
1478                                    wxWindowGTK *win )
1479 {
1480     wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1481
1482     if (gdk_event->is_hint)
1483     {
1484         int x = 0;
1485         int y = 0;
1486         GdkModifierType state;
1487         gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1488         gdk_event->x = x;
1489         gdk_event->y = y;
1490     }
1491
1492     g_lastMouseEvent = (GdkEvent*) gdk_event;
1493
1494     wxMouseEvent event( wxEVT_MOTION );
1495     InitMouseEvent(win, event, gdk_event);
1496
1497     if ( g_captureWindow )
1498     {
1499         // synthesise a mouse enter or leave event if needed
1500         GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
1501         // This seems to be necessary and actually been added to
1502         // GDK itself in version 2.0.X
1503         gdk_flush();
1504
1505         bool hasMouse = winUnderMouse == gdk_event->window;
1506         if ( hasMouse != g_captureWindowHasMouse )
1507         {
1508             // the mouse changed window
1509             g_captureWindowHasMouse = hasMouse;
1510
1511             wxMouseEvent eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1512                                                         : wxEVT_LEAVE_WINDOW);
1513             InitMouseEvent(win, eventM, gdk_event);
1514             eventM.SetEventObject(win);
1515             win->GTKProcessEvent(eventM);
1516         }
1517     }
1518     else // no capture
1519     {
1520         win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1521
1522         // reset the event object and id in case win changed.
1523         event.SetEventObject( win );
1524         event.SetId( win->GetId() );
1525     }
1526
1527     if ( !g_captureWindow )
1528     {
1529         wxSetCursorEvent cevent( event.m_x, event.m_y );
1530         if (win->GTKProcessEvent( cevent ))
1531         {
1532             win->SetCursor( cevent.GetCursor() );
1533         }
1534     }
1535
1536     bool ret = win->GTKProcessEvent(event);
1537
1538     g_lastMouseEvent = NULL;
1539
1540     return ret;
1541 }
1542
1543 //-----------------------------------------------------------------------------
1544 // "scroll_event" (mouse wheel event)
1545 //-----------------------------------------------------------------------------
1546
1547 static gboolean
1548 window_scroll_event_hscrollbar(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
1549 {
1550     if (gdk_event->direction != GDK_SCROLL_LEFT &&
1551         gdk_event->direction != GDK_SCROLL_RIGHT)
1552     {
1553         return false;
1554     }
1555
1556     wxMouseEvent event(wxEVT_MOUSEWHEEL);
1557     InitMouseEvent(win, event, gdk_event);
1558
1559     GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Horz];
1560     if (!range) return FALSE;
1561
1562     if (range && GTK_WIDGET_VISIBLE (range))
1563     {
1564         GtkAdjustment *adj = range->adjustment;
1565         gdouble delta = adj->step_increment * 3;
1566         if (gdk_event->direction == GDK_SCROLL_LEFT)
1567             delta = -delta;
1568
1569         gdouble new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size);
1570
1571         gtk_adjustment_set_value (adj, new_value);
1572
1573         return TRUE;
1574     }
1575
1576     return FALSE;
1577 }
1578
1579 static gboolean
1580 window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
1581 {
1582     if (gdk_event->direction != GDK_SCROLL_UP &&
1583         gdk_event->direction != GDK_SCROLL_DOWN)
1584     {
1585         return false;
1586     }
1587
1588     wxMouseEvent event(wxEVT_MOUSEWHEEL);
1589     InitMouseEvent(win, event, gdk_event);
1590
1591     // FIXME: Get these values from GTK or GDK
1592     event.m_linesPerAction = 3;
1593     event.m_wheelDelta = 120;
1594     if (gdk_event->direction == GDK_SCROLL_UP)
1595         event.m_wheelRotation = 120;
1596     else
1597         event.m_wheelRotation = -120;
1598
1599     if (win->GTKProcessEvent(event))
1600       return TRUE;
1601
1602     GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Vert];
1603     if (!range) return FALSE;
1604
1605     if (range && GTK_WIDGET_VISIBLE (range))
1606     {
1607         GtkAdjustment *adj = range->adjustment;
1608         gdouble delta = adj->step_increment * 3;
1609         if (gdk_event->direction == GDK_SCROLL_UP)
1610           delta = -delta;
1611
1612         gdouble new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size);
1613
1614         gtk_adjustment_set_value (adj, new_value);
1615
1616         return TRUE;
1617     }
1618
1619     return FALSE;
1620 }
1621
1622 //-----------------------------------------------------------------------------
1623 // "popup-menu"
1624 //-----------------------------------------------------------------------------
1625
1626 static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
1627 {
1628     wxContextMenuEvent event(wxEVT_CONTEXT_MENU, win->GetId(), wxPoint(-1, -1));
1629     event.SetEventObject(win);
1630     return win->GTKProcessEvent(event);
1631 }
1632
1633 //-----------------------------------------------------------------------------
1634 // "focus_in_event"
1635 //-----------------------------------------------------------------------------
1636
1637 static gboolean
1638 gtk_window_focus_in_callback( GtkWidget * WXUNUSED(widget),
1639                               GdkEventFocus *WXUNUSED(event),
1640                               wxWindowGTK *win )
1641 {
1642     return win->GTKHandleFocusIn();
1643 }
1644
1645 //-----------------------------------------------------------------------------
1646 // "focus_out_event"
1647 //-----------------------------------------------------------------------------
1648
1649 static gboolean
1650 gtk_window_focus_out_callback( GtkWidget * WXUNUSED(widget),
1651                                GdkEventFocus * WXUNUSED(gdk_event),
1652                                wxWindowGTK *win )
1653 {
1654     return win->GTKHandleFocusOut();
1655 }
1656
1657 //-----------------------------------------------------------------------------
1658 // "focus"
1659 //-----------------------------------------------------------------------------
1660
1661 static gboolean
1662 wx_window_focus_callback(GtkWidget *widget,
1663                          GtkDirectionType WXUNUSED(direction),
1664                          wxWindowGTK *win)
1665 {
1666     // the default handler for focus signal in GtkScrolledWindow sets
1667     // focus to the window itself even if it doesn't accept focus, i.e. has no
1668     // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1669     // the signal from reaching gtk_scrolled_window_focus() if we don't have
1670     // any children which might accept focus (we know we don't accept the focus
1671     // ourselves as this signal is only connected in this case)
1672     if ( win->GetChildren().empty() )
1673         g_signal_stop_emission_by_name(widget, "focus");
1674
1675     // we didn't change the focus
1676     return FALSE;
1677 }
1678
1679 //-----------------------------------------------------------------------------
1680 // "enter_notify_event"
1681 //-----------------------------------------------------------------------------
1682
1683 static gboolean
1684 gtk_window_enter_callback( GtkWidget *widget,
1685                            GdkEventCrossing *gdk_event,
1686                            wxWindowGTK *win )
1687 {
1688     wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1689
1690     // Event was emitted after a grab
1691     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1692
1693     int x = 0;
1694     int y = 0;
1695     GdkModifierType state = (GdkModifierType)0;
1696
1697     gdk_window_get_pointer( widget->window, &x, &y, &state );
1698
1699     wxMouseEvent event( wxEVT_ENTER_WINDOW );
1700     InitMouseEvent(win, event, gdk_event);
1701     wxPoint pt = win->GetClientAreaOrigin();
1702     event.m_x = x + pt.x;
1703     event.m_y = y + pt.y;
1704
1705     if ( !g_captureWindow )
1706     {
1707         wxSetCursorEvent cevent( event.m_x, event.m_y );
1708         if (win->GTKProcessEvent( cevent ))
1709         {
1710             win->SetCursor( cevent.GetCursor() );
1711         }
1712     }
1713
1714     return win->GTKProcessEvent(event);
1715 }
1716
1717 //-----------------------------------------------------------------------------
1718 // "leave_notify_event"
1719 //-----------------------------------------------------------------------------
1720
1721 static gboolean
1722 gtk_window_leave_callback( GtkWidget *widget,
1723                            GdkEventCrossing *gdk_event,
1724                            wxWindowGTK *win )
1725 {
1726     wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
1727
1728     // Event was emitted after an ungrab
1729     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1730
1731     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1732
1733     int x = 0;
1734     int y = 0;
1735     GdkModifierType state = (GdkModifierType)0;
1736
1737     gdk_window_get_pointer( widget->window, &x, &y, &state );
1738
1739     InitMouseEvent(win, event, gdk_event);
1740
1741     return win->GTKProcessEvent(event);
1742 }
1743
1744 //-----------------------------------------------------------------------------
1745 // "value_changed" from scrollbar
1746 //-----------------------------------------------------------------------------
1747
1748 static void
1749 gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win)
1750 {
1751     wxEventType eventType = win->GTKGetScrollEventType(range);
1752     if (eventType != wxEVT_NULL)
1753     {
1754         // Convert scroll event type to scrollwin event type
1755         eventType += wxEVT_SCROLLWIN_TOP - wxEVT_SCROLL_TOP;
1756
1757         // find the scrollbar which generated the event
1758         wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range);
1759
1760         // generate the corresponding wx event
1761         const int orient = wxWindow::OrientFromScrollDir(dir);
1762         wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
1763         event.SetEventObject(win);
1764
1765         win->GTKProcessEvent(event);
1766     }
1767 }
1768
1769 //-----------------------------------------------------------------------------
1770 // "button_press_event" from scrollbar
1771 //-----------------------------------------------------------------------------
1772
1773 static gboolean
1774 gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
1775 {
1776     g_blockEventsOnScroll = true;
1777     win->m_mouseButtonDown = true;
1778
1779     return false;
1780 }
1781
1782 //-----------------------------------------------------------------------------
1783 // "event_after" from scrollbar
1784 //-----------------------------------------------------------------------------
1785
1786 static void
1787 gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win)
1788 {
1789     if (event->type == GDK_BUTTON_RELEASE)
1790     {
1791         g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win);
1792
1793         const int orient = wxWindow::OrientFromScrollDir(
1794                                         win->ScrollDirFromRange(range));
1795         wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBRELEASE,
1796                                 win->GetScrollPos(orient), orient);
1797         evt.SetEventObject(win);
1798         win->GTKProcessEvent(evt);
1799     }
1800 }
1801
1802 //-----------------------------------------------------------------------------
1803 // "button_release_event" from scrollbar
1804 //-----------------------------------------------------------------------------
1805
1806 static gboolean
1807 gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win)
1808 {
1809     g_blockEventsOnScroll = false;
1810     win->m_mouseButtonDown = false;
1811     // If thumb tracking
1812     if (win->m_isScrolling)
1813     {
1814         win->m_isScrolling = false;
1815         // Hook up handler to send thumb release event after this emission is finished.
1816         // To allow setting scroll position from event handler, sending event must
1817         // be deferred until after the GtkRange handler for this signal has run
1818         g_signal_handlers_unblock_by_func(range, (void*)gtk_scrollbar_event_after, win);
1819     }
1820
1821     return false;
1822 }
1823
1824 //-----------------------------------------------------------------------------
1825 // "realize" from m_widget
1826 //-----------------------------------------------------------------------------
1827
1828 static void
1829 gtk_window_realized_callback(GtkWidget* widget, wxWindow* win)
1830 {
1831     if (win->m_imData)
1832     {
1833         gtk_im_context_set_client_window( win->m_imData->context,
1834                                           widget->window);
1835     }
1836
1837     // We cannot set colours and fonts before the widget
1838     // been realized, so we do this directly after realization
1839     // or otherwise in idle time
1840
1841     if (win->m_needsStyleChange)
1842     {
1843         win->SetBackgroundStyle(win->GetBackgroundStyle());
1844         win->m_needsStyleChange = false;
1845     }
1846
1847     wxWindowCreateEvent event( win );
1848     event.SetEventObject( win );
1849     win->GTKProcessEvent( event );
1850 }
1851
1852 //-----------------------------------------------------------------------------
1853 // "size_allocate" from m_wxwindow or m_widget
1854 //-----------------------------------------------------------------------------
1855
1856 static void
1857 size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
1858 {
1859     int w = alloc->width;
1860     int h = alloc->height;
1861     if (win->m_wxwindow)
1862     {
1863         int border_x, border_y;
1864         WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y);
1865         w -= 2 * border_x;
1866         h -= 2 * border_y;
1867         if (w < 0) w = 0;
1868         if (h < 0) h = 0;
1869     }
1870     if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
1871     {
1872         win->m_oldClientWidth  = w;
1873         win->m_oldClientHeight = h;
1874         // this callback can be connected to m_wxwindow,
1875         // so always get size from m_widget->allocation
1876         win->m_width  = win->m_widget->allocation.width;
1877         win->m_height = win->m_widget->allocation.height;
1878         if (!win->m_nativeSizeEvent)
1879         {
1880             wxSizeEvent event(win->GetSize(), win->GetId());
1881             event.SetEventObject(win);
1882             win->GTKProcessEvent(event);
1883         }
1884     }
1885 }
1886
1887 //-----------------------------------------------------------------------------
1888 // "grab_broken"
1889 //-----------------------------------------------------------------------------
1890
1891 #if GTK_CHECK_VERSION(2, 8, 0)
1892 static gboolean
1893 gtk_window_grab_broken( GtkWidget*,
1894                         GdkEventGrabBroken *event,
1895                         wxWindow *win )
1896 {
1897     // Mouse capture has been lost involuntarily, notify the application
1898     if(!event->keyboard && wxWindow::GetCapture() == win)
1899     {
1900         wxMouseCaptureLostEvent evt( win->GetId() );
1901         evt.SetEventObject( win );
1902         win->HandleWindowEvent( evt );
1903     }
1904     return false;
1905 }
1906 #endif
1907
1908 //-----------------------------------------------------------------------------
1909 // "style_set"
1910 //-----------------------------------------------------------------------------
1911
1912 static
1913 void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
1914                                GtkStyle *previous_style,
1915                                wxWindow* win )
1916 {
1917     if (win && previous_style)
1918     {
1919         wxSysColourChangedEvent event;
1920         event.SetEventObject(win);
1921
1922         win->GTKProcessEvent( event );
1923     }
1924 }
1925
1926 } // extern "C"
1927
1928 // ----------------------------------------------------------------------------
1929 // this wxWindowBase function is implemented here (in platform-specific file)
1930 // because it is static and so couldn't be made virtual
1931 // ----------------------------------------------------------------------------
1932
1933 wxWindow *wxWindowBase::DoFindFocus()
1934 {
1935     wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
1936     // the cast is necessary when we compile in wxUniversal mode
1937     return static_cast<wxWindow*>(focus);
1938 }
1939
1940 void wxWindowGTK::AddChildGTK(wxWindowGTK* child)
1941 {
1942     wxASSERT_MSG(m_wxwindow, "Cannot add a child to a window without a client area");
1943
1944     // the window might have been scrolled already, we
1945     // have to adapt the position
1946     wxPizza* pizza = WX_PIZZA(m_wxwindow);
1947     child->m_x += pizza->m_scroll_x;
1948     child->m_y += pizza->m_scroll_y;
1949
1950     gtk_widget_set_size_request(
1951         child->m_widget, child->m_width, child->m_height);
1952     gtk_fixed_put(
1953         GTK_FIXED(m_wxwindow), child->m_widget, child->m_x, child->m_y);
1954 }
1955
1956 //-----------------------------------------------------------------------------
1957 // global functions
1958 //-----------------------------------------------------------------------------
1959
1960 wxWindow *wxGetActiveWindow()
1961 {
1962     return wxWindow::FindFocus();
1963 }
1964
1965
1966 wxMouseState wxGetMouseState()
1967 {
1968     wxMouseState ms;
1969
1970     gint x;
1971     gint y;
1972     GdkModifierType mask;
1973
1974     gdk_window_get_pointer(NULL, &x, &y, &mask);
1975
1976     ms.SetX(x);
1977     ms.SetY(y);
1978     ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0);
1979     ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0);
1980     ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0);
1981     ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0);
1982     ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0);
1983
1984     ms.SetControlDown((mask & GDK_CONTROL_MASK) != 0);
1985     ms.SetShiftDown((mask & GDK_SHIFT_MASK) != 0);
1986     ms.SetAltDown((mask & GDK_MOD1_MASK) != 0);
1987     ms.SetMetaDown((mask & GDK_META_MASK) != 0);
1988
1989     return ms;
1990 }
1991
1992 //-----------------------------------------------------------------------------
1993 // wxWindowGTK
1994 //-----------------------------------------------------------------------------
1995
1996 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
1997 // method
1998 #ifdef __WXUNIVERSAL__
1999     IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2000 #else // __WXGTK__
2001     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
2002 #endif // __WXUNIVERSAL__/__WXGTK__
2003
2004 void wxWindowGTK::Init()
2005 {
2006     // GTK specific
2007     m_widget = NULL;
2008     m_wxwindow = NULL;
2009     m_focusWidget = NULL;
2010
2011     // position/size
2012     m_x = 0;
2013     m_y = 0;
2014     m_width = 0;
2015     m_height = 0;
2016
2017     m_hasVMT = false;
2018
2019     m_showOnIdle = false;
2020
2021     m_noExpose = false;
2022     m_nativeSizeEvent = false;
2023
2024     m_isScrolling = false;
2025     m_mouseButtonDown = false;
2026
2027     // initialize scrolling stuff
2028     for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2029     {
2030         m_scrollBar[dir] = NULL;
2031         m_scrollPos[dir] = 0;
2032     }
2033
2034     m_oldClientWidth =
2035     m_oldClientHeight = 0;
2036
2037     m_clipPaintRegion = false;
2038
2039     m_needsStyleChange = false;
2040
2041     m_cursor = *wxSTANDARD_CURSOR;
2042
2043     m_imData = NULL;
2044     m_dirtyTabOrder = false;
2045 }
2046
2047 wxWindowGTK::wxWindowGTK()
2048 {
2049     Init();
2050 }
2051
2052 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2053                           wxWindowID id,
2054                           const wxPoint &pos,
2055                           const wxSize &size,
2056                           long style,
2057                           const wxString &name  )
2058 {
2059     Init();
2060
2061     Create( parent, id, pos, size, style, name );
2062 }
2063
2064 bool wxWindowGTK::Create( wxWindow *parent,
2065                           wxWindowID id,
2066                           const wxPoint &pos,
2067                           const wxSize &size,
2068                           long style,
2069                           const wxString &name  )
2070 {
2071     // Get default border
2072     wxBorder border = GetBorder(style);
2073
2074     style &= ~wxBORDER_MASK;
2075     style |= border;
2076
2077     if (!PreCreation( parent, pos, size ) ||
2078         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2079     {
2080         wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2081         return false;
2082     }
2083
2084         // We should accept the native look
2085 #if 0
2086         GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2087         scroll_class->scrollbar_spacing = 0;
2088 #endif
2089
2090
2091     m_wxwindow = wxPizza::New(m_windowStyle);
2092 #ifndef __WXUNIVERSAL__
2093     if (HasFlag(wxPizza::BORDER_STYLES))
2094     {
2095         g_signal_connect(m_wxwindow, "parent_set",
2096             G_CALLBACK(parent_set), this);
2097     }
2098 #endif
2099     if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
2100         m_widget = m_wxwindow;
2101     else
2102     {
2103         m_widget = gtk_scrolled_window_new( NULL, NULL );
2104
2105         GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2106
2107         // There is a conflict with default bindings at GTK+
2108         // level between scrolled windows and notebooks both of which want to use
2109         // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2110         // direction and notebooks for changing pages -- we decide that if we don't
2111         // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2112         // means we can get working keyboard navigation in notebooks
2113         if ( !HasFlag(wxHSCROLL) )
2114         {
2115             GtkBindingSet *
2116                 bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
2117             if ( bindings )
2118             {
2119                 gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
2120                 gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
2121             }
2122         }
2123
2124         if (HasFlag(wxALWAYS_SHOW_SB))
2125         {
2126             gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
2127
2128             scrolledWindow->hscrollbar_visible = TRUE;
2129             scrolledWindow->vscrollbar_visible = TRUE;
2130         }
2131         else
2132         {
2133             gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2134         }
2135
2136         m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
2137         m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
2138         if (GetLayoutDirection() == wxLayout_RightToLeft)
2139             gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
2140
2141         gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2142
2143         // connect various scroll-related events
2144         for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2145         {
2146             // these handlers block mouse events to any window during scrolling
2147             // such as motion events and prevent GTK and wxWidgets from fighting
2148             // over where the slider should be
2149             g_signal_connect(m_scrollBar[dir], "button_press_event",
2150                          G_CALLBACK(gtk_scrollbar_button_press_event), this);
2151             g_signal_connect(m_scrollBar[dir], "button_release_event",
2152                          G_CALLBACK(gtk_scrollbar_button_release_event), this);
2153
2154             gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
2155                                 G_CALLBACK(gtk_scrollbar_event_after), this);
2156             g_signal_handler_block(m_scrollBar[dir], handler_id);
2157
2158             // these handlers get notified when scrollbar slider moves
2159             g_signal_connect_after(m_scrollBar[dir], "value_changed",
2160                          G_CALLBACK(gtk_scrollbar_value_changed), this);
2161         }
2162
2163         gtk_widget_show( m_wxwindow );
2164     }
2165     g_object_ref(m_widget);
2166
2167     if (m_parent)
2168         m_parent->DoAddChild( this );
2169
2170     m_focusWidget = m_wxwindow;
2171
2172     SetCanFocus(AcceptsFocus());
2173
2174     PostCreation();
2175
2176     return true;
2177 }
2178
2179 wxWindowGTK::~wxWindowGTK()
2180 {
2181     SendDestroyEvent();
2182
2183     if (gs_currentFocus == this)
2184         gs_currentFocus = NULL;
2185     if (gs_pendingFocus == this)
2186         gs_pendingFocus = NULL;
2187
2188     if ( gs_deferredFocusOut == this )
2189         gs_deferredFocusOut = NULL;
2190
2191     m_hasVMT = false;
2192
2193     // destroy children before destroying this window itself
2194     DestroyChildren();
2195
2196     // unhook focus handlers to prevent stray events being
2197     // propagated to this (soon to be) dead object
2198     if (m_focusWidget != NULL)
2199     {
2200         g_signal_handlers_disconnect_by_func (m_focusWidget,
2201                                               (gpointer) gtk_window_focus_in_callback,
2202                                               this);
2203         g_signal_handlers_disconnect_by_func (m_focusWidget,
2204                                               (gpointer) gtk_window_focus_out_callback,
2205                                               this);
2206     }
2207
2208     if (m_widget)
2209         Show( false );
2210
2211     // delete before the widgets to avoid a crash on solaris
2212     delete m_imData;
2213
2214     if (m_widget)
2215     {
2216         // Note that gtk_widget_destroy() does not destroy the widget, it just
2217         // emits the "destroy" signal. The widget is not actually destroyed
2218         // until its reference count drops to zero.
2219         gtk_widget_destroy(m_widget);
2220         // Release our reference, should be the last one
2221         g_object_unref(m_widget);
2222         m_widget = NULL;
2223     }
2224     m_wxwindow = NULL;
2225 }
2226
2227 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos,  const wxSize &size )
2228 {
2229     if ( GTKNeedsParent() )
2230     {
2231         wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
2232     }
2233
2234     // Use either the given size, or the default if -1 is given.
2235     // See wxWindowBase for these functions.
2236     m_width = WidthDefault(size.x) ;
2237     m_height = HeightDefault(size.y);
2238
2239     m_x = (int)pos.x;
2240     m_y = (int)pos.y;
2241
2242     return true;
2243 }
2244
2245 void wxWindowGTK::PostCreation()
2246 {
2247     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2248
2249     if (m_wxwindow)
2250     {
2251         if (!m_noExpose)
2252         {
2253             // these get reported to wxWidgets -> wxPaintEvent
2254
2255             g_signal_connect (m_wxwindow, "expose_event",
2256                               G_CALLBACK (gtk_window_expose_callback), this);
2257
2258             if (GetLayoutDirection() == wxLayout_LeftToRight)
2259                 gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
2260         }
2261
2262         // Create input method handler
2263         m_imData = new wxGtkIMData;
2264
2265         // Cannot handle drawing preedited text yet
2266         gtk_im_context_set_use_preedit( m_imData->context, FALSE );
2267
2268         g_signal_connect (m_imData->context, "commit",
2269                           G_CALLBACK (gtk_wxwindow_commit_cb), this);
2270     }
2271
2272     // focus handling
2273
2274     if (!GTK_IS_WINDOW(m_widget))
2275     {
2276         if (m_focusWidget == NULL)
2277             m_focusWidget = m_widget;
2278
2279         if (m_wxwindow)
2280         {
2281             g_signal_connect (m_focusWidget, "focus_in_event",
2282                           G_CALLBACK (gtk_window_focus_in_callback), this);
2283             g_signal_connect (m_focusWidget, "focus_out_event",
2284                                 G_CALLBACK (gtk_window_focus_out_callback), this);
2285         }
2286         else
2287         {
2288             g_signal_connect_after (m_focusWidget, "focus_in_event",
2289                           G_CALLBACK (gtk_window_focus_in_callback), this);
2290             g_signal_connect_after (m_focusWidget, "focus_out_event",
2291                                 G_CALLBACK (gtk_window_focus_out_callback), this);
2292         }
2293     }
2294
2295     if ( !AcceptsFocusFromKeyboard() )
2296     {
2297         SetCanFocus(false);
2298
2299         g_signal_connect(m_widget, "focus",
2300                             G_CALLBACK(wx_window_focus_callback), this);
2301     }
2302
2303     // connect to the various key and mouse handlers
2304
2305     GtkWidget *connect_widget = GetConnectWidget();
2306
2307     ConnectWidget( connect_widget );
2308
2309     /* We cannot set colours, fonts and cursors before the widget has
2310        been realized, so we do this directly after realization */
2311     g_signal_connect (connect_widget, "realize",
2312                       G_CALLBACK (gtk_window_realized_callback), this);
2313
2314     if (!IsTopLevel())
2315     {
2316         g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate",
2317             G_CALLBACK(size_allocate), this);
2318     }
2319
2320 #if GTK_CHECK_VERSION(2, 8, 0)
2321     if ( gtk_check_version(2,8,0) == NULL )
2322     {
2323         // Make sure we can notify the app when mouse capture is lost
2324         if ( m_wxwindow )
2325         {
2326             g_signal_connect (m_wxwindow, "grab_broken_event",
2327                           G_CALLBACK (gtk_window_grab_broken), this);
2328         }
2329
2330         if ( connect_widget != m_wxwindow )
2331         {
2332             g_signal_connect (connect_widget, "grab_broken_event",
2333                         G_CALLBACK (gtk_window_grab_broken), this);
2334         }
2335     }
2336 #endif // GTK+ >= 2.8
2337
2338     if ( GTKShouldConnectSizeRequest() )
2339     {
2340         // This is needed if we want to add our windows into native
2341         // GTK controls, such as the toolbar. With this callback, the
2342         // toolbar gets to know the correct size (the one set by the
2343         // programmer). Sadly, it misbehaves for wxComboBox.
2344         g_signal_connect (m_widget, "size_request",
2345                           G_CALLBACK (wxgtk_window_size_request_callback),
2346                           this);
2347     }
2348
2349     InheritAttributes();
2350
2351     m_hasVMT = true;
2352
2353     SetLayoutDirection(wxLayout_Default);
2354
2355     // unless the window was created initially hidden (i.e. Hide() had been
2356     // called before Create()), we should show it at GTK+ level as well
2357     if ( IsShown() )
2358         gtk_widget_show( m_widget );
2359 }
2360
2361 gulong wxWindowGTK::GTKConnectWidget(const char *signal, void (*callback)())
2362 {
2363     return g_signal_connect(m_widget, signal, callback, this);
2364 }
2365
2366 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2367 {
2368     g_signal_connect (widget, "key_press_event",
2369                       G_CALLBACK (gtk_window_key_press_callback), this);
2370     g_signal_connect (widget, "key_release_event",
2371                       G_CALLBACK (gtk_window_key_release_callback), this);
2372     g_signal_connect (widget, "button_press_event",
2373                       G_CALLBACK (gtk_window_button_press_callback), this);
2374     g_signal_connect (widget, "button_release_event",
2375                       G_CALLBACK (gtk_window_button_release_callback), this);
2376     g_signal_connect (widget, "motion_notify_event",
2377                       G_CALLBACK (gtk_window_motion_notify_callback), this);
2378
2379     g_signal_connect (widget, "scroll_event",
2380                       G_CALLBACK (window_scroll_event), this);
2381     if (m_scrollBar[ScrollDir_Horz])
2382         g_signal_connect (m_scrollBar[ScrollDir_Horz], "scroll_event",
2383                       G_CALLBACK (window_scroll_event_hscrollbar), this);
2384     if (m_scrollBar[ScrollDir_Vert])
2385         g_signal_connect (m_scrollBar[ScrollDir_Vert], "scroll_event",
2386                       G_CALLBACK (window_scroll_event), this);
2387
2388     g_signal_connect (widget, "popup_menu",
2389                      G_CALLBACK (wxgtk_window_popup_menu_callback), this);
2390     g_signal_connect (widget, "enter_notify_event",
2391                       G_CALLBACK (gtk_window_enter_callback), this);
2392     g_signal_connect (widget, "leave_notify_event",
2393                       G_CALLBACK (gtk_window_leave_callback), this);
2394
2395     if (IsTopLevel() && m_wxwindow)
2396         g_signal_connect (m_wxwindow, "style_set",
2397                               G_CALLBACK (gtk_window_style_set_callback), this);
2398 }
2399
2400 bool wxWindowGTK::Destroy()
2401 {
2402     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2403
2404     m_hasVMT = false;
2405
2406     return wxWindowBase::Destroy();
2407 }
2408
2409 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2410 {
2411     gtk_widget_set_size_request(m_widget, width, height);
2412
2413     // inform the parent to perform the move
2414     wxASSERT_MSG(m_parent && m_parent->m_wxwindow,
2415                  "the parent window has no client area?");
2416     WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y);
2417 }
2418
2419 void wxWindowGTK::ConstrainSize()
2420 {
2421 #ifdef __WXGPE__
2422     // GPE's window manager doesn't like size hints at all, esp. when the user
2423     // has to use the virtual keyboard, so don't constrain size there
2424     if (!IsTopLevel())
2425 #endif
2426     {
2427         const wxSize minSize = GetMinSize();
2428         const wxSize maxSize = GetMaxSize();
2429         if (minSize.x > 0 && m_width  < minSize.x) m_width  = minSize.x;
2430         if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
2431         if (maxSize.x > 0 && m_width  > maxSize.x) m_width  = maxSize.x;
2432         if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
2433     }
2434 }
2435
2436 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2437 {
2438     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2439     wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2440
2441     int currentX, currentY;
2442     GetPosition(&currentX, &currentY);
2443     if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2444         x = currentX;
2445     if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2446         y = currentY;
2447     AdjustForParentClientOrigin(x, y, sizeFlags);
2448
2449     // calculate the best size if we should auto size the window
2450     if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2451          ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2452     {
2453         const wxSize sizeBest = GetBestSize();
2454         if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2455             width = sizeBest.x;
2456         if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2457             height = sizeBest.y;
2458     }
2459
2460     const wxSize oldSize(m_width, m_height);
2461     if (width != -1)
2462         m_width = width;
2463     if (height != -1)
2464         m_height = height;
2465
2466     if (m_parent->m_wxwindow)
2467     {
2468         wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2469         m_x = x + pizza->m_scroll_x;
2470         m_y = y + pizza->m_scroll_y;
2471
2472         int left_border = 0;
2473         int right_border = 0;
2474         int top_border = 0;
2475         int bottom_border = 0;
2476
2477         /* the default button has a border around it */
2478         if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2479         {
2480             GtkBorder *default_border = NULL;
2481             gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
2482             if (default_border)
2483             {
2484                 left_border += default_border->left;
2485                 right_border += default_border->right;
2486                 top_border += default_border->top;
2487                 bottom_border += default_border->bottom;
2488                 gtk_border_free( default_border );
2489             }
2490         }
2491
2492         DoMoveWindow( m_x - left_border,
2493                       m_y - top_border,
2494                       m_width+left_border+right_border,
2495                       m_height+top_border+bottom_border );
2496     }
2497
2498     if (m_width != oldSize.x || m_height != oldSize.y)
2499     {
2500         // update these variables to keep size_allocate handler
2501         // from sending another size event for this change
2502         GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2503
2504         gtk_widget_queue_resize(m_widget);
2505         if (!m_nativeSizeEvent)
2506         {
2507             wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2508             event.SetEventObject( this );
2509             HandleWindowEvent( event );
2510         }
2511     } else
2512     if (sizeFlags & wxSIZE_FORCE_EVENT)
2513     {
2514         wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2515         event.SetEventObject( this );
2516         HandleWindowEvent( event );
2517     }
2518 }
2519
2520 bool wxWindowGTK::GTKShowFromOnIdle()
2521 {
2522     if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget))
2523     {
2524         GtkAllocation alloc;
2525         alloc.x = m_x;
2526         alloc.y = m_y;
2527         alloc.width = m_width;
2528         alloc.height = m_height;
2529         gtk_widget_size_allocate( m_widget, &alloc );
2530         gtk_widget_show( m_widget );
2531         wxShowEvent eventShow(GetId(), true);
2532         eventShow.SetEventObject(this);
2533         HandleWindowEvent(eventShow);
2534         m_showOnIdle = false;
2535         return true;
2536     }
2537
2538     return false;
2539 }
2540
2541 void wxWindowGTK::OnInternalIdle()
2542 {
2543     if ( gs_deferredFocusOut )
2544         GTKHandleDeferredFocusOut();
2545
2546     // Check if we have to show window now
2547     if (GTKShowFromOnIdle()) return;
2548
2549     if ( m_dirtyTabOrder )
2550     {
2551         m_dirtyTabOrder = false;
2552         RealizeTabOrder();
2553     }
2554
2555     // Update style if the window was not yet realized when
2556     // SetBackgroundStyle() was called
2557     if (m_needsStyleChange)
2558     {
2559         SetBackgroundStyle(GetBackgroundStyle());
2560         m_needsStyleChange = false;
2561     }
2562
2563     wxCursor cursor = m_cursor;
2564     if (g_globalCursor.Ok()) cursor = g_globalCursor;
2565
2566     if (cursor.Ok())
2567     {
2568         /* I now set the cursor anew in every OnInternalIdle call
2569            as setting the cursor in a parent window also effects the
2570            windows above so that checking for the current cursor is
2571            not possible. */
2572
2573         if (m_wxwindow && (m_wxwindow != m_widget))
2574         {
2575             GdkWindow *window = m_wxwindow->window;
2576             if (window)
2577                 gdk_window_set_cursor( window, cursor.GetCursor() );
2578
2579             if (!g_globalCursor.Ok())
2580                 cursor = *wxSTANDARD_CURSOR;
2581
2582             window = m_widget->window;
2583             if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2584                 gdk_window_set_cursor( window, cursor.GetCursor() );
2585
2586         }
2587         else if ( m_widget )
2588         {
2589             GdkWindow *window = m_widget->window;
2590             if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) )
2591                gdk_window_set_cursor( window, cursor.GetCursor() );
2592         }
2593     }
2594
2595     if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
2596         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
2597 }
2598
2599 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2600 {
2601     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2602
2603     if (width) (*width) = m_width;
2604     if (height) (*height) = m_height;
2605 }
2606
2607 void wxWindowGTK::DoSetClientSize( int width, int height )
2608 {
2609     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2610
2611     const wxSize size = GetSize();
2612     const wxSize clientSize = GetClientSize();
2613     SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
2614 }
2615
2616 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2617 {
2618     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2619
2620     int w = m_width;
2621     int h = m_height;
2622
2623     if ( m_wxwindow )
2624     {
2625         // if window is scrollable, account for scrollbars
2626         if ( GTK_IS_SCROLLED_WINDOW(m_widget) )
2627         {
2628             GtkPolicyType policy[ScrollDir_Max];
2629             gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
2630                                            &policy[ScrollDir_Horz],
2631                                            &policy[ScrollDir_Vert]);
2632
2633             for ( int i = 0; i < ScrollDir_Max; i++ )
2634             {
2635                 // don't account for the scrollbars we don't have
2636                 GtkRange * const range = m_scrollBar[i];
2637                 if ( !range )
2638                     continue;
2639
2640                 // nor for the ones we have but don't current show
2641                 switch ( policy[i] )
2642                 {
2643                     case GTK_POLICY_NEVER:
2644                         // never shown so doesn't take any place
2645                         continue;
2646
2647                     case GTK_POLICY_ALWAYS:
2648                         // no checks necessary
2649                         break;
2650
2651                     case GTK_POLICY_AUTOMATIC:
2652                         // may be shown or not, check
2653                         GtkAdjustment *adj = gtk_range_get_adjustment(range);
2654                         if ( adj->upper <= adj->page_size )
2655                             continue;
2656                 }
2657
2658                 GtkScrolledWindowClass *scroll_class =
2659                     GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2660
2661                 GtkRequisition req;
2662                 gtk_widget_size_request(GTK_WIDGET(range), &req);
2663                 if (i == ScrollDir_Horz)
2664                     h -= req.height + scroll_class->scrollbar_spacing;
2665                 else
2666                     w -= req.width + scroll_class->scrollbar_spacing;
2667             }
2668         }
2669
2670         int border_x, border_y;
2671         WX_PIZZA(m_wxwindow)->get_border_widths(border_x, border_y);
2672         w -= 2 * border_x;
2673         h -= 2 * border_y;
2674
2675         if (w < 0)
2676             w = 0;
2677         if (h < 0)
2678             h = 0;
2679     }
2680
2681     if (width) *width = w;
2682     if (height) *height = h;
2683 }
2684
2685 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2686 {
2687     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2688
2689     int dx = 0;
2690     int dy = 0;
2691     if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
2692     {
2693         wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2694         dx = pizza->m_scroll_x;
2695         dy = pizza->m_scroll_y;
2696     }
2697
2698     if (m_x == -1 && m_y == -1)
2699     {
2700         GdkWindow *source = NULL;
2701         if (m_wxwindow)
2702             source = m_wxwindow->window;
2703         else
2704             source = m_widget->window;
2705
2706         if (source)
2707         {
2708             int org_x = 0;
2709             int org_y = 0;
2710             gdk_window_get_origin( source, &org_x, &org_y );
2711
2712             if (m_parent)
2713                 m_parent->ScreenToClient(&org_x, &org_y);
2714
2715             const_cast<wxWindowGTK*>(this)->m_x = org_x;
2716             const_cast<wxWindowGTK*>(this)->m_y = org_y;
2717         }
2718     }
2719
2720     if (x) (*x) = m_x - dx;
2721     if (y) (*y) = m_y - dy;
2722 }
2723
2724 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2725 {
2726     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2727
2728     if (!m_widget->window) return;
2729
2730     GdkWindow *source = NULL;
2731     if (m_wxwindow)
2732         source = m_wxwindow->window;
2733     else
2734         source = m_widget->window;
2735
2736     int org_x = 0;
2737     int org_y = 0;
2738     gdk_window_get_origin( source, &org_x, &org_y );
2739
2740     if (!m_wxwindow)
2741     {
2742         if (GTK_WIDGET_NO_WINDOW (m_widget))
2743         {
2744             org_x += m_widget->allocation.x;
2745             org_y += m_widget->allocation.y;
2746         }
2747     }
2748
2749
2750     if (x)
2751     {
2752         if (GetLayoutDirection() == wxLayout_RightToLeft)
2753             *x = (GetClientSize().x - *x) + org_x;
2754         else
2755             *x += org_x;
2756     }
2757
2758     if (y) *y += org_y;
2759 }
2760
2761 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
2762 {
2763     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2764
2765     if (!m_widget->window) return;
2766
2767     GdkWindow *source = NULL;
2768     if (m_wxwindow)
2769         source = m_wxwindow->window;
2770     else
2771         source = m_widget->window;
2772
2773     int org_x = 0;
2774     int org_y = 0;
2775     gdk_window_get_origin( source, &org_x, &org_y );
2776
2777     if (!m_wxwindow)
2778     {
2779         if (GTK_WIDGET_NO_WINDOW (m_widget))
2780         {
2781             org_x += m_widget->allocation.x;
2782             org_y += m_widget->allocation.y;
2783         }
2784     }
2785
2786     if (x)
2787     {
2788         if (GetLayoutDirection() == wxLayout_RightToLeft)
2789             *x = (GetClientSize().x - *x) - org_x;
2790         else
2791             *x -= org_x;
2792     }
2793     if (y) *y -= org_y;
2794 }
2795
2796 bool wxWindowGTK::Show( bool show )
2797 {
2798     if ( !wxWindowBase::Show(show) )
2799     {
2800         // nothing to do
2801         return false;
2802     }
2803
2804     // notice that we may call Hide() before the window is created and this is
2805     // actually useful to create it hidden initially -- but we can't call
2806     // Show() before it is created
2807     if ( !m_widget )
2808     {
2809         wxASSERT_MSG( !show, "can't show invalid window" );
2810         return true;
2811     }
2812
2813     if ( show )
2814     {
2815         if ( m_showOnIdle )
2816         {
2817             // defer until later
2818             return true;
2819         }
2820
2821         gtk_widget_show(m_widget);
2822     }
2823     else // hide
2824     {
2825         gtk_widget_hide(m_widget);
2826     }
2827
2828     wxShowEvent eventShow(GetId(), show);
2829     eventShow.SetEventObject(this);
2830     HandleWindowEvent(eventShow);
2831
2832     return true;
2833 }
2834
2835 void wxWindowGTK::DoEnable( bool enable )
2836 {
2837     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2838
2839     gtk_widget_set_sensitive( m_widget, enable );
2840     if (m_wxwindow && (m_wxwindow != m_widget))
2841         gtk_widget_set_sensitive( m_wxwindow, enable );
2842 }
2843
2844 int wxWindowGTK::GetCharHeight() const
2845 {
2846     wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
2847
2848     wxFont font = GetFont();
2849     wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
2850
2851     PangoContext* context = gtk_widget_get_pango_context(m_widget);
2852
2853     if (!context)
2854         return 0;
2855
2856     PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2857     PangoLayout *layout = pango_layout_new(context);
2858     pango_layout_set_font_description(layout, desc);
2859     pango_layout_set_text(layout, "H", 1);
2860     PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2861
2862     PangoRectangle rect;
2863     pango_layout_line_get_extents(line, NULL, &rect);
2864
2865     g_object_unref (layout);
2866
2867     return (int) PANGO_PIXELS(rect.height);
2868 }
2869
2870 int wxWindowGTK::GetCharWidth() const
2871 {
2872     wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
2873
2874     wxFont font = GetFont();
2875     wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
2876
2877     PangoContext* context = gtk_widget_get_pango_context(m_widget);
2878
2879     if (!context)
2880         return 0;
2881
2882     PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2883     PangoLayout *layout = pango_layout_new(context);
2884     pango_layout_set_font_description(layout, desc);
2885     pango_layout_set_text(layout, "g", 1);
2886     PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2887
2888     PangoRectangle rect;
2889     pango_layout_line_get_extents(line, NULL, &rect);
2890
2891     g_object_unref (layout);
2892
2893     return (int) PANGO_PIXELS(rect.width);
2894 }
2895
2896 void wxWindowGTK::DoGetTextExtent( const wxString& string,
2897                                    int *x,
2898                                    int *y,
2899                                    int *descent,
2900                                    int *externalLeading,
2901                                    const wxFont *theFont ) const
2902 {
2903     wxFont fontToUse = theFont ? *theFont : GetFont();
2904
2905     wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
2906
2907     if (string.empty())
2908     {
2909         if (x) (*x) = 0;
2910         if (y) (*y) = 0;
2911         return;
2912     }
2913
2914     PangoContext *context = NULL;
2915     if (m_widget)
2916         context = gtk_widget_get_pango_context( m_widget );
2917
2918     if (!context)
2919     {
2920         if (x) (*x) = 0;
2921         if (y) (*y) = 0;
2922         return;
2923     }
2924
2925     PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
2926     PangoLayout *layout = pango_layout_new(context);
2927     pango_layout_set_font_description(layout, desc);
2928     {
2929         const wxCharBuffer data = wxGTK_CONV( string );
2930         if ( data )
2931             pango_layout_set_text(layout, data, strlen(data));
2932     }
2933
2934     PangoRectangle rect;
2935     pango_layout_get_extents(layout, NULL, &rect);
2936
2937     if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
2938     if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
2939     if (descent)
2940     {
2941         PangoLayoutIter *iter = pango_layout_get_iter(layout);
2942         int baseline = pango_layout_iter_get_baseline(iter);
2943         pango_layout_iter_free(iter);
2944         *descent = *y - PANGO_PIXELS(baseline);
2945     }
2946     if (externalLeading) (*externalLeading) = 0;  // ??
2947
2948     g_object_unref (layout);
2949 }
2950
2951 void wxWindowGTK::GTKDisableFocusOutEvent()
2952 {
2953     g_signal_handlers_block_by_func( m_focusWidget,
2954                                 (gpointer) gtk_window_focus_out_callback, this);
2955 }
2956
2957 void wxWindowGTK::GTKEnableFocusOutEvent()
2958 {
2959     g_signal_handlers_unblock_by_func( m_focusWidget,
2960                                 (gpointer) gtk_window_focus_out_callback, this);
2961 }
2962
2963 bool wxWindowGTK::GTKHandleFocusIn()
2964 {
2965     // Disable default focus handling for custom windows since the default GTK+
2966     // handler issues a repaint
2967     const bool retval = m_wxwindow ? true : false;
2968
2969
2970     // NB: if there's still unprocessed deferred focus-out event (see
2971     //     GTKHandleFocusOut() for explanation), we need to process it first so
2972     //     that the order of focus events -- focus-out first, then focus-in
2973     //     elsewhere -- is preserved
2974     if ( gs_deferredFocusOut )
2975     {
2976         if ( GTKNeedsToFilterSameWindowFocus() &&
2977              gs_deferredFocusOut == this )
2978         {
2979             // GTK+ focus changed from this wxWindow back to itself, so don't
2980             // emit any events at all
2981             wxLogTrace(TRACE_FOCUS,
2982                        "filtered out spurious focus change within %s(%p, %s)",
2983                        GetClassInfo()->GetClassName(), this, GetLabel());
2984             gs_deferredFocusOut = NULL;
2985             return retval;
2986         }
2987
2988         // otherwise we need to send focus-out first
2989         wxASSERT_MSG ( gs_deferredFocusOut != this,
2990                        "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
2991         GTKHandleDeferredFocusOut();
2992     }
2993
2994
2995     wxLogTrace(TRACE_FOCUS,
2996                "handling focus_in event for %s(%p, %s)",
2997                GetClassInfo()->GetClassName(), this, GetLabel());
2998
2999     if (m_imData)
3000         gtk_im_context_focus_in(m_imData->context);
3001
3002     gs_currentFocus = this;
3003     gs_pendingFocus = NULL;
3004
3005 #if wxUSE_CARET
3006     // caret needs to be informed about focus change
3007     wxCaret *caret = GetCaret();
3008     if ( caret )
3009     {
3010         caret->OnSetFocus();
3011     }
3012 #endif // wxUSE_CARET
3013
3014     // Notify the parent keeping track of focus for the kbd navigation
3015     // purposes that we got it.
3016     wxChildFocusEvent eventChildFocus(static_cast<wxWindow*>(this));
3017     GTKProcessEvent(eventChildFocus);
3018
3019     wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
3020     eventFocus.SetEventObject(this);
3021     GTKProcessEvent(eventFocus);
3022
3023     return retval;
3024 }
3025
3026 bool wxWindowGTK::GTKHandleFocusOut()
3027 {
3028     // Disable default focus handling for custom windows since the default GTK+
3029     // handler issues a repaint
3030     const bool retval = m_wxwindow ? true : false;
3031
3032
3033     // NB: If a control is composed of several GtkWidgets and when focus
3034     //     changes from one of them to another within the same wxWindow, we get
3035     //     a focus-out event followed by focus-in for another GtkWidget owned
3036     //     by the same wx control. We don't want to generate two spurious
3037     //     wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3038     //     from GTKHandleFocusOut() until we know for sure it's not coming back
3039     //     (i.e. in GTKHandleFocusIn() or at idle time).
3040     if ( GTKNeedsToFilterSameWindowFocus() )
3041     {
3042         wxASSERT_MSG( gs_deferredFocusOut == NULL,
3043                       "deferred focus out event already pending" );
3044         wxLogTrace(TRACE_FOCUS,
3045                    "deferring focus_out event for %s(%p, %s)",
3046                    GetClassInfo()->GetClassName(), this, GetLabel());
3047         gs_deferredFocusOut = this;
3048         return retval;
3049     }
3050
3051     GTKHandleFocusOutNoDeferring();
3052
3053     return retval;
3054 }
3055
3056 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3057 {
3058     wxLogTrace(TRACE_FOCUS,
3059                "handling focus_out event for %s(%p, %s)",
3060                GetClassInfo()->GetClassName(), this, GetLabel());
3061
3062     if (m_imData)
3063         gtk_im_context_focus_out(m_imData->context);
3064
3065     if ( gs_currentFocus != this )
3066     {
3067         // Something is terribly wrong, gs_currentFocus is out of sync with the
3068         // real focus. We will reset it to NULL anyway, because after this
3069         // focus-out event is handled, one of the following with happen:
3070         //
3071         // * either focus will go out of the app altogether, in which case
3072         //   gs_currentFocus _should_ be NULL
3073         //
3074         // * or it goes to another control, in which case focus-in event will
3075         //   follow immediately and it will set gs_currentFocus to the right
3076         //   value
3077         wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3078                    GetClassInfo()->GetClassName(), this, GetLabel());
3079     }
3080     gs_currentFocus = NULL;
3081
3082 #if wxUSE_CARET
3083     // caret needs to be informed about focus change
3084     wxCaret *caret = GetCaret();
3085     if ( caret )
3086     {
3087         caret->OnKillFocus();
3088     }
3089 #endif // wxUSE_CARET
3090
3091     wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
3092     event.SetEventObject( this );
3093     GTKProcessEvent( event );
3094 }
3095
3096 /*static*/
3097 void wxWindowGTK::GTKHandleDeferredFocusOut()
3098 {
3099     // NB: See GTKHandleFocusOut() for explanation. This function is called
3100     //     from either GTKHandleFocusIn() or OnInternalIdle() to process
3101     //     deferred event.
3102     if ( gs_deferredFocusOut )
3103     {
3104         wxWindowGTK *win = gs_deferredFocusOut;
3105         gs_deferredFocusOut = NULL;
3106
3107         wxLogTrace(TRACE_FOCUS,
3108                    "processing deferred focus_out event for %s(%p, %s)",
3109                    win->GetClassInfo()->GetClassName(), win, win->GetLabel());
3110
3111         win->GTKHandleFocusOutNoDeferring();
3112     }
3113 }
3114
3115 void wxWindowGTK::SetFocus()
3116 {
3117     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3118
3119     // Setting "physical" focus is not immediate in GTK+ and while
3120     // gtk_widget_is_focus ("determines if the widget is the focus widget
3121     // within its toplevel", i.e. returns true for one widget per TLW, not
3122     // globally) returns true immediately after grabbing focus,
3123     // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3124     // has focus at the moment) takes affect only after the window is shown
3125     // (if it was hidden at the moment of the call) or at the next event loop
3126     // iteration.
3127     //
3128     // Because we want to FindFocus() call immediately following
3129     // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3130     // ourselves.
3131     gs_pendingFocus = this;
3132
3133     GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
3134
3135     if ( GTK_IS_CONTAINER(widget) &&
3136          !GTK_WIDGET_CAN_FOCUS(widget) )
3137     {
3138         wxLogTrace(TRACE_FOCUS,
3139                    wxT("Setting focus to a child of %s(%p, %s)"),
3140                    GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3141         gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
3142     }
3143     else
3144     {
3145         wxLogTrace(TRACE_FOCUS,
3146                    wxT("Setting focus to %s(%p, %s)"),
3147                    GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3148         gtk_widget_grab_focus(widget);
3149     }
3150 }
3151
3152 void wxWindowGTK::SetCanFocus(bool canFocus)
3153 {
3154     if ( canFocus )
3155         GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
3156     else
3157         GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
3158
3159     if ( m_wxwindow && (m_widget != m_wxwindow) )
3160     {
3161         if ( canFocus )
3162             GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3163         else
3164             GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3165     }
3166 }
3167
3168 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3169 {
3170     wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3171
3172     wxWindowGTK *oldParent = m_parent,
3173              *newParent = (wxWindowGTK *)newParentBase;
3174
3175     wxASSERT( GTK_IS_WIDGET(m_widget) );
3176
3177     if ( !wxWindowBase::Reparent(newParent) )
3178         return false;
3179
3180     wxASSERT( GTK_IS_WIDGET(m_widget) );
3181
3182     if (oldParent)
3183         gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3184
3185     wxASSERT( GTK_IS_WIDGET(m_widget) );
3186
3187     if (newParent)
3188     {
3189         if (GTK_WIDGET_VISIBLE (newParent->m_widget))
3190         {
3191             m_showOnIdle = true;
3192             gtk_widget_hide( m_widget );
3193         }
3194         /* insert GTK representation */
3195         newParent->AddChildGTK(this);
3196     }
3197
3198     SetLayoutDirection(wxLayout_Default);
3199
3200     return true;
3201 }
3202
3203 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3204 {
3205     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3206     wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3207
3208     /* add to list */
3209     AddChild( child );
3210
3211     /* insert GTK representation */
3212     AddChildGTK(child);
3213 }
3214
3215 void wxWindowGTK::AddChild(wxWindowBase *child)
3216 {
3217     wxWindowBase::AddChild(child);
3218     m_dirtyTabOrder = true;
3219     wxTheApp->WakeUpIdle();
3220 }
3221
3222 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3223 {
3224     wxWindowBase::RemoveChild(child);
3225     m_dirtyTabOrder = true;
3226     wxTheApp->WakeUpIdle();
3227 }
3228
3229 /* static */
3230 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3231 {
3232     return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3233                 ? wxLayout_RightToLeft
3234                 : wxLayout_LeftToRight;
3235 }
3236
3237 /* static */
3238 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3239 {
3240     wxASSERT_MSG( dir != wxLayout_Default, wxT("invalid layout direction") );
3241
3242     gtk_widget_set_direction(widget,
3243                              dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3244                                                          : GTK_TEXT_DIR_LTR);
3245 }
3246
3247 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3248 {
3249     return GTKGetLayout(m_widget);
3250 }
3251
3252 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3253 {
3254     if ( dir == wxLayout_Default )
3255     {
3256         const wxWindow *const parent = GetParent();
3257         if ( parent )
3258         {
3259             // inherit layout from parent.
3260             dir = parent->GetLayoutDirection();
3261         }
3262         else // no parent, use global default layout
3263         {
3264             dir = wxTheApp->GetLayoutDirection();
3265         }
3266     }
3267
3268     if ( dir == wxLayout_Default )
3269         return;
3270
3271     GTKSetLayout(m_widget, dir);
3272
3273     if (m_wxwindow && (m_wxwindow != m_widget))
3274         GTKSetLayout(m_wxwindow, dir);
3275 }
3276
3277 wxCoord
3278 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3279                                       wxCoord WXUNUSED(width),
3280                                       wxCoord WXUNUSED(widthTotal)) const
3281 {
3282     // We now mirror the coordinates of RTL windows in wxPizza
3283     return x;
3284 }
3285
3286 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
3287 {
3288     wxWindowBase::DoMoveInTabOrder(win, move);
3289     m_dirtyTabOrder = true;
3290     wxTheApp->WakeUpIdle();
3291 }
3292
3293 bool wxWindowGTK::DoNavigateIn(int flags)
3294 {
3295     if ( flags & wxNavigationKeyEvent::WinChange )
3296     {
3297         wxFAIL_MSG( wxT("not implemented") );
3298
3299         return false;
3300     }
3301     else // navigate inside the container
3302     {
3303         wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3304         wxCHECK_MSG( parent, false, wxT("every window must have a TLW parent") );
3305
3306         GtkDirectionType dir;
3307         dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3308                                                       : GTK_DIR_TAB_BACKWARD;
3309
3310         gboolean rc;
3311         g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3312
3313         return rc == TRUE;
3314     }
3315 }
3316
3317 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3318 {
3319     // none needed by default
3320     return false;
3321 }
3322
3323 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3324 {
3325     // nothing to do by default since none is needed
3326 }
3327
3328 void wxWindowGTK::RealizeTabOrder()
3329 {
3330     if (m_wxwindow)
3331     {
3332         if ( !m_children.empty() )
3333         {
3334             // we don't only construct the correct focus chain but also use
3335             // this opportunity to update the mnemonic widgets for the widgets
3336             // that need them
3337
3338             GList *chain = NULL;
3339             wxWindowGTK* mnemonicWindow = NULL;
3340
3341             for ( wxWindowList::const_iterator i = m_children.begin();
3342                   i != m_children.end();
3343                   ++i )
3344             {
3345                 wxWindowGTK *win = *i;
3346
3347                 if ( mnemonicWindow )
3348                 {
3349                     if ( win->AcceptsFocusFromKeyboard() )
3350                     {
3351                         // wxComboBox et al. needs to focus on on a different
3352                         // widget than m_widget, so if the main widget isn't
3353                         // focusable try the connect widget
3354                         GtkWidget* w = win->m_widget;
3355                         if ( !GTK_WIDGET_CAN_FOCUS(w) )
3356                         {
3357                             w = win->GetConnectWidget();
3358                             if ( !GTK_WIDGET_CAN_FOCUS(w) )
3359                                 w = NULL;
3360                         }
3361
3362                         if ( w )
3363                         {
3364                             mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3365                             mnemonicWindow = NULL;
3366                         }
3367                     }
3368                 }
3369                 else if ( win->GTKWidgetNeedsMnemonic() )
3370                 {
3371                     mnemonicWindow = win;
3372                 }
3373
3374                 chain = g_list_prepend(chain, win->m_widget);
3375             }
3376
3377             chain = g_list_reverse(chain);
3378
3379             gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3380             g_list_free(chain);
3381         }
3382         else // no children
3383         {
3384             gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3385         }
3386     }
3387 }
3388
3389 void wxWindowGTK::Raise()
3390 {
3391     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3392
3393     if (m_wxwindow && m_wxwindow->window)
3394     {
3395         gdk_window_raise( m_wxwindow->window );
3396     }
3397     else if (m_widget->window)
3398     {
3399         gdk_window_raise( m_widget->window );
3400     }
3401 }
3402
3403 void wxWindowGTK::Lower()
3404 {
3405     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3406
3407     if (m_wxwindow && m_wxwindow->window)
3408     {
3409         gdk_window_lower( m_wxwindow->window );
3410     }
3411     else if (m_widget->window)
3412     {
3413         gdk_window_lower( m_widget->window );
3414     }
3415 }
3416
3417 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3418 {
3419     if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
3420         return false;
3421
3422     GTKUpdateCursor();
3423
3424     return true;
3425 }
3426
3427 void wxWindowGTK::GTKUpdateCursor()
3428 {
3429     wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
3430     if ( cursor.Ok() )
3431     {
3432         wxArrayGdkWindows windowsThis;
3433         GdkWindow * const winThis = GTKGetWindow(windowsThis);
3434         if ( winThis )
3435         {
3436             gdk_window_set_cursor(winThis, cursor.GetCursor());
3437         }
3438         else
3439         {
3440             const size_t count = windowsThis.size();
3441             for ( size_t n = 0; n < count; n++ )
3442             {
3443                 GdkWindow *win = windowsThis[n];
3444                 if ( !win )
3445                 {
3446                     wxFAIL_MSG(wxT("NULL window returned by GTKGetWindow()?"));
3447                     continue;
3448                 }
3449
3450                 gdk_window_set_cursor(win, cursor.GetCursor());
3451             }
3452         }
3453     }
3454 }
3455
3456 void wxWindowGTK::WarpPointer( int x, int y )
3457 {
3458     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3459
3460     // We provide this function ourselves as it is
3461     // missing in GDK (top of this file).
3462
3463     GdkWindow *window = NULL;
3464     if (m_wxwindow)
3465         window = m_wxwindow->window;
3466     else
3467         window = GetConnectWidget()->window;
3468
3469     if (window)
3470         gdk_window_warp_pointer( window, x, y );
3471 }
3472
3473 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3474 {
3475     // find the scrollbar which generated the event
3476     for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3477     {
3478         if ( range == m_scrollBar[dir] )
3479             return (ScrollDir)dir;
3480     }
3481
3482     wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3483
3484     return ScrollDir_Max;
3485 }
3486
3487 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3488 {
3489     bool changed = false;
3490     GtkRange* range = m_scrollBar[dir];
3491     if ( range && units )
3492     {
3493         GtkAdjustment* adj = range->adjustment;
3494         gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
3495                                               : adj->page_increment;
3496
3497         const int posOld = int(adj->value + 0.5);
3498         gtk_range_set_value(range, posOld + units*inc);
3499
3500         changed = int(adj->value + 0.5) != posOld;
3501     }
3502
3503     return changed;
3504 }
3505
3506 bool wxWindowGTK::ScrollLines(int lines)
3507 {
3508     return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3509 }
3510
3511 bool wxWindowGTK::ScrollPages(int pages)
3512 {
3513     return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3514 }
3515
3516 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
3517                           const wxRect *rect)
3518 {
3519     if ( !m_widget )
3520     {
3521         // it is valid to call Refresh() for a window which hasn't been created
3522         // yet, it simply doesn't do anything in this case
3523         return;
3524     }
3525
3526     if (!m_wxwindow)
3527     {
3528         if (rect)
3529             gtk_widget_queue_draw_area( m_widget, rect->x, rect->y, rect->width, rect->height );
3530         else
3531             gtk_widget_queue_draw( m_widget );
3532     }
3533     else
3534     {
3535         // Just return if the widget or one of its ancestors isn't mapped
3536         GtkWidget *w;
3537         for (w = m_wxwindow; w != NULL; w = w->parent)
3538             if (!GTK_WIDGET_MAPPED (w))
3539                 return;
3540
3541         if (rect)
3542         {
3543             int x = rect->x;
3544             if (GetLayoutDirection() == wxLayout_RightToLeft)
3545                 x = GetClientSize().x - x - rect->width;
3546             GdkRectangle r;
3547             r.x = rect->x;
3548             r.y = rect->y;
3549             r.width = rect->width;
3550             r.height = rect->height;
3551             gdk_window_invalidate_rect( m_wxwindow->window, &r, TRUE );
3552         }
3553         else
3554             gdk_window_invalidate_rect( m_wxwindow->window, NULL, TRUE );
3555     }
3556 }
3557
3558 void wxWindowGTK::Update()
3559 {
3560     if (m_widget && m_widget->window)
3561     {
3562         GdkDisplay* display = gtk_widget_get_display(m_widget);
3563         // Flush everything out to the server, and wait for it to finish.
3564         // This ensures nothing will overwrite the drawing we are about to do.
3565         gdk_display_sync(display);
3566
3567         gdk_window_process_updates(m_widget->window, TRUE);
3568
3569         // Flush again, but no need to wait for it to finish
3570         gdk_display_flush(display);
3571     }
3572 }
3573
3574 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3575 {
3576     return m_updateRegion.Contains(x, y) != wxOutRegion;
3577 }
3578
3579 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3580 {
3581     if (GetLayoutDirection() == wxLayout_RightToLeft)
3582         return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3583     else
3584         return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3585 }
3586
3587 void wxWindowGTK::GtkSendPaintEvents()
3588 {
3589     if (!m_wxwindow)
3590     {
3591         m_updateRegion.Clear();
3592         return;
3593     }
3594
3595     // Clip to paint region in wxClientDC
3596     m_clipPaintRegion = true;
3597
3598     m_nativeUpdateRegion = m_updateRegion;
3599
3600     if (GetLayoutDirection() == wxLayout_RightToLeft)
3601     {
3602         // Transform m_updateRegion under RTL
3603         m_updateRegion.Clear();
3604
3605         gint width;
3606         gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
3607
3608         wxRegionIterator upd( m_nativeUpdateRegion );
3609         while (upd)
3610         {
3611             wxRect rect;
3612             rect.x = upd.GetX();
3613             rect.y = upd.GetY();
3614             rect.width = upd.GetWidth();
3615             rect.height = upd.GetHeight();
3616
3617             rect.x = width - rect.x - rect.width;
3618             m_updateRegion.Union( rect );
3619
3620             ++upd;
3621         }
3622     }
3623
3624     switch ( GetBackgroundStyle() )
3625     {
3626         case wxBG_STYLE_ERASE:
3627             {
3628                 wxWindowDC dc( (wxWindow*)this );
3629                 dc.SetDeviceClippingRegion( m_updateRegion );
3630
3631                 // Work around gtk-qt <= 0.60 bug whereby the window colour
3632                 // remains grey
3633                 if ( UseBgCol() &&
3634                         wxSystemOptions::
3635                             GetOptionInt("gtk.window.force-background-colour") )
3636                 {
3637                     dc.SetBackground(GetBackgroundColour());
3638                     dc.Clear();
3639                 }
3640
3641                 wxEraseEvent erase_event( GetId(), &dc );
3642                 erase_event.SetEventObject( this );
3643
3644                 if ( HandleWindowEvent(erase_event) )
3645                 {
3646                     // background erased, don't do it again
3647                     break;
3648                 }
3649             }
3650             // fall through
3651
3652         case wxBG_STYLE_SYSTEM:
3653             if ( GetThemeEnabled() )
3654             {
3655                 // find ancestor from which to steal background
3656                 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3657                 if (!parent)
3658                     parent = (wxWindow*)this;
3659
3660                 if (GTK_WIDGET_MAPPED(parent->m_widget))
3661                 {
3662                     wxRegionIterator upd( m_nativeUpdateRegion );
3663                     while (upd)
3664                     {
3665                         GdkRectangle rect;
3666                         rect.x = upd.GetX();
3667                         rect.y = upd.GetY();
3668                         rect.width = upd.GetWidth();
3669                         rect.height = upd.GetHeight();
3670
3671                         gtk_paint_flat_box( parent->m_widget->style,
3672                                     m_wxwindow->window,
3673                                     (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
3674                                     GTK_SHADOW_NONE,
3675                                     &rect,
3676                                     parent->m_widget,
3677                                     (char *)"base",
3678                                     0, 0, -1, -1 );
3679
3680                         ++upd;
3681                     }
3682                 }
3683             }
3684             break;
3685
3686         case wxBG_STYLE_PAINT:
3687             // nothing to do: window will be painted over in EVT_PAINT
3688             break;
3689
3690         default:
3691             wxFAIL_MSG( "unsupported background style" );
3692     }
3693
3694     wxNcPaintEvent nc_paint_event( GetId() );
3695     nc_paint_event.SetEventObject( this );
3696     HandleWindowEvent( nc_paint_event );
3697
3698     wxPaintEvent paint_event( GetId() );
3699     paint_event.SetEventObject( this );
3700     HandleWindowEvent( paint_event );
3701
3702     m_clipPaintRegion = false;
3703
3704     m_updateRegion.Clear();
3705     m_nativeUpdateRegion.Clear();
3706 }
3707
3708 void wxWindowGTK::SetDoubleBuffered( bool on )
3709 {
3710     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3711
3712     if ( m_wxwindow )
3713         gtk_widget_set_double_buffered( m_wxwindow, on );
3714 }
3715
3716 bool wxWindowGTK::IsDoubleBuffered() const
3717 {
3718     return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
3719 }
3720
3721 void wxWindowGTK::ClearBackground()
3722 {
3723     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3724 }
3725
3726 #if wxUSE_TOOLTIPS
3727 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3728 {
3729     wxWindowBase::DoSetToolTip(tip);
3730
3731     if (m_tooltip)
3732     {
3733         m_tooltip->GTKApply( (wxWindow *)this );
3734     }
3735     else
3736     {
3737         GtkWidget *w = GetConnectWidget();
3738         wxToolTip::GTKApply(w, NULL);
3739 #if GTK_CHECK_VERSION(2, 12, 0)
3740         // Just applying NULL doesn't work on 2.12.0, so also use
3741         // gtk_widget_set_has_tooltip. It is part of the new GtkTooltip API
3742         // but seems also to work with the old GtkTooltips.
3743         if (gtk_check_version(2, 12, 0) == NULL)
3744             gtk_widget_set_has_tooltip(w, FALSE);
3745 #endif
3746     }
3747 }
3748
3749 void wxWindowGTK::GTKApplyToolTip( GtkTooltips *tips, const gchar *tip )
3750 {
3751     gtk_tooltips_set_tip(tips, GetConnectWidget(), tip, NULL);
3752 }
3753 #endif // wxUSE_TOOLTIPS
3754
3755 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3756 {
3757     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3758
3759     if (!wxWindowBase::SetBackgroundColour(colour))
3760         return false;
3761
3762     if (colour.Ok())
3763     {
3764         // We need the pixel value e.g. for background clearing.
3765         m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3766     }
3767
3768     // apply style change (forceStyle=true so that new style is applied
3769     // even if the bg colour changed from valid to wxNullColour)
3770     GTKApplyWidgetStyle(true);
3771
3772     return true;
3773 }
3774
3775 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3776 {
3777     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3778
3779     if (!wxWindowBase::SetForegroundColour(colour))
3780     {
3781         return false;
3782     }
3783
3784     if (colour.Ok())
3785     {
3786         // We need the pixel value e.g. for background clearing.
3787         m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3788     }
3789
3790     // apply style change (forceStyle=true so that new style is applied
3791     // even if the bg colour changed from valid to wxNullColour):
3792     GTKApplyWidgetStyle(true);
3793
3794     return true;
3795 }
3796
3797 PangoContext *wxWindowGTK::GTKGetPangoDefaultContext()
3798 {
3799     return gtk_widget_get_pango_context( m_widget );
3800 }
3801
3802 GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
3803 {
3804     // do we need to apply any changes at all?
3805     if ( !forceStyle &&
3806          !m_font.Ok() &&
3807          !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
3808     {
3809         return NULL;
3810     }
3811
3812     GtkRcStyle *style = gtk_rc_style_new();
3813
3814     if ( m_font.Ok() )
3815     {
3816         style->font_desc =
3817             pango_font_description_copy( m_font.GetNativeFontInfo()->description );
3818     }
3819
3820     int flagsNormal = 0,
3821         flagsPrelight = 0,
3822         flagsActive = 0,
3823         flagsInsensitive = 0;
3824
3825     if ( m_foregroundColour.Ok() )
3826     {
3827         const GdkColor *fg = m_foregroundColour.GetColor();
3828
3829         style->fg[GTK_STATE_NORMAL] =
3830         style->text[GTK_STATE_NORMAL] = *fg;
3831         flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
3832
3833         style->fg[GTK_STATE_PRELIGHT] =
3834         style->text[GTK_STATE_PRELIGHT] = *fg;
3835         flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
3836
3837         style->fg[GTK_STATE_ACTIVE] =
3838         style->text[GTK_STATE_ACTIVE] = *fg;
3839         flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
3840     }
3841
3842     if ( m_backgroundColour.Ok() )
3843     {
3844         const GdkColor *bg = m_backgroundColour.GetColor();
3845
3846         style->bg[GTK_STATE_NORMAL] =
3847         style->base[GTK_STATE_NORMAL] = *bg;
3848         flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
3849
3850         style->bg[GTK_STATE_PRELIGHT] =
3851         style->base[GTK_STATE_PRELIGHT] = *bg;
3852         flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
3853
3854         style->bg[GTK_STATE_ACTIVE] =
3855         style->base[GTK_STATE_ACTIVE] = *bg;
3856         flagsActive |= GTK_RC_BG | GTK_RC_BASE;
3857
3858         style->bg[GTK_STATE_INSENSITIVE] =
3859         style->base[GTK_STATE_INSENSITIVE] = *bg;
3860         flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
3861     }
3862
3863     style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
3864     style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
3865     style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
3866     style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
3867
3868     return style;
3869 }
3870
3871 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
3872 {
3873     GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
3874     if ( style )
3875     {
3876         DoApplyWidgetStyle(style);
3877         gtk_rc_style_unref(style);
3878     }
3879
3880     // Style change may affect GTK+'s size calculation:
3881     InvalidateBestSize();
3882 }
3883
3884 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3885 {
3886     if ( m_wxwindow )
3887     {
3888         // block the signal temporarily to avoid sending
3889         // wxSysColourChangedEvents when we change the colours ourselves
3890         bool unblock = false;
3891         if ( IsTopLevel() )
3892         {
3893             unblock = true;
3894             g_signal_handlers_block_by_func(
3895                 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3896         }
3897
3898         gtk_widget_modify_style(m_wxwindow, style);
3899
3900         if ( unblock )
3901         {
3902             g_signal_handlers_unblock_by_func(
3903                 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3904         }
3905     }
3906     else
3907     {
3908         gtk_widget_modify_style(m_widget, style);
3909     }
3910 }
3911
3912 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3913 {
3914     wxWindowBase::SetBackgroundStyle(style);
3915
3916     if ( style == wxBG_STYLE_PAINT )
3917     {
3918         GdkWindow *window;
3919         if ( m_wxwindow )
3920         {
3921             window = m_wxwindow->window;
3922         }
3923         else
3924         {
3925             GtkWidget * const w = GetConnectWidget();
3926             window = w ? w->window : NULL;
3927         }
3928
3929         if (window)
3930         {
3931             // Make sure GDK/X11 doesn't refresh the window
3932             // automatically.
3933             gdk_window_set_back_pixmap( window, None, False );
3934 #ifdef __X__
3935             Display* display = GDK_WINDOW_DISPLAY(window);
3936             XFlush(display);
3937 #endif
3938             m_needsStyleChange = false;
3939         }
3940         else // window not realized yet
3941         {
3942             // Do in OnIdle, because the window is not yet available
3943             m_needsStyleChange = true;
3944         }
3945
3946         // Don't apply widget style, or we get a grey background
3947     }
3948     else
3949     {
3950         // apply style change (forceStyle=true so that new style is applied
3951         // even if the bg colour changed from valid to wxNullColour):
3952         GTKApplyWidgetStyle(true);
3953     }
3954
3955     return true;
3956 }
3957
3958 // ----------------------------------------------------------------------------
3959 // Pop-up menu stuff
3960 // ----------------------------------------------------------------------------
3961
3962 #if wxUSE_MENUS_NATIVE
3963
3964 static void SetInvokingWindow( wxMenu *menu, wxWindow* win )
3965 {
3966     menu->SetInvokingWindow( win );
3967
3968     wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
3969     while (node)
3970     {
3971         wxMenuItem *menuitem = node->GetData();
3972         if (menuitem->IsSubMenu())
3973         {
3974             SetInvokingWindow( menuitem->GetSubMenu(), win );
3975         }
3976
3977         node = node->GetNext();
3978     }
3979 }
3980
3981 extern "C" {
3982 static
3983 void wxPopupMenuPositionCallback( GtkMenu *menu,
3984                                   gint *x, gint *y,
3985                                   gboolean * WXUNUSED(whatever),
3986                                   gpointer user_data )
3987 {
3988     // ensure that the menu appears entirely on screen
3989     GtkRequisition req;
3990     gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
3991
3992     wxSize sizeScreen = wxGetDisplaySize();
3993     wxPoint *pos = (wxPoint*)user_data;
3994
3995     gint xmax = sizeScreen.x - req.width,
3996          ymax = sizeScreen.y - req.height;
3997
3998     *x = pos->x < xmax ? pos->x : xmax;
3999     *y = pos->y < ymax ? pos->y : ymax;
4000 }
4001 }
4002
4003 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4004 {
4005     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4006
4007     wxCHECK_MSG( menu != NULL, false, wxT("invalid popup-menu") );
4008
4009     SetInvokingWindow( menu, this );
4010
4011     menu->UpdateUI();
4012
4013     wxPoint pos;
4014     gpointer userdata;
4015     GtkMenuPositionFunc posfunc;
4016     if ( x == -1 && y == -1 )
4017     {
4018         // use GTK's default positioning algorithm
4019         userdata = NULL;
4020         posfunc = NULL;
4021     }
4022     else
4023     {
4024         pos = ClientToScreen(wxPoint(x, y));
4025         userdata = &pos;
4026         posfunc = wxPopupMenuPositionCallback;
4027     }
4028
4029     menu->m_popupShown = true;
4030     gtk_menu_popup(
4031                   GTK_MENU(menu->m_menu),
4032                   NULL,           // parent menu shell
4033                   NULL,           // parent menu item
4034                   posfunc,                      // function to position it
4035                   userdata,                     // client data
4036                   0,                            // button used to activate it
4037                   gtk_get_current_event_time()
4038                 );
4039
4040     while (menu->m_popupShown)
4041     {
4042         gtk_main_iteration();
4043     }
4044
4045     return true;
4046 }
4047
4048 #endif // wxUSE_MENUS_NATIVE
4049
4050 #if wxUSE_DRAG_AND_DROP
4051
4052 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4053 {
4054     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4055
4056     GtkWidget *dnd_widget = GetConnectWidget();
4057
4058     if (m_dropTarget) m_dropTarget->GtkUnregisterWidget( dnd_widget );
4059
4060     if (m_dropTarget) delete m_dropTarget;
4061     m_dropTarget = dropTarget;
4062
4063     if (m_dropTarget) m_dropTarget->GtkRegisterWidget( dnd_widget );
4064 }
4065
4066 #endif // wxUSE_DRAG_AND_DROP
4067
4068 GtkWidget* wxWindowGTK::GetConnectWidget()
4069 {
4070     GtkWidget *connect_widget = m_widget;
4071     if (m_wxwindow) connect_widget = m_wxwindow;
4072
4073     return connect_widget;
4074 }
4075
4076 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
4077 {
4078     wxArrayGdkWindows windowsThis;
4079     GdkWindow * const winThis = GTKGetWindow(windowsThis);
4080
4081     return winThis ? window == winThis
4082                    : windowsThis.Index(window) != wxNOT_FOUND;
4083 }
4084
4085 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
4086 {
4087     return m_wxwindow ? m_wxwindow->window : m_widget->window;
4088 }
4089
4090 bool wxWindowGTK::SetFont( const wxFont &font )
4091 {
4092     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4093
4094     if (!wxWindowBase::SetFont(font))
4095         return false;
4096
4097     // apply style change (forceStyle=true so that new style is applied
4098     // even if the font changed from valid to wxNullFont):
4099     GTKApplyWidgetStyle(true);
4100
4101     return true;
4102 }
4103
4104 void wxWindowGTK::DoCaptureMouse()
4105 {
4106     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4107
4108     GdkWindow *window = NULL;
4109     if (m_wxwindow)
4110         window = m_wxwindow->window;
4111     else
4112         window = GetConnectWidget()->window;
4113
4114     wxCHECK_RET( window, wxT("CaptureMouse() failed") );
4115
4116     const wxCursor* cursor = &m_cursor;
4117     if (!cursor->Ok())
4118         cursor = wxSTANDARD_CURSOR;
4119
4120     gdk_pointer_grab( window, FALSE,
4121                       (GdkEventMask)
4122                          (GDK_BUTTON_PRESS_MASK |
4123                           GDK_BUTTON_RELEASE_MASK |
4124                           GDK_POINTER_MOTION_HINT_MASK |
4125                           GDK_POINTER_MOTION_MASK),
4126                       NULL,
4127                       cursor->GetCursor(),
4128                       (guint32)GDK_CURRENT_TIME );
4129     g_captureWindow = this;
4130     g_captureWindowHasMouse = true;
4131 }
4132
4133 void wxWindowGTK::DoReleaseMouse()
4134 {
4135     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4136
4137     wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4138
4139     g_captureWindow = NULL;
4140
4141     GdkWindow *window = NULL;
4142     if (m_wxwindow)
4143         window = m_wxwindow->window;
4144     else
4145         window = GetConnectWidget()->window;
4146
4147     if (!window)
4148         return;
4149
4150     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4151 }
4152
4153 void wxWindowGTK::GTKReleaseMouseAndNotify()
4154 {
4155     DoReleaseMouse();
4156     wxMouseCaptureLostEvent evt(GetId());
4157     evt.SetEventObject( this );
4158     HandleWindowEvent( evt );
4159 }
4160
4161 /* static */
4162 wxWindow *wxWindowBase::GetCapture()
4163 {
4164     return (wxWindow *)g_captureWindow;
4165 }
4166
4167 bool wxWindowGTK::IsRetained() const
4168 {
4169     return false;
4170 }
4171
4172 void wxWindowGTK::SetScrollbar(int orient,
4173                                int pos,
4174                                int thumbVisible,
4175                                int range,
4176                                bool WXUNUSED(update))
4177 {
4178     const int dir = ScrollDirFromOrient(orient);
4179     GtkRange* const sb = m_scrollBar[dir];
4180     wxCHECK_RET( sb, wxT("this window is not scrollable") );
4181
4182     if (range <= 0)
4183     {
4184         // GtkRange requires upper > lower
4185         range =
4186         thumbVisible = 1;
4187     }
4188
4189     GtkAdjustment * const adj = sb->adjustment;
4190     adj->step_increment = 1;
4191     adj->page_increment =
4192     adj->page_size = thumbVisible;
4193     adj->value = pos;
4194
4195     g_signal_handlers_block_by_func(
4196         sb, (void*)gtk_scrollbar_value_changed, this);
4197
4198     gtk_range_set_range(sb, 0, range);
4199     m_scrollPos[dir] = sb->adjustment->value;
4200
4201     g_signal_handlers_unblock_by_func(
4202         sb, (void*)gtk_scrollbar_value_changed, this);
4203 }
4204
4205 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4206 {
4207     const int dir = ScrollDirFromOrient(orient);
4208     GtkRange * const sb = m_scrollBar[dir];
4209     wxCHECK_RET( sb, wxT("this window is not scrollable") );
4210
4211     // This check is more than an optimization. Without it, the slider
4212     //   will not move smoothly while tracking when using wxScrollHelper.
4213     if (GetScrollPos(orient) != pos)
4214     {
4215         g_signal_handlers_block_by_func(
4216             sb, (void*)gtk_scrollbar_value_changed, this);
4217
4218         gtk_range_set_value(sb, pos);
4219         m_scrollPos[dir] = sb->adjustment->value;
4220
4221         g_signal_handlers_unblock_by_func(
4222             sb, (void*)gtk_scrollbar_value_changed, this);
4223     }
4224 }
4225
4226 int wxWindowGTK::GetScrollThumb(int orient) const
4227 {
4228     GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4229     wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4230
4231     return wxRound(sb->adjustment->page_size);
4232 }
4233
4234 int wxWindowGTK::GetScrollPos( int orient ) const
4235 {
4236     GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4237     wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4238
4239     return wxRound(sb->adjustment->value);
4240 }
4241
4242 int wxWindowGTK::GetScrollRange( int orient ) const
4243 {
4244     GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4245     wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4246
4247     return wxRound(sb->adjustment->upper);
4248 }
4249
4250 // Determine if increment is the same as +/-x, allowing for some small
4251 //   difference due to possible inexactness in floating point arithmetic
4252 static inline bool IsScrollIncrement(double increment, double x)
4253 {
4254     wxASSERT(increment > 0);
4255     const double tolerance = 1.0 / 1024;
4256     return fabs(increment - fabs(x)) < tolerance;
4257 }
4258
4259 wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range)
4260 {
4261     wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4262
4263     const int barIndex = range == m_scrollBar[1];
4264     GtkAdjustment* adj = range->adjustment;
4265
4266     const int value = wxRound(adj->value);
4267
4268     // save previous position
4269     const double oldPos = m_scrollPos[barIndex];
4270     // update current position
4271     m_scrollPos[barIndex] = adj->value;
4272     // If event should be ignored, or integral position has not changed
4273     if (!m_hasVMT || g_blockEventsOnDrag || value == wxRound(oldPos))
4274     {
4275         return wxEVT_NULL;
4276     }
4277
4278     wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4279     if (!m_isScrolling)
4280     {
4281         // Difference from last change event
4282         const double diff = adj->value - oldPos;
4283         const bool isDown = diff > 0;
4284
4285         if (IsScrollIncrement(adj->step_increment, diff))
4286         {
4287             eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4288         }
4289         else if (IsScrollIncrement(adj->page_increment, diff))
4290         {
4291             eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4292         }
4293         else if (m_mouseButtonDown)
4294         {
4295             // Assume track event
4296             m_isScrolling = true;
4297         }
4298     }
4299     return eventType;
4300 }
4301
4302 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4303 {
4304     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4305
4306     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4307
4308     // No scrolling requested.
4309     if ((dx == 0) && (dy == 0)) return;
4310
4311     m_clipPaintRegion = true;
4312
4313     WX_PIZZA(m_wxwindow)->scroll(dx, dy);
4314
4315     m_clipPaintRegion = false;
4316
4317 #if wxUSE_CARET
4318     bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4319     if (restoreCaret)
4320     {
4321         wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4322         if (dx > 0)
4323             caretRect.width += dx;
4324         else
4325         {
4326             caretRect.x += dx; caretRect.width -= dx;
4327         }
4328         if (dy > 0)
4329             caretRect.height += dy;
4330         else
4331         {
4332             caretRect.y += dy; caretRect.height -= dy;
4333         }
4334
4335         RefreshRect(caretRect);
4336     }
4337 #endif // wxUSE_CARET
4338 }
4339
4340 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4341 {
4342     //RN: Note that static controls usually have no border on gtk, so maybe
4343     //it makes sense to treat that as simply no border at the wx level
4344     //as well...
4345     if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4346     {
4347         GtkShadowType gtkstyle;
4348
4349         if(wxstyle & wxBORDER_RAISED)
4350             gtkstyle = GTK_SHADOW_OUT;
4351         else if ((wxstyle & wxBORDER_SUNKEN) || (wxstyle & wxBORDER_THEME))
4352             gtkstyle = GTK_SHADOW_IN;
4353 #if 0
4354         // Now obsolete
4355         else if (wxstyle & wxBORDER_DOUBLE)
4356             gtkstyle = GTK_SHADOW_ETCHED_IN;
4357 #endif
4358         else //default
4359             gtkstyle = GTK_SHADOW_IN;
4360
4361         gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4362                                              gtkstyle );
4363     }
4364 }
4365
4366 void wxWindowGTK::SetWindowStyleFlag( long style )
4367 {
4368     // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4369     wxWindowBase::SetWindowStyleFlag(style);
4370 }
4371
4372 // Find the wxWindow at the current mouse position, also returning the mouse
4373 // position.
4374 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4375 {
4376     pt = wxGetMousePosition();
4377     wxWindow* found = wxFindWindowAtPoint(pt);
4378     return found;
4379 }
4380
4381 // Get the current mouse position.
4382 wxPoint wxGetMousePosition()
4383 {
4384   /* This crashes when used within wxHelpContext,
4385      so we have to use the X-specific implementation below.
4386     gint x, y;
4387     GdkModifierType *mask;
4388     (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4389
4390     return wxPoint(x, y);
4391   */
4392
4393     int x, y;
4394     GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4395
4396     Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4397     Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4398     Window rootReturn, childReturn;
4399     int rootX, rootY, winX, winY;
4400     unsigned int maskReturn;
4401
4402     XQueryPointer (display,
4403            rootWindow,
4404            &rootReturn,
4405                    &childReturn,
4406                    &rootX, &rootY, &winX, &winY, &maskReturn);
4407     return wxPoint(rootX, rootY);
4408
4409 }
4410
4411 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4412 {
4413     GdkWindow* window = NULL;
4414     if (m_wxwindow)
4415         window = m_wxwindow->window;
4416     return window;
4417 }
4418
4419 // ----------------------------------------------------------------------------
4420 // freeze/thaw
4421 // ----------------------------------------------------------------------------
4422
4423 extern "C"
4424 {
4425
4426 // this is called if we attempted to freeze unrealized widget when it finally
4427 // is realized (and so can be frozen):
4428 static void wx_frozen_widget_realize(GtkWidget* w, void* WXUNUSED(data))
4429 {
4430     wxASSERT( w && !GTK_WIDGET_NO_WINDOW(w) );
4431     wxASSERT( GTK_WIDGET_REALIZED(w) );
4432
4433     g_signal_handlers_disconnect_by_func
4434     (
4435         w,
4436         (void*)wx_frozen_widget_realize,
4437         NULL
4438     );
4439
4440     gdk_window_freeze_updates(w->window);
4441 }
4442
4443 } // extern "C"
4444
4445 void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
4446 {
4447     if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4448         return; // window-less widget, cannot be frozen
4449
4450     if ( !GTK_WIDGET_REALIZED(w) )
4451     {
4452         // we can't thaw unrealized widgets because they don't have GdkWindow,
4453         // so set it up to be done immediately after realization:
4454         g_signal_connect_after
4455         (
4456             w,
4457             "realize",
4458             G_CALLBACK(wx_frozen_widget_realize),
4459             NULL
4460         );
4461         return;
4462     }
4463
4464     gdk_window_freeze_updates(w->window);
4465 }
4466
4467 void wxWindowGTK::GTKThawWidget(GtkWidget *w)
4468 {
4469     if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4470         return; // window-less widget, cannot be frozen
4471
4472     if ( !GTK_WIDGET_REALIZED(w) )
4473     {
4474         // the widget wasn't realized yet, no need to thaw
4475         g_signal_handlers_disconnect_by_func
4476         (
4477             w,
4478             (void*)wx_frozen_widget_realize,
4479             NULL
4480         );
4481         return;
4482     }
4483
4484     gdk_window_thaw_updates(w->window);
4485 }
4486
4487 void wxWindowGTK::DoFreeze()
4488 {
4489     GTKFreezeWidget(m_widget);
4490     if ( m_wxwindow && m_widget != m_wxwindow )
4491         GTKFreezeWidget(m_wxwindow);
4492 }
4493
4494 void wxWindowGTK::DoThaw()
4495 {
4496     GTKThawWidget(m_widget);
4497     if ( m_wxwindow && m_widget != m_wxwindow )
4498         GTKThawWidget(m_wxwindow);
4499 }