src/gtk/window.cpp

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