src/gtk1/window.cpp

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