src/gtk1/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk1/window.cpp
   3 // Purpose:
   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/intl.h"
  21     #include "wx/log.h"
  22     #include "wx/app.h"
  23     #include "wx/utils.h"
  24     #include "wx/frame.h"
  25     #include "wx/dcclient.h"
  26     #include "wx/menu.h"
  27     #include "wx/dialog.h"
  28     #include "wx/settings.h"
  29     #include "wx/msgdlg.h"
  30     #include "wx/textctrl.h"
  31     #include "wx/combobox.h"
  32     #include "wx/layout.h"
  33     #include "wx/statusbr.h"
  34     #include "wx/math.h"
  35     #include "wx/module.h"
  36 #endif
  37
  38 #if wxUSE_DRAG_AND_DROP
  39     #include "wx/dnd.h"
  40 #endif
  41
  42 #if wxUSE_TOOLTIPS
  43     #include "wx/tooltip.h"
  44 #endif
  45
  46 #if wxUSE_CARET
  47     #include "wx/caret.h"
  48 #endif // wxUSE_CARET
  49
  50 #include "wx/fontutil.h"
  51
  52 #if wxDEBUG_LEVEL
  53     #include "wx/thread.h"
  54 #endif
  55
  56 #include <ctype.h>
  57
  58 #include "wx/gtk1/private.h"
  59 #include <gdk/gdkprivate.h>
  60 #include <gdk/gdkkeysyms.h>
  61 #include <gdk/gdkx.h>
  62
  63 #include <gtk/gtk.h>
  64 #include <gtk/gtkprivate.h>
  65
  66 #include "wx/gtk1/win_gtk.h"
  67
  68 //-----------------------------------------------------------------------------
  69 // documentation on internals
  70 //-----------------------------------------------------------------------------
  71
  72 /*
  73    I have been asked several times about writing some documentation about
  74    the GTK port of wxWidgets, especially its internal structures. Obviously,
  75    you cannot understand wxGTK without knowing a little about the GTK, but
  76    some more information about what the wxWindow, which is the base class
  77    for all other window classes, does seems required as well.
  78
  79    I)
  80
  81    What does wxWindow do? It contains the common interface for the following
  82    jobs of its descendants:
  83
  84    1) Define the rudimentary behaviour common to all window classes, such as
  85    resizing, intercepting user input (so as to make it possible to use these
  86    events for special purposes in a derived class), window names etc.
  87
  88    2) Provide the possibility to contain and manage children, if the derived
  89    class is allowed to contain children, which holds true for those window
  90    classes which do not display a native GTK widget. To name them, these
  91    classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
  92    work classes are a special case and are handled a bit differently from
  93    the rest. The same holds true for the wxNotebook class.
  94
  95    3) Provide the possibility to draw into a client area of a window. This,
  96    too, only holds true for classes that do not display a native GTK widget
  97    as above.
  98
  99    4) Provide the entire mechanism for scrolling widgets. This actual inter-
 100    face for this is usually in wxScrolledWindow, but the GTK implementation
 101    is in this class.
 102
 103    5) A multitude of helper or extra methods for special purposes, such as
 104    Drag'n'Drop, managing validators etc.
 105
 106    6) Display a border (sunken, raised, simple or none).
 107
 108    Normally one might expect, that one wxWidgets window would always correspond
 109    to one GTK widget. Under GTK, there is no such allround widget that has all
 110    the functionality. Moreover, the GTK defines a client area as a different
 111    widget from the actual widget you are handling. Last but not least some
 112    special classes (e.g. wxFrame) handle different categories of widgets and
 113    still have the possibility to draw something in the client area.
 114    It was therefore required to write a special purpose GTK widget, that would
 115    represent a client area in the sense of wxWidgets capable to do the jobs
 116    2), 3) and 4). I have written this class and it resides in win_gtk.c of
 117    this directory.
 118
 119    All windows must have a widget, with which they interact with other under-
 120    lying GTK widgets. It is this widget, e.g. that has to be resized etc and
 121    the wxWindow class has a member variable called m_widget which holds a
 122    pointer to this widget. When the window class represents a GTK native widget,
 123    this is (in most cases) the only GTK widget the class manages. E.g. the
 124    wxStaticText class handles only a GtkLabel widget a pointer to which you
 125    can find in m_widget (defined in wxWindow)
 126
 127    When the class has a client area for drawing into and for containing children
 128    it has to handle the client area widget (of the type GtkPizza, defined in
 129    win_gtk.c), but there could be any number of widgets, handled by a class
 130    The common rule for all windows is only, that the widget that interacts with
 131    the rest of GTK must be referenced in m_widget and all other widgets must be
 132    children of this widget on the GTK level. The top-most widget, which also
 133    represents the client area, must be in the m_wxwindow field and must be of
 134    the type GtkPizza.
 135
 136    As I said, the window classes that display a GTK native widget only have
 137    one widget, so in the case of e.g. the wxButton class m_widget holds a
 138    pointer to a GtkButton widget. But windows with client areas (for drawing
 139    and children) have a m_widget field that is a pointer to a GtkScrolled-
 140    Window and a m_wxwindow field that is pointer to a GtkPizza and this
 141    one is (in the GTK sense) a child of the GtkScrolledWindow.
 142
 143    If the m_wxwindow field is set, then all input to this widget is inter-
 144    cepted and sent to the wxWidgets class. If not, all input to the widget
 145    that gets pointed to by m_widget gets intercepted and sent to the class.
 146
 147    II)
 148
 149    The design of scrolling in wxWidgets is markedly different from that offered
 150    by the GTK itself and therefore we cannot simply take it as it is. In GTK,
 151    clicking on a scrollbar belonging to scrolled window will inevitably move
 152    the window. In wxWidgets, the scrollbar will only emit an event, send this
 153    to (normally) a wxScrolledWindow and that class will call ScrollWindow()
 154    which actually moves the window and its subchildren. Note that GtkPizza
 155    memorizes how much it has been scrolled but that wxWidgets forgets this
 156    so that the two coordinates systems have to be kept in synch. This is done
 157    in various places using the pizza->xoffset and pizza->yoffset values.
 158
 159    III)
 160
 161    Singularily the most broken code in GTK is the code that is supposed to
 162    inform subwindows (child windows) about new positions. Very often, duplicate
 163    events are sent without changes in size or position, equally often no
 164    events are sent at all (All this is due to a bug in the GtkContainer code
 165    which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
 166    GTK's own system and it simply waits for size events for toplevel windows
 167    and then iterates down the respective size events to all window. This has
 168    the disadvantage that windows might get size events before the GTK widget
 169    actually has the reported size. This doesn't normally pose any problem, but
 170    the OpenGL drawing routines rely on correct behaviour. Therefore, I have
 171    added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
 172    i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
 173    window that is used for OpenGL output really has that size (as reported by
 174    GTK).
 175
 176    IV)
 177
 178    If someone at some point of time feels the immense desire to have a look at,
 179    change or attempt to optimise the Refresh() logic, this person will need an
 180    intimate understanding of what "draw" and "expose" events are and what
 181    they are used for, in particular when used in connection with GTK's
 182    own windowless widgets. Beware.
 183
 184    V)
 185
 186    Cursors, too, have been a constant source of pleasure. The main difficulty
 187    is that a GdkWindow inherits a cursor if the programmer sets a new cursor
 188    for the parent. To prevent this from doing too much harm, I use idle time
 189    to set the cursor over and over again, starting from the toplevel windows
 190    and ending with the youngest generation (speaking of parent and child windows).
 191    Also don't forget that cursors (like much else) are connected to GdkWindows,
 192    not GtkWidgets and that the "window" field of a GtkWidget might very well
 193    point to the GdkWindow of the parent widget (-> "window-less widget") and
 194    that the two obviously have very different meanings.
 195
 196 */
 197
 198 //-----------------------------------------------------------------------------
 199 // data
 200 //-----------------------------------------------------------------------------
 201
 202 extern bool       g_blockEventsOnDrag;
 203 extern bool       g_blockEventsOnScroll;
 204 extern wxCursor   g_globalCursor;
 205
 206 static GdkGC *g_eraseGC = NULL;
 207
 208 // mouse capture state: the window which has it and if the mouse is currently
 209 // inside it
 210 static wxWindowGTK  *g_captureWindow = NULL;
 211 static bool g_captureWindowHasMouse = false;
 212
 213 wxWindowGTK  *g_focusWindow = NULL;
 214
 215 // the last window which had the focus - this is normally never NULL (except
 216 // if we never had focus at all) as even when g_focusWindow is NULL it still
 217 // keeps its previous value
 218 wxWindowGTK *g_focusWindowLast = NULL;
 219
 220 // If a window get the focus set but has not been realized
 221 // yet, defer setting the focus to idle time.
 222 wxWindowGTK *g_delayedFocus = NULL;
 223
 224 // hack: we need something to pass to gtk_menu_popup, so we store the time of
 225 // the last click here (extern: used from gtk/menu.cpp)
 226 guint32 wxGtkTimeLastClick = 0;
 227
 228 // global variables because GTK+ DnD want to have the
 229 // mouse event that caused it
 230 GdkEvent *g_lastMouseEvent = NULL;
 231 int g_lastButtonNumber = 0;
 232
 233 extern bool g_mainThreadLocked;
 234
 235 //-----------------------------------------------------------------------------
 236 // debug
 237 //-----------------------------------------------------------------------------
 238
 239 #if wxUSE_THREADS
 240 #   define DEBUG_MAIN_THREAD \
 241         wxASSERT_MSG( !g_mainThreadLocked || !wxThread::IsMain(), \
 242                       "GUI reentrancy detected" );
 243 #else
 244 #   define DEBUG_MAIN_THREAD
 245 #endif
 246
 247 // the trace mask used for the focus debugging messages
 248 #define TRACE_FOCUS wxT("focus")
 249
 250 //-----------------------------------------------------------------------------
 251 // missing gdk functions
 252 //-----------------------------------------------------------------------------
 253
 254 void
 255 gdk_window_warp_pointer (GdkWindow      *window,
 256                          gint            x,
 257                          gint            y)
 258 {
 259   GdkWindowPrivate *priv;
 260
 261   if (!window)
 262     window = GDK_ROOT_PARENT();
 263
 264   priv = (GdkWindowPrivate*) window;
 265
 266   if (!priv->destroyed)
 267   {
 268       XWarpPointer (priv->xdisplay,
 269                     None,              /* not source window -> move from anywhere */
 270                     priv->xwindow,  /* dest window */
 271                     0, 0, 0, 0,        /* not source window -> move from anywhere */
 272                     x, y );
 273   }
 274 }
 275
 276 //-----------------------------------------------------------------------------
 277 // idle system
 278 //-----------------------------------------------------------------------------
 279
 280 extern void wxapp_install_idle_handler();
 281 extern bool g_isIdle;
 282
 283 //-----------------------------------------------------------------------------
 284 // local code (see below)
 285 //-----------------------------------------------------------------------------
 286
 287 // returns the child of win which currently has focus or NULL if not found
 288 //
 289 // Note: can't be static, needed by textctrl.cpp.
 290 wxWindow *wxFindFocusedChild(wxWindowGTK *win)
 291 {
 292     wxWindow *winFocus = wxWindowGTK::FindFocus();
 293     if ( !winFocus )
 294         return NULL;
 295
 296     if ( winFocus == win )
 297         return (wxWindow *)win;
 298
 299     for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
 300           node;
 301           node = node->GetNext() )
 302     {
 303         wxWindow *child = wxFindFocusedChild(node->GetData());
 304         if ( child )
 305             return child;
 306     }
 307
 308     return NULL;
 309 }
 310
 311 static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
 312 {
 313     // wxUniversal widgets draw the borders and scrollbars themselves
 314 #ifndef __WXUNIVERSAL__
 315     if (!win->m_hasVMT)
 316         return;
 317
 318     int dw = 0;
 319     int dh = 0;
 320
 321     if (win->m_hasScrolling)
 322     {
 323         GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
 324
 325         GtkRequisition vscroll_req;
 326         vscroll_req.width = 2;
 327         vscroll_req.height = 2;
 328         (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
 329             (scroll_window->vscrollbar, &vscroll_req );
 330
 331         GtkRequisition hscroll_req;
 332         hscroll_req.width = 2;
 333         hscroll_req.height = 2;
 334         (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
 335             (scroll_window->hscrollbar, &hscroll_req );
 336
 337         GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget) );
 338
 339         if (scroll_window->vscrollbar_visible)
 340         {
 341             dw += vscroll_req.width;
 342             dw += scroll_class->scrollbar_spacing;
 343         }
 344
 345         if (scroll_window->hscrollbar_visible)
 346         {
 347             dh += hscroll_req.height;
 348             dh += scroll_class->scrollbar_spacing;
 349         }
 350     }
 351
 352     int dx = 0;
 353     int dy = 0;
 354     if (GTK_WIDGET_NO_WINDOW (widget))
 355     {
 356         dx += widget->allocation.x;
 357         dy += widget->allocation.y;
 358     }
 359
 360     if (win->HasFlag(wxRAISED_BORDER))
 361     {
 362         gtk_draw_shadow( widget->style,
 363                          widget->window,
 364                          GTK_STATE_NORMAL,
 365                          GTK_SHADOW_OUT,
 366                          dx, dy,
 367                          widget->allocation.width-dw, widget->allocation.height-dh );
 368         return;
 369     }
 370
 371     if (win->HasFlag(wxSUNKEN_BORDER) || win->HasFlag(wxBORDER_THEME))
 372     {
 373         gtk_draw_shadow( widget->style,
 374                          widget->window,
 375                          GTK_STATE_NORMAL,
 376                          GTK_SHADOW_IN,
 377                          dx, dy,
 378                          widget->allocation.width-dw, widget->allocation.height-dh );
 379         return;
 380     }
 381
 382     if (win->HasFlag(wxSIMPLE_BORDER))
 383     {
 384         GdkGC *gc;
 385         gc = gdk_gc_new( widget->window );
 386         gdk_gc_set_foreground( gc, &widget->style->black );
 387         gdk_draw_rectangle( widget->window, gc, FALSE,
 388                          dx, dy,
 389                          widget->allocation.width-dw-1, widget->allocation.height-dh-1 );
 390         gdk_gc_unref( gc );
 391         return;
 392     }
 393 #endif // __WXUNIVERSAL__
 394 }
 395
 396 //-----------------------------------------------------------------------------
 397 // "expose_event" of m_widget
 398 //-----------------------------------------------------------------------------
 399
 400 extern "C" {
 401 static gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win )
 402 {
 403     if (gdk_event->count > 0) return FALSE;
 404
 405     draw_frame( widget, win );
 406
 407     return TRUE;
 408 }
 409 }
 410
 411 //-----------------------------------------------------------------------------
 412 // "draw" of m_widget
 413 //-----------------------------------------------------------------------------
 414
 415 extern "C" {
 416 static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )
 417 {
 418     draw_frame( widget, win );
 419 }
 420 }
 421
 422 //-----------------------------------------------------------------------------
 423 // "size_request" of m_widget
 424 //-----------------------------------------------------------------------------
 425
 426 // make it extern because wxStaticText needs to disconnect this one
 427 extern "C" {
 428 void wxgtk_window_size_request_callback(GtkWidget *WXUNUSED(widget),
 429                                         GtkRequisition *requisition,
 430                                         wxWindow *win)
 431 {
 432     int w, h;
 433     win->GetSize( &w, &h );
 434     if (w < 2)
 435         w = 2;
 436     if (h < 2)
 437         h = 2;
 438
 439     requisition->height = h;
 440     requisition->width = w;
 441 }
 442 }
 443
 444 extern "C" {
 445 static
 446 void wxgtk_combo_size_request_callback(GtkWidget *WXUNUSED(widget),
 447                                        GtkRequisition *requisition,
 448                                        wxComboBox *win)
 449 {
 450     // This callback is actually hooked into the text entry
 451     // of the combo box, not the GtkHBox.
 452
 453     int w, h;
 454     win->GetSize( &w, &h );
 455     if (w < 2)
 456         w = 2;
 457     if (h < 2)
 458         h = 2;
 459
 460     GtkCombo *gcombo = GTK_COMBO(win->m_widget);
 461
 462     GtkRequisition entry_req;
 463     entry_req.width = 2;
 464     entry_req.height = 2;
 465     (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->button) )->size_request )
 466         (gcombo->button, &entry_req );
 467
 468     requisition->width = w - entry_req.width;
 469     requisition->height = entry_req.height;
 470 }
 471 }
 472
 473 //-----------------------------------------------------------------------------
 474 // "expose_event" of m_wxwindow
 475 //-----------------------------------------------------------------------------
 476
 477 extern "C" {
 478 static int gtk_window_expose_callback( GtkWidget *WXUNUSED(widget),
 479                                        GdkEventExpose *gdk_event,
 480                                        wxWindow *win )
 481 {
 482     DEBUG_MAIN_THREAD
 483
 484     if (g_isIdle)
 485         wxapp_install_idle_handler();
 486
 487     // This gets called immediately after an expose event
 488     // under GTK 1.2 so we collect the calls and wait for
 489     // the idle handler to pick things up.
 490
 491     win->GetUpdateRegion().Union( gdk_event->area.x,
 492                                   gdk_event->area.y,
 493                                   gdk_event->area.width,
 494                                   gdk_event->area.height );
 495     win->m_clearRegion.Union( gdk_event->area.x,
 496                                   gdk_event->area.y,
 497                                   gdk_event->area.width,
 498                                   gdk_event->area.height );
 499
 500     // Actual redrawing takes place in idle time.
 501     // win->GtkUpdate();
 502
 503     return FALSE;
 504 }
 505 }
 506
 507 //-----------------------------------------------------------------------------
 508 // "event" of m_wxwindow
 509 //-----------------------------------------------------------------------------
 510
 511 // GTK thinks it is clever and filters out a certain amount of "unneeded"
 512 // expose events. We need them, of course, so we override the main event
 513 // procedure in GtkWidget by giving our own handler for all system events.
 514 // There, we look for expose events ourselves whereas all other events are
 515 // handled normally.
 516
 517 extern "C" {
 518 static
 519 gint gtk_window_event_event_callback( GtkWidget *widget,
 520                                       GdkEventExpose *event,
 521                                       wxWindow *win )
 522 {
 523     if (event->type == GDK_EXPOSE)
 524     {
 525         gint ret = gtk_window_expose_callback( widget, event, win );
 526         return ret;
 527     }
 528
 529     return FALSE;
 530 }
 531 }
 532
 533 //-----------------------------------------------------------------------------
 534 // "draw" of m_wxwindow
 535 //-----------------------------------------------------------------------------
 536
 537 // This callback is a complete replacement of the gtk_pizza_draw() function,
 538 // which is disabled.
 539
 540 extern "C" {
 541 static void gtk_window_draw_callback( GtkWidget *widget,
 542                                       GdkRectangle *rect,
 543                                       wxWindow *win )
 544 {
 545     DEBUG_MAIN_THREAD
 546
 547     if (g_isIdle)
 548         wxapp_install_idle_handler();
 549
 550     // if there are any children we must refresh everything
 551     //
 552     // VZ: why?
 553     if ( !win->HasFlag(wxFULL_REPAINT_ON_RESIZE) &&
 554             win->GetChildren().IsEmpty() )
 555     {
 556         return;
 557     }
 558
 559 #if 0
 560     if (win->GetName())
 561     {
 562         wxPrintf( wxT("OnDraw from ") );
 563         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 564             wxPrintf( win->GetClassInfo()->GetClassName() );
 565         wxPrintf( wxT(" %d %d %d %d\n"), (int)rect->x,
 566                                          (int)rect->y,
 567                                          (int)rect->width,
 568                                          (int)rect->height );
 569     }
 570 #endif
 571
 572 #ifndef __WXUNIVERSAL__
 573     GtkPizza *pizza = GTK_PIZZA (widget);
 574
 575     if (win->GetThemeEnabled() && win->GetBackgroundStyle() == wxBG_STYLE_SYSTEM)
 576     {
 577         wxWindow *parent = win->GetParent();
 578         while (parent && !parent->IsTopLevel())
 579             parent = parent->GetParent();
 580         if (!parent)
 581             parent = win;
 582
 583         gtk_paint_flat_box (parent->m_widget->style,
 584                             pizza->bin_window,
 585                             GTK_STATE_NORMAL,
 586                             GTK_SHADOW_NONE,
 587                             rect,
 588                             parent->m_widget,
 589                             (char *)"base",
 590                             0, 0, -1, -1);
 591     }
 592 #endif
 593
 594     win->m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
 595     win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
 596
 597     // Update immediately, not in idle time.
 598     win->GtkUpdate();
 599
 600 #ifndef __WXUNIVERSAL__
 601     // Redraw child widgets
 602     GList *children = pizza->children;
 603     while (children)
 604     {
 605         GtkPizzaChild *child = (GtkPizzaChild*) children->data;
 606         children = children->next;
 607
 608         GdkRectangle child_area;
 609         if (gtk_widget_intersect (child->widget, rect, &child_area))
 610         {
 611             gtk_widget_draw (child->widget, &child_area /* NULL*/ );
 612         }
 613     }
 614 #endif
 615 }
 616 }
 617
 618 //-----------------------------------------------------------------------------
 619 // "key_press_event" from any window
 620 //-----------------------------------------------------------------------------
 621
 622 // set WXTRACE to this to see the key event codes on the console
 623 #define TRACE_KEYS  wxT("keyevent")
 624
 625 // translates an X key symbol to WXK_XXX value
 626 //
 627 // if isChar is true it means that the value returned will be used for EVT_CHAR
 628 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
 629 // for example, while if it is false it means that the value is going to be
 630 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
 631 // WXK_NUMPAD_DIVIDE
 632 static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
 633 {
 634     long key_code;
 635
 636     switch ( keysym )
 637     {
 638         // Shift, Control and Alt don't generate the CHAR events at all
 639         case GDK_Shift_L:
 640         case GDK_Shift_R:
 641             key_code = isChar ? 0 : WXK_SHIFT;
 642             break;
 643         case GDK_Control_L:
 644         case GDK_Control_R:
 645             key_code = isChar ? 0 : WXK_CONTROL;
 646             break;
 647         case GDK_Meta_L:
 648         case GDK_Meta_R:
 649         case GDK_Alt_L:
 650         case GDK_Alt_R:
 651         case GDK_Super_L:
 652         case GDK_Super_R:
 653             key_code = isChar ? 0 : WXK_ALT;
 654             break;
 655
 656         // neither do the toggle modifies
 657         case GDK_Scroll_Lock:
 658             key_code = isChar ? 0 : WXK_SCROLL;
 659             break;
 660
 661         case GDK_Caps_Lock:
 662             key_code = isChar ? 0 : WXK_CAPITAL;
 663             break;
 664
 665         case GDK_Num_Lock:
 666             key_code = isChar ? 0 : WXK_NUMLOCK;
 667             break;
 668
 669
 670         // various other special keys
 671         case GDK_Menu:
 672             key_code = WXK_MENU;
 673             break;
 674
 675         case GDK_Help:
 676             key_code = WXK_HELP;
 677             break;
 678
 679         case GDK_BackSpace:
 680             key_code = WXK_BACK;
 681             break;
 682
 683         case GDK_ISO_Left_Tab:
 684         case GDK_Tab:
 685             key_code = WXK_TAB;
 686             break;
 687
 688         case GDK_Linefeed:
 689         case GDK_Return:
 690             key_code = WXK_RETURN;
 691             break;
 692
 693         case GDK_Clear:
 694             key_code = WXK_CLEAR;
 695             break;
 696
 697         case GDK_Pause:
 698             key_code = WXK_PAUSE;
 699             break;
 700
 701         case GDK_Select:
 702             key_code = WXK_SELECT;
 703             break;
 704
 705         case GDK_Print:
 706             key_code = WXK_PRINT;
 707             break;
 708
 709         case GDK_Execute:
 710             key_code = WXK_EXECUTE;
 711             break;
 712
 713         case GDK_Escape:
 714             key_code = WXK_ESCAPE;
 715             break;
 716
 717         // cursor and other extended keyboard keys
 718         case GDK_Delete:
 719             key_code = WXK_DELETE;
 720             break;
 721
 722         case GDK_Home:
 723             key_code = WXK_HOME;
 724             break;
 725
 726         case GDK_Left:
 727             key_code = WXK_LEFT;
 728             break;
 729
 730         case GDK_Up:
 731             key_code = WXK_UP;
 732             break;
 733
 734         case GDK_Right:
 735             key_code = WXK_RIGHT;
 736             break;
 737
 738         case GDK_Down:
 739             key_code = WXK_DOWN;
 740             break;
 741
 742         case GDK_Prior:     // == GDK_Page_Up
 743             key_code = WXK_PAGEUP;
 744             break;
 745
 746         case GDK_Next:      // == GDK_Page_Down
 747             key_code = WXK_PAGEDOWN;
 748             break;
 749
 750         case GDK_End:
 751             key_code = WXK_END;
 752             break;
 753
 754         case GDK_Begin:
 755             key_code = WXK_HOME;
 756             break;
 757
 758         case GDK_Insert:
 759             key_code = WXK_INSERT;
 760             break;
 761
 762
 763         // numpad keys
 764         case GDK_KP_0:
 765         case GDK_KP_1:
 766         case GDK_KP_2:
 767         case GDK_KP_3:
 768         case GDK_KP_4:
 769         case GDK_KP_5:
 770         case GDK_KP_6:
 771         case GDK_KP_7:
 772         case GDK_KP_8:
 773         case GDK_KP_9:
 774             key_code = (isChar ? '0' : WXK_NUMPAD0) + keysym - GDK_KP_0;
 775             break;
 776
 777         case GDK_KP_Space:
 778             key_code = isChar ? ' ' : WXK_NUMPAD_SPACE;
 779             break;
 780
 781         case GDK_KP_Tab:
 782             key_code = isChar ? WXK_TAB : WXK_NUMPAD_TAB;
 783             break;
 784
 785         case GDK_KP_Enter:
 786             key_code = isChar ? WXK_RETURN : WXK_NUMPAD_ENTER;
 787             break;
 788
 789         case GDK_KP_F1:
 790             key_code = isChar ? WXK_F1 : WXK_NUMPAD_F1;
 791             break;
 792
 793         case GDK_KP_F2:
 794             key_code = isChar ? WXK_F2 : WXK_NUMPAD_F2;
 795             break;
 796
 797         case GDK_KP_F3:
 798             key_code = isChar ? WXK_F3 : WXK_NUMPAD_F3;
 799             break;
 800
 801         case GDK_KP_F4:
 802             key_code = isChar ? WXK_F4 : WXK_NUMPAD_F4;
 803             break;
 804
 805         case GDK_KP_Home:
 806             key_code = isChar ? WXK_HOME : WXK_NUMPAD_HOME;
 807             break;
 808
 809         case GDK_KP_Left:
 810             key_code = isChar ? WXK_LEFT : WXK_NUMPAD_LEFT;
 811             break;
 812
 813         case GDK_KP_Up:
 814             key_code = isChar ? WXK_UP : WXK_NUMPAD_UP;
 815             break;
 816
 817         case GDK_KP_Right:
 818             key_code = isChar ? WXK_RIGHT : WXK_NUMPAD_RIGHT;
 819             break;
 820
 821         case GDK_KP_Down:
 822             key_code = isChar ? WXK_DOWN : WXK_NUMPAD_DOWN;
 823             break;
 824
 825         case GDK_KP_Prior: // == GDK_KP_Page_Up
 826             key_code = isChar ? WXK_PAGEUP : WXK_NUMPAD_PAGEUP;
 827             break;
 828
 829         case GDK_KP_Next: // == GDK_KP_Page_Down
 830             key_code = isChar ? WXK_PAGEDOWN : WXK_NUMPAD_PAGEDOWN;
 831             break;
 832
 833         case GDK_KP_End:
 834             key_code = isChar ? WXK_END : WXK_NUMPAD_END;
 835             break;
 836
 837         case GDK_KP_Begin:
 838             key_code = isChar ? WXK_HOME : WXK_NUMPAD_BEGIN;
 839             break;
 840
 841         case GDK_KP_Insert:
 842             key_code = isChar ? WXK_INSERT : WXK_NUMPAD_INSERT;
 843             break;
 844
 845         case GDK_KP_Delete:
 846             key_code = isChar ? WXK_DELETE : WXK_NUMPAD_DELETE;
 847             break;
 848
 849         case GDK_KP_Equal:
 850             key_code = isChar ? '=' : WXK_NUMPAD_EQUAL;
 851             break;
 852
 853         case GDK_KP_Multiply:
 854             key_code = isChar ? '*' : WXK_NUMPAD_MULTIPLY;
 855             break;
 856
 857         case GDK_KP_Add:
 858             key_code = isChar ? '+' : WXK_NUMPAD_ADD;
 859             break;
 860
 861         case GDK_KP_Separator:
 862             // FIXME: what is this?
 863             key_code = isChar ? '.' : WXK_NUMPAD_SEPARATOR;
 864             break;
 865
 866         case GDK_KP_Subtract:
 867             key_code = isChar ? '-' : WXK_NUMPAD_SUBTRACT;
 868             break;
 869
 870         case GDK_KP_Decimal:
 871             key_code = isChar ? '.' : WXK_NUMPAD_DECIMAL;
 872             break;
 873
 874         case GDK_KP_Divide:
 875             key_code = isChar ? '/' : WXK_NUMPAD_DIVIDE;
 876             break;
 877
 878
 879         // function keys
 880         case GDK_F1:
 881         case GDK_F2:
 882         case GDK_F3:
 883         case GDK_F4:
 884         case GDK_F5:
 885         case GDK_F6:
 886         case GDK_F7:
 887         case GDK_F8:
 888         case GDK_F9:
 889         case GDK_F10:
 890         case GDK_F11:
 891         case GDK_F12:
 892             key_code = WXK_F1 + keysym - GDK_F1;
 893             break;
 894
 895         default:
 896             key_code = 0;
 897     }
 898
 899     return key_code;
 900 }
 901
 902 static inline bool wxIsAsciiKeysym(KeySym ks)
 903 {
 904     return ks < 256;
 905 }
 906
 907 static void wxFillOtherKeyEventFields(wxKeyEvent& event,
 908                                       wxWindowGTK *win,
 909                                       GdkEventKey *gdk_event)
 910 {
 911     int x = 0;
 912     int y = 0;
 913     GdkModifierType state;
 914     if (gdk_event->window)
 915         gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
 916
 917     event.SetTimestamp( gdk_event->time );
 918     event.SetId(win->GetId());
 919     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
 920     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
 921     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
 922     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
 923     event.m_rawCode = (wxUint32) gdk_event->keyval;
 924     event.m_rawFlags = 0;
 925 #if wxUSE_UNICODE
 926 #if 0
 927    // this is not gtk1.x
 928    event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval);
 929 #endif
 930 #endif
 931     wxGetMousePosition( &x, &y );
 932     win->ScreenToClient( &x, &y );
 933     event.m_x = x;
 934     event.m_y = y;
 935     event.SetEventObject( win );
 936 }
 937
 938
 939 static bool
 940 wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
 941                            wxWindowGTK *win,
 942                            GdkEventKey *gdk_event)
 943 {
 944     // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
 945     //     but only event->keyval which is quite useless to us, so remember
 946     //     the last character from GDK_KEY_PRESS and reuse it as last resort
 947     //
 948     // NB: should be MT-safe as we're always called from the main thread only
 949     static struct
 950     {
 951         KeySym keysym;
 952         long   keycode;
 953     } s_lastKeyPress = { 0, 0 };
 954
 955     KeySym keysym = gdk_event->keyval;
 956
 957     wxLogTrace(TRACE_KEYS, wxT("Key %s event: keysym = %ld"),
 958                event.GetEventType() == wxEVT_KEY_UP ? wxT("release")
 959                                                     : wxT("press"),
 960                keysym);
 961
 962     long key_code = wxTranslateKeySymToWXKey(keysym, false /* !isChar */);
 963
 964     if ( !key_code )
 965     {
 966         // do we have the translation or is it a plain ASCII character?
 967         if ( (gdk_event->length == 1) || wxIsAsciiKeysym(keysym) )
 968         {
 969             // we should use keysym if it is ASCII as X does some translations
 970             // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
 971             // which we don't want here (but which we do use for OnChar())
 972             if ( !wxIsAsciiKeysym(keysym) )
 973             {
 974                 keysym = (KeySym)gdk_event->string[0];
 975             }
 976
 977             // we want to always get the same key code when the same key is
 978             // pressed regardless of the state of the modifiers, i.e. on a
 979             // standard US keyboard pressing '5' or '%' ('5' key with
 980             // Shift) should result in the same key code in OnKeyDown():
 981             // '5' (although OnChar() will get either '5' or '%').
 982             //
 983             // to do it we first translate keysym to keycode (== scan code)
 984             // and then back but always using the lower register
 985             Display *dpy = (Display *)wxGetDisplay();
 986             KeyCode keycode = XKeysymToKeycode(dpy, keysym);
 987
 988             wxLogTrace(TRACE_KEYS, wxT("\t-> keycode %d"), keycode);
 989
 990             KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
 991
 992             // use the normalized, i.e. lower register, keysym if we've
 993             // got one
 994             key_code = keysymNormalized ? keysymNormalized : keysym;
 995
 996             // as explained above, we want to have lower register key codes
 997             // normally but for the letter keys we want to have the upper ones
 998             //
 999             // NB: don't use XConvertCase() here, we want to do it for letters
1000             // only
1001             key_code = toupper(key_code);
1002         }
1003         else // non ASCII key, what to do?
1004         {
1005             // by default, ignore it
1006             key_code = 0;
1007
1008             // but if we have cached information from the last KEY_PRESS
1009             if ( gdk_event->type == GDK_KEY_RELEASE )
1010             {
1011                 // then reuse it
1012                 if ( keysym == s_lastKeyPress.keysym )
1013                 {
1014                     key_code = s_lastKeyPress.keycode;
1015                 }
1016             }
1017         }
1018
1019         if ( gdk_event->type == GDK_KEY_PRESS )
1020         {
1021             // remember it to be reused for KEY_UP event later
1022             s_lastKeyPress.keysym = keysym;
1023             s_lastKeyPress.keycode = key_code;
1024         }
1025     }
1026
1027     wxLogTrace(TRACE_KEYS, wxT("\t-> wxKeyCode %ld"), key_code);
1028
1029     // sending unknown key events doesn't really make sense
1030     if ( !key_code )
1031         return false;
1032
1033     // now fill all the other fields
1034     wxFillOtherKeyEventFields(event, win, gdk_event);
1035
1036     event.m_keyCode = key_code;
1037
1038     return true;
1039 }
1040
1041
1042 extern "C" {
1043 static gint gtk_window_key_press_callback( GtkWidget *widget,
1044                                            GdkEventKey *gdk_event,
1045                                            wxWindow *win )
1046 {
1047     DEBUG_MAIN_THREAD
1048
1049     if (g_isIdle)
1050         wxapp_install_idle_handler();
1051
1052     if (!win->m_hasVMT)
1053         return FALSE;
1054     if (g_blockEventsOnDrag)
1055         return FALSE;
1056
1057
1058     wxKeyEvent event( wxEVT_KEY_DOWN );
1059     bool ret = false;
1060     bool return_after_IM = false;
1061
1062     if ( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1063     {
1064         // Emit KEY_DOWN event
1065         ret = win->HandleWindowEvent( event );
1066     }
1067     else
1068     {
1069         // Return after IM processing as we cannot do
1070         // anything with it anyhow.
1071         return_after_IM = true;
1072     }
1073
1074     // This is for GTK+ 1.2 only. The char event generatation for GTK+ 2.0 is done
1075     // in the "commit" handler.
1076
1077     // 2005.02.02 modified by Hong Jen Yee (hzysoft@sina.com.tw).
1078     // In GTK+ 1.2, strings sent by IMs are also regarded as key_press events whose
1079     // keyCodes cannot be recognized by wxWidgets. These MBCS strings, however, are
1080     // composed of more than one character, which means gdk_event->length will always
1081     // greater than one. When gtk_event->length == 1, this may be an ASCII character
1082     // and can be translated by wx.  However, when MBCS characters are sent by IM,
1083     // gdk_event->length will >= 2. So neither should we pass it to accelerator table,
1084     // nor should we pass it to controls. The following explanation was excerpted
1085     // from GDK documentation.
1086     // gint length : the length of string.
1087     // gchar *string : a null-terminated multi-byte string containing the composed
1088     // characters resulting from the key press. When text is being input, in a GtkEntry
1089     // for example, it is these characters which should be added to the input buffer.
1090     // When using Input Methods to support internationalized text input, the composed
1091     // characters appear here after the pre-editing has been completed.
1092
1093     if ( (!ret) && (gdk_event->length > 1) ) // If this event contains a pre-edited string from IM.
1094     {
1095         // We should translate this key event into wxEVT_CHAR not wxEVT_KEY_DOWN.
1096         #if wxUSE_UNICODE   // GTK+ 1.2 is not UTF-8 based.
1097             const wxWCharBuffer string = wxConvLocal.cMB2WC( gdk_event->string );
1098             if( !string )
1099                 return false;
1100         #else
1101             const char* string = gdk_event->string;
1102         #endif
1103
1104         // Implement OnCharHook by checking ancestor top level windows
1105         wxWindow *parent = win;
1106         while (parent && !parent->IsTopLevel())
1107             parent = parent->GetParent();
1108
1109         for( const wxChar* pstr = string; *pstr; pstr++ )
1110         {
1111         #if wxUSE_UNICODE
1112             event.m_uniChar = *pstr;
1113             // Backward compatible for ISO-8859-1
1114             event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
1115         #else
1116             event.m_keyCode = *pstr;
1117         #endif
1118             if (parent)
1119             {
1120                 event.SetEventType( wxEVT_CHAR_HOOK );
1121                 ret = parent->HandleWindowEvent( event );
1122             }
1123             if (!ret)
1124             {
1125                 event.SetEventType(wxEVT_CHAR);
1126                 win->HandleWindowEvent( event );
1127             }
1128         }
1129         return true;
1130     }
1131
1132     if (return_after_IM)
1133         return false;
1134
1135 #if wxUSE_ACCEL
1136     if (!ret)
1137     {
1138         wxWindowGTK *ancestor = win;
1139         while (ancestor)
1140         {
1141             int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1142             if (command != -1)
1143             {
1144                 wxCommandEvent command_event( wxEVT_MENU, command );
1145                 ret = ancestor->HandleWindowEvent( command_event );
1146                 break;
1147             }
1148             if (ancestor->IsTopLevel())
1149                 break;
1150             ancestor = ancestor->GetParent();
1151         }
1152     }
1153 #endif // wxUSE_ACCEL
1154
1155     // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1156     // will only be sent if it is not in an accelerator table.
1157     if (!ret)
1158     {
1159         long key_code;
1160         KeySym keysym = gdk_event->keyval;
1161         // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1162         key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */);
1163         if ( !key_code )
1164         {
1165             if ( wxIsAsciiKeysym(keysym) )
1166             {
1167                 // ASCII key
1168                 key_code = (unsigned char)keysym;
1169             }
1170             // gdk_event->string is actually deprecated
1171             else if ( gdk_event->length == 1 )
1172             {
1173                 key_code = (unsigned char)gdk_event->string[0];
1174             }
1175         }
1176
1177         if ( key_code )
1178         {
1179             wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
1180
1181             event.m_keyCode = key_code;
1182
1183             // Implement OnCharHook by checking ancestor top level windows
1184             wxWindow *parent = win;
1185             while (parent && !parent->IsTopLevel())
1186                 parent = parent->GetParent();
1187             if (parent)
1188             {
1189                 event.SetEventType( wxEVT_CHAR_HOOK );
1190                 ret = parent->HandleWindowEvent( event );
1191             }
1192
1193             if (!ret)
1194             {
1195                 event.SetEventType(wxEVT_CHAR);
1196                 ret = win->HandleWindowEvent( event );
1197             }
1198         }
1199     }
1200
1201
1202
1203
1204
1205     // win is a control: tab can be propagated up
1206     if ( !ret &&
1207          ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
1208 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here - the control may
1209 //     have this style, yet choose not to process this particular TAB in which
1210 //     case TAB must still work as a navigational character
1211 // JS: enabling again to make consistent with other platforms
1212 //     (with wxTE_PROCESS_TAB you have to call Navigate to get default
1213 //     navigation behaviour)
1214 #if wxUSE_TEXTCTRL
1215          (! (win->HasFlag(wxTE_PROCESS_TAB) && win->IsKindOf(CLASSINFO(wxTextCtrl)) )) &&
1216 #endif
1217          win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1218     {
1219         wxNavigationKeyEvent new_event;
1220         new_event.SetEventObject( win->GetParent() );
1221         // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1222         new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
1223         // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1224         new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
1225         new_event.SetCurrentFocus( win );
1226         ret = win->GetParent()->HandleWindowEvent( new_event );
1227     }
1228
1229     // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
1230     if ( !ret &&
1231          (gdk_event->keyval == GDK_Escape) )
1232     {
1233         // however only do it if we have a Cancel button in the dialog,
1234         // otherwise the user code may get confused by the events from a
1235         // non-existing button and, worse, a wxButton might get button event
1236         // from another button which is not really expected
1237         wxWindow *winForCancel = win,
1238                  *btnCancel = NULL;
1239         while ( winForCancel )
1240         {
1241             btnCancel = winForCancel->FindWindow(wxID_CANCEL);
1242             if ( btnCancel )
1243             {
1244                 // found a cancel button
1245                 break;
1246             }
1247
1248             if ( winForCancel->IsTopLevel() )
1249             {
1250                 // no need to look further
1251                 break;
1252             }
1253
1254             // maybe our parent has a cancel button?
1255             winForCancel = winForCancel->GetParent();
1256         }
1257
1258         if ( btnCancel )
1259         {
1260             wxCommandEvent eventClick(wxEVT_BUTTON, wxID_CANCEL);
1261             eventClick.SetEventObject(btnCancel);
1262             ret = btnCancel->HandleWindowEvent(eventClick);
1263         }
1264     }
1265
1266     if (ret)
1267     {
1268         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
1269         return TRUE;
1270     }
1271
1272     return FALSE;
1273 }
1274 }
1275
1276 //-----------------------------------------------------------------------------
1277 // "key_release_event" from any window
1278 //-----------------------------------------------------------------------------
1279
1280 extern "C" {
1281 static gint gtk_window_key_release_callback( GtkWidget *widget,
1282                                              GdkEventKey *gdk_event,
1283                                              wxWindowGTK *win )
1284 {
1285     DEBUG_MAIN_THREAD
1286
1287     if (g_isIdle)
1288         wxapp_install_idle_handler();
1289
1290     if (!win->m_hasVMT)
1291         return FALSE;
1292
1293     if (g_blockEventsOnDrag)
1294         return FALSE;
1295
1296     wxKeyEvent event( wxEVT_KEY_UP );
1297     if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1298     {
1299         // unknown key pressed, ignore (the event would be useless anyhow)
1300         return FALSE;
1301     }
1302
1303     if ( !win->HandleWindowEvent( event ) )
1304         return FALSE;
1305
1306     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
1307     return TRUE;
1308 }
1309 }
1310
1311 // ============================================================================
1312 // the mouse events
1313 // ============================================================================
1314
1315 // ----------------------------------------------------------------------------
1316 // mouse event processing helpers
1317 // ----------------------------------------------------------------------------
1318
1319 // init wxMouseEvent with the info from GdkEventXXX struct
1320 template<typename T> void InitMouseEvent(wxWindowGTK *win,
1321                                          wxMouseEvent& event,
1322                                          T *gdk_event)
1323 {
1324     event.SetTimestamp( gdk_event->time );
1325     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
1326     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
1327     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
1328     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
1329     event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
1330     event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
1331     event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
1332     if (event.GetEventType() == wxEVT_MOUSEWHEEL)
1333     {
1334        event.m_linesPerAction = 3;
1335        event.m_columnsPerAction = 3;
1336        event.m_wheelDelta = 120;
1337        if (((GdkEventButton*)gdk_event)->button == 4)
1338            event.m_wheelRotation = 120;
1339        else if (((GdkEventButton*)gdk_event)->button == 5)
1340            event.m_wheelRotation = -120;
1341     }
1342
1343     wxPoint pt = win->GetClientAreaOrigin();
1344     event.m_x = (wxCoord)gdk_event->x - pt.x;
1345     event.m_y = (wxCoord)gdk_event->y - pt.y;
1346
1347     event.SetEventObject( win );
1348     event.SetId( win->GetId() );
1349     event.SetTimestamp( gdk_event->time );
1350 }
1351
1352 static void AdjustEventButtonState(wxMouseEvent& event)
1353 {
1354     // GDK reports the old state of the button for a button press event, but
1355     // for compatibility with MSW and common sense we want m_leftDown be true
1356     // for a LEFT_DOWN event, not FALSE, so we will invert
1357     // left/right/middleDown for the corresponding click events
1358
1359     if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1360         (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1361         (event.GetEventType() == wxEVT_LEFT_UP))
1362     {
1363         event.m_leftDown = !event.m_leftDown;
1364         return;
1365     }
1366
1367     if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1368         (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1369         (event.GetEventType() == wxEVT_MIDDLE_UP))
1370     {
1371         event.m_middleDown = !event.m_middleDown;
1372         return;
1373     }
1374
1375     if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1376         (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1377         (event.GetEventType() == wxEVT_RIGHT_UP))
1378     {
1379         event.m_rightDown = !event.m_rightDown;
1380         return;
1381     }
1382 }
1383
1384 // find the window to send the mouse event too
1385 static
1386 wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1387 {
1388     wxCoord xx = x;
1389     wxCoord yy = y;
1390
1391     if (win->m_wxwindow)
1392     {
1393         GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
1394         xx += pizza->xoffset;
1395         yy += pizza->yoffset;
1396     }
1397
1398     wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
1399     while (node)
1400     {
1401         wxWindowGTK *child = node->GetData();
1402
1403         node = node->GetNext();
1404         if (!child->IsShown())
1405             continue;
1406
1407         if (child->IsTransparentForMouse())
1408         {
1409             // wxStaticBox is transparent in the box itself
1410             int xx1 = child->m_x;
1411             int yy1 = child->m_y;
1412             int xx2 = child->m_x + child->m_width;
1413             int yy2 = child->m_y + child->m_height;
1414
1415             // left
1416             if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
1417             // right
1418                 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
1419             // top
1420                 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
1421             // bottom
1422                 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
1423             {
1424                 win = child;
1425                 x -= child->m_x;
1426                 y -= child->m_y;
1427                 break;
1428             }
1429
1430         }
1431         else
1432         {
1433             if ((child->m_wxwindow == NULL) &&
1434                 (child->m_x <= xx) &&
1435                 (child->m_y <= yy) &&
1436                 (child->m_x+child->m_width  >= xx) &&
1437                 (child->m_y+child->m_height >= yy))
1438             {
1439                 win = child;
1440                 x -= child->m_x;
1441                 y -= child->m_y;
1442                 break;
1443             }
1444         }
1445     }
1446
1447     return win;
1448 }
1449
1450 //-----------------------------------------------------------------------------
1451 // "button_press_event"
1452 //-----------------------------------------------------------------------------
1453
1454 extern "C" {
1455 static gint gtk_window_button_press_callback( GtkWidget *widget,
1456                                               GdkEventButton *gdk_event,
1457                                               wxWindowGTK *win )
1458 {
1459     DEBUG_MAIN_THREAD
1460
1461     if (g_isIdle)
1462         wxapp_install_idle_handler();
1463
1464 /*
1465     wxPrintf( wxT("1) OnButtonPress from ") );
1466     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1467         wxPrintf( win->GetClassInfo()->GetClassName() );
1468     wxPrintf( wxT(".\n") );
1469 */
1470     if (!win->m_hasVMT) return FALSE;
1471     if (g_blockEventsOnDrag) return TRUE;
1472     if (g_blockEventsOnScroll) return TRUE;
1473
1474     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1475
1476     g_lastButtonNumber = gdk_event->button;
1477
1478     if (win->m_wxwindow && (g_focusWindow != win) && win->IsFocusable())
1479     {
1480         gtk_widget_grab_focus( win->m_wxwindow );
1481 /*
1482         wxPrintf( wxT("GrabFocus from ") );
1483         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1484             wxPrintf( win->GetClassInfo()->GetClassName() );
1485         wxPrintf( wxT(".\n") );
1486 */
1487     }
1488
1489     // GDK sends surplus button down events
1490     // before a double click event. We
1491     // need to filter these out.
1492     if (gdk_event->type == GDK_BUTTON_PRESS)
1493     {
1494         GdkEvent *peek_event = gdk_event_peek();
1495         if (peek_event)
1496         {
1497             if ((peek_event->type == GDK_2BUTTON_PRESS) ||
1498                 (peek_event->type == GDK_3BUTTON_PRESS))
1499             {
1500                 gdk_event_free( peek_event );
1501                 return TRUE;
1502             }
1503             else
1504             {
1505                 gdk_event_free( peek_event );
1506             }
1507         }
1508     }
1509
1510     wxEventType event_type = wxEVT_NULL;
1511
1512     if (gdk_event->button == 1)
1513     {
1514         // note that GDK generates triple click events which are not supported
1515         // by wxWidgets but still have to be passed to the app as otherwise
1516         // clicks would simply go missing
1517         switch (gdk_event->type)
1518         {
1519             // we shouldn't get triple clicks at all for GTK2 because we
1520             // suppress them artificially using the code above but we still
1521             // should map them to something for GTK1 and not just ignore them
1522             // as this would lose clicks
1523             case GDK_3BUTTON_PRESS:     // we could also map this to DCLICK...
1524             case GDK_BUTTON_PRESS:
1525                 event_type = wxEVT_LEFT_DOWN;
1526                 break;
1527
1528             case GDK_2BUTTON_PRESS:
1529                 event_type = wxEVT_LEFT_DCLICK;
1530                 break;
1531
1532             default:
1533                 // just to silence gcc warnings
1534                 ;
1535         }
1536     }
1537     else if (gdk_event->button == 2)
1538     {
1539         switch (gdk_event->type)
1540         {
1541             case GDK_3BUTTON_PRESS:
1542             case GDK_BUTTON_PRESS:
1543                 event_type = wxEVT_MIDDLE_DOWN;
1544                 break;
1545
1546             case GDK_2BUTTON_PRESS:
1547                 event_type = wxEVT_MIDDLE_DCLICK;
1548                 break;
1549
1550             default:
1551                 ;
1552         }
1553     }
1554     else if (gdk_event->button == 3)
1555     {
1556         switch (gdk_event->type)
1557         {
1558             case GDK_3BUTTON_PRESS:
1559             case GDK_BUTTON_PRESS:
1560                 event_type = wxEVT_RIGHT_DOWN;
1561                 break;
1562
1563             case GDK_2BUTTON_PRESS:
1564                 event_type = wxEVT_RIGHT_DCLICK;
1565                 break;
1566
1567             default:
1568                 ;
1569         }
1570     }
1571     else if (gdk_event->button == 4 || gdk_event->button == 5)
1572     {
1573         if (gdk_event->type == GDK_BUTTON_PRESS )
1574         {
1575             event_type = wxEVT_MOUSEWHEEL;
1576         }
1577     }
1578
1579     if ( event_type == wxEVT_NULL )
1580     {
1581         // unknown mouse button or click type
1582         return FALSE;
1583     }
1584
1585     g_lastMouseEvent = (GdkEvent*) gdk_event;
1586
1587     wxMouseEvent event( event_type );
1588     InitMouseEvent( win, event, gdk_event );
1589
1590     AdjustEventButtonState(event);
1591
1592     // wxListBox actually gets mouse events from the item, so we need to give it
1593     // a chance to correct this
1594     win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1595
1596     // find the correct window to send the event to: it may be a different one
1597     // from the one which got it at GTK+ level because some controls don't have
1598     // their own X window and thus cannot get any events.
1599     if ( !g_captureWindow )
1600         win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1601
1602     wxGtkTimeLastClick = gdk_event->time;
1603
1604     if (event_type == wxEVT_LEFT_DCLICK)
1605     {
1606         // GTK 1.2 crashes when intercepting double
1607         // click events from both wxSpinButton and
1608         // wxSpinCtrl
1609         if (GTK_IS_SPIN_BUTTON(win->m_widget))
1610         {
1611             // Just disable this event for now.
1612             return FALSE;
1613         }
1614     }
1615
1616     if (win->HandleWindowEvent( event ))
1617     {
1618         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
1619         g_lastMouseEvent = NULL;
1620         return TRUE;
1621     }
1622     g_lastMouseEvent = NULL;
1623
1624     if (event_type == wxEVT_RIGHT_DOWN)
1625     {
1626         // generate a "context menu" event: this is similar to right mouse
1627         // click under many GUIs except that it is generated differently
1628         // (right up under MSW, ctrl-click under Mac, right down here) and
1629         //
1630         // (a) it's a command event and so is propagated to the parent
1631         // (b) under some ports it can be generated from kbd too
1632         // (c) it uses screen coords (because of (a))
1633         wxContextMenuEvent evtCtx(
1634             wxEVT_CONTEXT_MENU,
1635             win->GetId(),
1636             win->ClientToScreen(event.GetPosition()));
1637         evtCtx.SetEventObject(win);
1638         return win->HandleWindowEvent(evtCtx);
1639     }
1640
1641     return FALSE;
1642 }
1643 }
1644
1645 //-----------------------------------------------------------------------------
1646 // "button_release_event"
1647 //-----------------------------------------------------------------------------
1648
1649 extern "C" {
1650 static gint gtk_window_button_release_callback( GtkWidget *widget,
1651                                                 GdkEventButton *gdk_event,
1652                                                 wxWindowGTK *win )
1653 {
1654     DEBUG_MAIN_THREAD
1655
1656     if (g_isIdle)
1657         wxapp_install_idle_handler();
1658
1659     if (!win->m_hasVMT) return FALSE;
1660     if (g_blockEventsOnDrag) return FALSE;
1661     if (g_blockEventsOnScroll) return FALSE;
1662
1663     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1664
1665     g_lastButtonNumber = 0;
1666
1667     wxEventType event_type = wxEVT_NULL;
1668
1669     switch (gdk_event->button)
1670     {
1671         case 1:
1672             event_type = wxEVT_LEFT_UP;
1673             break;
1674
1675         case 2:
1676             event_type = wxEVT_MIDDLE_UP;
1677             break;
1678
1679         case 3:
1680             event_type = wxEVT_RIGHT_UP;
1681             break;
1682
1683         default:
1684             // unknown button, don't process
1685             return FALSE;
1686     }
1687
1688     g_lastMouseEvent = (GdkEvent*) gdk_event;
1689
1690     wxMouseEvent event( event_type );
1691     InitMouseEvent( win, event, gdk_event );
1692
1693     AdjustEventButtonState(event);
1694
1695     // same wxListBox hack as above
1696     win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1697
1698     if ( !g_captureWindow )
1699         win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1700
1701     if (win->HandleWindowEvent( event ))
1702     {
1703         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
1704         return TRUE;
1705     }
1706
1707     return FALSE;
1708 }
1709 }
1710
1711 //-----------------------------------------------------------------------------
1712 // "motion_notify_event"
1713 //-----------------------------------------------------------------------------
1714
1715 extern "C" {
1716 static gint gtk_window_motion_notify_callback( GtkWidget *widget,
1717                                                GdkEventMotion *gdk_event,
1718                                                wxWindowGTK *win )
1719 {
1720     DEBUG_MAIN_THREAD
1721
1722     if (g_isIdle)
1723         wxapp_install_idle_handler();
1724
1725     if (!win->m_hasVMT) return FALSE;
1726     if (g_blockEventsOnDrag) return FALSE;
1727     if (g_blockEventsOnScroll) return FALSE;
1728
1729     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1730
1731     if (gdk_event->is_hint)
1732     {
1733         int x = 0;
1734         int y = 0;
1735         GdkModifierType state;
1736         gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1737         gdk_event->x = x;
1738         gdk_event->y = y;
1739     }
1740
1741     g_lastMouseEvent = (GdkEvent*) gdk_event;
1742
1743 /*
1744     printf( "OnMotion from " );
1745     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1746       printf( win->GetClassInfo()->GetClassName() );
1747     printf( ".\n" );
1748 */
1749
1750     wxMouseEvent event( wxEVT_MOTION );
1751     InitMouseEvent(win, event, gdk_event);
1752
1753     if ( g_captureWindow )
1754     {
1755         // synthetize a mouse enter or leave event if needed
1756         GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
1757         // This seems to be necessary and actually been added to
1758         // GDK itself in version 2.0.X
1759         gdk_flush();
1760
1761         bool hasMouse = winUnderMouse == gdk_event->window;
1762         if ( hasMouse != g_captureWindowHasMouse )
1763         {
1764             // the mouse changed window
1765             g_captureWindowHasMouse = hasMouse;
1766
1767             wxMouseEvent eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1768                                                         : wxEVT_LEAVE_WINDOW);
1769             InitMouseEvent(win, eventM, gdk_event);
1770             eventM.SetEventObject(win);
1771             win->HandleWindowEvent(eventM);
1772         }
1773     }
1774     else // no capture
1775     {
1776         win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1777     }
1778
1779     bool ret = win->HandleWindowEvent( event );
1780     g_lastMouseEvent = NULL;
1781
1782     if ( ret )
1783     {
1784         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
1785     }
1786
1787     return ret ? TRUE : FALSE;
1788 }
1789 }
1790
1791 //-----------------------------------------------------------------------------
1792 // "focus_in_event"
1793 //-----------------------------------------------------------------------------
1794
1795 // send the wxChildFocusEvent and wxFocusEvent, common code of
1796 // gtk_window_focus_in_callback() and SetFocus()
1797 static bool DoSendFocusEvents(wxWindow *win)
1798 {
1799     // Notify the parent keeping track of focus for the kbd navigation
1800     // purposes that we got it.
1801     wxChildFocusEvent eventChildFocus(win);
1802     (void)win->HandleWindowEvent(eventChildFocus);
1803
1804     wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
1805     eventFocus.SetEventObject(win);
1806
1807     return win->HandleWindowEvent(eventFocus);
1808 }
1809
1810 extern "C" {
1811 static gint gtk_window_focus_in_callback( GtkWidget *widget,
1812                                           GdkEvent *WXUNUSED(event),
1813                                           wxWindow *win )
1814 {
1815     DEBUG_MAIN_THREAD
1816
1817     if (g_isIdle)
1818         wxapp_install_idle_handler();
1819
1820     g_focusWindowLast =
1821     g_focusWindow = win;
1822
1823     wxLogTrace(TRACE_FOCUS,
1824                wxT("%s: focus in"), win->GetName().c_str());
1825
1826 #ifdef HAVE_XIM
1827     if (win->m_ic)
1828         gdk_im_begin(win->m_ic, win->m_wxwindow->window);
1829 #endif
1830
1831 #if wxUSE_CARET
1832     // caret needs to be informed about focus change
1833     wxCaret *caret = win->GetCaret();
1834     if ( caret )
1835     {
1836         caret->OnSetFocus();
1837     }
1838 #endif // wxUSE_CARET
1839
1840     // does the window itself think that it has the focus?
1841     if ( !win->m_hasFocus )
1842     {
1843         // not yet, notify it
1844         win->m_hasFocus = true;
1845
1846         if ( DoSendFocusEvents(win) )
1847         {
1848            gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
1849            return TRUE;
1850         }
1851     }
1852
1853     return FALSE;
1854 }
1855 }
1856
1857 //-----------------------------------------------------------------------------
1858 // "focus_out_event"
1859 //-----------------------------------------------------------------------------
1860
1861 extern "C" {
1862 static gint gtk_window_focus_out_callback( GtkWidget *WXUNUSED(widget),
1863                                            GdkEventFocus *WXUNUSED(gdk_event),
1864                                            wxWindowGTK *win )
1865 {
1866     DEBUG_MAIN_THREAD
1867
1868     if (g_isIdle)
1869         wxapp_install_idle_handler();
1870
1871     wxLogTrace( TRACE_FOCUS,
1872                 wxT("%s: focus out"), win->GetName().c_str() );
1873
1874
1875     wxWindowGTK *winFocus = wxFindFocusedChild(win);
1876     if ( winFocus )
1877         win = winFocus;
1878
1879     g_focusWindow = NULL;
1880
1881 #ifdef HAVE_XIM
1882     if (win->m_ic)
1883         gdk_im_end();
1884 #endif
1885
1886 #if wxUSE_CARET
1887     // caret needs to be informed about focus change
1888     wxCaret *caret = win->GetCaret();
1889     if ( caret )
1890     {
1891         caret->OnKillFocus();
1892     }
1893 #endif // wxUSE_CARET
1894
1895     // don't send the window a kill focus event if it thinks that it doesn't
1896     // have focus already
1897     if ( win->m_hasFocus )
1898     {
1899         win->m_hasFocus = false;
1900
1901         wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
1902         event.SetEventObject( win );
1903
1904         // even if we did process the event in wx code, still let GTK itself
1905         // process it too as otherwise bad things happen, especially in GTK2
1906         // where the text control simply aborts the program if it doesn't get
1907         // the matching focus out event
1908         (void)win->HandleWindowEvent( event );
1909     }
1910
1911     return FALSE;
1912 }
1913 }
1914
1915 //-----------------------------------------------------------------------------
1916 // "enter_notify_event"
1917 //-----------------------------------------------------------------------------
1918
1919 extern "C" {
1920 static
1921 gint gtk_window_enter_callback( GtkWidget *widget,
1922                                 GdkEventCrossing *gdk_event,
1923                                 wxWindowGTK *win )
1924 {
1925     DEBUG_MAIN_THREAD
1926
1927     if (g_isIdle)
1928         wxapp_install_idle_handler();
1929
1930     if (!win->m_hasVMT) return FALSE;
1931     if (g_blockEventsOnDrag) return FALSE;
1932
1933     // Event was emitted after a grab
1934     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1935
1936     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1937
1938     int x = 0;
1939     int y = 0;
1940     GdkModifierType state = (GdkModifierType)0;
1941
1942     gdk_window_get_pointer( widget->window, &x, &y, &state );
1943
1944     wxMouseEvent event( wxEVT_ENTER_WINDOW );
1945     InitMouseEvent(win, event, gdk_event);
1946     wxPoint pt = win->GetClientAreaOrigin();
1947     event.m_x = x + pt.x;
1948     event.m_y = y + pt.y;
1949
1950     if (win->HandleWindowEvent( event ))
1951     {
1952        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
1953        return TRUE;
1954     }
1955
1956     return FALSE;
1957 }
1958 }
1959
1960 //-----------------------------------------------------------------------------
1961 // "leave_notify_event"
1962 //-----------------------------------------------------------------------------
1963
1964 extern "C" {
1965 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
1966 {
1967     DEBUG_MAIN_THREAD
1968
1969     if (g_isIdle)
1970         wxapp_install_idle_handler();
1971
1972     if (!win->m_hasVMT) return FALSE;
1973     if (g_blockEventsOnDrag) return FALSE;
1974
1975     // Event was emitted after an ungrab
1976     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1977
1978     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1979
1980     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1981     event.SetTimestamp( gdk_event->time );
1982     event.SetEventObject( win );
1983
1984     int x = 0;
1985     int y = 0;
1986     GdkModifierType state = (GdkModifierType)0;
1987
1988     gdk_window_get_pointer( widget->window, &x, &y, &state );
1989
1990     event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
1991     event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
1992     event.m_altDown = (state & GDK_MOD1_MASK) != 0;
1993     event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
1994     event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
1995     event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
1996     event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
1997
1998     wxPoint pt = win->GetClientAreaOrigin();
1999     event.m_x = x + pt.x;
2000     event.m_y = y + pt.y;
2001
2002     if (win->HandleWindowEvent( event ))
2003     {
2004         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
2005         return TRUE;
2006     }
2007
2008     return FALSE;
2009 }
2010 }
2011
2012 //-----------------------------------------------------------------------------
2013 // "value_changed" from m_vAdjust
2014 //-----------------------------------------------------------------------------
2015
2016 extern "C" {
2017 static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
2018                                          SCROLLBAR_CBACK_ARG
2019                                          wxWindowGTK *win )
2020 {
2021     DEBUG_MAIN_THREAD
2022
2023     if (g_isIdle)
2024         wxapp_install_idle_handler();
2025
2026     if (g_blockEventsOnDrag) return;
2027
2028     if (!win->m_hasVMT) return;
2029
2030     float diff = adjust->value - win->m_oldVerticalPos;
2031     if (fabs(diff) < 0.2) return;
2032
2033     win->m_oldVerticalPos = adjust->value;
2034
2035     GtkScrolledWindow   *sw = GTK_SCROLLED_WINDOW(win->m_widget);
2036     wxEventType         command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->vscrollbar));
2037
2038     int value = (int)(adjust->value+0.5);
2039
2040     wxScrollWinEvent event( command, value, wxVERTICAL );
2041     event.SetEventObject( win );
2042     win->HandleWindowEvent( event );
2043 }
2044 }
2045
2046 //-----------------------------------------------------------------------------
2047 // "value_changed" from m_hAdjust
2048 //-----------------------------------------------------------------------------
2049
2050 extern "C" {
2051 static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
2052                                          SCROLLBAR_CBACK_ARG
2053                                          wxWindowGTK *win )
2054 {
2055     DEBUG_MAIN_THREAD
2056
2057     if (g_isIdle)
2058         wxapp_install_idle_handler();
2059
2060     if (g_blockEventsOnDrag) return;
2061     if (!win->m_hasVMT) return;
2062
2063     float diff = adjust->value - win->m_oldHorizontalPos;
2064     if (fabs(diff) < 0.2) return;
2065
2066     GtkScrolledWindow   *sw = GTK_SCROLLED_WINDOW(win->m_widget);
2067     wxEventType         command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->hscrollbar));
2068
2069     win->m_oldHorizontalPos = adjust->value;
2070
2071     int value = (int)(adjust->value+0.5);
2072
2073     wxScrollWinEvent event( command, value, wxHORIZONTAL );
2074     event.SetEventObject( win );
2075     win->HandleWindowEvent( event );
2076 }
2077 }
2078
2079 //-----------------------------------------------------------------------------
2080 // "button_press_event" from scrollbar
2081 //-----------------------------------------------------------------------------
2082
2083 extern "C" {
2084 static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
2085                                                  GdkEventButton *gdk_event,
2086                                                  wxWindowGTK *win)
2087 {
2088     DEBUG_MAIN_THREAD
2089
2090     if (g_isIdle)
2091         wxapp_install_idle_handler();
2092
2093
2094     g_blockEventsOnScroll = true;
2095
2096     // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2097     win->m_isScrolling = (gdk_event->window == widget->slider);
2098
2099     return FALSE;
2100 }
2101 }
2102
2103 //-----------------------------------------------------------------------------
2104 // "button_release_event" from scrollbar
2105 //-----------------------------------------------------------------------------
2106
2107 extern "C" {
2108 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
2109                                                    GdkEventButton *WXUNUSED(gdk_event),
2110                                                    wxWindowGTK *win)
2111 {
2112     DEBUG_MAIN_THREAD
2113
2114 //  don't test here as we can release the mouse while being over
2115 //  a different window than the slider
2116 //
2117 //    if (gdk_event->window != widget->slider) return FALSE;
2118
2119     g_blockEventsOnScroll = false;
2120
2121     if (win->m_isScrolling)
2122     {
2123         wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
2124         int value = -1;
2125         int dir = -1;
2126
2127         GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
2128         if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
2129         {
2130             value = (int)(win->m_hAdjust->value+0.5);
2131             dir = wxHORIZONTAL;
2132         }
2133         if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
2134         {
2135             value = (int)(win->m_vAdjust->value+0.5);
2136             dir = wxVERTICAL;
2137         }
2138
2139         wxScrollWinEvent event( command, value, dir );
2140         event.SetEventObject( win );
2141         win->HandleWindowEvent( event );
2142     }
2143
2144     win->m_isScrolling = false;
2145
2146     return FALSE;
2147 }
2148 }
2149
2150 // ----------------------------------------------------------------------------
2151 // this wxWindowBase function is implemented here (in platform-specific file)
2152 // because it is static and so couldn't be made virtual
2153 // ----------------------------------------------------------------------------
2154
2155 wxWindow *wxWindowBase::DoFindFocus()
2156 {
2157     // the cast is necessary when we compile in wxUniversal mode
2158     return (wxWindow *)g_focusWindow;
2159 }
2160
2161 //-----------------------------------------------------------------------------
2162 // "realize" from m_widget
2163 //-----------------------------------------------------------------------------
2164
2165 /* We cannot set colours and fonts before the widget has
2166    been realized, so we do this directly after realization. */
2167
2168 extern "C" {
2169 static gint
2170 gtk_window_realized_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
2171 {
2172     DEBUG_MAIN_THREAD
2173
2174     if (g_isIdle)
2175         wxapp_install_idle_handler();
2176
2177     wxWindowCreateEvent event( win );
2178     event.SetEventObject( win );
2179     win->HandleWindowEvent( event );
2180
2181     return FALSE;
2182 }
2183 }
2184
2185 //-----------------------------------------------------------------------------
2186 // "size_allocate"
2187 //-----------------------------------------------------------------------------
2188
2189 extern "C" {
2190 static
2191 void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2192                                GtkAllocation *WXUNUSED(alloc),
2193                                wxWindow *win )
2194 {
2195     if (g_isIdle)
2196         wxapp_install_idle_handler();
2197
2198     if (!win->m_hasScrolling) return;
2199
2200     int client_width = 0;
2201     int client_height = 0;
2202     win->GetClientSize( &client_width, &client_height );
2203     if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2204         return;
2205
2206     win->m_oldClientWidth = client_width;
2207     win->m_oldClientHeight = client_height;
2208
2209     if (!win->m_nativeSizeEvent)
2210     {
2211         wxSizeEvent event( win->GetSize(), win->GetId() );
2212         event.SetEventObject( win );
2213         win->HandleWindowEvent( event );
2214     }
2215 }
2216 }
2217
2218
2219 #ifdef HAVE_XIM
2220     #define WXUNUSED_UNLESS_XIM(param)  param
2221 #else
2222     #define WXUNUSED_UNLESS_XIM(param)  WXUNUSED(param)
2223 #endif
2224
2225 /* Resize XIM window */
2226
2227 extern "C" {
2228 static
2229 void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
2230                                  GtkAllocation* WXUNUSED(alloc),
2231                                  wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
2232 {
2233     if (g_isIdle)
2234         wxapp_install_idle_handler();
2235
2236 #ifdef HAVE_XIM
2237     if (!win->m_ic)
2238         return;
2239
2240     if  (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
2241     {
2242         gint width, height;
2243
2244         gdk_window_get_size (widget->window, &width, &height);
2245         win->m_icattr->preedit_area.width = width;
2246         win->m_icattr->preedit_area.height = height;
2247         gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
2248     }
2249 #endif // HAVE_XIM
2250 }
2251 }
2252
2253 //-----------------------------------------------------------------------------
2254 // "realize" from m_wxwindow
2255 //-----------------------------------------------------------------------------
2256
2257 /* Initialize XIM support */
2258
2259 extern "C" {
2260 static gint
2261 gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
2262                                 wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
2263 {
2264     if (g_isIdle)
2265         wxapp_install_idle_handler();
2266
2267 #ifdef HAVE_XIM
2268     if (win->m_ic) return FALSE;
2269     if (!widget) return FALSE;
2270     if (!gdk_im_ready()) return FALSE;
2271
2272     win->m_icattr = gdk_ic_attr_new();
2273     if (!win->m_icattr) return FALSE;
2274
2275     gint width, height;
2276     GdkEventMask mask;
2277     GdkColormap *colormap;
2278     GdkICAttr *attr = win->m_icattr;
2279     unsigned attrmask = GDK_IC_ALL_REQ;
2280     GdkIMStyle style;
2281     GdkIMStyle supported_style = (GdkIMStyle)
2282                                   (GDK_IM_PREEDIT_NONE |
2283                                    GDK_IM_PREEDIT_NOTHING |
2284                                    GDK_IM_PREEDIT_POSITION |
2285                                    GDK_IM_STATUS_NONE |
2286                                    GDK_IM_STATUS_NOTHING);
2287
2288     if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2289         supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
2290
2291     attr->style = style = gdk_im_decide_style (supported_style);
2292     attr->client_window = widget->window;
2293
2294     if ((colormap = gtk_widget_get_colormap (widget)) !=
2295             gtk_widget_get_default_colormap ())
2296     {
2297         attrmask |= GDK_IC_PREEDIT_COLORMAP;
2298         attr->preedit_colormap = colormap;
2299     }
2300
2301     attrmask |= GDK_IC_PREEDIT_FOREGROUND;
2302     attrmask |= GDK_IC_PREEDIT_BACKGROUND;
2303     attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
2304     attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
2305
2306     switch (style & GDK_IM_PREEDIT_MASK)
2307     {
2308         case GDK_IM_PREEDIT_POSITION:
2309             if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2310             {
2311                 g_warning ("over-the-spot style requires fontset");
2312                 break;
2313             }
2314
2315             gdk_window_get_size (widget->window, &width, &height);
2316
2317             attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
2318             attr->spot_location.x = 0;
2319             attr->spot_location.y = height;
2320             attr->preedit_area.x = 0;
2321             attr->preedit_area.y = 0;
2322             attr->preedit_area.width = width;
2323             attr->preedit_area.height = height;
2324             attr->preedit_fontset = widget->style->font;
2325
2326             break;
2327     }
2328
2329       win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
2330
2331       if (win->m_ic == NULL)
2332           g_warning ("Can't create input context.");
2333       else
2334       {
2335           mask = gdk_window_get_events (widget->window);
2336           mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
2337           gdk_window_set_events (widget->window, mask);
2338
2339           if (GTK_WIDGET_HAS_FOCUS(widget))
2340               gdk_im_begin (win->m_ic, widget->window);
2341       }
2342 #endif // HAVE_XIM
2343
2344     return FALSE;
2345 }
2346 }
2347
2348 //-----------------------------------------------------------------------------
2349 // InsertChild for wxWindowGTK.
2350 //-----------------------------------------------------------------------------
2351
2352 /* Callback for wxWindowGTK. This very strange beast has to be used because
2353  * C++ has no virtual methods in a constructor. We have to emulate a
2354  * virtual function here as wxNotebook requires a different way to insert
2355  * a child in it. I had opted for creating a wxNotebookPage window class
2356  * which would have made this superfluous (such in the MDI window system),
2357  * but no-one was listening to me... */
2358
2359 static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
2360 {
2361     /* the window might have been scrolled already, do we
2362        have to adapt the position */
2363     GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2364     child->m_x += pizza->xoffset;
2365     child->m_y += pizza->yoffset;
2366
2367     gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
2368                      GTK_WIDGET(child->m_widget),
2369                      child->m_x,
2370                      child->m_y,
2371                      child->m_width,
2372                      child->m_height );
2373 }
2374
2375 //-----------------------------------------------------------------------------
2376 // global functions
2377 //-----------------------------------------------------------------------------
2378
2379 wxWindow *wxGetActiveWindow()
2380 {
2381     return wxWindow::FindFocus();
2382 }
2383
2384
2385 wxMouseState wxGetMouseState()
2386 {
2387     wxMouseState ms;
2388
2389     gint x;
2390     gint y;
2391     GdkModifierType mask;
2392
2393     gdk_window_get_pointer(NULL, &x, &y, &mask);
2394
2395     ms.SetX(x);
2396     ms.SetY(y);
2397     ms.SetLeftDown(mask & GDK_BUTTON1_MASK);
2398     ms.SetMiddleDown(mask & GDK_BUTTON2_MASK);
2399     ms.SetRightDown(mask & GDK_BUTTON3_MASK);
2400
2401     ms.SetControlDown(mask & GDK_CONTROL_MASK);
2402     ms.SetShiftDown(mask & GDK_SHIFT_MASK);
2403     ms.SetAltDown(mask & GDK_MOD1_MASK);
2404     ms.SetMetaDown(mask & GDK_MOD2_MASK);
2405
2406     return ms;
2407 }
2408
2409 //-----------------------------------------------------------------------------
2410 // wxWindowGTK
2411 //-----------------------------------------------------------------------------
2412
2413 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2414 // method
2415 #ifdef __WXUNIVERSAL__
2416     IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2417 #endif // __WXUNIVERSAL__
2418
2419 void wxWindowGTK::Init()
2420 {
2421     // GTK specific
2422     m_widget = NULL;
2423     m_wxwindow = NULL;
2424     m_focusWidget = NULL;
2425
2426     // position/size
2427     m_x = 0;
2428     m_y = 0;
2429     m_width = 0;
2430     m_height = 0;
2431
2432     m_sizeSet = false;
2433     m_hasVMT = false;
2434     m_needParent = true;
2435
2436     m_noExpose = false;
2437     m_nativeSizeEvent = false;
2438
2439     m_hasScrolling = false;
2440     m_isScrolling = false;
2441
2442     m_hAdjust = NULL;
2443     m_vAdjust = NULL;
2444     m_oldHorizontalPos =
2445     m_oldVerticalPos = 0.0;
2446     m_oldClientWidth =
2447     m_oldClientHeight = 0;
2448
2449     m_resizing = false;
2450
2451     m_insertCallback = (wxInsertChildFunction) NULL;
2452
2453     m_acceptsFocus = false;
2454     m_hasFocus = false;
2455
2456     m_clipPaintRegion = false;
2457
2458     m_needsStyleChange = false;
2459
2460     m_cursor = *wxSTANDARD_CURSOR;
2461
2462 #ifdef HAVE_XIM
2463     m_ic = NULL;
2464     m_icattr = NULL;
2465 #endif
2466 }
2467
2468 wxWindowGTK::wxWindowGTK()
2469 {
2470     Init();
2471 }
2472
2473 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2474                           wxWindowID id,
2475                           const wxPoint &pos,
2476                           const wxSize &size,
2477                           long style,
2478                           const wxString &name  )
2479 {
2480     Init();
2481
2482     Create( parent, id, pos, size, style, name );
2483 }
2484
2485 bool wxWindowGTK::Create( wxWindow *parent,
2486                           wxWindowID id,
2487                           const wxPoint &pos,
2488                           const wxSize &size,
2489                           long style,
2490                           const wxString &name  )
2491 {
2492     // Get default border
2493     wxBorder border = GetBorder(style);
2494     style &= ~wxBORDER_MASK;
2495     style |= border;
2496
2497     if (!PreCreation( parent, pos, size ) ||
2498         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2499     {
2500         wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2501         return false;
2502     }
2503
2504     m_insertCallback = wxInsertChildInWindow;
2505
2506     m_widget = gtk_scrolled_window_new( NULL, NULL );
2507     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
2508
2509     GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2510
2511     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2512     scroll_class->scrollbar_spacing = 0;
2513
2514     gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2515
2516     m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
2517     m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
2518
2519     m_wxwindow = gtk_pizza_new();
2520
2521 #ifndef __WXUNIVERSAL__
2522     GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2523
2524     if (HasFlag(wxRAISED_BORDER))
2525     {
2526         gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
2527     }
2528     else if (HasFlag(wxSUNKEN_BORDER) || HasFlag(wxBORDER_THEME))
2529     {
2530         gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
2531     }
2532     else if (HasFlag(wxSIMPLE_BORDER))
2533     {
2534         gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
2535     }
2536     else
2537     {
2538         gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
2539     }
2540 #endif // __WXUNIVERSAL__
2541
2542     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2543
2544     GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
2545     m_acceptsFocus = true;
2546
2547     // I _really_ don't want scrollbars in the beginning
2548     m_vAdjust->lower = 0.0;
2549     m_vAdjust->upper = 1.0;
2550     m_vAdjust->value = 0.0;
2551     m_vAdjust->step_increment = 1.0;
2552     m_vAdjust->page_increment = 1.0;
2553     m_vAdjust->page_size = 5.0;
2554     gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2555     m_hAdjust->lower = 0.0;
2556     m_hAdjust->upper = 1.0;
2557     m_hAdjust->value = 0.0;
2558     m_hAdjust->step_increment = 1.0;
2559     m_hAdjust->page_increment = 1.0;
2560     m_hAdjust->page_size = 5.0;
2561     gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2562
2563     // these handlers block mouse events to any window during scrolling such as
2564     // motion events and prevent GTK and wxWidgets from fighting over where the
2565     // slider should be
2566
2567     gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
2568           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2569
2570     gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
2571           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2572
2573     gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
2574           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2575
2576     gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
2577           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2578
2579     // these handlers get notified when screen updates are required either when
2580     // scrolling or when the window size (and therefore scrollbar configuration)
2581     // has changed
2582
2583     gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2584           (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2585     gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2586           (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2587
2588     gtk_widget_show( m_wxwindow );
2589
2590     if (m_parent)
2591         m_parent->DoAddChild( this );
2592
2593     m_focusWidget = m_wxwindow;
2594
2595     PostCreation();
2596
2597     return true;
2598 }
2599
2600 wxWindowGTK::~wxWindowGTK()
2601 {
2602     SendDestroyEvent();
2603
2604     if (g_focusWindow == this)
2605         g_focusWindow = NULL;
2606
2607     if ( g_delayedFocus == this )
2608         g_delayedFocus = NULL;
2609
2610     m_hasVMT = false;
2611
2612     // destroy children before destroying this window itself
2613     DestroyChildren();
2614
2615     // unhook focus handlers to prevent stray events being
2616     // propagated to this (soon to be) dead object
2617     if (m_focusWidget != NULL)
2618     {
2619         gtk_signal_disconnect_by_func( GTK_OBJECT(m_focusWidget),
2620             (GtkSignalFunc) gtk_window_focus_in_callback, (gpointer) this );
2621         gtk_signal_disconnect_by_func( GTK_OBJECT(m_focusWidget),
2622             (GtkSignalFunc) gtk_window_focus_out_callback, (gpointer) this );
2623     }
2624
2625     if (m_widget)
2626         Show( false );
2627
2628 #ifdef HAVE_XIM
2629     if (m_ic)
2630         gdk_ic_destroy (m_ic);
2631     if (m_icattr)
2632         gdk_ic_attr_destroy (m_icattr);
2633 #endif
2634
2635     if (m_wxwindow)
2636     {
2637         gtk_widget_destroy( m_wxwindow );
2638         m_wxwindow = NULL;
2639     }
2640
2641     if (m_widget)
2642     {
2643         gtk_widget_destroy( m_widget );
2644         m_widget = NULL;
2645     }
2646 }
2647
2648 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos,  const wxSize &size )
2649 {
2650     wxCHECK_MSG( !m_needParent || parent, false, wxT("Need complete parent.") );
2651
2652     // Use either the given size, or the default if -1 is given.
2653     // See wxWindowBase for these functions.
2654     m_width = WidthDefault(size.x) ;
2655     m_height = HeightDefault(size.y);
2656
2657     m_x = (int)pos.x;
2658     m_y = (int)pos.y;
2659
2660     return true;
2661 }
2662
2663 void wxWindowGTK::PostCreation()
2664 {
2665     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2666
2667     if (m_wxwindow)
2668     {
2669         if (!m_noExpose)
2670         {
2671             // these get reported to wxWidgets -> wxPaintEvent
2672
2673             gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2674
2675             gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2676                 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2677
2678             gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2679                 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
2680
2681             if (!HasFlag(wxFULL_REPAINT_ON_RESIZE))
2682             {
2683                 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2684                     GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2685             }
2686         }
2687
2688         // these are called when the "sunken" or "raised" borders are drawn
2689         gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2690           GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2691
2692         gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2693           GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
2694     }
2695
2696     // focus handling
2697
2698     if (!GTK_IS_WINDOW(m_widget))
2699     {
2700         if (m_focusWidget == NULL)
2701             m_focusWidget = m_widget;
2702
2703         gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2704             GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2705
2706         gtk_signal_connect_after( GTK_OBJECT(m_focusWidget), "focus_out_event",
2707             GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2708     }
2709
2710     // connect to the various key and mouse handlers
2711
2712     GtkWidget *connect_widget = GetConnectWidget();
2713
2714     ConnectWidget( connect_widget );
2715
2716     /* We cannot set colours, fonts and cursors before the widget has
2717        been realized, so we do this directly after realization */
2718     gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
2719                             GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2720
2721     if (m_wxwindow)
2722     {
2723         // Catch native resize events
2724         gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2725                             GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2726
2727         // Initialize XIM support
2728         gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2729                             GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
2730
2731         // And resize XIM window
2732         gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2733                             GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
2734     }
2735
2736     if (GTK_IS_COMBO(m_widget))
2737     {
2738         GtkCombo *gcombo = GTK_COMBO(m_widget);
2739
2740         gtk_signal_connect( GTK_OBJECT(gcombo->entry), "size_request",
2741                             GTK_SIGNAL_FUNC(wxgtk_combo_size_request_callback),
2742                             (gpointer) this );
2743     }
2744     else
2745     {
2746         // This is needed if we want to add our windows into native
2747         // GTK controls, such as the toolbar. With this callback, the
2748         // toolbar gets to know the correct size (the one set by the
2749         // programmer). Sadly, it misbehaves for wxComboBox.
2750         gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
2751                             GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback),
2752                             (gpointer) this );
2753     }
2754
2755     InheritAttributes();
2756
2757     m_hasVMT = true;
2758
2759     // unless the window was created initially hidden (i.e. Hide() had been
2760     // called before Create()), we should show it at GTK+ level as well
2761     if ( IsShown() )
2762         gtk_widget_show( m_widget );
2763 }
2764
2765 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2766 {
2767     gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2768       GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
2769
2770     gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2771       GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2772
2773     gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2774       GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
2775
2776     gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2777       GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
2778
2779     gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2780       GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
2781
2782     gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2783       GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
2784
2785     gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2786       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
2787 }
2788
2789 bool wxWindowGTK::Destroy()
2790 {
2791     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2792
2793     m_hasVMT = false;
2794
2795     return wxWindowBase::Destroy();
2796 }
2797
2798 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2799 {
2800     gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2801 }
2802
2803 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2804 {
2805     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2806     wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2807
2808 /*
2809     printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2810 */
2811
2812     if (m_resizing) return; /* I don't like recursions */
2813     m_resizing = true;
2814
2815     int currentX, currentY;
2816     GetPosition(&currentX, &currentY);
2817     if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2818         x = currentX;
2819     if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2820         y = currentY;
2821     AdjustForParentClientOrigin(x, y, sizeFlags);
2822
2823     if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
2824     {
2825         /* don't set the size for children of wxNotebook, just take the values. */
2826         m_x = x;
2827         m_y = y;
2828         m_width = width;
2829         m_height = height;
2830     }
2831     else
2832     {
2833         GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2834         if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
2835         {
2836             if (x != -1) m_x = x + pizza->xoffset;
2837             if (y != -1) m_y = y + pizza->yoffset;
2838         }
2839         else
2840         {
2841             m_x = x + pizza->xoffset;
2842             m_y = y + pizza->yoffset;
2843         }
2844
2845         // calculate the best size if we should auto size the window
2846         if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2847                 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2848         {
2849             const wxSize sizeBest = GetBestSize();
2850             if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2851                 width = sizeBest.x;
2852             if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2853                 height = sizeBest.y;
2854         }
2855
2856         if (width != -1)
2857             m_width = width;
2858         if (height != -1)
2859             m_height = height;
2860
2861         int minWidth = GetMinWidth(),
2862             minHeight = GetMinHeight(),
2863             maxWidth = GetMaxWidth(),
2864             maxHeight = GetMaxHeight();
2865
2866         if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
2867         if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
2868         if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
2869         if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
2870
2871         int left_border = 0;
2872         int right_border = 0;
2873         int top_border = 0;
2874         int bottom_border = 0;
2875
2876         /* the default button has a border around it */
2877         if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2878         {
2879             left_border = 6;
2880             right_border = 6;
2881             top_border = 6;
2882             bottom_border = 5;
2883         }
2884
2885         DoMoveWindow( m_x-top_border,
2886                       m_y-left_border,
2887                       m_width+left_border+right_border,
2888                       m_height+top_border+bottom_border );
2889     }
2890
2891     if (m_hasScrolling)
2892     {
2893         /* Sometimes the client area changes size without the
2894            whole windows's size changing, but if the whole
2895            windows's size doesn't change, no wxSizeEvent will
2896            normally be sent. Here we add an extra test if
2897            the client test has been changed and this will
2898            be used then. */
2899         GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2900     }
2901
2902 /*
2903     wxPrintf( "OnSize sent from " );
2904     if (GetClassInfo() && GetClassInfo()->GetClassName())
2905         wxPrintf( GetClassInfo()->GetClassName() );
2906     wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2907 */
2908
2909     if (!m_nativeSizeEvent)
2910     {
2911         wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2912         event.SetEventObject( this );
2913         HandleWindowEvent( event );
2914     }
2915
2916     m_resizing = false;
2917 }
2918
2919 void wxWindowGTK::OnInternalIdle()
2920 {
2921     // Update style if the window was not yet realized
2922     // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2923     if (m_needsStyleChange)
2924     {
2925         SetBackgroundStyle(GetBackgroundStyle());
2926         m_needsStyleChange = false;
2927     }
2928
2929     // Update invalidated regions.
2930     GtkUpdate();
2931
2932     wxCursor cursor = m_cursor;
2933     if (g_globalCursor.IsOk()) cursor = g_globalCursor;
2934
2935     if (cursor.IsOk())
2936     {
2937         /* I now set the cursor anew in every OnInternalIdle call
2938            as setting the cursor in a parent window also effects the
2939            windows above so that checking for the current cursor is
2940            not possible. */
2941
2942         if (m_wxwindow)
2943         {
2944             GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
2945             if (window)
2946                 gdk_window_set_cursor( window, cursor.GetCursor() );
2947
2948             if (!g_globalCursor.IsOk())
2949                 cursor = *wxSTANDARD_CURSOR;
2950
2951             window = m_widget->window;
2952             if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2953                 gdk_window_set_cursor( window, cursor.GetCursor() );
2954
2955         }
2956         else if ( m_widget )
2957         {
2958             GdkWindow *window = m_widget->window;
2959             if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) )
2960                gdk_window_set_cursor( window, cursor.GetCursor() );
2961         }
2962     }
2963
2964     wxWindowBase::OnInternalIdle();
2965 }
2966
2967 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2968 {
2969     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2970
2971     if (width) (*width) = m_width;
2972     if (height) (*height) = m_height;
2973 }
2974
2975 void wxWindowGTK::DoSetClientSize( int width, int height )
2976 {
2977     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2978
2979     if (!m_wxwindow)
2980     {
2981         SetSize( width, height );
2982     }
2983     else
2984     {
2985         int dw = 0;
2986         int dh = 0;
2987
2988 #ifndef __WXUNIVERSAL__
2989         if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER) || HasFlag(wxBORDER_THEME))
2990         {
2991             /* when using GTK 1.2 we set the shadow border size to 2 */
2992             dw += 2 * 2;
2993             dh += 2 * 2;
2994         }
2995         if (HasFlag(wxSIMPLE_BORDER))
2996         {
2997             /* when using GTK 1.2 we set the simple border size to 1 */
2998             dw += 1 * 2;
2999             dh += 1 * 2;
3000         }
3001 #endif // __WXUNIVERSAL__
3002
3003         if (m_hasScrolling)
3004         {
3005             GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
3006
3007             GtkRequisition vscroll_req;
3008             vscroll_req.width = 2;
3009             vscroll_req.height = 2;
3010             (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
3011                 (scroll_window->vscrollbar, &vscroll_req );
3012
3013             GtkRequisition hscroll_req;
3014             hscroll_req.width = 2;
3015             hscroll_req.height = 2;
3016             (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
3017                 (scroll_window->hscrollbar, &hscroll_req );
3018
3019             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
3020
3021             if (scroll_window->vscrollbar_visible)
3022             {
3023                 dw += vscroll_req.width;
3024                 dw += scroll_class->scrollbar_spacing;
3025             }
3026
3027             if (scroll_window->hscrollbar_visible)
3028             {
3029                 dh += hscroll_req.height;
3030                 dh += scroll_class->scrollbar_spacing;
3031             }
3032         }
3033
3034        SetSize( width+dw, height+dh );
3035     }
3036 }
3037
3038 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
3039 {
3040     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3041
3042     if (!m_wxwindow)
3043     {
3044         if (width) (*width) = m_width;
3045         if (height) (*height) = m_height;
3046     }
3047     else
3048     {
3049         int dw = 0;
3050         int dh = 0;
3051
3052 #ifndef __WXUNIVERSAL__
3053         if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER) || HasFlag(wxBORDER_THEME))
3054         {
3055             /* when using GTK 1.2 we set the shadow border size to 2 */
3056             dw += 2 * 2;
3057             dh += 2 * 2;
3058         }
3059         if (HasFlag(wxSIMPLE_BORDER))
3060         {
3061             /* when using GTK 1.2 we set the simple border size to 1 */
3062             dw += 1 * 2;
3063             dh += 1 * 2;
3064         }
3065 #endif // __WXUNIVERSAL__
3066
3067         if (m_hasScrolling)
3068         {
3069             GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
3070
3071             GtkRequisition vscroll_req;
3072             vscroll_req.width = 2;
3073             vscroll_req.height = 2;
3074             (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
3075                 (scroll_window->vscrollbar, &vscroll_req );
3076
3077             GtkRequisition hscroll_req;
3078             hscroll_req.width = 2;
3079             hscroll_req.height = 2;
3080             (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
3081                 (scroll_window->hscrollbar, &hscroll_req );
3082
3083             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
3084
3085             if (scroll_window->vscrollbar_visible)
3086             {
3087                 dw += vscroll_req.width;
3088                 dw += scroll_class->scrollbar_spacing;
3089             }
3090
3091             if (scroll_window->hscrollbar_visible)
3092             {
3093                 dh += hscroll_req.height;
3094                 dh += scroll_class->scrollbar_spacing;
3095             }
3096         }
3097
3098         if (width) (*width) = m_width - dw;
3099         if (height) (*height) = m_height - dh;
3100     }
3101
3102 /*
3103     printf( "GetClientSize, name %s ", GetName().c_str() );
3104     if (width) printf( " width = %d", (*width) );
3105     if (height) printf( " height = %d", (*height) );
3106     printf( "\n" );
3107 */
3108 }
3109
3110 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
3111 {
3112     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3113
3114     int dx = 0;
3115     int dy = 0;
3116     if (m_parent && m_parent->m_wxwindow)
3117     {
3118         GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
3119         dx = pizza->xoffset;
3120         dy = pizza->yoffset;
3121     }
3122
3123     if (x) (*x) = m_x - dx;
3124     if (y) (*y) = m_y - dy;
3125 }
3126
3127 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
3128 {
3129     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3130
3131     if (!m_widget->window) return;
3132
3133     GdkWindow *source = NULL;
3134     if (m_wxwindow)
3135         source = GTK_PIZZA(m_wxwindow)->bin_window;
3136     else
3137         source = m_widget->window;
3138
3139     int org_x = 0;
3140     int org_y = 0;
3141     gdk_window_get_origin( source, &org_x, &org_y );
3142
3143     if (!m_wxwindow)
3144     {
3145         if (GTK_WIDGET_NO_WINDOW (m_widget))
3146         {
3147             org_x += m_widget->allocation.x;
3148             org_y += m_widget->allocation.y;
3149         }
3150     }
3151
3152     if (x) *x += org_x;
3153     if (y) *y += org_y;
3154 }
3155
3156 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
3157 {
3158     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3159
3160     if (!m_widget->window) return;
3161
3162     GdkWindow *source = NULL;
3163     if (m_wxwindow)
3164         source = GTK_PIZZA(m_wxwindow)->bin_window;
3165     else
3166         source = m_widget->window;
3167
3168     int org_x = 0;
3169     int org_y = 0;
3170     gdk_window_get_origin( source, &org_x, &org_y );
3171
3172     if (!m_wxwindow)
3173     {
3174         if (GTK_WIDGET_NO_WINDOW (m_widget))
3175         {
3176             org_x += m_widget->allocation.x;
3177             org_y += m_widget->allocation.y;
3178         }
3179     }
3180
3181     if (x) *x -= org_x;
3182     if (y) *y -= org_y;
3183 }
3184
3185 bool wxWindowGTK::Show( bool show )
3186 {
3187     wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3188
3189     if (!wxWindowBase::Show(show))
3190     {
3191         // nothing to do
3192         return false;
3193     }
3194
3195     if (show)
3196         gtk_widget_show( m_widget );
3197     else
3198         gtk_widget_hide( m_widget );
3199
3200     wxShowEvent eventShow(GetId(), show);
3201     eventShow.SetEventObject(this);
3202
3203     HandleWindowEvent(eventShow);
3204
3205     return true;
3206 }
3207
3208 void wxWindowGTK::DoEnable( bool enable )
3209 {
3210     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3211
3212     gtk_widget_set_sensitive( m_widget, enable );
3213     if ( m_wxwindow )
3214         gtk_widget_set_sensitive( m_wxwindow, enable );
3215 }
3216
3217 int wxWindowGTK::GetCharHeight() const
3218 {
3219     wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3220
3221     wxFont font = GetFont();
3222     wxCHECK_MSG( font.IsOk(), 12, wxT("invalid font") );
3223
3224     GdkFont *gfont = font.GetInternalFont( 1.0 );
3225
3226     return gfont->ascent + gfont->descent;
3227 }
3228
3229 int wxWindowGTK::GetCharWidth() const
3230 {
3231     wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3232
3233     wxFont font = GetFont();
3234     wxCHECK_MSG( font.IsOk(), 8, wxT("invalid font") );
3235
3236     GdkFont *gfont = font.GetInternalFont( 1.0 );
3237
3238     return gdk_string_width( gfont, "g" );
3239 }
3240
3241 void wxWindowGTK::DoGetTextExtent(const wxString& string,
3242                                   int *x,
3243                                   int *y,
3244                                   int *descent,
3245                                   int *externalLeading,
3246                                   const wxFont *theFont) const
3247 {
3248     wxFont fontToUse = theFont ? *theFont : GetFont();
3249
3250     wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
3251
3252     if (string.empty())
3253     {
3254         if (x) (*x) = 0;
3255         if (y) (*y) = 0;
3256         return;
3257     }
3258
3259     GdkFont *font = fontToUse.GetInternalFont( 1.0 );
3260     if (x) (*x) = gdk_string_width( font, wxGTK_CONV( string ) );
3261     if (y) (*y) = font->ascent + font->descent;
3262     if (descent) (*descent) = font->descent;
3263     if (externalLeading) (*externalLeading) = 0;  // ??
3264 }
3265
3266 void wxWindowGTK::SetFocus()
3267 {
3268     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3269     if ( m_hasFocus )
3270     {
3271         // don't do anything if we already have focus
3272         return;
3273     }
3274
3275     if (m_wxwindow)
3276     {
3277         if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3278         {
3279             gtk_widget_grab_focus (m_wxwindow);
3280         }
3281     }
3282     else if (m_widget)
3283     {
3284         if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3285         {
3286
3287             if (!GTK_WIDGET_REALIZED(m_widget))
3288             {
3289                 // we can't set the focus to the widget now so we remember that
3290                 // it should be focused and will do it later, during the idle
3291                 // time, as soon as we can
3292                 wxLogTrace(TRACE_FOCUS,
3293                            wxT("Delaying setting focus to %s(%s)"),
3294                            GetClassInfo()->GetClassName(), GetLabel().c_str());
3295
3296                 g_delayedFocus = this;
3297             }
3298             else
3299             {
3300                 wxLogTrace(TRACE_FOCUS,
3301                            wxT("Setting focus to %s(%s)"),
3302                            GetClassInfo()->GetClassName(), GetLabel().c_str());
3303
3304                 gtk_widget_grab_focus (m_widget);
3305             }
3306         }
3307         else
3308         if (GTK_IS_CONTAINER(m_widget))
3309         {
3310             gtk_container_focus( GTK_CONTAINER(m_widget), GTK_DIR_TAB_FORWARD );
3311         }
3312         else
3313         {
3314            wxLogTrace(TRACE_FOCUS,
3315                       wxT("Can't set focus to %s(%s)"),
3316                       GetClassInfo()->GetClassName(), GetLabel().c_str());
3317         }
3318     }
3319 }
3320
3321 bool wxWindowGTK::AcceptsFocus() const
3322 {
3323     return m_acceptsFocus && wxWindowBase::AcceptsFocus();
3324 }
3325
3326 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3327 {
3328     wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3329
3330     wxWindowGTK *oldParent = m_parent,
3331              *newParent = (wxWindowGTK *)newParentBase;
3332
3333     wxASSERT( GTK_IS_WIDGET(m_widget) );
3334
3335     if ( !wxWindowBase::Reparent(newParent) )
3336         return false;
3337
3338     wxASSERT( GTK_IS_WIDGET(m_widget) );
3339
3340     /* prevent GTK from deleting the widget arbitrarily */
3341     gtk_widget_ref( m_widget );
3342
3343     if (oldParent)
3344     {
3345         gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3346     }
3347
3348     wxASSERT( GTK_IS_WIDGET(m_widget) );
3349
3350     if (newParent)
3351     {
3352         /* insert GTK representation */
3353         (*(newParent->m_insertCallback))(newParent, this);
3354     }
3355
3356     /* reverse: prevent GTK from deleting the widget arbitrarily */
3357     gtk_widget_unref( m_widget );
3358
3359     return true;
3360 }
3361
3362 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3363 {
3364     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3365
3366     wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3367
3368     wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
3369
3370     /* add to list */
3371     AddChild( child );
3372
3373     /* insert GTK representation */
3374     (*m_insertCallback)(this, child);
3375 }
3376
3377 void wxWindowGTK::Raise()
3378 {
3379     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3380
3381     if (m_wxwindow && m_wxwindow->window)
3382     {
3383         gdk_window_raise( m_wxwindow->window );
3384     }
3385     else if (m_widget->window)
3386     {
3387         gdk_window_raise( m_widget->window );
3388     }
3389 }
3390
3391 void wxWindowGTK::Lower()
3392 {
3393     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3394
3395     if (m_wxwindow && m_wxwindow->window)
3396     {
3397         gdk_window_lower( m_wxwindow->window );
3398     }
3399     else if (m_widget->window)
3400     {
3401         gdk_window_lower( m_widget->window );
3402     }
3403 }
3404
3405 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3406 {
3407     wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3408
3409     if ( cursor.IsSameAs(m_cursor) )
3410        return false;
3411
3412     if (g_isIdle)
3413         wxapp_install_idle_handler();
3414
3415     return wxWindowBase::SetCursor( cursor.IsOk() ? cursor
3416                                                   : *wxSTANDARD_CURSOR );
3417 }
3418
3419 void wxWindowGTK::WarpPointer( int x, int y )
3420 {
3421     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3422
3423     // We provide this function ourselves as it is
3424     // missing in GDK (top of this file).
3425
3426     GdkWindow *window = NULL;
3427     if (m_wxwindow)
3428         window = GTK_PIZZA(m_wxwindow)->bin_window;
3429     else
3430         window = GetConnectWidget()->window;
3431
3432     if (window)
3433         gdk_window_warp_pointer( window, x, y );
3434 }
3435
3436
3437 void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3438 {
3439     if (!m_widget)
3440         return;
3441     if (!m_widget->window)
3442         return;
3443
3444     if (g_isIdle)
3445         wxapp_install_idle_handler();
3446
3447     wxRect myRect;
3448     if (m_wxwindow && rect)
3449     {
3450         myRect.SetSize(wxSize( m_wxwindow->allocation.width,
3451                                m_wxwindow->allocation.height));
3452         if ( myRect.Intersect(*rect).IsEmpty() )
3453         {
3454             // nothing to do, rectangle is empty
3455             return;
3456         }
3457
3458         rect = &myRect;
3459     }
3460
3461     // schedule the area for later updating in GtkUpdate()
3462     if (eraseBackground && m_wxwindow && m_wxwindow->window)
3463     {
3464         if (rect)
3465         {
3466             m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
3467         }
3468         else
3469         {
3470             m_clearRegion.Clear();
3471             m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3472         }
3473     }
3474
3475     if (rect)
3476     {
3477         if (m_wxwindow)
3478         {
3479             m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
3480         }
3481         else
3482         {
3483             GdkRectangle gdk_rect;
3484             gdk_rect.x = rect->x;
3485             gdk_rect.y = rect->y;
3486             gdk_rect.width = rect->width;
3487             gdk_rect.height = rect->height;
3488             gtk_widget_draw( m_widget, &gdk_rect );
3489         }
3490     }
3491     else
3492     {
3493         if (m_wxwindow)
3494         {
3495             m_updateRegion.Clear();
3496             m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3497         }
3498         else
3499         {
3500             gtk_widget_draw( m_widget, NULL );
3501         }
3502     }
3503 }
3504
3505 void wxWindowGTK::Update()
3506 {
3507     GtkUpdate();
3508
3509     // when we call Update() we really want to update the window immediately on
3510     // screen, even if it means flushing the entire queue and hence slowing down
3511     // everything -- but it should still be done, it's just that Update() should
3512     // be called very rarely
3513     gdk_flush();
3514 }
3515
3516 void wxWindowGTK::GtkUpdate()
3517 {
3518     if (!m_updateRegion.IsEmpty())
3519         GtkSendPaintEvents();
3520
3521     // for consistency with other platforms (and also because it's convenient
3522     // to be able to update an entire TLW by calling Update() only once), we
3523     // should also update all our children here
3524     for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3525           node;
3526           node = node->GetNext() )
3527     {
3528         node->GetData()->GtkUpdate();
3529     }
3530 }
3531
3532 void wxWindowGTK::GtkSendPaintEvents()
3533 {
3534     if (!m_wxwindow)
3535     {
3536         m_clearRegion.Clear();
3537         m_updateRegion.Clear();
3538         return;
3539     }
3540
3541     // Clip to paint region in wxClientDC
3542     m_clipPaintRegion = true;
3543
3544     // widget to draw on
3545     GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
3546
3547     if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))
3548     {
3549         // find ancestor from which to steal background
3550         wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3551         if (!parent)
3552             parent = (wxWindow*)this;
3553
3554         if (GTK_WIDGET_MAPPED(parent->m_widget))
3555         {
3556             wxRegionIterator upd( m_updateRegion );
3557             while (upd)
3558             {
3559                 GdkRectangle rect;
3560                 rect.x = upd.GetX();
3561                 rect.y = upd.GetY();
3562                 rect.width = upd.GetWidth();
3563                 rect.height = upd.GetHeight();
3564
3565                 gtk_paint_flat_box( parent->m_widget->style,
3566                             pizza->bin_window,
3567                             (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
3568                             GTK_SHADOW_NONE,
3569                             &rect,
3570                             parent->m_widget,
3571                             (char *)"base",
3572                             0, 0, -1, -1 );
3573
3574                 ++upd;
3575             }
3576         }
3577     }
3578     else // Always send an erase event under GTK 1.2
3579     {
3580         wxWindowDC dc( (wxWindow*)this );
3581         dc.SetDeviceClippingRegion( m_clearRegion.IsEmpty() ? m_updateRegion
3582                                                             : m_clearRegion );
3583
3584         wxEraseEvent erase_event( GetId(), &dc );
3585         erase_event.SetEventObject( this );
3586
3587         if (!HandleWindowEvent(erase_event) && GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
3588         {
3589             if (!g_eraseGC)
3590             {
3591                 g_eraseGC = gdk_gc_new( pizza->bin_window );
3592                 gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
3593             }
3594             gdk_gc_set_foreground( g_eraseGC, GetBackgroundColour().GetColor() );
3595
3596             wxRegionIterator upd( m_clearRegion );
3597             while (upd)
3598             {
3599                 gdk_draw_rectangle( pizza->bin_window, g_eraseGC, 1,
3600                                     upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
3601                 upd ++;
3602             }
3603         }
3604         m_clearRegion.Clear();
3605     }
3606
3607     wxNcPaintEvent nc_paint_event( GetId() );
3608     nc_paint_event.SetEventObject( this );
3609     HandleWindowEvent( nc_paint_event );
3610
3611     wxPaintEvent paint_event( GetId() );
3612     paint_event.SetEventObject( this );
3613     HandleWindowEvent( paint_event );
3614
3615     m_clipPaintRegion = false;
3616
3617 #if !defined(__WXUNIVERSAL__)
3618     // The following code will result in all window-less widgets
3619     // being redrawn because the wxWidgets class is allowed to
3620     // paint over the window-less widgets.
3621
3622     GList *children = pizza->children;
3623     while (children)
3624     {
3625         GtkPizzaChild *child = (GtkPizzaChild*) children->data;
3626         children = children->next;
3627
3628         if (GTK_WIDGET_NO_WINDOW (child->widget) &&
3629             GTK_WIDGET_DRAWABLE (child->widget))
3630         {
3631             // Get intersection of widget area and update region
3632             wxRegion region( m_updateRegion );
3633
3634             GdkEventExpose gdk_event;
3635             gdk_event.type = GDK_EXPOSE;
3636             gdk_event.window = pizza->bin_window;
3637             gdk_event.count = 0;
3638             gdk_event.send_event = TRUE;
3639
3640             wxRegionIterator upd( m_updateRegion );
3641             while (upd)
3642             {
3643                 GdkRectangle rect;
3644                 rect.x = upd.GetX();
3645                 rect.y = upd.GetY();
3646                 rect.width = upd.GetWidth();
3647                 rect.height = upd.GetHeight();
3648
3649                 if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
3650                 {
3651                     gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
3652                 }
3653
3654                 upd ++;
3655             }
3656         }
3657     }
3658 #endif // native GTK 1
3659
3660     m_updateRegion.Clear();
3661 }
3662
3663 void wxWindowGTK::ClearBackground()
3664 {
3665     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3666
3667     if (m_wxwindow && m_wxwindow->window)
3668     {
3669         m_clearRegion.Clear();
3670         wxSize size( GetClientSize() );
3671         m_clearRegion.Union( 0,0,size.x,size.y );
3672
3673         // Better do this in idle?
3674         GtkUpdate();
3675     }
3676 }
3677
3678 #if wxUSE_TOOLTIPS
3679 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3680 {
3681     wxWindowBase::DoSetToolTip(tip);
3682
3683     if (m_tooltip)
3684         m_tooltip->Apply( (wxWindow *)this );
3685 }
3686
3687 void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
3688 {
3689     wxString tmp( tip );
3690     gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), NULL );
3691 }
3692 #endif // wxUSE_TOOLTIPS
3693
3694 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3695 {
3696     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3697
3698     if (!wxWindowBase::SetBackgroundColour(colour))
3699         return false;
3700
3701     if (colour.IsOk())
3702     {
3703         // We need the pixel value e.g. for background clearing.
3704         m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3705     }
3706
3707     // apply style change (forceStyle=true so that new style is applied
3708     // even if the bg colour changed from valid to wxNullColour)
3709     if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
3710         ApplyWidgetStyle(true);
3711
3712     return true;
3713 }
3714
3715 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3716 {
3717     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3718
3719     if (!wxWindowBase::SetForegroundColour(colour))
3720     {
3721         return false;
3722     }
3723
3724     if (colour.IsOk())
3725     {
3726         // We need the pixel value e.g. for background clearing.
3727         m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3728     }
3729
3730     // apply style change (forceStyle=true so that new style is applied
3731     // even if the bg colour changed from valid to wxNullColour):
3732     ApplyWidgetStyle(true);
3733
3734     return true;
3735 }
3736
3737 GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
3738 {
3739     // do we need to apply any changes at all?
3740     if ( !forceStyle &&
3741          !m_font.IsOk() &&
3742          !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() )
3743     {
3744         return NULL;
3745     }
3746
3747     GtkRcStyle *style = gtk_rc_style_new();
3748
3749     if ( m_font.IsOk() )
3750     {
3751         wxString xfontname = m_font.GetNativeFontInfo()->GetXFontName();
3752         style->fontset_name = g_strdup(xfontname.c_str());
3753     }
3754
3755     if ( m_foregroundColour.IsOk() )
3756     {
3757         GdkColor *fg = m_foregroundColour.GetColor();
3758
3759         style->fg[GTK_STATE_NORMAL] = *fg;
3760         style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG;
3761
3762         style->fg[GTK_STATE_PRELIGHT] = *fg;
3763         style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG;
3764
3765         style->fg[GTK_STATE_ACTIVE] = *fg;
3766         style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG;
3767     }
3768
3769     if ( m_backgroundColour.IsOk() )
3770     {
3771         GdkColor *bg = m_backgroundColour.GetColor();
3772
3773         style->bg[GTK_STATE_NORMAL] = *bg;
3774         style->base[GTK_STATE_NORMAL] = *bg;
3775         style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)
3776             (style->color_flags[GTK_STATE_NORMAL] | GTK_RC_BG | GTK_RC_BASE);
3777
3778         style->bg[GTK_STATE_PRELIGHT] = *bg;
3779         style->base[GTK_STATE_PRELIGHT] = *bg;
3780         style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)
3781             (style->color_flags[GTK_STATE_PRELIGHT] | GTK_RC_BG | GTK_RC_BASE);
3782
3783         style->bg[GTK_STATE_ACTIVE] = *bg;
3784         style->base[GTK_STATE_ACTIVE] = *bg;
3785         style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)
3786             (style->color_flags[GTK_STATE_ACTIVE] | GTK_RC_BG | GTK_RC_BASE);
3787
3788         style->bg[GTK_STATE_INSENSITIVE] = *bg;
3789         style->base[GTK_STATE_INSENSITIVE] = *bg;
3790         style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)
3791             (style->color_flags[GTK_STATE_INSENSITIVE] | GTK_RC_BG | GTK_RC_BASE);
3792     }
3793
3794     return style;
3795 }
3796
3797 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle)
3798 {
3799     GtkRcStyle *style = CreateWidgetStyle(forceStyle);
3800     if ( style )
3801     {
3802         DoApplyWidgetStyle(style);
3803         gtk_rc_style_unref(style);
3804     }
3805
3806     // Style change may affect GTK+'s size calculation:
3807     InvalidateBestSize();
3808 }
3809
3810 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3811 {
3812     if (m_wxwindow)
3813         gtk_widget_modify_style(m_wxwindow, style);
3814     else
3815         gtk_widget_modify_style(m_widget, style);
3816 }
3817
3818 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3819 {
3820     wxWindowBase::SetBackgroundStyle(style);
3821
3822     if (style == wxBG_STYLE_CUSTOM)
3823     {
3824         GdkWindow *window = NULL;
3825         if (m_wxwindow)
3826             window = GTK_PIZZA(m_wxwindow)->bin_window;
3827         else
3828             window = GetConnectWidget()->window;
3829
3830         if (window)
3831         {
3832             // Make sure GDK/X11 doesn't refresh the window
3833             // automatically.
3834             gdk_window_set_back_pixmap( window, None, False );
3835 #ifdef __X__
3836             Display* display = GDK_WINDOW_DISPLAY(window);
3837             XFlush(display);
3838 #endif
3839             m_needsStyleChange = false;
3840         }
3841         else
3842             // Do in OnIdle, because the window is not yet available
3843             m_needsStyleChange = true;
3844
3845         // Don't apply widget style, or we get a grey background
3846     }
3847     else
3848     {
3849         // apply style change (forceStyle=true so that new style is applied
3850         // even if the bg colour changed from valid to wxNullColour):
3851         ApplyWidgetStyle(true);
3852     }
3853     return true;
3854 }
3855
3856 #if wxUSE_DRAG_AND_DROP
3857
3858 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
3859 {
3860     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3861
3862     GtkWidget *dnd_widget = GetConnectWidget();
3863
3864     if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
3865
3866     if (m_dropTarget) delete m_dropTarget;
3867     m_dropTarget = dropTarget;
3868
3869     if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
3870 }
3871
3872 #endif // wxUSE_DRAG_AND_DROP
3873
3874 GtkWidget* wxWindowGTK::GetConnectWidget()
3875 {
3876     GtkWidget *connect_widget = m_widget;
3877     if (m_wxwindow) connect_widget = m_wxwindow;
3878
3879     return connect_widget;
3880 }
3881
3882 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
3883 {
3884     if (m_wxwindow)
3885         return (window == GTK_PIZZA(m_wxwindow)->bin_window);
3886
3887     return (window == m_widget->window);
3888 }
3889
3890 bool wxWindowGTK::SetFont( const wxFont &font )
3891 {
3892     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3893
3894     if (!wxWindowBase::SetFont(font))
3895         return false;
3896
3897     // apply style change (forceStyle=true so that new style is applied
3898     // even if the font changed from valid to wxNullFont):
3899     ApplyWidgetStyle(true);
3900
3901     return true;
3902 }
3903
3904 void wxWindowGTK::DoCaptureMouse()
3905 {
3906     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3907
3908     GdkWindow *window = NULL;
3909     if (m_wxwindow)
3910         window = GTK_PIZZA(m_wxwindow)->bin_window;
3911     else
3912         window = GetConnectWidget()->window;
3913
3914     wxCHECK_RET( window, wxT("CaptureMouse() failed") );
3915
3916     const wxCursor* cursor = &m_cursor;
3917     if (!cursor->IsOk())
3918         cursor = wxSTANDARD_CURSOR;
3919
3920     gdk_pointer_grab( window, FALSE,
3921                       (GdkEventMask)
3922                          (GDK_BUTTON_PRESS_MASK |
3923                           GDK_BUTTON_RELEASE_MASK |
3924                           GDK_POINTER_MOTION_HINT_MASK |
3925                           GDK_POINTER_MOTION_MASK),
3926                       NULL,
3927                       cursor->GetCursor(),
3928                       (guint32)GDK_CURRENT_TIME );
3929     g_captureWindow = this;
3930     g_captureWindowHasMouse = true;
3931 }
3932
3933 void wxWindowGTK::DoReleaseMouse()
3934 {
3935     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3936
3937     wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
3938
3939     g_captureWindow = NULL;
3940
3941     GdkWindow *window = NULL;
3942     if (m_wxwindow)
3943         window = GTK_PIZZA(m_wxwindow)->bin_window;
3944     else
3945         window = GetConnectWidget()->window;
3946
3947     if (!window)
3948         return;
3949
3950     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
3951 }
3952
3953 /* static */
3954 wxWindow *wxWindowBase::GetCapture()
3955 {
3956     return (wxWindow *)g_captureWindow;
3957 }
3958
3959 bool wxWindowGTK::IsRetained() const
3960 {
3961     return false;
3962 }
3963
3964 void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
3965       int range, bool refresh )
3966 {
3967     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3968
3969     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
3970
3971     m_hasScrolling = true;
3972
3973     if (orient == wxHORIZONTAL)
3974     {
3975         float fpos = (float)pos;
3976         float frange = (float)range;
3977         float fthumb = (float)thumbVisible;
3978         if (fpos > frange-fthumb) fpos = frange-fthumb;
3979         if (fpos < 0.0) fpos = 0.0;
3980
3981         if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
3982             (fabs(fthumb-m_hAdjust->page_size) < 0.2))
3983         {
3984             SetScrollPos( orient, pos, refresh );
3985             return;
3986         }
3987
3988         m_oldHorizontalPos = fpos;
3989
3990         m_hAdjust->lower = 0.0;
3991         m_hAdjust->upper = frange;
3992         m_hAdjust->value = fpos;
3993         m_hAdjust->step_increment = 1.0;
3994         m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
3995         m_hAdjust->page_size = fthumb;
3996     }
3997     else
3998     {
3999         float fpos = (float)pos;
4000         float frange = (float)range;
4001         float fthumb = (float)thumbVisible;
4002         if (fpos > frange-fthumb) fpos = frange-fthumb;
4003         if (fpos < 0.0) fpos = 0.0;
4004
4005         if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
4006             (fabs(fthumb-m_vAdjust->page_size) < 0.2))
4007         {
4008             SetScrollPos( orient, pos, refresh );
4009             return;
4010         }
4011
4012         m_oldVerticalPos = fpos;
4013
4014         m_vAdjust->lower = 0.0;
4015         m_vAdjust->upper = frange;
4016         m_vAdjust->value = fpos;
4017         m_vAdjust->step_increment = 1.0;
4018         m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
4019         m_vAdjust->page_size = fthumb;
4020     }
4021
4022     if (orient == wxHORIZONTAL)
4023         gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
4024     else
4025         gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
4026 }
4027
4028 void wxWindowGTK::GtkUpdateScrollbar(int orient)
4029 {
4030     GtkAdjustment *adj = orient == wxHORIZONTAL ? m_hAdjust : m_vAdjust;
4031     GtkSignalFunc fn = orient == wxHORIZONTAL
4032                         ? (GtkSignalFunc)gtk_window_hscroll_callback
4033                         : (GtkSignalFunc)gtk_window_vscroll_callback;
4034
4035     gtk_signal_disconnect_by_func(GTK_OBJECT(adj), fn, (gpointer)this);
4036     gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed");
4037     gtk_signal_connect(GTK_OBJECT(adj), "value_changed", fn, (gpointer)this);
4038 }
4039
4040 void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
4041 {
4042     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4043     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4044
4045     GtkAdjustment *adj = orient == wxHORIZONTAL ? m_hAdjust : m_vAdjust;
4046
4047     float fpos = (float)pos;
4048     if (fpos > adj->upper - adj->page_size)
4049         fpos = adj->upper - adj->page_size;
4050     if (fpos < 0.0)
4051         fpos = 0.0;
4052     *(orient == wxHORIZONTAL ? &m_oldHorizontalPos : &m_oldVerticalPos) = fpos;
4053
4054     if (fabs(fpos-adj->value) < 0.2)
4055         return;
4056     adj->value = fpos;
4057
4058     if ( m_wxwindow->window )
4059     {
4060     }
4061 }
4062
4063 int wxWindowGTK::GetScrollThumb( int orient ) const
4064 {
4065     wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4066
4067     wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4068
4069     if (orient == wxHORIZONTAL)
4070         return (int)(m_hAdjust->page_size+0.5);
4071     else
4072         return (int)(m_vAdjust->page_size+0.5);
4073 }
4074
4075 int wxWindowGTK::GetScrollPos( int orient ) const
4076 {
4077     wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4078
4079     wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4080
4081     if (orient == wxHORIZONTAL)
4082         return (int)(m_hAdjust->value+0.5);
4083     else
4084         return (int)(m_vAdjust->value+0.5);
4085 }
4086
4087 int wxWindowGTK::GetScrollRange( int orient ) const
4088 {
4089     wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4090
4091     wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4092
4093     if (orient == wxHORIZONTAL)
4094         return (int)(m_hAdjust->upper+0.5);
4095     else
4096         return (int)(m_vAdjust->upper+0.5);
4097 }
4098
4099 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4100 {
4101     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4102
4103     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4104
4105     // No scrolling requested.
4106     if ((dx == 0) && (dy == 0)) return;
4107
4108     if (!m_updateRegion.IsEmpty())
4109     {
4110         m_updateRegion.Offset( dx, dy );
4111
4112         int cw = 0;
4113         int ch = 0;
4114         GetClientSize( &cw, &ch );
4115         m_updateRegion.Intersect( 0, 0, cw, ch );
4116     }
4117
4118     if (!m_clearRegion.IsEmpty())
4119     {
4120         m_clearRegion.Offset( dx, dy );
4121
4122         int cw = 0;
4123         int ch = 0;
4124         GetClientSize( &cw, &ch );
4125         m_clearRegion.Intersect( 0, 0, cw, ch );
4126     }
4127
4128     m_clipPaintRegion = true;
4129
4130     gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
4131
4132     m_clipPaintRegion = false;
4133 }
4134
4135 void wxWindowGTK::SetWindowStyleFlag( long style )
4136 {
4137     // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4138     wxWindowBase::SetWindowStyleFlag(style);
4139 }
4140
4141 // Find the wxWindow at the current mouse position, also returning the mouse
4142 // position.
4143 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4144 {
4145     pt = wxGetMousePosition();
4146     wxWindow* found = wxFindWindowAtPoint(pt);
4147     return found;
4148 }
4149
4150 // Get the current mouse position.
4151 wxPoint wxGetMousePosition()
4152 {
4153   /* This crashes when used within wxHelpContext,
4154      so we have to use the X-specific implementation below.
4155     gint x, y;
4156     GdkModifierType *mask;
4157     (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4158
4159     return wxPoint(x, y);
4160   */
4161
4162     int x, y;
4163     GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4164
4165     Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4166     Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4167     Window rootReturn, childReturn;
4168     int rootX, rootY, winX, winY;
4169     unsigned int maskReturn;
4170
4171     XQueryPointer (display,
4172            rootWindow,
4173            &rootReturn,
4174                    &childReturn,
4175                    &rootX, &rootY, &winX, &winY, &maskReturn);
4176     return wxPoint(rootX, rootY);
4177
4178 }
4179
4180 // Needed for implementing e.g. combobox on wxGTK within a modal dialog.
4181 void wxAddGrab(wxWindow* window)
4182 {
4183     gtk_grab_add( (GtkWidget*) window->GetHandle() );
4184 }
4185
4186 void wxRemoveGrab(wxWindow* window)
4187 {
4188     gtk_grab_remove( (GtkWidget*) window->GetHandle() );
4189 }
4190
4191 // ----------------------------------------------------------------------------
4192 // wxWinModule
4193 // ----------------------------------------------------------------------------
4194
4195 class wxWinModule : public wxModule
4196 {
4197 public:
4198     bool OnInit();
4199     void OnExit();
4200
4201 private:
4202     DECLARE_DYNAMIC_CLASS(wxWinModule)
4203 };
4204
4205 IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
4206
4207 bool wxWinModule::OnInit()
4208 {
4209     // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4210     // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4211
4212     return true;
4213 }
4214
4215 void wxWinModule::OnExit()
4216 {
4217     if (g_eraseGC)
4218         gdk_gc_unref( g_eraseGC );
4219 }
4220
4221 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4222 {
4223     GdkWindow* window = NULL;
4224     if (m_wxwindow)
4225         window = GTK_PIZZA(m_wxwindow)->bin_window;
4226     return window;
4227 }