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