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