src/gtk1/window.cpp

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