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, GtkWidget* 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 //-----------------------------------------------------------------------------
1887 // "unrealize" from m_wxwindow
1888 //-----------------------------------------------------------------------------
1889
1890 static void unrealize(GtkWidget*, wxWindowGTK* win)
1891 {
1892     if (win->m_imData)
1893         gtk_im_context_set_client_window(win->m_imData->context, NULL);
1894 }
1895
1896 //-----------------------------------------------------------------------------
1897 // "size_allocate" from m_wxwindow or m_widget
1898 //-----------------------------------------------------------------------------
1899
1900 static void
1901 size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
1902 {
1903     int w = alloc->width;
1904     int h = alloc->height;
1905     if (win->m_wxwindow)
1906     {
1907         int border_x, border_y;
1908         WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y);
1909         w -= 2 * border_x;
1910         h -= 2 * border_y;
1911         if (w < 0) w = 0;
1912         if (h < 0) h = 0;
1913     }
1914     if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
1915     {
1916         win->m_oldClientWidth  = w;
1917         win->m_oldClientHeight = h;
1918         // this callback can be connected to m_wxwindow,
1919         // so always get size from m_widget->allocation
1920         GtkAllocation a;
1921         gtk_widget_get_allocation(win->m_widget, &a);
1922         win->m_width  = a.width;
1923         win->m_height = a.height;
1924         if (!win->m_nativeSizeEvent)
1925         {
1926             wxSizeEvent event(win->GetSize(), win->GetId());
1927             event.SetEventObject(win);
1928             win->GTKProcessEvent(event);
1929         }
1930     }
1931 }
1932
1933 //-----------------------------------------------------------------------------
1934 // "grab_broken"
1935 //-----------------------------------------------------------------------------
1936
1937 #if GTK_CHECK_VERSION(2, 8, 0)
1938 static gboolean
1939 gtk_window_grab_broken( GtkWidget*,
1940                         GdkEventGrabBroken *event,
1941                         wxWindow *win )
1942 {
1943     // Mouse capture has been lost involuntarily, notify the application
1944     if(!event->keyboard && wxWindow::GetCapture() == win)
1945     {
1946         wxMouseCaptureLostEvent evt( win->GetId() );
1947         evt.SetEventObject( win );
1948         win->HandleWindowEvent( evt );
1949     }
1950     return false;
1951 }
1952 #endif
1953
1954 //-----------------------------------------------------------------------------
1955 // "style_set"
1956 //-----------------------------------------------------------------------------
1957
1958 static
1959 void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
1960                                GtkStyle *previous_style,
1961                                wxWindow* win )
1962 {
1963     if (win && previous_style)
1964     {
1965         wxSysColourChangedEvent event;
1966         event.SetEventObject(win);
1967
1968         win->GTKProcessEvent( event );
1969     }
1970 }
1971
1972 } // extern "C"
1973
1974 void wxWindowGTK::GTKHandleRealized()
1975 {
1976     if (m_imData)
1977     {
1978         gtk_im_context_set_client_window
1979         (
1980             m_imData->context,
1981             m_wxwindow ? GTKGetDrawingWindow()
1982                        : gtk_widget_get_window(m_widget)
1983         );
1984     }
1985
1986     // We cannot set colours and fonts before the widget
1987     // been realized, so we do this directly after realization
1988     // or otherwise in idle time
1989
1990     if (m_needsStyleChange)
1991     {
1992         SetBackgroundStyle(GetBackgroundStyle());
1993         m_needsStyleChange = false;
1994     }
1995
1996     wxWindowCreateEvent event( this );
1997     event.SetEventObject( this );
1998     GTKProcessEvent( event );
1999
2000     GTKUpdateCursor(true, false);
2001 }
2002
2003 // ----------------------------------------------------------------------------
2004 // this wxWindowBase function is implemented here (in platform-specific file)
2005 // because it is static and so couldn't be made virtual
2006 // ----------------------------------------------------------------------------
2007
2008 wxWindow *wxWindowBase::DoFindFocus()
2009 {
2010     wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
2011     // the cast is necessary when we compile in wxUniversal mode
2012     return static_cast<wxWindow*>(focus);
2013 }
2014
2015 void wxWindowGTK::AddChildGTK(wxWindowGTK* child)
2016 {
2017     wxASSERT_MSG(m_wxwindow, "Cannot add a child to a window without a client area");
2018
2019     // the window might have been scrolled already, we
2020     // have to adapt the position
2021     wxPizza* pizza = WX_PIZZA(m_wxwindow);
2022     child->m_x += pizza->m_scroll_x;
2023     child->m_y += pizza->m_scroll_y;
2024
2025     gtk_widget_set_size_request(
2026         child->m_widget, child->m_width, child->m_height);
2027     pizza->put(child->m_widget, child->m_x, child->m_y);
2028 }
2029
2030 //-----------------------------------------------------------------------------
2031 // global functions
2032 //-----------------------------------------------------------------------------
2033
2034 wxWindow *wxGetActiveWindow()
2035 {
2036     return wxWindow::FindFocus();
2037 }
2038
2039
2040 wxMouseState wxGetMouseState()
2041 {
2042     wxMouseState ms;
2043
2044     gint x;
2045     gint y;
2046     GdkModifierType mask;
2047
2048     gdk_window_get_pointer(NULL, &x, &y, &mask);
2049
2050     ms.SetX(x);
2051     ms.SetY(y);
2052     ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0);
2053     ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0);
2054     ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0);
2055     // see the comment in InitMouseEvent()
2056     ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0);
2057     ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0);
2058
2059     ms.SetControlDown((mask & GDK_CONTROL_MASK) != 0);
2060     ms.SetShiftDown((mask & GDK_SHIFT_MASK) != 0);
2061     ms.SetAltDown((mask & GDK_MOD1_MASK) != 0);
2062     ms.SetMetaDown((mask & GDK_META_MASK) != 0);
2063
2064     return ms;
2065 }
2066
2067 //-----------------------------------------------------------------------------
2068 // wxWindowGTK
2069 //-----------------------------------------------------------------------------
2070
2071 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2072 // method
2073 #ifdef __WXUNIVERSAL__
2074     IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2075 #endif // __WXUNIVERSAL__
2076
2077 void wxWindowGTK::Init()
2078 {
2079     // GTK specific
2080     m_widget = NULL;
2081     m_wxwindow = NULL;
2082     m_focusWidget = NULL;
2083
2084     // position/size
2085     m_x = 0;
2086     m_y = 0;
2087     m_width = 0;
2088     m_height = 0;
2089
2090     m_hasVMT = false;
2091
2092     m_showOnIdle = false;
2093
2094     m_noExpose = false;
2095     m_nativeSizeEvent = false;
2096
2097     m_isScrolling = false;
2098     m_mouseButtonDown = false;
2099
2100     // initialize scrolling stuff
2101     for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2102     {
2103         m_scrollBar[dir] = NULL;
2104         m_scrollPos[dir] = 0;
2105     }
2106
2107     m_oldClientWidth =
2108     m_oldClientHeight = 0;
2109
2110     m_clipPaintRegion = false;
2111
2112     m_needsStyleChange = false;
2113
2114     m_cursor = *wxSTANDARD_CURSOR;
2115
2116     m_imData = NULL;
2117     m_dirtyTabOrder = false;
2118 }
2119
2120 wxWindowGTK::wxWindowGTK()
2121 {
2122     Init();
2123 }
2124
2125 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2126                           wxWindowID id,
2127                           const wxPoint &pos,
2128                           const wxSize &size,
2129                           long style,
2130                           const wxString &name  )
2131 {
2132     Init();
2133
2134     Create( parent, id, pos, size, style, name );
2135 }
2136
2137 bool wxWindowGTK::Create( wxWindow *parent,
2138                           wxWindowID id,
2139                           const wxPoint &pos,
2140                           const wxSize &size,
2141                           long style,
2142                           const wxString &name  )
2143 {
2144     // Get default border
2145     wxBorder border = GetBorder(style);
2146
2147     style &= ~wxBORDER_MASK;
2148     style |= border;
2149
2150     if (!PreCreation( parent, pos, size ) ||
2151         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2152     {
2153         wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2154         return false;
2155     }
2156
2157         // We should accept the native look
2158 #if 0
2159         GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2160         scroll_class->scrollbar_spacing = 0;
2161 #endif
2162
2163
2164     m_wxwindow = wxPizza::New(m_windowStyle);
2165 #ifndef __WXUNIVERSAL__
2166     if (HasFlag(wxPizza::BORDER_STYLES))
2167     {
2168         g_signal_connect(m_wxwindow, "parent_set",
2169             G_CALLBACK(parent_set), this);
2170     }
2171 #endif
2172     if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
2173         m_widget = m_wxwindow;
2174     else
2175     {
2176         m_widget = gtk_scrolled_window_new( NULL, NULL );
2177
2178         GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2179
2180         // There is a conflict with default bindings at GTK+
2181         // level between scrolled windows and notebooks both of which want to use
2182         // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2183         // direction and notebooks for changing pages -- we decide that if we don't
2184         // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2185         // means we can get working keyboard navigation in notebooks
2186         if ( !HasFlag(wxHSCROLL) )
2187         {
2188             GtkBindingSet *
2189                 bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
2190             if ( bindings )
2191             {
2192                 gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
2193                 gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
2194             }
2195         }
2196
2197         if (HasFlag(wxALWAYS_SHOW_SB))
2198         {
2199             gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
2200         }
2201         else
2202         {
2203             gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2204         }
2205
2206         m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow));
2207         m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow));
2208         if (GetLayoutDirection() == wxLayout_RightToLeft)
2209             gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
2210
2211         gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2212
2213         // connect various scroll-related events
2214         for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2215         {
2216             // these handlers block mouse events to any window during scrolling
2217             // such as motion events and prevent GTK and wxWidgets from fighting
2218             // over where the slider should be
2219             g_signal_connect(m_scrollBar[dir], "button_press_event",
2220                          G_CALLBACK(gtk_scrollbar_button_press_event), this);
2221             g_signal_connect(m_scrollBar[dir], "button_release_event",
2222                          G_CALLBACK(gtk_scrollbar_button_release_event), this);
2223
2224             gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
2225                                 G_CALLBACK(gtk_scrollbar_event_after), this);
2226             g_signal_handler_block(m_scrollBar[dir], handler_id);
2227
2228             // these handlers get notified when scrollbar slider moves
2229             g_signal_connect_after(m_scrollBar[dir], "value_changed",
2230                          G_CALLBACK(gtk_scrollbar_value_changed), this);
2231         }
2232
2233         gtk_widget_show( m_wxwindow );
2234     }
2235     g_object_ref(m_widget);
2236
2237     if (m_parent)
2238         m_parent->DoAddChild( this );
2239
2240     m_focusWidget = m_wxwindow;
2241
2242     SetCanFocus(AcceptsFocus());
2243
2244     PostCreation();
2245
2246     return true;
2247 }
2248
2249 wxWindowGTK::~wxWindowGTK()
2250 {
2251     SendDestroyEvent();
2252
2253     if (gs_currentFocus == this)
2254         gs_currentFocus = NULL;
2255     if (gs_pendingFocus == this)
2256         gs_pendingFocus = NULL;
2257
2258     if ( gs_deferredFocusOut == this )
2259         gs_deferredFocusOut = NULL;
2260
2261     m_hasVMT = false;
2262
2263     // destroy children before destroying this window itself
2264     DestroyChildren();
2265
2266     // unhook focus handlers to prevent stray events being
2267     // propagated to this (soon to be) dead object
2268     if (m_focusWidget != NULL)
2269     {
2270         g_signal_handlers_disconnect_by_func (m_focusWidget,
2271                                               (gpointer) gtk_window_focus_in_callback,
2272                                               this);
2273         g_signal_handlers_disconnect_by_func (m_focusWidget,
2274                                               (gpointer) gtk_window_focus_out_callback,
2275                                               this);
2276     }
2277
2278     if (m_widget)
2279         Show( false );
2280
2281     // delete before the widgets to avoid a crash on solaris
2282     delete m_imData;
2283     m_imData = NULL;
2284
2285     // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2286     // TLW to be frozen, and if the window is then destroyed, nothing ever
2287     // gets painted again
2288     if (IsFrozen())
2289         DoThaw();
2290
2291     if (m_widget)
2292     {
2293         // Note that gtk_widget_destroy() does not destroy the widget, it just
2294         // emits the "destroy" signal. The widget is not actually destroyed
2295         // until its reference count drops to zero.
2296         gtk_widget_destroy(m_widget);
2297         // Release our reference, should be the last one
2298         g_object_unref(m_widget);
2299         m_widget = NULL;
2300     }
2301     m_wxwindow = NULL;
2302 }
2303
2304 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos,  const wxSize &size )
2305 {
2306     if ( GTKNeedsParent() )
2307     {
2308         wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
2309     }
2310
2311     // Use either the given size, or the default if -1 is given.
2312     // See wxWindowBase for these functions.
2313     m_width = WidthDefault(size.x) ;
2314     m_height = HeightDefault(size.y);
2315
2316     m_x = (int)pos.x;
2317     m_y = (int)pos.y;
2318
2319     return true;
2320 }
2321
2322 void wxWindowGTK::PostCreation()
2323 {
2324     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2325
2326     if (m_wxwindow)
2327     {
2328         if (!m_noExpose)
2329         {
2330             // these get reported to wxWidgets -> wxPaintEvent
2331
2332             g_signal_connect (m_wxwindow, "expose_event",
2333                               G_CALLBACK (gtk_window_expose_callback), this);
2334
2335             if (GetLayoutDirection() == wxLayout_LeftToRight)
2336                 gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
2337         }
2338
2339         // Create input method handler
2340         m_imData = new wxGtkIMData;
2341
2342         // Cannot handle drawing preedited text yet
2343         gtk_im_context_set_use_preedit( m_imData->context, FALSE );
2344
2345         g_signal_connect (m_imData->context, "commit",
2346                           G_CALLBACK (gtk_wxwindow_commit_cb), this);
2347         g_signal_connect(m_wxwindow, "unrealize", G_CALLBACK(unrealize), this);
2348     }
2349
2350     // focus handling
2351
2352     if (!GTK_IS_WINDOW(m_widget))
2353     {
2354         if (m_focusWidget == NULL)
2355             m_focusWidget = m_widget;
2356
2357         if (m_wxwindow)
2358         {
2359             g_signal_connect (m_focusWidget, "focus_in_event",
2360                           G_CALLBACK (gtk_window_focus_in_callback), this);
2361             g_signal_connect (m_focusWidget, "focus_out_event",
2362                                 G_CALLBACK (gtk_window_focus_out_callback), this);
2363         }
2364         else
2365         {
2366             g_signal_connect_after (m_focusWidget, "focus_in_event",
2367                           G_CALLBACK (gtk_window_focus_in_callback), this);
2368             g_signal_connect_after (m_focusWidget, "focus_out_event",
2369                                 G_CALLBACK (gtk_window_focus_out_callback), this);
2370         }
2371     }
2372
2373     if ( !AcceptsFocusFromKeyboard() )
2374     {
2375         SetCanFocus(false);
2376
2377         g_signal_connect(m_widget, "focus",
2378                             G_CALLBACK(wx_window_focus_callback), this);
2379     }
2380
2381     // connect to the various key and mouse handlers
2382
2383     GtkWidget *connect_widget = GetConnectWidget();
2384
2385     ConnectWidget( connect_widget );
2386
2387     // We cannot set colours, fonts and cursors before the widget has been
2388     // realized, so we do this directly after realization -- unless the widget
2389     // was in fact realized already.
2390     if ( gtk_widget_get_realized(connect_widget) )
2391     {
2392         gtk_window_realized_callback(connect_widget, this);
2393     }
2394     else
2395     {
2396         g_signal_connect (connect_widget, "realize",
2397                           G_CALLBACK (gtk_window_realized_callback), this);
2398     }
2399
2400     if (!IsTopLevel())
2401     {
2402         g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate",
2403             G_CALLBACK(size_allocate), this);
2404     }
2405
2406 #if GTK_CHECK_VERSION(2, 8, 0)
2407     if ( gtk_check_version(2,8,0) == NULL )
2408     {
2409         // Make sure we can notify the app when mouse capture is lost
2410         if ( m_wxwindow )
2411         {
2412             g_signal_connect (m_wxwindow, "grab_broken_event",
2413                           G_CALLBACK (gtk_window_grab_broken), this);
2414         }
2415
2416         if ( connect_widget != m_wxwindow )
2417         {
2418             g_signal_connect (connect_widget, "grab_broken_event",
2419                         G_CALLBACK (gtk_window_grab_broken), this);
2420         }
2421     }
2422 #endif // GTK+ >= 2.8
2423
2424     if ( GTKShouldConnectSizeRequest() )
2425     {
2426         // This is needed if we want to add our windows into native
2427         // GTK controls, such as the toolbar. With this callback, the
2428         // toolbar gets to know the correct size (the one set by the
2429         // programmer). Sadly, it misbehaves for wxComboBox.
2430         g_signal_connect (m_widget, "size_request",
2431                           G_CALLBACK (wxgtk_window_size_request_callback),
2432                           this);
2433     }
2434
2435     InheritAttributes();
2436
2437     m_hasVMT = true;
2438
2439     SetLayoutDirection(wxLayout_Default);
2440
2441     // unless the window was created initially hidden (i.e. Hide() had been
2442     // called before Create()), we should show it at GTK+ level as well
2443     if ( IsShown() )
2444         gtk_widget_show( m_widget );
2445 }
2446
2447 unsigned long
2448 wxWindowGTK::GTKConnectWidget(const char *signal, wxGTKCallback callback)
2449 {
2450     return g_signal_connect(m_widget, signal, callback, this);
2451 }
2452
2453 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2454 {
2455     g_signal_connect (widget, "key_press_event",
2456                       G_CALLBACK (gtk_window_key_press_callback), this);
2457     g_signal_connect (widget, "key_release_event",
2458                       G_CALLBACK (gtk_window_key_release_callback), this);
2459     g_signal_connect (widget, "button_press_event",
2460                       G_CALLBACK (gtk_window_button_press_callback), this);
2461     g_signal_connect (widget, "button_release_event",
2462                       G_CALLBACK (gtk_window_button_release_callback), this);
2463     g_signal_connect (widget, "motion_notify_event",
2464                       G_CALLBACK (gtk_window_motion_notify_callback), this);
2465
2466     g_signal_connect (widget, "scroll_event",
2467                       G_CALLBACK (window_scroll_event), this);
2468     if (m_scrollBar[ScrollDir_Horz])
2469         g_signal_connect (m_scrollBar[ScrollDir_Horz], "scroll_event",
2470                       G_CALLBACK (window_scroll_event_hscrollbar), this);
2471     if (m_scrollBar[ScrollDir_Vert])
2472         g_signal_connect (m_scrollBar[ScrollDir_Vert], "scroll_event",
2473                       G_CALLBACK (window_scroll_event), this);
2474
2475     g_signal_connect (widget, "popup_menu",
2476                      G_CALLBACK (wxgtk_window_popup_menu_callback), this);
2477     g_signal_connect (widget, "enter_notify_event",
2478                       G_CALLBACK (gtk_window_enter_callback), this);
2479     g_signal_connect (widget, "leave_notify_event",
2480                       G_CALLBACK (gtk_window_leave_callback), this);
2481
2482     if (IsTopLevel() && m_wxwindow)
2483         g_signal_connect (m_wxwindow, "style_set",
2484                               G_CALLBACK (gtk_window_style_set_callback), this);
2485 }
2486
2487 bool wxWindowGTK::Destroy()
2488 {
2489     m_hasVMT = false;
2490
2491     return wxWindowBase::Destroy();
2492 }
2493
2494 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2495 {
2496     gtk_widget_set_size_request(m_widget, width, height);
2497
2498     // inform the parent to perform the move
2499     wxASSERT_MSG(m_parent && m_parent->m_wxwindow,
2500                  "the parent window has no client area?");
2501     WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y);
2502 }
2503
2504 void wxWindowGTK::ConstrainSize()
2505 {
2506 #ifdef __WXGPE__
2507     // GPE's window manager doesn't like size hints at all, esp. when the user
2508     // has to use the virtual keyboard, so don't constrain size there
2509     if (!IsTopLevel())
2510 #endif
2511     {
2512         const wxSize minSize = GetMinSize();
2513         const wxSize maxSize = GetMaxSize();
2514         if (minSize.x > 0 && m_width  < minSize.x) m_width  = minSize.x;
2515         if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
2516         if (maxSize.x > 0 && m_width  > maxSize.x) m_width  = maxSize.x;
2517         if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
2518     }
2519 }
2520
2521 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2522 {
2523     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2524     wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2525
2526     if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0 && (x == -1 || y == -1))
2527     {
2528         int currentX, currentY;
2529         GetPosition(&currentX, &currentY);
2530         if (x == -1)
2531             x = currentX;
2532         if (y == -1)
2533             y = currentY;
2534     }
2535     AdjustForParentClientOrigin(x, y, sizeFlags);
2536
2537     // calculate the best size if we should auto size the window
2538     if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2539          ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2540     {
2541         const wxSize sizeBest = GetBestSize();
2542         if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2543             width = sizeBest.x;
2544         if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2545             height = sizeBest.y;
2546     }
2547
2548     const wxSize oldSize(m_width, m_height);
2549     if (width != -1)
2550         m_width = width;
2551     if (height != -1)
2552         m_height = height;
2553
2554     if (m_parent->m_wxwindow)
2555     {
2556         wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2557         m_x = x + pizza->m_scroll_x;
2558         m_y = y + pizza->m_scroll_y;
2559
2560         int left_border = 0;
2561         int right_border = 0;
2562         int top_border = 0;
2563         int bottom_border = 0;
2564
2565         /* the default button has a border around it */
2566         if (gtk_widget_get_can_default(m_widget))
2567         {
2568             GtkBorder *default_border = NULL;
2569             gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
2570             if (default_border)
2571             {
2572                 left_border += default_border->left;
2573                 right_border += default_border->right;
2574                 top_border += default_border->top;
2575                 bottom_border += default_border->bottom;
2576                 gtk_border_free( default_border );
2577             }
2578         }
2579
2580         DoMoveWindow( m_x - left_border,
2581                       m_y - top_border,
2582                       m_width+left_border+right_border,
2583                       m_height+top_border+bottom_border );
2584     }
2585
2586     if (m_width != oldSize.x || m_height != oldSize.y)
2587     {
2588         // update these variables to keep size_allocate handler
2589         // from sending another size event for this change
2590         GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2591
2592         gtk_widget_queue_resize(m_widget);
2593         if (!m_nativeSizeEvent)
2594         {
2595             wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2596             event.SetEventObject( this );
2597             HandleWindowEvent( event );
2598         }
2599     } else
2600     if (sizeFlags & wxSIZE_FORCE_EVENT)
2601     {
2602         wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2603         event.SetEventObject( this );
2604         HandleWindowEvent( event );
2605     }
2606 }
2607
2608 bool wxWindowGTK::GTKShowFromOnIdle()
2609 {
2610     if (IsShown() && m_showOnIdle && !gtk_widget_get_visible (m_widget))
2611     {
2612         GtkAllocation alloc;
2613         alloc.x = m_x;
2614         alloc.y = m_y;
2615         alloc.width = m_width;
2616         alloc.height = m_height;
2617         gtk_widget_size_allocate( m_widget, &alloc );
2618         gtk_widget_show( m_widget );
2619         wxShowEvent eventShow(GetId(), true);
2620         eventShow.SetEventObject(this);
2621         HandleWindowEvent(eventShow);
2622         m_showOnIdle = false;
2623         return true;
2624     }
2625
2626     return false;
2627 }
2628
2629 void wxWindowGTK::OnInternalIdle()
2630 {
2631     if ( gs_deferredFocusOut )
2632         GTKHandleDeferredFocusOut();
2633
2634     // Check if we have to show window now
2635     if (GTKShowFromOnIdle()) return;
2636
2637     if ( m_dirtyTabOrder )
2638     {
2639         m_dirtyTabOrder = false;
2640         RealizeTabOrder();
2641     }
2642
2643     // Update style if the window was not yet realized when
2644     // SetBackgroundStyle() was called
2645     if (m_needsStyleChange)
2646     {
2647         SetBackgroundStyle(GetBackgroundStyle());
2648         m_needsStyleChange = false;
2649     }
2650
2651     wxWindowBase::OnInternalIdle();
2652 }
2653
2654 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2655 {
2656     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2657
2658     if (width) (*width) = m_width;
2659     if (height) (*height) = m_height;
2660 }
2661
2662 void wxWindowGTK::DoSetClientSize( int width, int height )
2663 {
2664     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2665
2666     const wxSize size = GetSize();
2667     const wxSize clientSize = GetClientSize();
2668     SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
2669 }
2670
2671 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2672 {
2673     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2674
2675     int w = m_width;
2676     int h = m_height;
2677
2678     if ( m_wxwindow )
2679     {
2680         // if window is scrollable, account for scrollbars
2681         if ( GTK_IS_SCROLLED_WINDOW(m_widget) )
2682         {
2683             GtkPolicyType policy[ScrollDir_Max];
2684             gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
2685                                            &policy[ScrollDir_Horz],
2686                                            &policy[ScrollDir_Vert]);
2687
2688             for ( int i = 0; i < ScrollDir_Max; i++ )
2689             {
2690                 // don't account for the scrollbars we don't have
2691                 GtkRange * const range = m_scrollBar[i];
2692                 if ( !range )
2693                     continue;
2694
2695                 // nor for the ones we have but don't current show
2696                 switch ( policy[i] )
2697                 {
2698                     case GTK_POLICY_NEVER:
2699                         // never shown so doesn't take any place
2700                         continue;
2701
2702                     case GTK_POLICY_ALWAYS:
2703                         // no checks necessary
2704                         break;
2705
2706                     case GTK_POLICY_AUTOMATIC:
2707                         // may be shown or not, check
2708                         GtkAdjustment *adj = gtk_range_get_adjustment(range);
2709                         if (gtk_adjustment_get_upper(adj) <= gtk_adjustment_get_page_size(adj))
2710                             continue;
2711                 }
2712
2713                 GtkScrolledWindowClass *scroll_class =
2714                     GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2715
2716                 GtkRequisition req;
2717                 gtk_widget_size_request(GTK_WIDGET(range), &req);
2718                 if (i == ScrollDir_Horz)
2719                     h -= req.height + scroll_class->scrollbar_spacing;
2720                 else
2721                     w -= req.width + scroll_class->scrollbar_spacing;
2722             }
2723         }
2724
2725         const wxSize sizeBorders = DoGetBorderSize();
2726         w -= sizeBorders.x;
2727         h -= sizeBorders.y;
2728
2729         if (w < 0)
2730             w = 0;
2731         if (h < 0)
2732             h = 0;
2733     }
2734
2735     if (width) *width = w;
2736     if (height) *height = h;
2737 }
2738
2739 wxSize wxWindowGTK::DoGetBorderSize() const
2740 {
2741     if ( !m_wxwindow )
2742         return wxWindowBase::DoGetBorderSize();
2743
2744     int x, y;
2745     WX_PIZZA(m_wxwindow)->get_border_widths(x, y);
2746
2747     return 2*wxSize(x, y);
2748 }
2749
2750 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2751 {
2752     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2753
2754     int dx = 0;
2755     int dy = 0;
2756     if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
2757     {
2758         wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2759         dx = pizza->m_scroll_x;
2760         dy = pizza->m_scroll_y;
2761     }
2762
2763     if (m_x == -1 && m_y == -1)
2764     {
2765         GdkWindow *source = NULL;
2766         if (m_wxwindow)
2767             source = gtk_widget_get_window(m_wxwindow);
2768         else
2769             source = gtk_widget_get_window(m_widget);
2770
2771         if (source)
2772         {
2773             int org_x = 0;
2774             int org_y = 0;
2775             gdk_window_get_origin( source, &org_x, &org_y );
2776
2777             if (m_parent)
2778                 m_parent->ScreenToClient(&org_x, &org_y);
2779
2780             const_cast<wxWindowGTK*>(this)->m_x = org_x;
2781             const_cast<wxWindowGTK*>(this)->m_y = org_y;
2782         }
2783     }
2784
2785     if (x) (*x) = m_x - dx;
2786     if (y) (*y) = m_y - dy;
2787 }
2788
2789 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2790 {
2791     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2792
2793     if (gtk_widget_get_window(m_widget) == NULL) return;
2794
2795     GdkWindow *source = NULL;
2796     if (m_wxwindow)
2797         source = gtk_widget_get_window(m_wxwindow);
2798     else
2799         source = gtk_widget_get_window(m_widget);
2800
2801     int org_x = 0;
2802     int org_y = 0;
2803     gdk_window_get_origin( source, &org_x, &org_y );
2804
2805     if (!m_wxwindow)
2806     {
2807         if (!gtk_widget_get_has_window(m_widget))
2808         {
2809             GtkAllocation a;
2810             gtk_widget_get_allocation(m_widget, &a);
2811             org_x += a.x;
2812             org_y += a.y;
2813         }
2814     }
2815
2816
2817     if (x)
2818     {
2819         if (GetLayoutDirection() == wxLayout_RightToLeft)
2820             *x = (GetClientSize().x - *x) + org_x;
2821         else
2822             *x += org_x;
2823     }
2824
2825     if (y) *y += org_y;
2826 }
2827
2828 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
2829 {
2830     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2831
2832     if (!gtk_widget_get_realized(m_widget)) return;
2833
2834     GdkWindow *source = NULL;
2835     if (m_wxwindow)
2836         source = gtk_widget_get_window(m_wxwindow);
2837     else
2838         source = gtk_widget_get_window(m_widget);
2839
2840     int org_x = 0;
2841     int org_y = 0;
2842     gdk_window_get_origin( source, &org_x, &org_y );
2843
2844     if (!m_wxwindow)
2845     {
2846         if (!gtk_widget_get_has_window(m_widget))
2847         {
2848             GtkAllocation a;
2849             gtk_widget_get_allocation(m_widget, &a);
2850             org_x += a.x;
2851             org_y += a.y;
2852         }
2853     }
2854
2855     if (x)
2856     {
2857         if (GetLayoutDirection() == wxLayout_RightToLeft)
2858             *x = (GetClientSize().x - *x) - org_x;
2859         else
2860             *x -= org_x;
2861     }
2862     if (y) *y -= org_y;
2863 }
2864
2865 bool wxWindowGTK::Show( bool show )
2866 {
2867     if ( !wxWindowBase::Show(show) )
2868     {
2869         // nothing to do
2870         return false;
2871     }
2872
2873     // notice that we may call Hide() before the window is created and this is
2874     // actually useful to create it hidden initially -- but we can't call
2875     // Show() before it is created
2876     if ( !m_widget )
2877     {
2878         wxASSERT_MSG( !show, "can't show invalid window" );
2879         return true;
2880     }
2881
2882     if ( show )
2883     {
2884         if ( m_showOnIdle )
2885         {
2886             // defer until later
2887             return true;
2888         }
2889
2890         gtk_widget_show(m_widget);
2891     }
2892     else // hide
2893     {
2894         gtk_widget_hide(m_widget);
2895     }
2896
2897     wxShowEvent eventShow(GetId(), show);
2898     eventShow.SetEventObject(this);
2899     HandleWindowEvent(eventShow);
2900
2901     return true;
2902 }
2903
2904 void wxWindowGTK::DoEnable( bool enable )
2905 {
2906     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2907
2908     gtk_widget_set_sensitive( m_widget, enable );
2909     if (m_wxwindow && (m_wxwindow != m_widget))
2910         gtk_widget_set_sensitive( m_wxwindow, enable );
2911 }
2912
2913 int wxWindowGTK::GetCharHeight() const
2914 {
2915     wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
2916
2917     wxFont font = GetFont();
2918     wxCHECK_MSG( font.IsOk(), 12, wxT("invalid font") );
2919
2920     PangoContext* context = gtk_widget_get_pango_context(m_widget);
2921
2922     if (!context)
2923         return 0;
2924
2925     PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2926     PangoLayout *layout = pango_layout_new(context);
2927     pango_layout_set_font_description(layout, desc);
2928     pango_layout_set_text(layout, "H", 1);
2929     PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2930
2931     PangoRectangle rect;
2932     pango_layout_line_get_extents(line, NULL, &rect);
2933
2934     g_object_unref (layout);
2935
2936     return (int) PANGO_PIXELS(rect.height);
2937 }
2938
2939 int wxWindowGTK::GetCharWidth() const
2940 {
2941     wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
2942
2943     wxFont font = GetFont();
2944     wxCHECK_MSG( font.IsOk(), 8, wxT("invalid font") );
2945
2946     PangoContext* context = gtk_widget_get_pango_context(m_widget);
2947
2948     if (!context)
2949         return 0;
2950
2951     PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2952     PangoLayout *layout = pango_layout_new(context);
2953     pango_layout_set_font_description(layout, desc);
2954     pango_layout_set_text(layout, "g", 1);
2955     PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2956
2957     PangoRectangle rect;
2958     pango_layout_line_get_extents(line, NULL, &rect);
2959
2960     g_object_unref (layout);
2961
2962     return (int) PANGO_PIXELS(rect.width);
2963 }
2964
2965 void wxWindowGTK::DoGetTextExtent( const wxString& string,
2966                                    int *x,
2967                                    int *y,
2968                                    int *descent,
2969                                    int *externalLeading,
2970                                    const wxFont *theFont ) const
2971 {
2972     wxFont fontToUse = theFont ? *theFont : GetFont();
2973
2974     wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
2975
2976     if (string.empty())
2977     {
2978         if (x) (*x) = 0;
2979         if (y) (*y) = 0;
2980         return;
2981     }
2982
2983     PangoContext *context = NULL;
2984     if (m_widget)
2985         context = gtk_widget_get_pango_context( m_widget );
2986
2987     if (!context)
2988     {
2989         if (x) (*x) = 0;
2990         if (y) (*y) = 0;
2991         return;
2992     }
2993
2994     PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
2995     PangoLayout *layout = pango_layout_new(context);
2996     pango_layout_set_font_description(layout, desc);
2997     {
2998         const wxCharBuffer data = wxGTK_CONV( string );
2999         if ( data )
3000             pango_layout_set_text(layout, data, strlen(data));
3001     }
3002
3003     PangoRectangle rect;
3004     pango_layout_get_extents(layout, NULL, &rect);
3005
3006     if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
3007     if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
3008     if (descent)
3009     {
3010         PangoLayoutIter *iter = pango_layout_get_iter(layout);
3011         int baseline = pango_layout_iter_get_baseline(iter);
3012         pango_layout_iter_free(iter);
3013         *descent = *y - PANGO_PIXELS(baseline);
3014     }
3015     if (externalLeading) (*externalLeading) = 0;  // ??
3016
3017     g_object_unref (layout);
3018 }
3019
3020 void wxWindowGTK::GTKDisableFocusOutEvent()
3021 {
3022     g_signal_handlers_block_by_func( m_focusWidget,
3023                                 (gpointer) gtk_window_focus_out_callback, this);
3024 }
3025
3026 void wxWindowGTK::GTKEnableFocusOutEvent()
3027 {
3028     g_signal_handlers_unblock_by_func( m_focusWidget,
3029                                 (gpointer) gtk_window_focus_out_callback, this);
3030 }
3031
3032 bool wxWindowGTK::GTKHandleFocusIn()
3033 {
3034     // Disable default focus handling for custom windows since the default GTK+
3035     // handler issues a repaint
3036     const bool retval = m_wxwindow ? true : false;
3037
3038
3039     // NB: if there's still unprocessed deferred focus-out event (see
3040     //     GTKHandleFocusOut() for explanation), we need to process it first so
3041     //     that the order of focus events -- focus-out first, then focus-in
3042     //     elsewhere -- is preserved
3043     if ( gs_deferredFocusOut )
3044     {
3045         if ( GTKNeedsToFilterSameWindowFocus() &&
3046              gs_deferredFocusOut == this )
3047         {
3048             // GTK+ focus changed from this wxWindow back to itself, so don't
3049             // emit any events at all
3050             wxLogTrace(TRACE_FOCUS,
3051                        "filtered out spurious focus change within %s(%p, %s)",
3052                        GetClassInfo()->GetClassName(), this, GetLabel());
3053             gs_deferredFocusOut = NULL;
3054             return retval;
3055         }
3056
3057         // otherwise we need to send focus-out first
3058         wxASSERT_MSG ( gs_deferredFocusOut != this,
3059                        "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3060         GTKHandleDeferredFocusOut();
3061     }
3062
3063
3064     wxLogTrace(TRACE_FOCUS,
3065                "handling focus_in event for %s(%p, %s)",
3066                GetClassInfo()->GetClassName(), this, GetLabel());
3067
3068     if (m_imData)
3069         gtk_im_context_focus_in(m_imData->context);
3070
3071     gs_currentFocus = this;
3072     gs_pendingFocus = NULL;
3073
3074 #if wxUSE_CARET
3075     // caret needs to be informed about focus change
3076     wxCaret *caret = GetCaret();
3077     if ( caret )
3078     {
3079         caret->OnSetFocus();
3080     }
3081 #endif // wxUSE_CARET
3082
3083     // Notify the parent keeping track of focus for the kbd navigation
3084     // purposes that we got it.
3085     wxChildFocusEvent eventChildFocus(static_cast<wxWindow*>(this));
3086     GTKProcessEvent(eventChildFocus);
3087
3088     wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
3089     eventFocus.SetEventObject(this);
3090     GTKProcessEvent(eventFocus);
3091
3092     return retval;
3093 }
3094
3095 bool wxWindowGTK::GTKHandleFocusOut()
3096 {
3097     // Disable default focus handling for custom windows since the default GTK+
3098     // handler issues a repaint
3099     const bool retval = m_wxwindow ? true : false;
3100
3101
3102     // NB: If a control is composed of several GtkWidgets and when focus
3103     //     changes from one of them to another within the same wxWindow, we get
3104     //     a focus-out event followed by focus-in for another GtkWidget owned
3105     //     by the same wx control. We don't want to generate two spurious
3106     //     wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3107     //     from GTKHandleFocusOut() until we know for sure it's not coming back
3108     //     (i.e. in GTKHandleFocusIn() or at idle time).
3109     if ( GTKNeedsToFilterSameWindowFocus() )
3110     {
3111         wxASSERT_MSG( gs_deferredFocusOut == NULL,
3112                       "deferred focus out event already pending" );
3113         wxLogTrace(TRACE_FOCUS,
3114                    "deferring focus_out event for %s(%p, %s)",
3115                    GetClassInfo()->GetClassName(), this, GetLabel());
3116         gs_deferredFocusOut = this;
3117         return retval;
3118     }
3119
3120     GTKHandleFocusOutNoDeferring();
3121
3122     return retval;
3123 }
3124
3125 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3126 {
3127     wxLogTrace(TRACE_FOCUS,
3128                "handling focus_out event for %s(%p, %s)",
3129                GetClassInfo()->GetClassName(), this, GetLabel());
3130
3131     if (m_imData)
3132         gtk_im_context_focus_out(m_imData->context);
3133
3134     if ( gs_currentFocus != this )
3135     {
3136         // Something is terribly wrong, gs_currentFocus is out of sync with the
3137         // real focus. We will reset it to NULL anyway, because after this
3138         // focus-out event is handled, one of the following with happen:
3139         //
3140         // * either focus will go out of the app altogether, in which case
3141         //   gs_currentFocus _should_ be NULL
3142         //
3143         // * or it goes to another control, in which case focus-in event will
3144         //   follow immediately and it will set gs_currentFocus to the right
3145         //   value
3146         wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3147                    GetClassInfo()->GetClassName(), this, GetLabel());
3148     }
3149     gs_currentFocus = NULL;
3150
3151 #if wxUSE_CARET
3152     // caret needs to be informed about focus change
3153     wxCaret *caret = GetCaret();
3154     if ( caret )
3155     {
3156         caret->OnKillFocus();
3157     }
3158 #endif // wxUSE_CARET
3159
3160     wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
3161     event.SetEventObject( this );
3162     event.SetWindow( FindFocus() );
3163     GTKProcessEvent( event );
3164 }
3165
3166 /*static*/
3167 void wxWindowGTK::GTKHandleDeferredFocusOut()
3168 {
3169     // NB: See GTKHandleFocusOut() for explanation. This function is called
3170     //     from either GTKHandleFocusIn() or OnInternalIdle() to process
3171     //     deferred event.
3172     if ( gs_deferredFocusOut )
3173     {
3174         wxWindowGTK *win = gs_deferredFocusOut;
3175         gs_deferredFocusOut = NULL;
3176
3177         wxLogTrace(TRACE_FOCUS,
3178                    "processing deferred focus_out event for %s(%p, %s)",
3179                    win->GetClassInfo()->GetClassName(), win, win->GetLabel());
3180
3181         win->GTKHandleFocusOutNoDeferring();
3182     }
3183 }
3184
3185 void wxWindowGTK::SetFocus()
3186 {
3187     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3188
3189     // Setting "physical" focus is not immediate in GTK+ and while
3190     // gtk_widget_is_focus ("determines if the widget is the focus widget
3191     // within its toplevel", i.e. returns true for one widget per TLW, not
3192     // globally) returns true immediately after grabbing focus,
3193     // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3194     // has focus at the moment) takes effect only after the window is shown
3195     // (if it was hidden at the moment of the call) or at the next event loop
3196     // iteration.
3197     //
3198     // Because we want to FindFocus() call immediately following
3199     // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3200     // ourselves.
3201     gs_pendingFocus = this;
3202
3203     GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
3204
3205     if ( GTK_IS_CONTAINER(widget) &&
3206          !gtk_widget_get_can_focus(widget) )
3207     {
3208         wxLogTrace(TRACE_FOCUS,
3209                    wxT("Setting focus to a child of %s(%p, %s)"),
3210                    GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3211         gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
3212     }
3213     else
3214     {
3215         wxLogTrace(TRACE_FOCUS,
3216                    wxT("Setting focus to %s(%p, %s)"),
3217                    GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3218         gtk_widget_grab_focus(widget);
3219     }
3220 }
3221
3222 void wxWindowGTK::SetCanFocus(bool canFocus)
3223 {
3224     gtk_widget_set_can_focus(m_widget, canFocus);
3225
3226     if ( m_wxwindow && (m_widget != m_wxwindow) )
3227     {
3228         gtk_widget_set_can_focus(m_wxwindow, canFocus);
3229     }
3230 }
3231
3232 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3233 {
3234     wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3235
3236     wxWindowGTK * const newParent = (wxWindowGTK *)newParentBase;
3237
3238     wxASSERT( GTK_IS_WIDGET(m_widget) );
3239
3240     if ( !wxWindowBase::Reparent(newParent) )
3241         return false;
3242
3243     wxASSERT( GTK_IS_WIDGET(m_widget) );
3244
3245     // Notice that old m_parent pointer might be non-NULL here but the widget
3246     // still not have any parent at GTK level if it's a notebook page that had
3247     // been removed from the notebook so test this at GTK level and not wx one.
3248     if ( GtkWidget *parentGTK = gtk_widget_get_parent(m_widget) )
3249         gtk_container_remove(GTK_CONTAINER(parentGTK), m_widget);
3250
3251     wxASSERT( GTK_IS_WIDGET(m_widget) );
3252
3253     if (newParent)
3254     {
3255         if (gtk_widget_get_visible (newParent->m_widget))
3256         {
3257             m_showOnIdle = true;
3258             gtk_widget_hide( m_widget );
3259         }
3260         /* insert GTK representation */
3261         newParent->AddChildGTK(this);
3262     }
3263
3264     SetLayoutDirection(wxLayout_Default);
3265
3266     return true;
3267 }
3268
3269 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3270 {
3271     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3272     wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3273
3274     /* add to list */
3275     AddChild( child );
3276
3277     /* insert GTK representation */
3278     AddChildGTK(child);
3279 }
3280
3281 void wxWindowGTK::AddChild(wxWindowBase *child)
3282 {
3283     wxWindowBase::AddChild(child);
3284     m_dirtyTabOrder = true;
3285     wxTheApp->WakeUpIdle();
3286 }
3287
3288 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3289 {
3290     wxWindowBase::RemoveChild(child);
3291     m_dirtyTabOrder = true;
3292     wxTheApp->WakeUpIdle();
3293 }
3294
3295 /* static */
3296 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3297 {
3298     return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3299                 ? wxLayout_RightToLeft
3300                 : wxLayout_LeftToRight;
3301 }
3302
3303 /* static */
3304 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3305 {
3306     wxASSERT_MSG( dir != wxLayout_Default, wxT("invalid layout direction") );
3307
3308     gtk_widget_set_direction(widget,
3309                              dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3310                                                          : GTK_TEXT_DIR_LTR);
3311 }
3312
3313 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3314 {
3315     return GTKGetLayout(m_widget);
3316 }
3317
3318 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3319 {
3320     if ( dir == wxLayout_Default )
3321     {
3322         const wxWindow *const parent = GetParent();
3323         if ( parent )
3324         {
3325             // inherit layout from parent.
3326             dir = parent->GetLayoutDirection();
3327         }
3328         else // no parent, use global default layout
3329         {
3330             dir = wxTheApp->GetLayoutDirection();
3331         }
3332     }
3333
3334     if ( dir == wxLayout_Default )
3335         return;
3336
3337     GTKSetLayout(m_widget, dir);
3338
3339     if (m_wxwindow && (m_wxwindow != m_widget))
3340         GTKSetLayout(m_wxwindow, dir);
3341 }
3342
3343 wxCoord
3344 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3345                                       wxCoord WXUNUSED(width),
3346                                       wxCoord WXUNUSED(widthTotal)) const
3347 {
3348     // We now mirror the coordinates of RTL windows in wxPizza
3349     return x;
3350 }
3351
3352 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
3353 {
3354     wxWindowBase::DoMoveInTabOrder(win, move);
3355     m_dirtyTabOrder = true;
3356     wxTheApp->WakeUpIdle();
3357 }
3358
3359 bool wxWindowGTK::DoNavigateIn(int flags)
3360 {
3361     if ( flags & wxNavigationKeyEvent::WinChange )
3362     {
3363         wxFAIL_MSG( wxT("not implemented") );
3364
3365         return false;
3366     }
3367     else // navigate inside the container
3368     {
3369         wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3370         wxCHECK_MSG( parent, false, wxT("every window must have a TLW parent") );
3371
3372         GtkDirectionType dir;
3373         dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3374                                                       : GTK_DIR_TAB_BACKWARD;
3375
3376         gboolean rc;
3377         g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3378
3379         return rc == TRUE;
3380     }
3381 }
3382
3383 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3384 {
3385     // none needed by default
3386     return false;
3387 }
3388
3389 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3390 {
3391     // nothing to do by default since none is needed
3392 }
3393
3394 void wxWindowGTK::RealizeTabOrder()
3395 {
3396     if (m_wxwindow)
3397     {
3398         if ( !m_children.empty() )
3399         {
3400             // we don't only construct the correct focus chain but also use
3401             // this opportunity to update the mnemonic widgets for the widgets
3402             // that need them
3403
3404             GList *chain = NULL;
3405             wxWindowGTK* mnemonicWindow = NULL;
3406
3407             for ( wxWindowList::const_iterator i = m_children.begin();
3408                   i != m_children.end();
3409                   ++i )
3410             {
3411                 wxWindowGTK *win = *i;
3412
3413                 bool focusableFromKeyboard = win->AcceptsFocusFromKeyboard();
3414
3415                 if ( mnemonicWindow )
3416                 {
3417                     if ( focusableFromKeyboard )
3418                     {
3419                         // wxComboBox et al. needs to focus on on a different
3420                         // widget than m_widget, so if the main widget isn't
3421                         // focusable try the connect widget
3422                         GtkWidget* w = win->m_widget;
3423                         if ( !gtk_widget_get_can_focus(w) )
3424                         {
3425                             w = win->GetConnectWidget();
3426                             if ( !gtk_widget_get_can_focus(w) )
3427                                 w = NULL;
3428                         }
3429
3430                         if ( w )
3431                         {
3432                             mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3433                             mnemonicWindow = NULL;
3434                         }
3435                     }
3436                 }
3437                 else if ( win->GTKWidgetNeedsMnemonic() )
3438                 {
3439                     mnemonicWindow = win;
3440                 }
3441
3442                 if ( focusableFromKeyboard )
3443                     chain = g_list_prepend(chain, win->m_widget);
3444             }
3445
3446             chain = g_list_reverse(chain);
3447
3448             gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3449             g_list_free(chain);
3450         }
3451         else // no children
3452         {
3453             gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3454         }
3455     }
3456 }
3457
3458 void wxWindowGTK::Raise()
3459 {
3460     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3461
3462     if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
3463     {
3464         gdk_window_raise(gtk_widget_get_window(m_wxwindow));
3465     }
3466     else if (gtk_widget_get_window(m_widget))
3467     {
3468         gdk_window_raise(gtk_widget_get_window(m_widget));
3469     }
3470 }
3471
3472 void wxWindowGTK::Lower()
3473 {
3474     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3475
3476     if (m_wxwindow && gtk_widget_get_window(m_wxwindow))
3477     {
3478         gdk_window_lower(gtk_widget_get_window(m_wxwindow));
3479     }
3480     else if (gtk_widget_get_window(m_widget))
3481     {
3482         gdk_window_lower(gtk_widget_get_window(m_widget));
3483     }
3484 }
3485
3486 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3487 {
3488     if ( !wxWindowBase::SetCursor(cursor.IsOk() ? cursor : *wxSTANDARD_CURSOR) )
3489         return false;
3490
3491     GTKUpdateCursor();
3492
3493     return true;
3494 }
3495
3496 void wxWindowGTK::GTKUpdateCursor(bool update_self /*=true*/, bool recurse /*=true*/)
3497 {
3498     if (update_self)
3499     {
3500         wxCursor cursor(g_globalCursor.IsOk() ? g_globalCursor : GetCursor());
3501         if ( cursor.IsOk() )
3502         {
3503             wxArrayGdkWindows windowsThis;
3504             GdkWindow* window = GTKGetWindow(windowsThis);
3505             if (window)
3506                 gdk_window_set_cursor( window, cursor.GetCursor() );
3507             else
3508             {
3509                 const size_t count = windowsThis.size();
3510                 for ( size_t n = 0; n < count; n++ )
3511                 {
3512                     GdkWindow *win = windowsThis[n];
3513                     // It can be zero if the window has not been realized yet.
3514                     if ( win )
3515                     {
3516                         gdk_window_set_cursor(win, cursor.GetCursor());
3517                     }
3518                 }
3519             }
3520         }
3521     }
3522
3523     if (recurse)
3524     {
3525         for (wxWindowList::iterator it = GetChildren().begin(); it != GetChildren().end(); ++it)
3526         {
3527             (*it)->GTKUpdateCursor( true );
3528         }
3529     }
3530 }
3531
3532 void wxWindowGTK::WarpPointer( int x, int y )
3533 {
3534     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3535
3536     ClientToScreen(&x, &y);
3537     GdkDisplay* display = gtk_widget_get_display(m_widget);
3538     GdkScreen* screen = gtk_widget_get_screen(m_widget);
3539 #ifdef __WXGTK30__
3540     GdkDeviceManager* manager = gdk_display_get_device_manager(display);
3541     gdk_device_warp(gdk_device_manager_get_client_pointer(manager), screen, x, y);
3542 #else
3543     XWarpPointer(GDK_DISPLAY_XDISPLAY(display),
3544         None,
3545         GDK_WINDOW_XID(gdk_screen_get_root_window(screen)),
3546         0, 0, 0, 0, x, y);
3547 #endif
3548 }
3549
3550 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3551 {
3552     // find the scrollbar which generated the event
3553     for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3554     {
3555         if ( range == m_scrollBar[dir] )
3556             return (ScrollDir)dir;
3557     }
3558
3559     wxFAIL_MSG( wxT("event from unknown scrollbar received") );
3560
3561     return ScrollDir_Max;
3562 }
3563
3564 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3565 {
3566     bool changed = false;
3567     GtkRange* range = m_scrollBar[dir];
3568     if ( range && units )
3569     {
3570         GtkAdjustment* adj = gtk_range_get_adjustment(range);
3571         double inc = unit == ScrollUnit_Line ? gtk_adjustment_get_step_increment(adj)
3572                                              : gtk_adjustment_get_page_increment(adj);
3573
3574         const int posOld = wxRound(gtk_adjustment_get_value(adj));
3575         gtk_range_set_value(range, posOld + units*inc);
3576
3577         changed = wxRound(gtk_adjustment_get_value(adj)) != posOld;
3578     }
3579
3580     return changed;
3581 }
3582
3583 bool wxWindowGTK::ScrollLines(int lines)
3584 {
3585     return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3586 }
3587
3588 bool wxWindowGTK::ScrollPages(int pages)
3589 {
3590     return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3591 }
3592
3593 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
3594                           const wxRect *rect)
3595 {
3596     if (m_widget == NULL || !gtk_widget_get_mapped(m_widget))
3597         return;
3598
3599     if (m_wxwindow)
3600     {
3601         GdkWindow* window = gtk_widget_get_window(m_wxwindow);
3602         if (rect)
3603         {
3604             GdkRectangle r = { rect->x, rect->y, rect->width, rect->height };
3605             if (GetLayoutDirection() == wxLayout_RightToLeft)
3606                 r.x = gdk_window_get_width(window) - r.x - rect->width;
3607             gdk_window_invalidate_rect(window, &r, true);
3608         }
3609         else
3610             gdk_window_invalidate_rect(window, NULL, true);
3611     }
3612     else
3613     {
3614         if (rect)
3615             gtk_widget_queue_draw_area(m_widget, rect->x, rect->y, rect->width, rect->height);
3616         else
3617             gtk_widget_queue_draw(m_widget);
3618     }
3619 }
3620
3621 void wxWindowGTK::Update()
3622 {
3623     if (m_widget && gtk_widget_get_mapped(m_widget))
3624     {
3625         GdkDisplay* display = gtk_widget_get_display(m_widget);
3626         // Flush everything out to the server, and wait for it to finish.
3627         // This ensures nothing will overwrite the drawing we are about to do.
3628         gdk_display_sync(display);
3629
3630         GdkWindow* window = GTKGetDrawingWindow();
3631         if (window == NULL)
3632             window = gtk_widget_get_window(m_widget);
3633         gdk_window_process_updates(window, true);
3634
3635         // Flush again, but no need to wait for it to finish
3636         gdk_display_flush(display);
3637     }
3638 }
3639
3640 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3641 {
3642     return m_updateRegion.Contains(x, y) != wxOutRegion;
3643 }
3644
3645 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3646 {
3647     if (GetLayoutDirection() == wxLayout_RightToLeft)
3648         return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3649     else
3650         return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3651 }
3652
3653 void wxWindowGTK::GtkSendPaintEvents()
3654 {
3655     if (!m_wxwindow)
3656     {
3657         m_updateRegion.Clear();
3658         return;
3659     }
3660
3661     // Clip to paint region in wxClientDC
3662     m_clipPaintRegion = true;
3663
3664     m_nativeUpdateRegion = m_updateRegion;
3665
3666     if (GetLayoutDirection() == wxLayout_RightToLeft)
3667     {
3668         // Transform m_updateRegion under RTL
3669         m_updateRegion.Clear();
3670
3671         gint width;
3672         gdk_drawable_get_size(gtk_widget_get_window(m_wxwindow), &width, NULL);
3673
3674         wxRegionIterator upd( m_nativeUpdateRegion );
3675         while (upd)
3676         {
3677             wxRect rect;
3678             rect.x = upd.GetX();
3679             rect.y = upd.GetY();
3680             rect.width = upd.GetWidth();
3681             rect.height = upd.GetHeight();
3682
3683             rect.x = width - rect.x - rect.width;
3684             m_updateRegion.Union( rect );
3685
3686             ++upd;
3687         }
3688     }
3689
3690     switch ( GetBackgroundStyle() )
3691     {
3692         case wxBG_STYLE_ERASE:
3693             {
3694                 wxWindowDC dc( (wxWindow*)this );
3695                 dc.SetDeviceClippingRegion( m_updateRegion );
3696
3697                 // Work around gtk-qt <= 0.60 bug whereby the window colour
3698                 // remains grey
3699                 if ( UseBgCol() &&
3700                         wxSystemOptions::
3701                             GetOptionInt("gtk.window.force-background-colour") )
3702                 {
3703                     dc.SetBackground(GetBackgroundColour());
3704                     dc.Clear();
3705                 }
3706
3707                 wxEraseEvent erase_event( GetId(), &dc );
3708                 erase_event.SetEventObject( this );
3709
3710                 if ( HandleWindowEvent(erase_event) )
3711                 {
3712                     // background erased, don't do it again
3713                     break;
3714                 }
3715             }
3716             // fall through
3717
3718         case wxBG_STYLE_SYSTEM:
3719             if ( GetThemeEnabled() )
3720             {
3721                 // find ancestor from which to steal background
3722                 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3723                 if (!parent)
3724                     parent = (wxWindow*)this;
3725
3726                 if (gtk_widget_get_mapped(parent->m_widget))
3727                 {
3728                     wxRegionIterator upd( m_nativeUpdateRegion );
3729                     while (upd)
3730                     {
3731                         GdkRectangle rect;
3732                         rect.x = upd.GetX();
3733                         rect.y = upd.GetY();
3734                         rect.width = upd.GetWidth();
3735                         rect.height = upd.GetHeight();
3736
3737                         gtk_paint_flat_box(gtk_widget_get_style(parent->m_widget),
3738                                     GTKGetDrawingWindow(),
3739                                     gtk_widget_get_state(m_wxwindow),
3740                                     GTK_SHADOW_NONE,
3741                                     &rect,
3742                                     parent->m_widget,
3743                                     (char *)"base",
3744                                     0, 0, -1, -1 );
3745
3746                         ++upd;
3747                     }
3748                 }
3749             }
3750             break;
3751
3752         case wxBG_STYLE_PAINT:
3753             // nothing to do: window will be painted over in EVT_PAINT
3754             break;
3755
3756         default:
3757             wxFAIL_MSG( "unsupported background style" );
3758     }
3759
3760     wxNcPaintEvent nc_paint_event( GetId() );
3761     nc_paint_event.SetEventObject( this );
3762     HandleWindowEvent( nc_paint_event );
3763
3764     wxPaintEvent paint_event( GetId() );
3765     paint_event.SetEventObject( this );
3766     HandleWindowEvent( paint_event );
3767
3768     m_clipPaintRegion = false;
3769
3770     m_updateRegion.Clear();
3771     m_nativeUpdateRegion.Clear();
3772 }
3773
3774 void wxWindowGTK::SetDoubleBuffered( bool on )
3775 {
3776     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3777
3778     if ( m_wxwindow )
3779         gtk_widget_set_double_buffered( m_wxwindow, on );
3780 }
3781
3782 bool wxWindowGTK::IsDoubleBuffered() const
3783 {
3784     return gtk_widget_get_double_buffered( m_wxwindow );
3785 }
3786
3787 void wxWindowGTK::ClearBackground()
3788 {
3789     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3790 }
3791
3792 #if wxUSE_TOOLTIPS
3793 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3794 {
3795     if (m_tooltip != tip)
3796     {
3797         wxWindowBase::DoSetToolTip(tip);
3798
3799         if (m_tooltip)
3800             m_tooltip->GTKSetWindow(static_cast<wxWindow*>(this));
3801         else
3802             GTKApplyToolTip(NULL);
3803     }
3804 }
3805
3806 void wxWindowGTK::GTKApplyToolTip(const char* tip)
3807 {
3808     wxToolTip::GTKApply(GetConnectWidget(), tip);
3809 }
3810 #endif // wxUSE_TOOLTIPS
3811
3812 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3813 {
3814     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3815
3816     if (!wxWindowBase::SetBackgroundColour(colour))
3817         return false;
3818
3819     if (colour.IsOk())
3820     {
3821         // We need the pixel value e.g. for background clearing.
3822         m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3823     }
3824
3825     // apply style change (forceStyle=true so that new style is applied
3826     // even if the bg colour changed from valid to wxNullColour)
3827     GTKApplyWidgetStyle(true);
3828
3829     return true;
3830 }
3831
3832 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3833 {
3834     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3835
3836     if (!wxWindowBase::SetForegroundColour(colour))
3837     {
3838         return false;
3839     }
3840
3841     if (colour.IsOk())
3842     {
3843         // We need the pixel value e.g. for background clearing.
3844         m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3845     }
3846
3847     // apply style change (forceStyle=true so that new style is applied
3848     // even if the bg colour changed from valid to wxNullColour):
3849     GTKApplyWidgetStyle(true);
3850
3851     return true;
3852 }
3853
3854 PangoContext *wxWindowGTK::GTKGetPangoDefaultContext()
3855 {
3856     return gtk_widget_get_pango_context( m_widget );
3857 }
3858
3859 GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
3860 {
3861     // do we need to apply any changes at all?
3862     if ( !forceStyle &&
3863          !m_font.IsOk() &&
3864          !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() )
3865     {
3866         return NULL;
3867     }
3868
3869     GtkRcStyle *style = gtk_rc_style_new();
3870
3871     if ( m_font.IsOk() )
3872     {
3873         style->font_desc =
3874             pango_font_description_copy( m_font.GetNativeFontInfo()->description );
3875     }
3876
3877     int flagsNormal = 0,
3878         flagsPrelight = 0,
3879         flagsActive = 0,
3880         flagsInsensitive = 0;
3881
3882     if ( m_foregroundColour.IsOk() )
3883     {
3884         const GdkColor *fg = m_foregroundColour.GetColor();
3885
3886         style->fg[GTK_STATE_NORMAL] =
3887         style->text[GTK_STATE_NORMAL] = *fg;
3888         flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
3889
3890         style->fg[GTK_STATE_PRELIGHT] =
3891         style->text[GTK_STATE_PRELIGHT] = *fg;
3892         flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
3893
3894         style->fg[GTK_STATE_ACTIVE] =
3895         style->text[GTK_STATE_ACTIVE] = *fg;
3896         flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
3897     }
3898
3899     if ( m_backgroundColour.IsOk() )
3900     {
3901         const GdkColor *bg = m_backgroundColour.GetColor();
3902
3903         style->bg[GTK_STATE_NORMAL] =
3904         style->base[GTK_STATE_NORMAL] = *bg;
3905         flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
3906
3907         style->bg[GTK_STATE_PRELIGHT] =
3908         style->base[GTK_STATE_PRELIGHT] = *bg;
3909         flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
3910
3911         style->bg[GTK_STATE_ACTIVE] =
3912         style->base[GTK_STATE_ACTIVE] = *bg;
3913         flagsActive |= GTK_RC_BG | GTK_RC_BASE;
3914
3915         style->bg[GTK_STATE_INSENSITIVE] =
3916         style->base[GTK_STATE_INSENSITIVE] = *bg;
3917         flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
3918     }
3919
3920     style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
3921     style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
3922     style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
3923     style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
3924
3925     return style;
3926 }
3927
3928 void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
3929 {
3930     GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
3931     if ( style )
3932     {
3933         DoApplyWidgetStyle(style);
3934         g_object_unref(style);
3935     }
3936
3937     // Style change may affect GTK+'s size calculation:
3938     InvalidateBestSize();
3939 }
3940
3941 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3942 {
3943     if ( m_wxwindow )
3944     {
3945         // block the signal temporarily to avoid sending
3946         // wxSysColourChangedEvents when we change the colours ourselves
3947         bool unblock = false;
3948         if ( IsTopLevel() )
3949         {
3950             unblock = true;
3951             g_signal_handlers_block_by_func(
3952                 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3953         }
3954
3955         gtk_widget_modify_style(m_wxwindow, style);
3956
3957         if ( unblock )
3958         {
3959             g_signal_handlers_unblock_by_func(
3960                 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3961         }
3962     }
3963     else
3964     {
3965         gtk_widget_modify_style(m_widget, style);
3966     }
3967 }
3968
3969 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3970 {
3971     wxWindowBase::SetBackgroundStyle(style);
3972
3973     if ( style == wxBG_STYLE_PAINT )
3974     {
3975         GdkWindow *window;
3976         if ( m_wxwindow )
3977         {
3978             window = GTKGetDrawingWindow();
3979         }
3980         else
3981         {
3982             GtkWidget * const w = GetConnectWidget();
3983             window = w ? gtk_widget_get_window(w) : NULL;
3984         }
3985
3986         if (window)
3987         {
3988             // Make sure GDK/X11 doesn't refresh the window
3989             // automatically.
3990             gdk_window_set_back_pixmap( window, None, False );
3991 #ifdef __X__
3992             Display* display = GDK_WINDOW_DISPLAY(window);
3993             XFlush(display);
3994 #endif
3995             m_needsStyleChange = false;
3996         }
3997         else // window not realized yet
3998         {
3999             // Do in OnIdle, because the window is not yet available
4000             m_needsStyleChange = true;
4001         }
4002
4003         // Don't apply widget style, or we get a grey background
4004     }
4005     else
4006     {
4007         // apply style change (forceStyle=true so that new style is applied
4008         // even if the bg colour changed from valid to wxNullColour):
4009         GTKApplyWidgetStyle(true);
4010     }
4011
4012     return true;
4013 }
4014
4015 // ----------------------------------------------------------------------------
4016 // Pop-up menu stuff
4017 // ----------------------------------------------------------------------------
4018
4019 #if wxUSE_MENUS_NATIVE
4020
4021 extern "C" {
4022 static
4023 void wxPopupMenuPositionCallback( GtkMenu *menu,
4024                                   gint *x, gint *y,
4025                                   gboolean * WXUNUSED(whatever),
4026                                   gpointer user_data )
4027 {
4028     // ensure that the menu appears entirely on screen
4029     GtkRequisition req;
4030     gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4031
4032     wxSize sizeScreen = wxGetDisplaySize();
4033     wxPoint *pos = (wxPoint*)user_data;
4034
4035     gint xmax = sizeScreen.x - req.width,
4036          ymax = sizeScreen.y - req.height;
4037
4038     *x = pos->x < xmax ? pos->x : xmax;
4039     *y = pos->y < ymax ? pos->y : ymax;
4040 }
4041 }
4042
4043 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4044 {
4045     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4046
4047     menu->UpdateUI();
4048
4049     wxPoint pos;
4050     gpointer userdata;
4051     GtkMenuPositionFunc posfunc;
4052     if ( x == -1 && y == -1 )
4053     {
4054         // use GTK's default positioning algorithm
4055         userdata = NULL;
4056         posfunc = NULL;
4057     }
4058     else
4059     {
4060         pos = ClientToScreen(wxPoint(x, y));
4061         userdata = &pos;
4062         posfunc = wxPopupMenuPositionCallback;
4063     }
4064
4065     menu->m_popupShown = true;
4066     gtk_menu_popup(
4067                   GTK_MENU(menu->m_menu),
4068                   NULL,           // parent menu shell
4069                   NULL,           // parent menu item
4070                   posfunc,                      // function to position it
4071                   userdata,                     // client data
4072                   0,                            // button used to activate it
4073                   gtk_get_current_event_time()
4074                 );
4075
4076     while (menu->m_popupShown)
4077     {
4078         gtk_main_iteration();
4079     }
4080
4081     return true;
4082 }
4083
4084 #endif // wxUSE_MENUS_NATIVE
4085
4086 #if wxUSE_DRAG_AND_DROP
4087
4088 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4089 {
4090     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4091
4092     GtkWidget *dnd_widget = GetConnectWidget();
4093
4094     if (m_dropTarget) m_dropTarget->GtkUnregisterWidget( dnd_widget );
4095
4096     if (m_dropTarget) delete m_dropTarget;
4097     m_dropTarget = dropTarget;
4098
4099     if (m_dropTarget) m_dropTarget->GtkRegisterWidget( dnd_widget );
4100 }
4101
4102 #endif // wxUSE_DRAG_AND_DROP
4103
4104 GtkWidget* wxWindowGTK::GetConnectWidget()
4105 {
4106     GtkWidget *connect_widget = m_widget;
4107     if (m_wxwindow) connect_widget = m_wxwindow;
4108
4109     return connect_widget;
4110 }
4111
4112 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
4113 {
4114     wxArrayGdkWindows windowsThis;
4115     GdkWindow * const winThis = GTKGetWindow(windowsThis);
4116
4117     return winThis ? window == winThis
4118                    : windowsThis.Index(window) != wxNOT_FOUND;
4119 }
4120
4121 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
4122 {
4123     return m_wxwindow ? GTKGetDrawingWindow() : gtk_widget_get_window(m_widget);
4124 }
4125
4126 bool wxWindowGTK::SetFont( const wxFont &font )
4127 {
4128     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4129
4130     if (!wxWindowBase::SetFont(font))
4131         return false;
4132
4133     // apply style change (forceStyle=true so that new style is applied
4134     // even if the font changed from valid to wxNullFont):
4135     GTKApplyWidgetStyle(true);
4136
4137     return true;
4138 }
4139
4140 void wxWindowGTK::DoCaptureMouse()
4141 {
4142     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4143
4144     GdkWindow *window = NULL;
4145     if (m_wxwindow)
4146         window = GTKGetDrawingWindow();
4147     else
4148         window = gtk_widget_get_window(GetConnectWidget());
4149
4150     wxCHECK_RET( window, wxT("CaptureMouse() failed") );
4151
4152     const wxCursor* cursor = &m_cursor;
4153     if (!cursor->IsOk())
4154         cursor = wxSTANDARD_CURSOR;
4155
4156     gdk_pointer_grab( window, FALSE,
4157                       (GdkEventMask)
4158                          (GDK_BUTTON_PRESS_MASK |
4159                           GDK_BUTTON_RELEASE_MASK |
4160                           GDK_POINTER_MOTION_HINT_MASK |
4161                           GDK_POINTER_MOTION_MASK),
4162                       NULL,
4163                       cursor->GetCursor(),
4164                       (guint32)GDK_CURRENT_TIME );
4165     g_captureWindow = this;
4166     g_captureWindowHasMouse = true;
4167 }
4168
4169 void wxWindowGTK::DoReleaseMouse()
4170 {
4171     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4172
4173     wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4174
4175     g_captureWindow = NULL;
4176
4177     GdkWindow *window = NULL;
4178     if (m_wxwindow)
4179         window = GTKGetDrawingWindow();
4180     else
4181         window = gtk_widget_get_window(GetConnectWidget());
4182
4183     if (!window)
4184         return;
4185
4186     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4187 }
4188
4189 void wxWindowGTK::GTKReleaseMouseAndNotify()
4190 {
4191     DoReleaseMouse();
4192     wxMouseCaptureLostEvent evt(GetId());
4193     evt.SetEventObject( this );
4194     HandleWindowEvent( evt );
4195 }
4196
4197 /* static */
4198 wxWindow *wxWindowBase::GetCapture()
4199 {
4200     return (wxWindow *)g_captureWindow;
4201 }
4202
4203 bool wxWindowGTK::IsRetained() const
4204 {
4205     return false;
4206 }
4207
4208 void wxWindowGTK::SetScrollbar(int orient,
4209                                int pos,
4210                                int thumbVisible,
4211                                int range,
4212                                bool WXUNUSED(update))
4213 {
4214     const int dir = ScrollDirFromOrient(orient);
4215     GtkRange* const sb = m_scrollBar[dir];
4216     wxCHECK_RET( sb, wxT("this window is not scrollable") );
4217
4218     if (range <= 0)
4219     {
4220         // GtkRange requires upper > lower
4221         range =
4222         thumbVisible = 1;
4223     }
4224
4225     g_signal_handlers_block_by_func(
4226         sb, (void*)gtk_scrollbar_value_changed, this);
4227
4228     gtk_range_set_increments(sb, 1, thumbVisible);
4229     gtk_adjustment_set_page_size(gtk_range_get_adjustment(sb), thumbVisible);
4230     gtk_range_set_range(sb, 0, range);
4231     gtk_range_set_value(sb, pos);
4232     m_scrollPos[dir] = gtk_range_get_value(sb);
4233
4234     g_signal_handlers_unblock_by_func(
4235         sb, (void*)gtk_scrollbar_value_changed, this);
4236 }
4237
4238 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4239 {
4240     const int dir = ScrollDirFromOrient(orient);
4241     GtkRange * const sb = m_scrollBar[dir];
4242     wxCHECK_RET( sb, wxT("this window is not scrollable") );
4243
4244     // This check is more than an optimization. Without it, the slider
4245     //   will not move smoothly while tracking when using wxScrollHelper.
4246     if (GetScrollPos(orient) != pos)
4247     {
4248         g_signal_handlers_block_by_func(
4249             sb, (void*)gtk_scrollbar_value_changed, this);
4250
4251         gtk_range_set_value(sb, pos);
4252         m_scrollPos[dir] = gtk_range_get_value(sb);
4253
4254         g_signal_handlers_unblock_by_func(
4255             sb, (void*)gtk_scrollbar_value_changed, this);
4256     }
4257 }
4258
4259 int wxWindowGTK::GetScrollThumb(int orient) const
4260 {
4261     GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4262     wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4263
4264     return wxRound(gtk_adjustment_get_page_size(gtk_range_get_adjustment(sb)));
4265 }
4266
4267 int wxWindowGTK::GetScrollPos( int orient ) const
4268 {
4269     GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4270     wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4271
4272     return wxRound(gtk_range_get_value(sb));
4273 }
4274
4275 int wxWindowGTK::GetScrollRange( int orient ) const
4276 {
4277     GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4278     wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
4279
4280     return wxRound(gtk_adjustment_get_upper(gtk_range_get_adjustment(sb)));
4281 }
4282
4283 // Determine if increment is the same as +/-x, allowing for some small
4284 //   difference due to possible inexactness in floating point arithmetic
4285 static inline bool IsScrollIncrement(double increment, double x)
4286 {
4287     wxASSERT(increment > 0);
4288     const double tolerance = 1.0 / 1024;
4289     return fabs(increment - fabs(x)) < tolerance;
4290 }
4291
4292 wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range)
4293 {
4294     wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4295
4296     const int barIndex = range == m_scrollBar[1];
4297
4298     const double value = gtk_range_get_value(range);
4299
4300     // save previous position
4301     const double oldPos = m_scrollPos[barIndex];
4302     // update current position
4303     m_scrollPos[barIndex] = value;
4304     // If event should be ignored, or integral position has not changed
4305     if (!m_hasVMT || g_blockEventsOnDrag || wxRound(value) == wxRound(oldPos))
4306     {
4307         return wxEVT_NULL;
4308     }
4309
4310     wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4311     if (!m_isScrolling)
4312     {
4313         // Difference from last change event
4314         const double diff = value - oldPos;
4315         const bool isDown = diff > 0;
4316
4317         GtkAdjustment* adj = gtk_range_get_adjustment(range);
4318         if (IsScrollIncrement(gtk_adjustment_get_step_increment(adj), diff))
4319         {
4320             eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4321         }
4322         else if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj), diff))
4323         {
4324             eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4325         }
4326         else if (m_mouseButtonDown)
4327         {
4328             // Assume track event
4329             m_isScrolling = true;
4330         }
4331     }
4332     return eventType;
4333 }
4334
4335 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4336 {
4337     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4338
4339     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4340
4341     // No scrolling requested.
4342     if ((dx == 0) && (dy == 0)) return;
4343
4344     m_clipPaintRegion = true;
4345
4346     WX_PIZZA(m_wxwindow)->scroll(dx, dy);
4347
4348     m_clipPaintRegion = false;
4349
4350 #if wxUSE_CARET
4351     bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4352     if (restoreCaret)
4353     {
4354         wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4355         if (dx > 0)
4356             caretRect.width += dx;
4357         else
4358         {
4359             caretRect.x += dx; caretRect.width -= dx;
4360         }
4361         if (dy > 0)
4362             caretRect.height += dy;
4363         else
4364         {
4365             caretRect.y += dy; caretRect.height -= dy;
4366         }
4367
4368         RefreshRect(caretRect);
4369     }
4370 #endif // wxUSE_CARET
4371 }
4372
4373 void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4374 {
4375     //RN: Note that static controls usually have no border on gtk, so maybe
4376     //it makes sense to treat that as simply no border at the wx level
4377     //as well...
4378     if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4379     {
4380         GtkShadowType gtkstyle;
4381
4382         if(wxstyle & wxBORDER_RAISED)
4383             gtkstyle = GTK_SHADOW_OUT;
4384         else if ((wxstyle & wxBORDER_SUNKEN) || (wxstyle & wxBORDER_THEME))
4385             gtkstyle = GTK_SHADOW_IN;
4386 #if 0
4387         // Now obsolete
4388         else if (wxstyle & wxBORDER_DOUBLE)
4389             gtkstyle = GTK_SHADOW_ETCHED_IN;
4390 #endif
4391         else //default
4392             gtkstyle = GTK_SHADOW_IN;
4393
4394         gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4395                                              gtkstyle );
4396     }
4397 }
4398
4399 void wxWindowGTK::SetWindowStyleFlag( long style )
4400 {
4401     // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4402     wxWindowBase::SetWindowStyleFlag(style);
4403 }
4404
4405 // Find the wxWindow at the current mouse position, also returning the mouse
4406 // position.
4407 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4408 {
4409     pt = wxGetMousePosition();
4410     wxWindow* found = wxFindWindowAtPoint(pt);
4411     return found;
4412 }
4413
4414 // Get the current mouse position.
4415 wxPoint wxGetMousePosition()
4416 {
4417   /* This crashes when used within wxHelpContext,
4418      so we have to use the X-specific implementation below.
4419     gint x, y;
4420     GdkModifierType *mask;
4421     (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4422
4423     return wxPoint(x, y);
4424   */
4425
4426     int x, y;
4427     GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4428
4429     Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4430     Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4431     Window rootReturn, childReturn;
4432     int rootX, rootY, winX, winY;
4433     unsigned int maskReturn;
4434
4435     XQueryPointer (display,
4436            rootWindow,
4437            &rootReturn,
4438                    &childReturn,
4439                    &rootX, &rootY, &winX, &winY, &maskReturn);
4440     return wxPoint(rootX, rootY);
4441
4442 }
4443
4444 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4445 {
4446     GdkWindow* window = NULL;
4447     if (m_wxwindow)
4448         window = gtk_widget_get_window(m_wxwindow);
4449     return window;
4450 }
4451
4452 // ----------------------------------------------------------------------------
4453 // freeze/thaw
4454 // ----------------------------------------------------------------------------
4455
4456 extern "C"
4457 {
4458
4459 // this is called if we attempted to freeze unrealized widget when it finally
4460 // is realized (and so can be frozen):
4461 static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win)
4462 {
4463     wxASSERT( w && gtk_widget_get_has_window(w) );
4464     wxASSERT( gtk_widget_get_realized(w) );
4465
4466     g_signal_handlers_disconnect_by_func
4467     (
4468         w,
4469         (void*)wx_frozen_widget_realize,
4470         win
4471     );
4472
4473     GdkWindow* window;
4474     if (w == win->m_wxwindow)
4475         window = win->GTKGetDrawingWindow();
4476     else
4477         window = gtk_widget_get_window(w);
4478     gdk_window_freeze_updates(window);
4479 }
4480
4481 } // extern "C"
4482
4483 void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
4484 {
4485     if ( !w || !gtk_widget_get_has_window(w) )
4486         return; // window-less widget, cannot be frozen
4487
4488     GdkWindow* window = gtk_widget_get_window(w);
4489     if (window == NULL)
4490     {
4491         // we can't thaw unrealized widgets because they don't have GdkWindow,
4492         // so set it up to be done immediately after realization:
4493         g_signal_connect_after
4494         (
4495             w,
4496             "realize",
4497             G_CALLBACK(wx_frozen_widget_realize),
4498             this
4499         );
4500         return;
4501     }
4502
4503     if (w == m_wxwindow)
4504         window = GTKGetDrawingWindow();
4505     gdk_window_freeze_updates(window);
4506 }
4507
4508 void wxWindowGTK::GTKThawWidget(GtkWidget *w)
4509 {
4510     if ( !w || !gtk_widget_get_has_window(w) )
4511         return; // window-less widget, cannot be frozen
4512
4513     GdkWindow* window = gtk_widget_get_window(w);
4514     if (window == NULL)
4515     {
4516         // the widget wasn't realized yet, no need to thaw
4517         g_signal_handlers_disconnect_by_func
4518         (
4519             w,
4520             (void*)wx_frozen_widget_realize,
4521             this
4522         );
4523         return;
4524     }
4525
4526     if (w == m_wxwindow)
4527         window = GTKGetDrawingWindow();
4528     gdk_window_thaw_updates(window);
4529 }
4530
4531 void wxWindowGTK::DoFreeze()
4532 {
4533     GTKFreezeWidget(m_widget);
4534     if ( m_wxwindow && m_widget != m_wxwindow )
4535         GTKFreezeWidget(m_wxwindow);
4536 }
4537
4538 void wxWindowGTK::DoThaw()
4539 {
4540     GTKThawWidget(m_widget);
4541     if ( m_wxwindow && m_widget != m_wxwindow )
4542         GTKThawWidget(m_wxwindow);
4543 }