src/gtk1/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk1/window.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling, Julian Smart
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __VMS
  14 #define XWarpPointer XWARPPOINTER
  15 #endif
  16
  17 #include "wx/window.h"
  18
  19 #ifndef WX_PRECOMP
  20     #include "wx/intl.h"
  21     #include "wx/log.h"
  22     #include "wx/app.h"
  23     #include "wx/utils.h"
  24     #include "wx/frame.h"
  25     #include "wx/dcclient.h"
  26     #include "wx/menu.h"
  27     #include "wx/dialog.h"
  28     #include "wx/settings.h"
  29     #include "wx/msgdlg.h"
  30     #include "wx/textctrl.h"
  31     #include "wx/combobox.h"
  32     #include "wx/layout.h"
  33     #include "wx/statusbr.h"
  34     #include "wx/math.h"
  35 #endif
  36
  37 #include "wx/module.h"
  38
  39 #if wxUSE_DRAG_AND_DROP
  40     #include "wx/dnd.h"
  41 #endif
  42
  43 #if wxUSE_TOOLTIPS
  44     #include "wx/tooltip.h"
  45 #endif
  46
  47 #if wxUSE_CARET
  48     #include "wx/caret.h"
  49 #endif // wxUSE_CARET
  50
  51 #include "wx/fontutil.h"
  52
  53 #ifdef __WXDEBUG__
  54     #include "wx/thread.h"
  55 #endif
  56
  57 #include <ctype.h>
  58
  59 #include "wx/gtk1/private.h"
  60 #include <gdk/gdkprivate.h>
  61 #include <gdk/gdkkeysyms.h>
  62 #include <gdk/gdkx.h>
  63
  64 #include <gtk/gtk.h>
  65 #include <gtk/gtkprivate.h>
  66
  67 #include "wx/gtk1/win_gtk.h"
  68
  69 //-----------------------------------------------------------------------------
  70 // documentation on internals
  71 //-----------------------------------------------------------------------------
  72
  73 /*
  74    I have been asked several times about writing some documentation about
  75    the GTK port of wxWidgets, especially its internal structures. Obviously,
  76    you cannot understand wxGTK without knowing a little about the GTK, but
  77    some more information about what the wxWindow, which is the base class
  78    for all other window classes, does seems required as well.
  79
  80    I)
  81
  82    What does wxWindow do? It contains the common interface for the following
  83    jobs of its descendants:
  84
  85    1) Define the rudimentary behaviour common to all window classes, such as
  86    resizing, intercepting user input (so as to make it possible to use these
  87    events for special purposes in a derived class), window names etc.
  88
  89    2) Provide the possibility to contain and manage children, if the derived
  90    class is allowed to contain children, which holds true for those window
  91    classes which do not display a native GTK widget. To name them, these
  92    classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
  93    work classes are a special case and are handled a bit differently from
  94    the rest. The same holds true for the wxNotebook class.
  95
  96    3) Provide the possibility to draw into a client area of a window. This,
  97    too, only holds true for classes that do not display a native GTK widget
  98    as above.
  99
 100    4) Provide the entire mechanism for scrolling widgets. This actual inter-
 101    face for this is usually in wxScrolledWindow, but the GTK implementation
 102    is in this class.
 103
 104    5) A multitude of helper or extra methods for special purposes, such as
 105    Drag'n'Drop, managing validators etc.
 106
 107    6) Display a border (sunken, raised, simple or none).
 108
 109    Normally one might expect, that one wxWidgets window would always correspond
 110    to one GTK widget. Under GTK, there is no such allround widget that has all
 111    the functionality. Moreover, the GTK defines a client area as a different
 112    widget from the actual widget you are handling. Last but not least some
 113    special classes (e.g. wxFrame) handle different categories of widgets and
 114    still have the possibility to draw something in the client area.
 115    It was therefore required to write a special purpose GTK widget, that would
 116    represent a client area in the sense of wxWidgets capable to do the jobs
 117    2), 3) and 4). I have written this class and it resides in win_gtk.c of
 118    this directory.
 119
 120    All windows must have a widget, with which they interact with other under-
 121    lying GTK widgets. It is this widget, e.g. that has to be resized etc and
 122    the wxWindow class has a member variable called m_widget which holds a
 123    pointer to this widget. When the window class represents a GTK native widget,
 124    this is (in most cases) the only GTK widget the class manages. E.g. the
 125    wxStaticText class handles only a GtkLabel widget a pointer to which you
 126    can find in m_widget (defined in wxWindow)
 127
 128    When the class has a client area for drawing into and for containing children
 129    it has to handle the client area widget (of the type GtkPizza, defined in
 130    win_gtk.c), but there could be any number of widgets, handled by a class
 131    The common rule for all windows is only, that the widget that interacts with
 132    the rest of GTK must be referenced in m_widget and all other widgets must be
 133    children of this widget on the GTK level. The top-most widget, which also
 134    represents the client area, must be in the m_wxwindow field and must be of
 135    the type GtkPizza.
 136
 137    As I said, the window classes that display a GTK native widget only have
 138    one widget, so in the case of e.g. the wxButton class m_widget holds a
 139    pointer to a GtkButton widget. But windows with client areas (for drawing
 140    and children) have a m_widget field that is a pointer to a GtkScrolled-
 141    Window and a m_wxwindow field that is pointer to a GtkPizza and this
 142    one is (in the GTK sense) a child of the GtkScrolledWindow.
 143
 144    If the m_wxwindow field is set, then all input to this widget is inter-
 145    cepted and sent to the wxWidgets class. If not, all input to the widget
 146    that gets pointed to by m_widget gets intercepted and sent to the class.
 147
 148    II)
 149
 150    The design of scrolling in wxWidgets is markedly different from that offered
 151    by the GTK itself and therefore we cannot simply take it as it is. In GTK,
 152    clicking on a scrollbar belonging to scrolled window will inevitably move
 153    the window. In wxWidgets, the scrollbar will only emit an event, send this
 154    to (normally) a wxScrolledWindow and that class will call ScrollWindow()
 155    which actually moves the window and its subchildren. Note that GtkPizza
 156    memorizes how much it has been scrolled but that wxWidgets forgets this
 157    so that the two coordinates systems have to be kept in synch. This is done
 158    in various places using the pizza->xoffset and pizza->yoffset values.
 159
 160    III)
 161
 162    Singularily the most broken code in GTK is the code that is supposed to
 163    inform subwindows (child windows) about new positions. Very often, duplicate
 164    events are sent without changes in size or position, equally often no
 165    events are sent at all (All this is due to a bug in the GtkContainer code
 166    which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
 167    GTK's own system and it simply waits for size events for toplevel windows
 168    and then iterates down the respective size events to all window. This has
 169    the disadvantage that windows might get size events before the GTK widget
 170    actually has the reported size. This doesn't normally pose any problem, but
 171    the OpenGL drawing routines rely on correct behaviour. Therefore, I have
 172    added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
 173    i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
 174    window that is used for OpenGL output really has that size (as reported by
 175    GTK).
 176
 177    IV)
 178
 179    If someone at some point of time feels the immense desire to have a look at,
 180    change or attempt to optimise the Refresh() logic, this person will need an
 181    intimate understanding of what "draw" and "expose" events are and what
 182    they are used for, in particular when used in connection with GTK's
 183    own windowless widgets. Beware.
 184
 185    V)
 186
 187    Cursors, too, have been a constant source of pleasure. The main difficulty
 188    is that a GdkWindow inherits a cursor if the programmer sets a new cursor
 189    for the parent. To prevent this from doing too much harm, I use idle time
 190    to set the cursor over and over again, starting from the toplevel windows
 191    and ending with the youngest generation (speaking of parent and child windows).
 192    Also don't forget that cursors (like much else) are connected to GdkWindows,
 193    not GtkWidgets and that the "window" field of a GtkWidget might very well
 194    point to the GdkWindow of the parent widget (-> "window-less widget") and
 195    that the two obviously have very different meanings.
 196
 197 */
 198
 199 //-----------------------------------------------------------------------------
 200 // data
 201 //-----------------------------------------------------------------------------
 202
 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_PAGEUP;
 743             break;
 744
 745         case GDK_Next:      // == GDK_Page_Down
 746             key_code = WXK_PAGEDOWN;
 747             break;
 748
 749         case GDK_End:
 750             key_code = WXK_END;
 751             break;
 752
 753         case GDK_Begin:
 754             key_code = WXK_HOME;
 755             break;
 756
 757         case GDK_Insert:
 758             key_code = WXK_INSERT;
 759             break;
 760
 761
 762         // numpad keys
 763         case GDK_KP_0:
 764         case GDK_KP_1:
 765         case GDK_KP_2:
 766         case GDK_KP_3:
 767         case GDK_KP_4:
 768         case GDK_KP_5:
 769         case GDK_KP_6:
 770         case GDK_KP_7:
 771         case GDK_KP_8:
 772         case GDK_KP_9:
 773             key_code = (isChar ? '0' : WXK_NUMPAD0) + keysym - GDK_KP_0;
 774             break;
 775
 776         case GDK_KP_Space:
 777             key_code = isChar ? ' ' : WXK_NUMPAD_SPACE;
 778             break;
 779
 780         case GDK_KP_Tab:
 781             key_code = isChar ? WXK_TAB : WXK_NUMPAD_TAB;
 782             break;
 783
 784         case GDK_KP_Enter:
 785             key_code = isChar ? WXK_RETURN : WXK_NUMPAD_ENTER;
 786             break;
 787
 788         case GDK_KP_F1:
 789             key_code = isChar ? WXK_F1 : WXK_NUMPAD_F1;
 790             break;
 791
 792         case GDK_KP_F2:
 793             key_code = isChar ? WXK_F2 : WXK_NUMPAD_F2;
 794             break;
 795
 796         case GDK_KP_F3:
 797             key_code = isChar ? WXK_F3 : WXK_NUMPAD_F3;
 798             break;
 799
 800         case GDK_KP_F4:
 801             key_code = isChar ? WXK_F4 : WXK_NUMPAD_F4;
 802             break;
 803
 804         case GDK_KP_Home:
 805             key_code = isChar ? WXK_HOME : WXK_NUMPAD_HOME;
 806             break;
 807
 808         case GDK_KP_Left:
 809             key_code = isChar ? WXK_LEFT : WXK_NUMPAD_LEFT;
 810             break;
 811
 812         case GDK_KP_Up:
 813             key_code = isChar ? WXK_UP : WXK_NUMPAD_UP;
 814             break;
 815
 816         case GDK_KP_Right:
 817             key_code = isChar ? WXK_RIGHT : WXK_NUMPAD_RIGHT;
 818             break;
 819
 820         case GDK_KP_Down:
 821             key_code = isChar ? WXK_DOWN : WXK_NUMPAD_DOWN;
 822             break;
 823
 824         case GDK_KP_Prior: // == GDK_KP_Page_Up
 825             key_code = isChar ? WXK_PAGEUP : WXK_NUMPAD_PAGEUP;
 826             break;
 827
 828         case GDK_KP_Next: // == GDK_KP_Page_Down
 829             key_code = isChar ? WXK_PAGEDOWN : WXK_NUMPAD_PAGEDOWN;
 830             break;
 831
 832         case GDK_KP_End:
 833             key_code = isChar ? WXK_END : WXK_NUMPAD_END;
 834             break;
 835
 836         case GDK_KP_Begin:
 837             key_code = isChar ? WXK_HOME : WXK_NUMPAD_BEGIN;
 838             break;
 839
 840         case GDK_KP_Insert:
 841             key_code = isChar ? WXK_INSERT : WXK_NUMPAD_INSERT;
 842             break;
 843
 844         case GDK_KP_Delete:
 845             key_code = isChar ? WXK_DELETE : WXK_NUMPAD_DELETE;
 846             break;
 847
 848         case GDK_KP_Equal:
 849             key_code = isChar ? '=' : WXK_NUMPAD_EQUAL;
 850             break;
 851
 852         case GDK_KP_Multiply:
 853             key_code = isChar ? '*' : WXK_NUMPAD_MULTIPLY;
 854             break;
 855
 856         case GDK_KP_Add:
 857             key_code = isChar ? '+' : WXK_NUMPAD_ADD;
 858             break;
 859
 860         case GDK_KP_Separator:
 861             // FIXME: what is this?
 862             key_code = isChar ? '.' : WXK_NUMPAD_SEPARATOR;
 863             break;
 864
 865         case GDK_KP_Subtract:
 866             key_code = isChar ? '-' : WXK_NUMPAD_SUBTRACT;
 867             break;
 868
 869         case GDK_KP_Decimal:
 870             key_code = isChar ? '.' : WXK_NUMPAD_DECIMAL;
 871             break;
 872
 873         case GDK_KP_Divide:
 874             key_code = isChar ? '/' : WXK_NUMPAD_DIVIDE;
 875             break;
 876
 877
 878         // function keys
 879         case GDK_F1:
 880         case GDK_F2:
 881         case GDK_F3:
 882         case GDK_F4:
 883         case GDK_F5:
 884         case GDK_F6:
 885         case GDK_F7:
 886         case GDK_F8:
 887         case GDK_F9:
 888         case GDK_F10:
 889         case GDK_F11:
 890         case GDK_F12:
 891             key_code = WXK_F1 + keysym - GDK_F1;
 892             break;
 893
 894         default:
 895             key_code = 0;
 896     }
 897
 898     return key_code;
 899 }
 900
 901 static inline bool wxIsAsciiKeysym(KeySym ks)
 902 {
 903     return ks < 256;
 904 }
 905
 906 static void wxFillOtherKeyEventFields(wxKeyEvent& event,
 907                                       wxWindowGTK *win,
 908                                       GdkEventKey *gdk_event)
 909 {
 910     int x = 0;
 911     int y = 0;
 912     GdkModifierType state;
 913     if (gdk_event->window)
 914         gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
 915
 916     event.SetTimestamp( gdk_event->time );
 917     event.SetId(win->GetId());
 918     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
 919     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
 920     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
 921     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
 922     event.m_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         // Emit KEY_DOWN event
1062         ret = win->GetEventHandler()->ProcessEvent( event );
1063     }
1064     else
1065     {
1066         // Return after IM processing as we cannot do
1067         // anything with it anyhow.
1068         return_after_IM = true;
1069     }
1070
1071     // This is for GTK+ 1.2 only. The char event generatation for GTK+ 2.0 is done
1072     // in the "commit" handler.
1073
1074     // 2005.02.02 modified by Hong Jen Yee (hzysoft@sina.com.tw).
1075     // In GTK+ 1.2, strings sent by IMs are also regarded as key_press events whose
1076     // keyCodes cannot be recognized by wxWidgets. These MBCS strings, however, are
1077     // composed of more than one character, which means gdk_event->length will always
1078     // greater than one. When gtk_event->length == 1, this may be an ASCII character
1079     // and can be translated by wx.  However, when MBCS characters are sent by IM,
1080     // gdk_event->length will >= 2. So neither should we pass it to accelerator table,
1081     // nor should we pass it to controls. The following explanation was excerpted
1082     // from GDK documentation.
1083     // gint length : the length of string.
1084     // gchar *string : a null-terminated multi-byte string containing the composed
1085     // characters resulting from the key press. When text is being input, in a GtkEntry
1086     // for example, it is these characters which should be added to the input buffer.
1087     // When using Input Methods to support internationalized text input, the composed
1088     // characters appear here after the pre-editing has been completed.
1089
1090     if ( (!ret) && (gdk_event->length > 1) ) // If this event contains a pre-edited string from IM.
1091     {
1092         // We should translate this key event into wxEVT_CHAR not wxEVT_KEY_DOWN.
1093         #if wxUSE_UNICODE   // GTK+ 1.2 is not UTF-8 based.
1094             const wxWCharBuffer string = wxConvLocal.cMB2WC( gdk_event->string );
1095             if( !string )
1096                 return false;
1097         #else
1098             const char* string = gdk_event->string;
1099         #endif
1100
1101         // Implement OnCharHook by checking ancestor top level windows
1102         wxWindow *parent = win;
1103         while (parent && !parent->IsTopLevel())
1104             parent = parent->GetParent();
1105
1106         for( const wxChar* pstr = string; *pstr; pstr++ )
1107         {
1108         #if wxUSE_UNICODE
1109             event.m_uniChar = *pstr;
1110             // Backward compatible for ISO-8859-1
1111             event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
1112         #else
1113             event.m_keyCode = *pstr;
1114         #endif
1115             if (parent)
1116             {
1117                 event.SetEventType( wxEVT_CHAR_HOOK );
1118                 ret = parent->GetEventHandler()->ProcessEvent( event );
1119             }
1120             if (!ret)
1121             {
1122                 event.SetEventType(wxEVT_CHAR);
1123                 win->GetEventHandler()->ProcessEvent( event );
1124             }
1125         }
1126         return true;
1127     }
1128
1129     if (return_after_IM)
1130         return false;
1131
1132 #if wxUSE_ACCEL
1133     if (!ret)
1134     {
1135         wxWindowGTK *ancestor = win;
1136         while (ancestor)
1137         {
1138             int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1139             if (command != -1)
1140             {
1141                 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1142                 ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
1143                 break;
1144             }
1145             if (ancestor->IsTopLevel())
1146                 break;
1147             ancestor = ancestor->GetParent();
1148         }
1149     }
1150 #endif // wxUSE_ACCEL
1151
1152     // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1153     // will only be sent if it is not in an accelerator table.
1154     if (!ret)
1155     {
1156         long key_code;
1157         KeySym keysym = gdk_event->keyval;
1158         // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1159         key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */);
1160         if ( !key_code )
1161         {
1162             if ( wxIsAsciiKeysym(keysym) )
1163             {
1164                 // ASCII key
1165                 key_code = (unsigned char)keysym;
1166             }
1167             // gdk_event->string is actually deprecated
1168             else if ( gdk_event->length == 1 )
1169             {
1170                 key_code = (unsigned char)gdk_event->string[0];
1171             }
1172         }
1173
1174         if ( key_code )
1175         {
1176             wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code);
1177
1178             event.m_keyCode = key_code;
1179
1180             // Implement OnCharHook by checking ancestor top level windows
1181             wxWindow *parent = win;
1182             while (parent && !parent->IsTopLevel())
1183                 parent = parent->GetParent();
1184             if (parent)
1185             {
1186                 event.SetEventType( wxEVT_CHAR_HOOK );
1187                 ret = parent->GetEventHandler()->ProcessEvent( event );
1188             }
1189
1190             if (!ret)
1191             {
1192                 event.SetEventType(wxEVT_CHAR);
1193                 ret = win->GetEventHandler()->ProcessEvent( event );
1194             }
1195         }
1196     }
1197
1198
1199
1200
1201
1202     // win is a control: tab can be propagated up
1203     if ( !ret &&
1204          ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
1205 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here - the control may
1206 //     have this style, yet choose not to process this particular TAB in which
1207 //     case TAB must still work as a navigational character
1208 // JS: enabling again to make consistent with other platforms
1209 //     (with wxTE_PROCESS_TAB you have to call Navigate to get default
1210 //     navigation behaviour)
1211 #if wxUSE_TEXTCTRL
1212          (! (win->HasFlag(wxTE_PROCESS_TAB) && win->IsKindOf(CLASSINFO(wxTextCtrl)) )) &&
1213 #endif
1214          win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1215     {
1216         wxNavigationKeyEvent new_event;
1217         new_event.SetEventObject( win->GetParent() );
1218         // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1219         new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
1220         // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1221         new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
1222         new_event.SetCurrentFocus( win );
1223         ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
1224     }
1225
1226     // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
1227     if ( !ret &&
1228          (gdk_event->keyval == GDK_Escape) )
1229     {
1230         // however only do it if we have a Cancel button in the dialog,
1231         // otherwise the user code may get confused by the events from a
1232         // non-existing button and, worse, a wxButton might get button event
1233         // from another button which is not really expected
1234         wxWindow *winForCancel = win,
1235                  *btnCancel = NULL;
1236         while ( winForCancel )
1237         {
1238             btnCancel = winForCancel->FindWindow(wxID_CANCEL);
1239             if ( btnCancel )
1240             {
1241                 // found a cancel button
1242                 break;
1243             }
1244
1245             if ( winForCancel->IsTopLevel() )
1246             {
1247                 // no need to look further
1248                 break;
1249             }
1250
1251             // maybe our parent has a cancel button?
1252             winForCancel = winForCancel->GetParent();
1253         }
1254
1255         if ( btnCancel )
1256         {
1257             wxCommandEvent eventClick(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
1258             eventClick.SetEventObject(btnCancel);
1259             ret = btnCancel->GetEventHandler()->ProcessEvent(eventClick);
1260         }
1261     }
1262
1263     if (ret)
1264     {
1265         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
1266         return TRUE;
1267     }
1268
1269     return FALSE;
1270 }
1271 }
1272
1273 //-----------------------------------------------------------------------------
1274 // "key_release_event" from any window
1275 //-----------------------------------------------------------------------------
1276
1277 extern "C" {
1278 static gint gtk_window_key_release_callback( GtkWidget *widget,
1279                                              GdkEventKey *gdk_event,
1280                                              wxWindowGTK *win )
1281 {
1282     DEBUG_MAIN_THREAD
1283
1284     if (g_isIdle)
1285         wxapp_install_idle_handler();
1286
1287     if (!win->m_hasVMT)
1288         return FALSE;
1289
1290     if (g_blockEventsOnDrag)
1291         return FALSE;
1292
1293     wxKeyEvent event( wxEVT_KEY_UP );
1294     if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1295     {
1296         // unknown key pressed, ignore (the event would be useless anyhow)
1297         return FALSE;
1298     }
1299
1300     if ( !win->GetEventHandler()->ProcessEvent( event ) )
1301         return FALSE;
1302
1303     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
1304     return TRUE;
1305 }
1306 }
1307
1308 // ============================================================================
1309 // the mouse events
1310 // ============================================================================
1311
1312 // ----------------------------------------------------------------------------
1313 // mouse event processing helpers
1314 // ----------------------------------------------------------------------------
1315
1316 // init wxMouseEvent with the info from GdkEventXXX struct
1317 template<typename T> void InitMouseEvent(wxWindowGTK *win,
1318                                          wxMouseEvent& event,
1319                                          T *gdk_event)
1320 {
1321     event.SetTimestamp( gdk_event->time );
1322     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
1323     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
1324     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
1325     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
1326     event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
1327     event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
1328     event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
1329     if (event.GetEventType() == wxEVT_MOUSEWHEEL)
1330     {
1331        event.m_linesPerAction = 3;
1332        event.m_wheelDelta = 120;
1333        if (((GdkEventButton*)gdk_event)->button == 4)
1334            event.m_wheelRotation = 120;
1335        else if (((GdkEventButton*)gdk_event)->button == 5)
1336            event.m_wheelRotation = -120;
1337     }
1338
1339     wxPoint pt = win->GetClientAreaOrigin();
1340     event.m_x = (wxCoord)gdk_event->x - pt.x;
1341     event.m_y = (wxCoord)gdk_event->y - pt.y;
1342
1343     event.SetEventObject( win );
1344     event.SetId( win->GetId() );
1345     event.SetTimestamp( gdk_event->time );
1346 }
1347
1348 static void AdjustEventButtonState(wxMouseEvent& event)
1349 {
1350     // GDK reports the old state of the button for a button press event, but
1351     // for compatibility with MSW and common sense we want m_leftDown be true
1352     // for a LEFT_DOWN event, not FALSE, so we will invert
1353     // left/right/middleDown for the corresponding click events
1354
1355     if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1356         (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1357         (event.GetEventType() == wxEVT_LEFT_UP))
1358     {
1359         event.m_leftDown = !event.m_leftDown;
1360         return;
1361     }
1362
1363     if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1364         (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1365         (event.GetEventType() == wxEVT_MIDDLE_UP))
1366     {
1367         event.m_middleDown = !event.m_middleDown;
1368         return;
1369     }
1370
1371     if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1372         (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1373         (event.GetEventType() == wxEVT_RIGHT_UP))
1374     {
1375         event.m_rightDown = !event.m_rightDown;
1376         return;
1377     }
1378 }
1379
1380 // find the window to send the mouse event too
1381 static
1382 wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1383 {
1384     wxCoord xx = x;
1385     wxCoord yy = y;
1386
1387     if (win->m_wxwindow)
1388     {
1389         GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
1390         xx += pizza->xoffset;
1391         yy += pizza->yoffset;
1392     }
1393
1394     wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
1395     while (node)
1396     {
1397         wxWindowGTK *child = node->GetData();
1398
1399         node = node->GetNext();
1400         if (!child->IsShown())
1401             continue;
1402
1403         if (child->IsTransparentForMouse())
1404         {
1405             // wxStaticBox is transparent in the box itself
1406             int xx1 = child->m_x;
1407             int yy1 = child->m_y;
1408             int xx2 = child->m_x + child->m_width;
1409             int yy2 = child->m_y + child->m_height;
1410
1411             // left
1412             if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
1413             // right
1414                 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
1415             // top
1416                 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
1417             // bottom
1418                 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
1419             {
1420                 win = child;
1421                 x -= child->m_x;
1422                 y -= child->m_y;
1423                 break;
1424             }
1425
1426         }
1427         else
1428         {
1429             if ((child->m_wxwindow == (GtkWidget*) NULL) &&
1430                 (child->m_x <= xx) &&
1431                 (child->m_y <= yy) &&
1432                 (child->m_x+child->m_width  >= xx) &&
1433                 (child->m_y+child->m_height >= yy))
1434             {
1435                 win = child;
1436                 x -= child->m_x;
1437                 y -= child->m_y;
1438                 break;
1439             }
1440         }
1441     }
1442
1443     return win;
1444 }
1445
1446 //-----------------------------------------------------------------------------
1447 // "button_press_event"
1448 //-----------------------------------------------------------------------------
1449
1450 extern "C" {
1451 static gint gtk_window_button_press_callback( GtkWidget *widget,
1452                                               GdkEventButton *gdk_event,
1453                                               wxWindowGTK *win )
1454 {
1455     DEBUG_MAIN_THREAD
1456
1457     if (g_isIdle)
1458         wxapp_install_idle_handler();
1459
1460 /*
1461     wxPrintf( wxT("1) OnButtonPress from ") );
1462     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1463         wxPrintf( win->GetClassInfo()->GetClassName() );
1464     wxPrintf( wxT(".\n") );
1465 */
1466     if (!win->m_hasVMT) return FALSE;
1467     if (g_blockEventsOnDrag) return TRUE;
1468     if (g_blockEventsOnScroll) return TRUE;
1469
1470     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1471
1472     if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus())
1473     {
1474         gtk_widget_grab_focus( win->m_wxwindow );
1475 /*
1476         wxPrintf( wxT("GrabFocus from ") );
1477         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1478             wxPrintf( win->GetClassInfo()->GetClassName() );
1479         wxPrintf( wxT(".\n") );
1480 */
1481     }
1482
1483     // GDK sends surplus button down events
1484     // before a double click event. We
1485     // need to filter these out.
1486     if (gdk_event->type == GDK_BUTTON_PRESS)
1487     {
1488         GdkEvent *peek_event = gdk_event_peek();
1489         if (peek_event)
1490         {
1491             if ((peek_event->type == GDK_2BUTTON_PRESS) ||
1492                 (peek_event->type == GDK_3BUTTON_PRESS))
1493             {
1494                 gdk_event_free( peek_event );
1495                 return TRUE;
1496             }
1497             else
1498             {
1499                 gdk_event_free( peek_event );
1500             }
1501         }
1502     }
1503
1504     wxEventType event_type = wxEVT_NULL;
1505
1506     if (gdk_event->button == 1)
1507     {
1508         // note that GDK generates triple click events which are not supported
1509         // by wxWidgets but still have to be passed to the app as otherwise
1510         // clicks would simply go missing
1511         switch (gdk_event->type)
1512         {
1513             // we shouldn't get triple clicks at all for GTK2 because we
1514             // suppress them artificially using the code above but we still
1515             // should map them to something for GTK1 and not just ignore them
1516             // as this would lose clicks
1517             case GDK_3BUTTON_PRESS:     // we could also map this to DCLICK...
1518             case GDK_BUTTON_PRESS:
1519                 event_type = wxEVT_LEFT_DOWN;
1520                 break;
1521
1522             case GDK_2BUTTON_PRESS:
1523                 event_type = wxEVT_LEFT_DCLICK;
1524                 break;
1525
1526             default:
1527                 // just to silence gcc warnings
1528                 ;
1529         }
1530     }
1531     else if (gdk_event->button == 2)
1532     {
1533         switch (gdk_event->type)
1534         {
1535             case GDK_3BUTTON_PRESS:
1536             case GDK_BUTTON_PRESS:
1537                 event_type = wxEVT_MIDDLE_DOWN;
1538                 break;
1539
1540             case GDK_2BUTTON_PRESS:
1541                 event_type = wxEVT_MIDDLE_DCLICK;
1542                 break;
1543
1544             default:
1545                 ;
1546         }
1547     }
1548     else if (gdk_event->button == 3)
1549     {
1550         switch (gdk_event->type)
1551         {
1552             case GDK_3BUTTON_PRESS:
1553             case GDK_BUTTON_PRESS:
1554                 event_type = wxEVT_RIGHT_DOWN;
1555                 break;
1556
1557             case GDK_2BUTTON_PRESS:
1558                 event_type = wxEVT_RIGHT_DCLICK;
1559                 break;
1560
1561             default:
1562                 ;
1563         }
1564     }
1565     else if (gdk_event->button == 4 || gdk_event->button == 5)
1566     {
1567         if (gdk_event->type == GDK_BUTTON_PRESS )
1568         {
1569             event_type = wxEVT_MOUSEWHEEL;
1570         }
1571     }
1572
1573     if ( event_type == wxEVT_NULL )
1574     {
1575         // unknown mouse button or click type
1576         return FALSE;
1577     }
1578
1579     wxMouseEvent event( event_type );
1580     InitMouseEvent( win, event, gdk_event );
1581
1582     AdjustEventButtonState(event);
1583
1584     // wxListBox actually gets mouse events from the item, so we need to give it
1585     // a chance to correct this
1586     win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1587
1588     // find the correct window to send the event to: it may be a different one
1589     // from the one which got it at GTK+ level because some controls don't have
1590     // their own X window and thus cannot get any events.
1591     if ( !g_captureWindow )
1592         win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1593
1594     wxGtkTimeLastClick = gdk_event->time;
1595
1596     if (event_type == wxEVT_LEFT_DCLICK)
1597     {
1598         // GTK 1.2 crashes when intercepting double
1599         // click events from both wxSpinButton and
1600         // wxSpinCtrl
1601         if (GTK_IS_SPIN_BUTTON(win->m_widget))
1602         {
1603             // Just disable this event for now.
1604             return FALSE;
1605         }
1606     }
1607
1608     if (win->GetEventHandler()->ProcessEvent( event ))
1609     {
1610         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
1611         return TRUE;
1612     }
1613
1614     if (event_type == wxEVT_RIGHT_DOWN)
1615     {
1616         // generate a "context menu" event: this is similar to right mouse
1617         // click under many GUIs except that it is generated differently
1618         // (right up under MSW, ctrl-click under Mac, right down here) and
1619         //
1620         // (a) it's a command event and so is propagated to the parent
1621         // (b) under some ports it can be generated from kbd too
1622         // (c) it uses screen coords (because of (a))
1623         wxContextMenuEvent evtCtx(
1624             wxEVT_CONTEXT_MENU,
1625             win->GetId(),
1626             win->ClientToScreen(event.GetPosition()));
1627         evtCtx.SetEventObject(win);
1628         return win->GetEventHandler()->ProcessEvent(evtCtx);
1629     }
1630
1631     return FALSE;
1632 }
1633 }
1634
1635 //-----------------------------------------------------------------------------
1636 // "button_release_event"
1637 //-----------------------------------------------------------------------------
1638
1639 extern "C" {
1640 static gint gtk_window_button_release_callback( GtkWidget *widget,
1641                                                 GdkEventButton *gdk_event,
1642                                                 wxWindowGTK *win )
1643 {
1644     DEBUG_MAIN_THREAD
1645
1646     if (g_isIdle)
1647         wxapp_install_idle_handler();
1648
1649     if (!win->m_hasVMT) return FALSE;
1650     if (g_blockEventsOnDrag) return FALSE;
1651     if (g_blockEventsOnScroll) return FALSE;
1652
1653     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1654
1655     wxEventType event_type = wxEVT_NULL;
1656
1657     switch (gdk_event->button)
1658     {
1659         case 1:
1660             event_type = wxEVT_LEFT_UP;
1661             break;
1662
1663         case 2:
1664             event_type = wxEVT_MIDDLE_UP;
1665             break;
1666
1667         case 3:
1668             event_type = wxEVT_RIGHT_UP;
1669             break;
1670
1671         default:
1672             // unknwon button, don't process
1673             return FALSE;
1674     }
1675
1676     wxMouseEvent event( event_type );
1677     InitMouseEvent( win, event, gdk_event );
1678
1679     AdjustEventButtonState(event);
1680
1681     // same wxListBox hack as above
1682     win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1683
1684     if ( !g_captureWindow )
1685         win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1686
1687     if (win->GetEventHandler()->ProcessEvent( event ))
1688     {
1689         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
1690         return TRUE;
1691     }
1692
1693     return FALSE;
1694 }
1695 }
1696
1697 //-----------------------------------------------------------------------------
1698 // "motion_notify_event"
1699 //-----------------------------------------------------------------------------
1700
1701 extern "C" {
1702 static gint gtk_window_motion_notify_callback( GtkWidget *widget,
1703                                                GdkEventMotion *gdk_event,
1704                                                wxWindowGTK *win )
1705 {
1706     DEBUG_MAIN_THREAD
1707
1708     if (g_isIdle)
1709         wxapp_install_idle_handler();
1710
1711     if (!win->m_hasVMT) return FALSE;
1712     if (g_blockEventsOnDrag) return FALSE;
1713     if (g_blockEventsOnScroll) return FALSE;
1714
1715     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1716
1717     if (gdk_event->is_hint)
1718     {
1719         int x = 0;
1720         int y = 0;
1721         GdkModifierType state;
1722         gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1723         gdk_event->x = x;
1724         gdk_event->y = y;
1725     }
1726
1727 /*
1728     printf( "OnMotion from " );
1729     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1730       printf( win->GetClassInfo()->GetClassName() );
1731     printf( ".\n" );
1732 */
1733
1734     wxMouseEvent event( wxEVT_MOTION );
1735     InitMouseEvent(win, event, gdk_event);
1736
1737     if ( g_captureWindow )
1738     {
1739         // synthetize a mouse enter or leave event if needed
1740         GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
1741         // This seems to be necessary and actually been added to
1742         // GDK itself in version 2.0.X
1743         gdk_flush();
1744
1745         bool hasMouse = winUnderMouse == gdk_event->window;
1746         if ( hasMouse != g_captureWindowHasMouse )
1747         {
1748             // the mouse changed window
1749             g_captureWindowHasMouse = hasMouse;
1750
1751             wxMouseEvent eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1752                                                         : wxEVT_LEAVE_WINDOW);
1753             InitMouseEvent(win, eventM, gdk_event);
1754             eventM.SetEventObject(win);
1755             win->GetEventHandler()->ProcessEvent(eventM);
1756         }
1757     }
1758     else // no capture
1759     {
1760         win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1761     }
1762
1763     if (win->GetEventHandler()->ProcessEvent( event ))
1764     {
1765         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
1766         return TRUE;
1767     }
1768
1769     return FALSE;
1770 }
1771 }
1772
1773 //-----------------------------------------------------------------------------
1774 // "focus_in_event"
1775 //-----------------------------------------------------------------------------
1776
1777 // send the wxChildFocusEvent and wxFocusEvent, common code of
1778 // gtk_window_focus_in_callback() and SetFocus()
1779 static bool DoSendFocusEvents(wxWindow *win)
1780 {
1781     // Notify the parent keeping track of focus for the kbd navigation
1782     // purposes that we got it.
1783     wxChildFocusEvent eventChildFocus(win);
1784     (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
1785
1786     wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
1787     eventFocus.SetEventObject(win);
1788
1789     return win->GetEventHandler()->ProcessEvent(eventFocus);
1790 }
1791
1792 extern "C" {
1793 static gint gtk_window_focus_in_callback( GtkWidget *widget,
1794                                           GdkEvent *WXUNUSED(event),
1795                                           wxWindow *win )
1796 {
1797     DEBUG_MAIN_THREAD
1798
1799     if (g_isIdle)
1800         wxapp_install_idle_handler();
1801
1802     g_focusWindowLast =
1803     g_focusWindow = win;
1804
1805     wxLogTrace(TRACE_FOCUS,
1806                _T("%s: focus in"), win->GetName().c_str());
1807
1808 #ifdef HAVE_XIM
1809     if (win->m_ic)
1810         gdk_im_begin(win->m_ic, win->m_wxwindow->window);
1811 #endif
1812
1813 #if wxUSE_CARET
1814     // caret needs to be informed about focus change
1815     wxCaret *caret = win->GetCaret();
1816     if ( caret )
1817     {
1818         caret->OnSetFocus();
1819     }
1820 #endif // wxUSE_CARET
1821
1822     // does the window itself think that it has the focus?
1823     if ( !win->m_hasFocus )
1824     {
1825         // not yet, notify it
1826         win->m_hasFocus = true;
1827
1828         if ( DoSendFocusEvents(win) )
1829         {
1830            gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
1831            return TRUE;
1832         }
1833     }
1834
1835     return FALSE;
1836 }
1837 }
1838
1839 //-----------------------------------------------------------------------------
1840 // "focus_out_event"
1841 //-----------------------------------------------------------------------------
1842
1843 extern "C" {
1844 static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )
1845 {
1846     DEBUG_MAIN_THREAD
1847
1848     if (g_isIdle)
1849         wxapp_install_idle_handler();
1850
1851     wxLogTrace( TRACE_FOCUS,
1852                 _T("%s: focus out"), win->GetName().c_str() );
1853
1854
1855     wxWindowGTK *winFocus = wxFindFocusedChild(win);
1856     if ( winFocus )
1857         win = winFocus;
1858
1859     g_focusWindow = (wxWindowGTK *)NULL;
1860
1861 #ifdef HAVE_XIM
1862     if (win->m_ic)
1863         gdk_im_end();
1864 #endif
1865
1866 #if wxUSE_CARET
1867     // caret needs to be informed about focus change
1868     wxCaret *caret = win->GetCaret();
1869     if ( caret )
1870     {
1871         caret->OnKillFocus();
1872     }
1873 #endif // wxUSE_CARET
1874
1875     // don't send the window a kill focus event if it thinks that it doesn't
1876     // have focus already
1877     if ( win->m_hasFocus )
1878     {
1879         win->m_hasFocus = false;
1880
1881         wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
1882         event.SetEventObject( win );
1883
1884         // even if we did process the event in wx code, still let GTK itself
1885         // process it too as otherwise bad things happen, especially in GTK2
1886         // where the text control simply aborts the program if it doesn't get
1887         // the matching focus out event
1888         (void)win->GetEventHandler()->ProcessEvent( event );
1889     }
1890
1891     return FALSE;
1892 }
1893 }
1894
1895 //-----------------------------------------------------------------------------
1896 // "enter_notify_event"
1897 //-----------------------------------------------------------------------------
1898
1899 extern "C" {
1900 static
1901 gint gtk_window_enter_callback( GtkWidget *widget,
1902                                 GdkEventCrossing *gdk_event,
1903                                 wxWindowGTK *win )
1904 {
1905     DEBUG_MAIN_THREAD
1906
1907     if (g_isIdle)
1908         wxapp_install_idle_handler();
1909
1910     if (!win->m_hasVMT) return FALSE;
1911     if (g_blockEventsOnDrag) return FALSE;
1912
1913     // Event was emitted after a grab
1914     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1915
1916     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1917
1918     int x = 0;
1919     int y = 0;
1920     GdkModifierType state = (GdkModifierType)0;
1921
1922     gdk_window_get_pointer( widget->window, &x, &y, &state );
1923
1924     wxMouseEvent event( wxEVT_ENTER_WINDOW );
1925     InitMouseEvent(win, event, gdk_event);
1926     wxPoint pt = win->GetClientAreaOrigin();
1927     event.m_x = x + pt.x;
1928     event.m_y = y + pt.y;
1929
1930     if (win->GetEventHandler()->ProcessEvent( event ))
1931     {
1932        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
1933        return TRUE;
1934     }
1935
1936     return FALSE;
1937 }
1938 }
1939
1940 //-----------------------------------------------------------------------------
1941 // "leave_notify_event"
1942 //-----------------------------------------------------------------------------
1943
1944 extern "C" {
1945 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
1946 {
1947     DEBUG_MAIN_THREAD
1948
1949     if (g_isIdle)
1950         wxapp_install_idle_handler();
1951
1952     if (!win->m_hasVMT) return FALSE;
1953     if (g_blockEventsOnDrag) return FALSE;
1954
1955     // Event was emitted after an ungrab
1956     if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
1957
1958     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1959
1960     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1961     event.SetTimestamp( gdk_event->time );
1962     event.SetEventObject( win );
1963
1964     int x = 0;
1965     int y = 0;
1966     GdkModifierType state = (GdkModifierType)0;
1967
1968     gdk_window_get_pointer( widget->window, &x, &y, &state );
1969
1970     event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
1971     event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
1972     event.m_altDown = (state & GDK_MOD1_MASK) != 0;
1973     event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
1974     event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
1975     event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
1976     event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
1977
1978     wxPoint pt = win->GetClientAreaOrigin();
1979     event.m_x = x + pt.x;
1980     event.m_y = y + pt.y;
1981
1982     if (win->GetEventHandler()->ProcessEvent( event ))
1983     {
1984         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
1985         return TRUE;
1986     }
1987
1988     return FALSE;
1989 }
1990 }
1991
1992 //-----------------------------------------------------------------------------
1993 // "value_changed" from m_vAdjust
1994 //-----------------------------------------------------------------------------
1995
1996 extern "C" {
1997 static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
1998                                          SCROLLBAR_CBACK_ARG
1999                                          wxWindowGTK *win )
2000 {
2001     DEBUG_MAIN_THREAD
2002
2003     if (g_isIdle)
2004         wxapp_install_idle_handler();
2005
2006     if (g_blockEventsOnDrag) return;
2007
2008     if (!win->m_hasVMT) return;
2009
2010     float diff = adjust->value - win->m_oldVerticalPos;
2011     if (fabs(diff) < 0.2) return;
2012
2013     win->m_oldVerticalPos = adjust->value;
2014
2015     GtkScrolledWindow   *sw = GTK_SCROLLED_WINDOW(win->m_widget);
2016     wxEventType         command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->vscrollbar));
2017
2018     int value = (int)(adjust->value+0.5);
2019
2020     wxScrollWinEvent event( command, value, wxVERTICAL );
2021     event.SetEventObject( win );
2022     win->GetEventHandler()->ProcessEvent( event );
2023 }
2024 }
2025
2026 //-----------------------------------------------------------------------------
2027 // "value_changed" from m_hAdjust
2028 //-----------------------------------------------------------------------------
2029
2030 extern "C" {
2031 static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
2032                                          SCROLLBAR_CBACK_ARG
2033                                          wxWindowGTK *win )
2034 {
2035     DEBUG_MAIN_THREAD
2036
2037     if (g_isIdle)
2038         wxapp_install_idle_handler();
2039
2040     if (g_blockEventsOnDrag) return;
2041     if (!win->m_hasVMT) return;
2042
2043     float diff = adjust->value - win->m_oldHorizontalPos;
2044     if (fabs(diff) < 0.2) return;
2045
2046     GtkScrolledWindow   *sw = GTK_SCROLLED_WINDOW(win->m_widget);
2047     wxEventType         command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->hscrollbar));
2048
2049     win->m_oldHorizontalPos = adjust->value;
2050
2051     int value = (int)(adjust->value+0.5);
2052
2053     wxScrollWinEvent event( command, value, wxHORIZONTAL );
2054     event.SetEventObject( win );
2055     win->GetEventHandler()->ProcessEvent( event );
2056 }
2057 }
2058
2059 //-----------------------------------------------------------------------------
2060 // "button_press_event" from scrollbar
2061 //-----------------------------------------------------------------------------
2062
2063 extern "C" {
2064 static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
2065                                                  GdkEventButton *gdk_event,
2066                                                  wxWindowGTK *win)
2067 {
2068     DEBUG_MAIN_THREAD
2069
2070     if (g_isIdle)
2071         wxapp_install_idle_handler();
2072
2073
2074     g_blockEventsOnScroll = true;
2075
2076     // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2077     win->m_isScrolling = (gdk_event->window == widget->slider);
2078
2079     return FALSE;
2080 }
2081 }
2082
2083 //-----------------------------------------------------------------------------
2084 // "button_release_event" from scrollbar
2085 //-----------------------------------------------------------------------------
2086
2087 extern "C" {
2088 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
2089                                                    GdkEventButton *WXUNUSED(gdk_event),
2090                                                    wxWindowGTK *win)
2091 {
2092     DEBUG_MAIN_THREAD
2093
2094 //  don't test here as we can release the mouse while being over
2095 //  a different window than the slider
2096 //
2097 //    if (gdk_event->window != widget->slider) return FALSE;
2098
2099     g_blockEventsOnScroll = false;
2100
2101     if (win->m_isScrolling)
2102     {
2103         wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
2104         int value = -1;
2105         int dir = -1;
2106
2107         GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
2108         if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
2109         {
2110             value = (int)(win->m_hAdjust->value+0.5);
2111             dir = wxHORIZONTAL;
2112         }
2113         if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
2114         {
2115             value = (int)(win->m_vAdjust->value+0.5);
2116             dir = wxVERTICAL;
2117         }
2118
2119         wxScrollWinEvent event( command, value, dir );
2120         event.SetEventObject( win );
2121         win->GetEventHandler()->ProcessEvent( event );
2122     }
2123
2124     win->m_isScrolling = false;
2125
2126     return FALSE;
2127 }
2128 }
2129
2130 // ----------------------------------------------------------------------------
2131 // this wxWindowBase function is implemented here (in platform-specific file)
2132 // because it is static and so couldn't be made virtual
2133 // ----------------------------------------------------------------------------
2134
2135 wxWindow *wxWindowBase::DoFindFocus()
2136 {
2137     // the cast is necessary when we compile in wxUniversal mode
2138     return (wxWindow *)g_focusWindow;
2139 }
2140
2141 //-----------------------------------------------------------------------------
2142 // "realize" from m_widget
2143 //-----------------------------------------------------------------------------
2144
2145 /* We cannot set colours and fonts before the widget has
2146    been realized, so we do this directly after realization. */
2147
2148 extern "C" {
2149 static gint
2150 gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
2151 {
2152     DEBUG_MAIN_THREAD
2153
2154     if (g_isIdle)
2155         wxapp_install_idle_handler();
2156
2157     wxWindowCreateEvent event( win );
2158     event.SetEventObject( win );
2159     win->GetEventHandler()->ProcessEvent( event );
2160
2161     return FALSE;
2162 }
2163 }
2164
2165 //-----------------------------------------------------------------------------
2166 // "size_allocate"
2167 //-----------------------------------------------------------------------------
2168
2169 extern "C" {
2170 static
2171 void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2172                                GtkAllocation *WXUNUSED(alloc),
2173                                wxWindow *win )
2174 {
2175     if (g_isIdle)
2176         wxapp_install_idle_handler();
2177
2178     if (!win->m_hasScrolling) return;
2179
2180     int client_width = 0;
2181     int client_height = 0;
2182     win->GetClientSize( &client_width, &client_height );
2183     if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2184         return;
2185
2186     win->m_oldClientWidth = client_width;
2187     win->m_oldClientHeight = client_height;
2188
2189     if (!win->m_nativeSizeEvent)
2190     {
2191         wxSizeEvent event( win->GetSize(), win->GetId() );
2192         event.SetEventObject( win );
2193         win->GetEventHandler()->ProcessEvent( event );
2194     }
2195 }
2196 }
2197
2198
2199 #ifdef HAVE_XIM
2200     #define WXUNUSED_UNLESS_XIM(param)  param
2201 #else
2202     #define WXUNUSED_UNLESS_XIM(param)  WXUNUSED(param)
2203 #endif
2204
2205 /* Resize XIM window */
2206
2207 extern "C" {
2208 static
2209 void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
2210                                  GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
2211                                  wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
2212 {
2213     if (g_isIdle)
2214         wxapp_install_idle_handler();
2215
2216 #ifdef HAVE_XIM
2217     if (!win->m_ic)
2218         return;
2219
2220     if  (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
2221     {
2222         gint width, height;
2223
2224         gdk_window_get_size (widget->window, &width, &height);
2225         win->m_icattr->preedit_area.width = width;
2226         win->m_icattr->preedit_area.height = height;
2227         gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
2228     }
2229 #endif // HAVE_XIM
2230 }
2231 }
2232
2233 //-----------------------------------------------------------------------------
2234 // "realize" from m_wxwindow
2235 //-----------------------------------------------------------------------------
2236
2237 /* Initialize XIM support */
2238
2239 extern "C" {
2240 static gint
2241 gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
2242                                 wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
2243 {
2244     if (g_isIdle)
2245         wxapp_install_idle_handler();
2246
2247 #ifdef HAVE_XIM
2248     if (win->m_ic) return FALSE;
2249     if (!widget) return FALSE;
2250     if (!gdk_im_ready()) return FALSE;
2251
2252     win->m_icattr = gdk_ic_attr_new();
2253     if (!win->m_icattr) return FALSE;
2254
2255     gint width, height;
2256     GdkEventMask mask;
2257     GdkColormap *colormap;
2258     GdkICAttr *attr = win->m_icattr;
2259     unsigned attrmask = GDK_IC_ALL_REQ;
2260     GdkIMStyle style;
2261     GdkIMStyle supported_style = (GdkIMStyle)
2262                                   (GDK_IM_PREEDIT_NONE |
2263                                    GDK_IM_PREEDIT_NOTHING |
2264                                    GDK_IM_PREEDIT_POSITION |
2265                                    GDK_IM_STATUS_NONE |
2266                                    GDK_IM_STATUS_NOTHING);
2267
2268     if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2269         supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
2270
2271     attr->style = style = gdk_im_decide_style (supported_style);
2272     attr->client_window = widget->window;
2273
2274     if ((colormap = gtk_widget_get_colormap (widget)) !=
2275             gtk_widget_get_default_colormap ())
2276     {
2277         attrmask |= GDK_IC_PREEDIT_COLORMAP;
2278         attr->preedit_colormap = colormap;
2279     }
2280
2281     attrmask |= GDK_IC_PREEDIT_FOREGROUND;
2282     attrmask |= GDK_IC_PREEDIT_BACKGROUND;
2283     attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
2284     attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
2285
2286     switch (style & GDK_IM_PREEDIT_MASK)
2287     {
2288         case GDK_IM_PREEDIT_POSITION:
2289             if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2290             {
2291                 g_warning ("over-the-spot style requires fontset");
2292                 break;
2293             }
2294
2295             gdk_window_get_size (widget->window, &width, &height);
2296
2297             attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
2298             attr->spot_location.x = 0;
2299             attr->spot_location.y = height;
2300             attr->preedit_area.x = 0;
2301             attr->preedit_area.y = 0;
2302             attr->preedit_area.width = width;
2303             attr->preedit_area.height = height;
2304             attr->preedit_fontset = widget->style->font;
2305
2306             break;
2307     }
2308
2309       win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
2310
2311       if (win->m_ic == NULL)
2312           g_warning ("Can't create input context.");
2313       else
2314       {
2315           mask = gdk_window_get_events (widget->window);
2316           mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
2317           gdk_window_set_events (widget->window, mask);
2318
2319           if (GTK_WIDGET_HAS_FOCUS(widget))
2320               gdk_im_begin (win->m_ic, widget->window);
2321       }
2322 #endif // HAVE_XIM
2323
2324     return FALSE;
2325 }
2326 }
2327
2328 //-----------------------------------------------------------------------------
2329 // InsertChild for wxWindowGTK.
2330 //-----------------------------------------------------------------------------
2331
2332 /* Callback for wxWindowGTK. This very strange beast has to be used because
2333  * C++ has no virtual methods in a constructor. We have to emulate a
2334  * virtual function here as wxNotebook requires a different way to insert
2335  * a child in it. I had opted for creating a wxNotebookPage window class
2336  * which would have made this superfluous (such in the MDI window system),
2337  * but no-one was listening to me... */
2338
2339 static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
2340 {
2341     /* the window might have been scrolled already, do we
2342        have to adapt the position */
2343     GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2344     child->m_x += pizza->xoffset;
2345     child->m_y += pizza->yoffset;
2346
2347     gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
2348                      GTK_WIDGET(child->m_widget),
2349                      child->m_x,
2350                      child->m_y,
2351                      child->m_width,
2352                      child->m_height );
2353 }
2354
2355 //-----------------------------------------------------------------------------
2356 // global functions
2357 //-----------------------------------------------------------------------------
2358
2359 wxWindow *wxGetActiveWindow()
2360 {
2361     return wxWindow::FindFocus();
2362 }
2363
2364
2365 wxMouseState wxGetMouseState()
2366 {
2367     wxMouseState ms;
2368
2369     gint x;
2370     gint y;
2371     GdkModifierType mask;
2372
2373     gdk_window_get_pointer(NULL, &x, &y, &mask);
2374
2375     ms.SetX(x);
2376     ms.SetY(y);
2377     ms.SetLeftDown(mask & GDK_BUTTON1_MASK);
2378     ms.SetMiddleDown(mask & GDK_BUTTON2_MASK);
2379     ms.SetRightDown(mask & GDK_BUTTON3_MASK);
2380
2381     ms.SetControlDown(mask & GDK_CONTROL_MASK);
2382     ms.SetShiftDown(mask & GDK_SHIFT_MASK);
2383     ms.SetAltDown(mask & GDK_MOD1_MASK);
2384     ms.SetMetaDown(mask & GDK_MOD2_MASK);
2385
2386     return ms;
2387 }
2388
2389 //-----------------------------------------------------------------------------
2390 // wxWindowGTK
2391 //-----------------------------------------------------------------------------
2392
2393 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2394 // method
2395 #ifdef __WXUNIVERSAL__
2396     IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2397 #else // __WXGTK__
2398     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
2399 #endif // __WXUNIVERSAL__/__WXGTK__
2400
2401 void wxWindowGTK::Init()
2402 {
2403     // GTK specific
2404     m_widget = (GtkWidget *) NULL;
2405     m_wxwindow = (GtkWidget *) NULL;
2406     m_focusWidget = (GtkWidget *) NULL;
2407
2408     // position/size
2409     m_x = 0;
2410     m_y = 0;
2411     m_width = 0;
2412     m_height = 0;
2413
2414     m_sizeSet = false;
2415     m_hasVMT = false;
2416     m_needParent = true;
2417     m_isBeingDeleted = false;
2418
2419     m_noExpose = false;
2420     m_nativeSizeEvent = false;
2421
2422     m_hasScrolling = false;
2423     m_isScrolling = false;
2424
2425     m_hAdjust = (GtkAdjustment*) NULL;
2426     m_vAdjust = (GtkAdjustment*) NULL;
2427     m_oldHorizontalPos =
2428     m_oldVerticalPos = 0.0;
2429     m_oldClientWidth =
2430     m_oldClientHeight = 0;
2431
2432     m_resizing = false;
2433
2434     m_insertCallback = (wxInsertChildFunction) NULL;
2435
2436     m_acceptsFocus = false;
2437     m_hasFocus = false;
2438
2439     m_clipPaintRegion = false;
2440
2441     m_needsStyleChange = false;
2442
2443     m_cursor = *wxSTANDARD_CURSOR;
2444
2445 #ifdef HAVE_XIM
2446     m_ic = (GdkIC*) NULL;
2447     m_icattr = (GdkICAttr*) NULL;
2448 #endif
2449 }
2450
2451 wxWindowGTK::wxWindowGTK()
2452 {
2453     Init();
2454 }
2455
2456 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2457                           wxWindowID id,
2458                           const wxPoint &pos,
2459                           const wxSize &size,
2460                           long style,
2461                           const wxString &name  )
2462 {
2463     Init();
2464
2465     Create( parent, id, pos, size, style, name );
2466 }
2467
2468 bool wxWindowGTK::Create( wxWindow *parent,
2469                           wxWindowID id,
2470                           const wxPoint &pos,
2471                           const wxSize &size,
2472                           long style,
2473                           const wxString &name  )
2474 {
2475     if (!PreCreation( parent, pos, size ) ||
2476         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2477     {
2478         wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2479         return false;
2480     }
2481
2482     m_insertCallback = wxInsertChildInWindow;
2483
2484     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
2485     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
2486
2487     GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2488
2489     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2490     scroll_class->scrollbar_spacing = 0;
2491
2492     gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2493
2494     m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
2495     m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
2496
2497     m_wxwindow = gtk_pizza_new();
2498
2499 #ifndef __WXUNIVERSAL__
2500     GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2501
2502     if (HasFlag(wxRAISED_BORDER))
2503     {
2504         gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
2505     }
2506     else if (HasFlag(wxSUNKEN_BORDER))
2507     {
2508         gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
2509     }
2510     else if (HasFlag(wxSIMPLE_BORDER))
2511     {
2512         gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
2513     }
2514     else
2515     {
2516         gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
2517     }
2518 #endif // __WXUNIVERSAL__
2519
2520     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2521
2522     GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
2523     m_acceptsFocus = true;
2524
2525     // I _really_ don't want scrollbars in the beginning
2526     m_vAdjust->lower = 0.0;
2527     m_vAdjust->upper = 1.0;
2528     m_vAdjust->value = 0.0;
2529     m_vAdjust->step_increment = 1.0;
2530     m_vAdjust->page_increment = 1.0;
2531     m_vAdjust->page_size = 5.0;
2532     gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2533     m_hAdjust->lower = 0.0;
2534     m_hAdjust->upper = 1.0;
2535     m_hAdjust->value = 0.0;
2536     m_hAdjust->step_increment = 1.0;
2537     m_hAdjust->page_increment = 1.0;
2538     m_hAdjust->page_size = 5.0;
2539     gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2540
2541     // these handlers block mouse events to any window during scrolling such as
2542     // motion events and prevent GTK and wxWidgets from fighting over where the
2543     // slider should be
2544
2545     gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
2546           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2547
2548     gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
2549           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2550
2551     gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
2552           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2553
2554     gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
2555           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2556
2557     // these handlers get notified when screen updates are required either when
2558     // scrolling or when the window size (and therefore scrollbar configuration)
2559     // has changed
2560
2561     gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2562           (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2563     gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2564           (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2565
2566     gtk_widget_show( m_wxwindow );
2567
2568     if (m_parent)
2569         m_parent->DoAddChild( this );
2570
2571     m_focusWidget = m_wxwindow;
2572
2573     PostCreation();
2574
2575     return true;
2576 }
2577
2578 wxWindowGTK::~wxWindowGTK()
2579 {
2580     SendDestroyEvent();
2581
2582     if (g_focusWindow == this)
2583         g_focusWindow = NULL;
2584
2585     if ( g_delayedFocus == this )
2586         g_delayedFocus = NULL;
2587
2588     m_isBeingDeleted = true;
2589     m_hasVMT = false;
2590
2591     // destroy children before destroying this window itself
2592     DestroyChildren();
2593
2594     // unhook focus handlers to prevent stray events being
2595     // propagated to this (soon to be) dead object
2596     if (m_focusWidget != NULL)
2597     {
2598         gtk_signal_disconnect_by_func( GTK_OBJECT(m_focusWidget),
2599             (GtkSignalFunc) gtk_window_focus_in_callback, (gpointer) this );
2600         gtk_signal_disconnect_by_func( GTK_OBJECT(m_focusWidget),
2601             (GtkSignalFunc) gtk_window_focus_out_callback, (gpointer) this );
2602     }
2603
2604     if (m_widget)
2605         Show( false );
2606
2607 #ifdef HAVE_XIM
2608     if (m_ic)
2609         gdk_ic_destroy (m_ic);
2610     if (m_icattr)
2611         gdk_ic_attr_destroy (m_icattr);
2612 #endif
2613
2614     if (m_wxwindow)
2615     {
2616         gtk_widget_destroy( m_wxwindow );
2617         m_wxwindow = (GtkWidget*) NULL;
2618     }
2619
2620     if (m_widget)
2621     {
2622         gtk_widget_destroy( m_widget );
2623         m_widget = (GtkWidget*) NULL;
2624     }
2625 }
2626
2627 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos,  const wxSize &size )
2628 {
2629     wxCHECK_MSG( !m_needParent || parent, false, wxT("Need complete parent.") );
2630
2631     // Use either the given size, or the default if -1 is given.
2632     // See wxWindowBase for these functions.
2633     m_width = WidthDefault(size.x) ;
2634     m_height = HeightDefault(size.y);
2635
2636     m_x = (int)pos.x;
2637     m_y = (int)pos.y;
2638
2639     return true;
2640 }
2641
2642 void wxWindowGTK::PostCreation()
2643 {
2644     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2645
2646     if (m_wxwindow)
2647     {
2648         if (!m_noExpose)
2649         {
2650             // these get reported to wxWidgets -> wxPaintEvent
2651
2652             gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2653
2654             gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2655                 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2656
2657             gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2658                 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
2659
2660             if (!HasFlag(wxFULL_REPAINT_ON_RESIZE))
2661             {
2662                 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2663                     GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2664             }
2665         }
2666
2667         // these are called when the "sunken" or "raised" borders are drawn
2668         gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2669           GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2670
2671         gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2672           GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
2673     }
2674
2675     // focus handling
2676
2677     if (!GTK_IS_WINDOW(m_widget))
2678     {
2679         if (m_focusWidget == NULL)
2680             m_focusWidget = m_widget;
2681
2682         gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2683             GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2684
2685         gtk_signal_connect_after( GTK_OBJECT(m_focusWidget), "focus_out_event",
2686             GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2687     }
2688
2689     // connect to the various key and mouse handlers
2690
2691     GtkWidget *connect_widget = GetConnectWidget();
2692
2693     ConnectWidget( connect_widget );
2694
2695     /* We cannot set colours, fonts and cursors before the widget has
2696        been realized, so we do this directly after realization */
2697     gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
2698                             GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2699
2700     if (m_wxwindow)
2701     {
2702         // Catch native resize events
2703         gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2704                             GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2705
2706         // Initialize XIM support
2707         gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2708                             GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
2709
2710         // And resize XIM window
2711         gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2712                             GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
2713     }
2714
2715     if (GTK_IS_COMBO(m_widget))
2716     {
2717         GtkCombo *gcombo = GTK_COMBO(m_widget);
2718
2719         gtk_signal_connect( GTK_OBJECT(gcombo->entry), "size_request",
2720                             GTK_SIGNAL_FUNC(wxgtk_combo_size_request_callback),
2721                             (gpointer) this );
2722     }
2723     else
2724     {
2725         // This is needed if we want to add our windows into native
2726         // GTK controls, such as the toolbar. With this callback, the
2727         // toolbar gets to know the correct size (the one set by the
2728         // programmer). Sadly, it misbehaves for wxComboBox.
2729         gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
2730                             GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback),
2731                             (gpointer) this );
2732     }
2733
2734     InheritAttributes();
2735
2736     m_hasVMT = true;
2737
2738     // unless the window was created initially hidden (i.e. Hide() had been
2739     // called before Create()), we should show it at GTK+ level as well
2740     if ( IsShown() )
2741         gtk_widget_show( m_widget );
2742 }
2743
2744 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2745 {
2746     gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2747       GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
2748
2749     gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2750       GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2751
2752     gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2753       GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
2754
2755     gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2756       GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
2757
2758     gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2759       GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
2760
2761     gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2762       GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
2763
2764     gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2765       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
2766 }
2767
2768 bool wxWindowGTK::Destroy()
2769 {
2770     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2771
2772     m_hasVMT = false;
2773
2774     return wxWindowBase::Destroy();
2775 }
2776
2777 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2778 {
2779     gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2780 }
2781
2782 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2783 {
2784     wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2785     wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2786
2787 /*
2788     printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2789 */
2790
2791     if (m_resizing) return; /* I don't like recursions */
2792     m_resizing = true;
2793
2794     int currentX, currentY;
2795     GetPosition(&currentX, &currentY);
2796     if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2797         x = currentX;
2798     if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2799         y = currentY;
2800     AdjustForParentClientOrigin(x, y, sizeFlags);
2801
2802     if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
2803     {
2804         /* don't set the size for children of wxNotebook, just take the values. */
2805         m_x = x;
2806         m_y = y;
2807         m_width = width;
2808         m_height = height;
2809     }
2810     else
2811     {
2812         GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2813         if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
2814         {
2815             if (x != -1) m_x = x + pizza->xoffset;
2816             if (y != -1) m_y = y + pizza->yoffset;
2817         }
2818         else
2819         {
2820             m_x = x + pizza->xoffset;
2821             m_y = y + pizza->yoffset;
2822         }
2823
2824         // calculate the best size if we should auto size the window
2825         if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2826                 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2827         {
2828             const wxSize sizeBest = GetBestSize();
2829             if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2830                 width = sizeBest.x;
2831             if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2832                 height = sizeBest.y;
2833         }
2834
2835         if (width != -1)
2836             m_width = width;
2837         if (height != -1)
2838             m_height = height;
2839
2840         int minWidth = GetMinWidth(),
2841             minHeight = GetMinHeight(),
2842             maxWidth = GetMaxWidth(),
2843             maxHeight = GetMaxHeight();
2844
2845         if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
2846         if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
2847         if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
2848         if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
2849
2850         int left_border = 0;
2851         int right_border = 0;
2852         int top_border = 0;
2853         int bottom_border = 0;
2854
2855         /* the default button has a border around it */
2856         if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2857         {
2858             left_border = 6;
2859             right_border = 6;
2860             top_border = 6;
2861             bottom_border = 5;
2862         }
2863
2864         DoMoveWindow( m_x-top_border,
2865                       m_y-left_border,
2866                       m_width+left_border+right_border,
2867                       m_height+top_border+bottom_border );
2868     }
2869
2870     if (m_hasScrolling)
2871     {
2872         /* Sometimes the client area changes size without the
2873            whole windows's size changing, but if the whole
2874            windows's size doesn't change, no wxSizeEvent will
2875            normally be sent. Here we add an extra test if
2876            the client test has been changed and this will
2877            be used then. */
2878         GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2879     }
2880
2881 /*
2882     wxPrintf( "OnSize sent from " );
2883     if (GetClassInfo() && GetClassInfo()->GetClassName())
2884         wxPrintf( GetClassInfo()->GetClassName() );
2885     wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2886 */
2887
2888     if (!m_nativeSizeEvent)
2889     {
2890         wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2891         event.SetEventObject( this );
2892         GetEventHandler()->ProcessEvent( event );
2893     }
2894
2895     m_resizing = false;
2896 }
2897
2898 void wxWindowGTK::OnInternalIdle()
2899 {
2900     // Update style if the window was not yet realized
2901     // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2902     if (m_needsStyleChange)
2903     {
2904         SetBackgroundStyle(GetBackgroundStyle());
2905         m_needsStyleChange = false;
2906     }
2907
2908     // Update invalidated regions.
2909     GtkUpdate();
2910
2911     wxCursor cursor = m_cursor;
2912     if (g_globalCursor.Ok()) cursor = g_globalCursor;
2913
2914     if (cursor.Ok())
2915     {
2916         /* I now set the cursor anew in every OnInternalIdle call
2917            as setting the cursor in a parent window also effects the
2918            windows above so that checking for the current cursor is
2919            not possible. */
2920
2921         if (m_wxwindow)
2922         {
2923             GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
2924             if (window)
2925                 gdk_window_set_cursor( window, cursor.GetCursor() );
2926
2927             if (!g_globalCursor.Ok())
2928                 cursor = *wxSTANDARD_CURSOR;
2929
2930             window = m_widget->window;
2931             if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2932                 gdk_window_set_cursor( window, cursor.GetCursor() );
2933
2934         }
2935         else if ( m_widget )
2936         {
2937             GdkWindow *window = m_widget->window;
2938             if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) )
2939                gdk_window_set_cursor( window, cursor.GetCursor() );
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     const 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 }