src/gtk1/window.cpp

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