src/gtk1/window.cpp

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