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