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