src/gtk/window.cpp

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