src/gtk/window.cpp

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