src/gtk/window.cpp

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