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