src/gtk1/window.cpp

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