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