]> git.saurik.com Git - wxWidgets.git/blobdiff - src/gtk1/window.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fixed wxListCtrl::SetTextColour to set the RGB value instead of the
[wxWidgets.git] / src / gtk1 / window.cpp
diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp
index 86fc0bed68fc56882d7899bb3c41e18be94b975d..c61a2a2c67899f873a889e16ec1e773ecd8ce791 100644 (file)
--- a/src/gtk1/window.cpp
+++ b/src/gtk1/window.cpp
@@ -44,6 +44,8 @@
 #include "gdk/gdkkeysyms.h"
 #include "wx/gtk/win_gtk.h"
 
 #include "gdk/gdkkeysyms.h"
 #include "wx/gtk/win_gtk.h"
 
+#include "gdk/gdkx.h"
+
 //-----------------------------------------------------------------------------
 // documentation on internals
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // documentation on internals
 //-----------------------------------------------------------------------------
@@ -128,27 +130,455 @@
 extern wxList     wxPendingDelete;
 extern bool       g_blockEventsOnDrag;
 extern bool       g_blockEventsOnScroll;
 extern wxList     wxPendingDelete;
 extern bool       g_blockEventsOnDrag;
 extern bool       g_blockEventsOnScroll;
-static bool       g_capturing = FALSE;
+extern wxCursor   g_globalCursor;
+static wxWindow  *g_captureWindow = (wxWindow*) NULL;
 static wxWindow  *g_focusWindow = (wxWindow*) NULL;
 
 /* hack: we need something to pass to gtk_menu_popup, so we store the time of
    the last click here */
 static guint32 gs_timeLastClick = 0;
 
 static wxWindow  *g_focusWindow = (wxWindow*) NULL;
 
 /* hack: we need something to pass to gtk_menu_popup, so we store the time of
    the last click here */
 static guint32 gs_timeLastClick = 0;
 
-#if (GTK_MINOR_VERSION > 0)
+//-----------------------------------------------------------------------------
+// debug
+//-----------------------------------------------------------------------------
+
+#ifdef __WXDEBUG__
+
+static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
+                                         GdkEvent *WXUNUSED(event),
+                                         const wxChar *name )
+{
+/*
+    static bool s_done = FALSE;
+    if ( !s_done )
+    {
+        wxLog::AddTraceMask("focus");
+        s_done = TRUE;
+    }
+    wxLogTrace(_T("FOCUS NOW AT: %s"), name);
+*/
+
+    return FALSE;
+}
+
+void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window )
+{
+    wxString tmp = name;
+    tmp += _T(" FROM ");
+    tmp += window;
+
+    wxChar *s = new wxChar[tmp.Length()+1];
+
+    wxStrcpy( s, tmp );
+
+    gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
+      GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s );
+}
+
+#endif // Debug
+
+//-----------------------------------------------------------------------------
+// missing gdk functions
+//-----------------------------------------------------------------------------
+
+void
+gdk_window_warp_pointer (GdkWindow      *window,
+                         gint            x,
+                         gint            y)
+{
+  GdkWindowPrivate *priv;
+
+  if (!window)
+    window = (GdkWindow*) &gdk_root_parent;
+
+  priv = (GdkWindowPrivate*) window;
+
+  if (!priv->destroyed)
+  {
+      XWarpPointer (priv->xdisplay,
+                    None,              /* not source window -> move from anywhere */
+                    priv->xwindow,  /* dest window */
+                    0, 0, 0, 0,        /* not source window -> move from anywhere */
+                    x, y );
+  }
+}
+
+//-----------------------------------------------------------------------------
+// idle system
+//-----------------------------------------------------------------------------
+
+extern void wxapp_install_idle_handler();
+extern bool g_isIdle;
+
+//-----------------------------------------------------------------------------
+// key event conversion routines
+//-----------------------------------------------------------------------------
+
+#if (GTK_MINOR_VERSION == 0)
+/* these functions are copied verbatim from GTK 1.2 */
+static void
+gdkx_XConvertCase (KeySym symbol,
+                   KeySym *lower,
+                   KeySym *upper)
+{
+  register KeySym sym = symbol;
+
+  g_return_if_fail (lower != NULL);
+  g_return_if_fail (upper != NULL);
+
+  *lower = sym;
+  *upper = sym;
+
+  switch (sym >> 8)
+    {
+#if        defined (GDK_A) && defined (GDK_Ooblique)
+    case 0: /* Latin 1 */
+      if ((sym >= GDK_A) && (sym <= GDK_Z))
+        *lower += (GDK_a - GDK_A);
+      else if ((sym >= GDK_a) && (sym <= GDK_z))
+        *upper -= (GDK_a - GDK_A);
+      else if ((sym >= GDK_Agrave) && (sym <= GDK_Odiaeresis))
+        *lower += (GDK_agrave - GDK_Agrave);
+      else if ((sym >= GDK_agrave) && (sym <= GDK_odiaeresis))
+        *upper -= (GDK_agrave - GDK_Agrave);
+      else if ((sym >= GDK_Ooblique) && (sym <= GDK_Thorn))
+        *lower += (GDK_oslash - GDK_Ooblique);
+      else if ((sym >= GDK_oslash) && (sym <= GDK_thorn))
+        *upper -= (GDK_oslash - GDK_Ooblique);
+      break;
+#endif        /* LATIN1 */
+
+#if        defined (GDK_Aogonek) && defined (GDK_tcedilla)
+    case 1: /* Latin 2 */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (sym == GDK_Aogonek)
+        *lower = GDK_aogonek;
+      else if (sym >= GDK_Lstroke && sym <= GDK_Sacute)
+        *lower += (GDK_lstroke - GDK_Lstroke);
+      else if (sym >= GDK_Scaron && sym <= GDK_Zacute)
+        *lower += (GDK_scaron - GDK_Scaron);
+      else if (sym >= GDK_Zcaron && sym <= GDK_Zabovedot)
+        *lower += (GDK_zcaron - GDK_Zcaron);
+      else if (sym == GDK_aogonek)
+        *upper = GDK_Aogonek;
+      else if (sym >= GDK_lstroke && sym <= GDK_sacute)
+        *upper -= (GDK_lstroke - GDK_Lstroke);
+      else if (sym >= GDK_scaron && sym <= GDK_zacute)
+        *upper -= (GDK_scaron - GDK_Scaron);
+      else if (sym >= GDK_zcaron && sym <= GDK_zabovedot)
+        *upper -= (GDK_zcaron - GDK_Zcaron);
+      else if (sym >= GDK_Racute && sym <= GDK_Tcedilla)
+        *lower += (GDK_racute - GDK_Racute);
+      else if (sym >= GDK_racute && sym <= GDK_tcedilla)
+        *upper -= (GDK_racute - GDK_Racute);
+      break;
+#endif        /* LATIN2 */
+
+#if        defined (GDK_Hstroke) && defined (GDK_Cabovedot)
+    case 2: /* Latin 3 */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (sym >= GDK_Hstroke && sym <= GDK_Hcircumflex)
+        *lower += (GDK_hstroke - GDK_Hstroke);
+      else if (sym >= GDK_Gbreve && sym <= GDK_Jcircumflex)
+        *lower += (GDK_gbreve - GDK_Gbreve);
+      else if (sym >= GDK_hstroke && sym <= GDK_hcircumflex)
+        *upper -= (GDK_hstroke - GDK_Hstroke);
+      else if (sym >= GDK_gbreve && sym <= GDK_jcircumflex)
+        *upper -= (GDK_gbreve - GDK_Gbreve);
+      else if (sym >= GDK_Cabovedot && sym <= GDK_Scircumflex)
+        *lower += (GDK_cabovedot - GDK_Cabovedot);
+      else if (sym >= GDK_cabovedot && sym <= GDK_scircumflex)
+        *upper -= (GDK_cabovedot - GDK_Cabovedot);
+      break;
+#endif        /* LATIN3 */
+
+#if        defined (GDK_Rcedilla) && defined (GDK_Amacron)
+    case 3: /* Latin 4 */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (sym >= GDK_Rcedilla && sym <= GDK_Tslash)
+        *lower += (GDK_rcedilla - GDK_Rcedilla);
+      else if (sym >= GDK_rcedilla && sym <= GDK_tslash)
+        *upper -= (GDK_rcedilla - GDK_Rcedilla);
+      else if (sym == GDK_ENG)
+        *lower = GDK_eng;
+      else if (sym == GDK_eng)
+        *upper = GDK_ENG;
+      else if (sym >= GDK_Amacron && sym <= GDK_Umacron)
+        *lower += (GDK_amacron - GDK_Amacron);
+      else if (sym >= GDK_amacron && sym <= GDK_umacron)
+        *upper -= (GDK_amacron - GDK_Amacron);
+      break;
+#endif        /* LATIN4 */
+
+#if        defined (GDK_Serbian_DJE) && defined (GDK_Cyrillic_yu)
+    case 6: /* Cyrillic */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (sym >= GDK_Serbian_DJE && sym <= GDK_Serbian_DZE)
+        *lower -= (GDK_Serbian_DJE - GDK_Serbian_dje);
+      else if (sym >= GDK_Serbian_dje && sym <= GDK_Serbian_dze)
+        *upper += (GDK_Serbian_DJE - GDK_Serbian_dje);
+      else if (sym >= GDK_Cyrillic_YU && sym <= GDK_Cyrillic_HARDSIGN)
+        *lower -= (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
+      else if (sym >= GDK_Cyrillic_yu && sym <= GDK_Cyrillic_hardsign)
+        *upper += (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
+      break;
+#endif        /* CYRILLIC */
+
+#if        defined (GDK_Greek_ALPHAaccent) && defined (GDK_Greek_finalsmallsigma)
+    case 7: /* Greek */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (sym >= GDK_Greek_ALPHAaccent && sym <= GDK_Greek_OMEGAaccent)
+        *lower += (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
+      else if (sym >= GDK_Greek_alphaaccent && sym <= GDK_Greek_omegaaccent &&
+               sym != GDK_Greek_iotaaccentdieresis &&
+               sym != GDK_Greek_upsilonaccentdieresis)
+        *upper -= (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
+      else if (sym >= GDK_Greek_ALPHA && sym <= GDK_Greek_OMEGA)
+        *lower += (GDK_Greek_alpha - GDK_Greek_ALPHA);
+      else if (sym >= GDK_Greek_alpha && sym <= GDK_Greek_omega &&
+               sym != GDK_Greek_finalsmallsigma)
+        *upper -= (GDK_Greek_alpha - GDK_Greek_ALPHA);
+      break;
+#endif        /* GREEK */
+    }
+}
+
+static guint
+gdk_keyval_to_upper (guint          keyval)
+{
+  if (keyval)
+    {
+      KeySym lower_val = 0;
+      KeySym upper_val = 0;
+
+      gdkx_XConvertCase (keyval, &lower_val, &upper_val);
+      return upper_val;
+    }
+  return 0;
+}
+#endif
+
+static long map_to_unmodified_wx_keysym( KeySym keysym )
+{
+    guint key_code = 0;
+
+    switch (keysym)
+    {
+        case GDK_Shift_L:
+        case GDK_Shift_R:       key_code = WXK_SHIFT;       break;
+        case GDK_Control_L:
+        case GDK_Control_R:     key_code = WXK_CONTROL;     break;
+        case GDK_Meta_L:
+        case GDK_Meta_R:
+        case GDK_Alt_L:
+        case GDK_Alt_R:
+        case GDK_Super_L:
+        case GDK_Super_R:       key_code = WXK_ALT;         break;
+        case GDK_Menu:          key_code = WXK_MENU;        break;
+        case GDK_Help:          key_code = WXK_HELP;        break;
+        case GDK_BackSpace:     key_code = WXK_BACK;        break;
+        case GDK_ISO_Left_Tab:
+        case GDK_Tab:           key_code = WXK_TAB;         break;
+        case GDK_Linefeed:      key_code = WXK_RETURN;      break;
+        case GDK_Clear:         key_code = WXK_CLEAR;       break;
+        case GDK_Return:        key_code = WXK_RETURN;      break;
+        case GDK_Pause:         key_code = WXK_PAUSE;       break;
+        case GDK_Scroll_Lock:   key_code = WXK_SCROLL;      break;
+        case GDK_Escape:        key_code = WXK_ESCAPE;      break;
+        case GDK_Delete:        key_code = WXK_DELETE;      break;
+        case GDK_Home:          key_code = WXK_HOME;        break;
+        case GDK_Left:          key_code = WXK_LEFT;        break;
+        case GDK_Up:            key_code = WXK_UP;          break;
+        case GDK_Right:         key_code = WXK_RIGHT;       break;
+        case GDK_Down:          key_code = WXK_DOWN;        break;
+        case GDK_Prior:         key_code = WXK_PRIOR;       break;
+//      case GDK_Page_Up:       key_code = WXK_PAGEUP;      break;
+        case GDK_Next:          key_code = WXK_NEXT;        break;
+//      case GDK_Page_Down:     key_code = WXK_PAGEDOWN;    break;
+        case GDK_End:           key_code = WXK_END;         break;
+        case GDK_Begin:         key_code = WXK_HOME;        break;
+        case GDK_Select:        key_code = WXK_SELECT;      break;
+        case GDK_Print:         key_code = WXK_PRINT;       break;
+        case GDK_Execute:       key_code = WXK_EXECUTE;     break;
+        case GDK_Insert:        key_code = WXK_INSERT;      break;
+        case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;
+
+        case GDK_KP_0:         key_code = WXK_NUMPAD0;      break;
+        case GDK_KP_1:         key_code = WXK_NUMPAD1;      break;
+        case GDK_KP_2:         key_code = WXK_NUMPAD2;      break;
+        case GDK_KP_3:         key_code = WXK_NUMPAD3;      break;
+        case GDK_KP_4:         key_code = WXK_NUMPAD4;      break;
+        case GDK_KP_5:         key_code = WXK_NUMPAD5;      break;
+        case GDK_KP_6:         key_code = WXK_NUMPAD6;      break;
+        case GDK_KP_7:         key_code = WXK_NUMPAD7;      break;
+        case GDK_KP_8:         key_code = WXK_NUMPAD8;      break;
+        case GDK_KP_9:         key_code = WXK_NUMPAD9;      break;
+        case GDK_KP_Space:     key_code = WXK_NUMPAD_SPACE; break;
+        case GDK_KP_Tab:       key_code = WXK_NUMPAD_TAB;   break;
+        case GDK_KP_Enter:     key_code = WXK_NUMPAD_ENTER; break;
+        case GDK_KP_F1:        key_code = WXK_NUMPAD_F1;    break;
+        case GDK_KP_F2:        key_code = WXK_NUMPAD_F2;    break;
+        case GDK_KP_F3:        key_code = WXK_NUMPAD_F3;    break;
+        case GDK_KP_F4:        key_code = WXK_NUMPAD_F4;    break;
+        case GDK_KP_Home:      key_code = WXK_NUMPAD_HOME;  break;
+        case GDK_KP_Left:      key_code = WXK_NUMPAD_LEFT;  break;
+        case GDK_KP_Up:        key_code = WXK_NUMPAD_UP;    break;
+        case GDK_KP_Right:     key_code = WXK_NUMPAD_RIGHT; break;
+        case GDK_KP_Down:      key_code = WXK_NUMPAD_DOWN;  break;
+        case GDK_KP_Prior:     key_code = WXK_NUMPAD_PRIOR; break;
+//      case GDK_KP_Page_Up:   key_code = WXK_NUMPAD_PAGEUP;   break;
+        case GDK_KP_Next:      key_code = WXK_NUMPAD_NEXT;  break;
+//      case GDK_KP_Page_Down: key_code = WXK_NUMPAD_PAGEDOWN; break;
+        case GDK_KP_End:       key_code = WXK_NUMPAD_END;   break;
+        case GDK_KP_Begin:     key_code = WXK_NUMPAD_BEGIN; break;
+        case GDK_KP_Insert:    key_code = WXK_NUMPAD_INSERT; break;
+        case GDK_KP_Delete:    key_code = WXK_NUMPAD_DELETE; break;
+        case GDK_KP_Equal:     key_code = WXK_NUMPAD_EQUAL;  break;
+        case GDK_KP_Multiply:  key_code = WXK_NUMPAD_MULTIPLY; break;
+        case GDK_KP_Add:       key_code = WXK_NUMPAD_ADD;    break;
+        case GDK_KP_Separator: key_code = WXK_NUMPAD_SEPARATOR; break;
+        case GDK_KP_Subtract:  key_code = WXK_NUMPAD_SUBTRACT;  break;
+        case GDK_KP_Decimal:   key_code = WXK_NUMPAD_DECIMAL;   break;
+        case GDK_KP_Divide:    key_code = WXK_NUMPAD_DIVIDE;    break;
+
+        case GDK_F1:            key_code = WXK_F1;          break;
+        case GDK_F2:            key_code = WXK_F2;          break;
+        case GDK_F3:            key_code = WXK_F3;          break;
+        case GDK_F4:            key_code = WXK_F4;          break;
+        case GDK_F5:            key_code = WXK_F5;          break;
+        case GDK_F6:            key_code = WXK_F6;          break;
+        case GDK_F7:            key_code = WXK_F7;          break;
+        case GDK_F8:            key_code = WXK_F8;          break;
+        case GDK_F9:            key_code = WXK_F9;          break;
+        case GDK_F10:           key_code = WXK_F10;         break;
+        case GDK_F11:           key_code = WXK_F11;         break;
+        case GDK_F12:           key_code = WXK_F12;         break;
+        default:
+        {
+            if (keysym <= 0xFF)
+            {
+                guint upper = gdk_keyval_to_upper( keysym );
+                keysym = (upper != 0 ? upper : keysym ); /* to be MSW compatible */
+                key_code = keysym;
+            }
+        }
+    }
+
+    return (key_code);
+}
+
+static long map_to_wx_keysym( KeySym keysym )
+{
+    guint key_code = 0;
+
+    switch (keysym)
+    {
+        case GDK_Menu:          key_code = WXK_MENU;        break;
+        case GDK_Help:          key_code = WXK_HELP;        break;
+        case GDK_BackSpace:     key_code = WXK_BACK;        break;
+        case GDK_ISO_Left_Tab:
+        case GDK_Tab:           key_code = WXK_TAB;         break;
+        case GDK_Linefeed:      key_code = WXK_RETURN;      break;
+        case GDK_Clear:         key_code = WXK_CLEAR;       break;
+        case GDK_Return:        key_code = WXK_RETURN;      break;
+        case GDK_Pause:         key_code = WXK_PAUSE;       break;
+        case GDK_Scroll_Lock:   key_code = WXK_SCROLL;      break;
+        case GDK_Escape:        key_code = WXK_ESCAPE;      break;
+        case GDK_Delete:        key_code = WXK_DELETE;      break;
+        case GDK_Home:          key_code = WXK_HOME;        break;
+        case GDK_Left:          key_code = WXK_LEFT;        break;
+        case GDK_Up:            key_code = WXK_UP;          break;
+        case GDK_Right:         key_code = WXK_RIGHT;       break;
+        case GDK_Down:          key_code = WXK_DOWN;        break;
+        case GDK_Prior:         key_code = WXK_PRIOR;       break;
+//      case GDK_Page_Up:       key_code = WXK_PAGEUP;      break;
+        case GDK_Next:          key_code = WXK_NEXT;        break;
+//      case GDK_Page_Down:     key_code = WXK_PAGEDOWN;    break;
+        case GDK_End:           key_code = WXK_END;         break;
+        case GDK_Begin:         key_code = WXK_HOME;        break;
+        case GDK_Select:        key_code = WXK_SELECT;      break;
+        case GDK_Print:         key_code = WXK_PRINT;       break;
+        case GDK_Execute:       key_code = WXK_EXECUTE;     break;
+        case GDK_Insert:        key_code = WXK_INSERT;      break;
+        case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;
+
+        case GDK_KP_0:         key_code = '0';      break;
+        case GDK_KP_1:         key_code = '1';      break;
+        case GDK_KP_2:         key_code = '2';      break;
+        case GDK_KP_3:         key_code = '3';      break;
+        case GDK_KP_4:         key_code = '4';      break;
+        case GDK_KP_5:         key_code = '5';      break;
+        case GDK_KP_6:         key_code = '6';      break;
+        case GDK_KP_7:         key_code = '7';      break;
+        case GDK_KP_8:         key_code = '8';      break;
+        case GDK_KP_9:         key_code = '9';      break;
+        case GDK_KP_Space:     key_code = ' ';      break;
+        case GDK_KP_Tab:       key_code = WXK_TAB;    break;        /* or '\t' ??? */
+        case GDK_KP_Enter:     key_code = WXK_RETURN; break;        /* or '\r' ??? */
+        case GDK_KP_F1:        key_code = WXK_NUMPAD_F1;    break;
+        case GDK_KP_F2:        key_code = WXK_NUMPAD_F2;    break;
+        case GDK_KP_F3:        key_code = WXK_NUMPAD_F3;    break;
+        case GDK_KP_F4:        key_code = WXK_NUMPAD_F4;    break;
+        case GDK_KP_Home:      key_code = WXK_HOME;  break;
+        case GDK_KP_Left:      key_code = WXK_LEFT;  break;
+        case GDK_KP_Up:        key_code = WXK_UP;    break;
+        case GDK_KP_Right:     key_code = WXK_RIGHT; break;
+        case GDK_KP_Down:      key_code = WXK_DOWN;  break;
+        case GDK_KP_Prior:     key_code = WXK_PRIOR; break;
+//      case GDK_KP_Page_Up:   key_code = WXK_PAGEUP; break;
+        case GDK_KP_Next:      key_code = WXK_NEXT;  break;
+//      case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
+        case GDK_KP_End:       key_code = WXK_END;    break;
+        case GDK_KP_Begin:     key_code = WXK_HOME;   break;
+        case GDK_KP_Insert:    key_code = WXK_INSERT; break;
+        case GDK_KP_Delete:    key_code = WXK_DELETE; break;
+        case GDK_KP_Equal:     key_code = '=';   break;
+        case GDK_KP_Multiply:  key_code = '*';   break;
+        case GDK_KP_Add:       key_code = '+';   break;
+        case GDK_KP_Separator: key_code = ',';   break;
+        case GDK_KP_Subtract:  key_code = '-';   break;
+        case GDK_KP_Decimal:   key_code = '.';   break;
+        case GDK_KP_Divide:    key_code = '/';   break;
+
+        case GDK_F1:            key_code = WXK_F1;          break;
+        case GDK_F2:            key_code = WXK_F2;          break;
+        case GDK_F3:            key_code = WXK_F3;          break;
+        case GDK_F4:            key_code = WXK_F4;          break;
+        case GDK_F5:            key_code = WXK_F5;          break;
+        case GDK_F6:            key_code = WXK_F6;          break;
+        case GDK_F7:            key_code = WXK_F7;          break;
+        case GDK_F8:            key_code = WXK_F8;          break;
+        case GDK_F9:            key_code = WXK_F9;          break;
+        case GDK_F10:           key_code = WXK_F10;         break;
+        case GDK_F11:           key_code = WXK_F11;         break;
+        case GDK_F12:           key_code = WXK_F12;         break;
+        default:
+        {
+            if (keysym <= 0xFF)
+            {
+                key_code = keysym;
+            }
+        }
+    }
+
+    return (key_code);
+}
 
 //-----------------------------------------------------------------------------
 // local code (see below)
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // local code (see below)
 //-----------------------------------------------------------------------------
 
+#if (GTK_MINOR_VERSION > 0)
+
 static void draw_frame( GtkWidget *widget, wxWindow *win )
 {
 static void draw_frame( GtkWidget *widget, wxWindow *win )
 {
-    if (!win->HasVMT()) return;
+    if (!win->m_hasVMT)
+        return;
 
     int dw = 0;
     int dh = 0;
 
     int dw = 0;
     int dh = 0;
-    
-    if (win->m_hasScrolling)
+
+    if (win->HasScrolling())
     {
         GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
         GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget)->klass );
     {
         GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
         GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget)->klass );
@@ -156,8 +586,8 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
 /*
             GtkWidget *hscrollbar = scroll_window->hscrollbar;
             GtkWidget *vscrollbar = scroll_window->vscrollbar;
 /*
             GtkWidget *hscrollbar = scroll_window->hscrollbar;
             GtkWidget *vscrollbar = scroll_window->vscrollbar;
-           
-           we use this instead:  range.slider_width = 11 + 2*2pts edge 
+
+            we use this instead:  range.slider_width = 11 + 2*2pts edge
 */
 
         if (scroll_window->vscrollbar_visible)
 */
 
         if (scroll_window->vscrollbar_visible)
@@ -169,10 +599,10 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
         if (scroll_window->hscrollbar_visible)
         {
             dh += 15;   /* dh += hscrollbar->allocation.height; */
         if (scroll_window->hscrollbar_visible)
         {
             dh += 15;   /* dh += hscrollbar->allocation.height; */
-            dw += scroll_class->scrollbar_spacing;
+            dh += scroll_class->scrollbar_spacing;
         }
     }
         }
     }
-    
+
     int dx = 0;
     int dy = 0;
     if (GTK_WIDGET_NO_WINDOW (widget))
     int dx = 0;
     int dy = 0;
     if (GTK_WIDGET_NO_WINDOW (widget))
@@ -180,27 +610,27 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
         dx += widget->allocation.x;
         dy += widget->allocation.y;
     }
         dx += widget->allocation.x;
         dy += widget->allocation.y;
     }
-    
-    if (win->m_windowStyle & wxRAISED_BORDER)
+
+    if (win->HasFlag(wxRAISED_BORDER))
     {
     {
-        gtk_draw_shadow( widget->style, 
+        gtk_draw_shadow( widget->style,
                          widget->window,
                          widget->window,
-                        GTK_STATE_NORMAL,
-                        GTK_SHADOW_OUT,
-                        dx, dy,
-                        win->m_width-dw, win->m_height-dh );
-       return;
-    } 
-    
-    if (win->m_windowStyle & wxSUNKEN_BORDER)
-    {
-        gtk_draw_shadow( widget->style, 
+                         GTK_STATE_NORMAL,
+                         GTK_SHADOW_OUT,
+                         dx, dy,
+                         win->m_width-dw, win->m_height-dh );
+        return;
+    }
+
+    if (win->HasFlag(wxSUNKEN_BORDER))
+    {
+        gtk_draw_shadow( widget->style,
                          widget->window,
                          widget->window,
-                        GTK_STATE_NORMAL,
-                        GTK_SHADOW_IN,
-                        dx, dy, 
-                        win->m_width-dw, win->m_height-dh );
-       return;
+                         GTK_STATE_NORMAL,
+                         GTK_SHADOW_IN,
+                         dx, dy,
+                         win->m_width-dw, win->m_height-dh );
+        return;
     }
 }
 
     }
 }
 
@@ -223,7 +653,7 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU
     draw_frame( widget, win );
 }
 
     draw_frame( widget, win );
 }
 
-#endif
+#endif // GTK_MINOR_VERSION > 0
 
 //-----------------------------------------------------------------------------
 // "expose_event" of m_wxwindow
 
 //-----------------------------------------------------------------------------
 // "expose_event" of m_wxwindow
@@ -231,27 +661,35 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU
 
 static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
 {
 
 static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
 {
-    if (!win->HasVMT()) return;
+    if (!win->m_hasVMT)
+        return;
 
 
-    win->m_updateRegion.Union( gdk_event->area.x,
-                               gdk_event->area.y,
-                               gdk_event->area.width,
-                               gdk_event->area.height );
+    if (gdk_event->window != win->m_wxwindow->window)
+        return;
 
 
-    if (gdk_event->count > 0) return;
+    win->GetUpdateRegion().Union( gdk_event->area.x,
+                                  gdk_event->area.y,
+                                  gdk_event->area.width,
+                                  gdk_event->area.height );
 
 
-/*
-    printf( "OnExpose from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    if (gdk_event->count > 0)
+        return;
 
     wxPaintEvent event( win->GetId() );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 
 
     wxPaintEvent event( win->GetId() );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 
-    win->m_updateRegion.Clear();
+/*
+    wxPrintf( "OnExpose from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        wxPrintf( win->GetClassInfo()->GetClassName() );
+    wxPrintf( " %d %d %d %d\n", (int)gdk_event->area.x,
+                                (int)gdk_event->area.y,
+                                (int)gdk_event->area.width,
+                                (int)gdk_event->area.height );
+*/
+
+    win->GetUpdateRegion().Clear();
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
@@ -260,15 +698,31 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
 
 static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
 {
 
 static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
 {
-    if (!win->HasVMT()) return;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    if (!win->m_hasVMT)
+        return;
 
 
-    win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
+    win->GetUpdateRegion().Union( rect->x, rect->y,
+                                  rect->width, rect->height );
 
     wxPaintEvent event( win->GetId() );
     event.SetEventObject( win );
 
     wxPaintEvent event( win->GetId() );
     event.SetEventObject( win );
+
+/*
+    wxPrintf( "OnDraw from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    wxPrintf( " %d %d %d %d\n", (int)rect->x,
+                                (int)rect->y,
+                                (int)rect->width,
+                                (int)rect->height );
+*/
+
     win->GetEventHandler()->ProcessEvent( event );
 
     win->GetEventHandler()->ProcessEvent( event );
 
-    win->m_updateRegion.Clear();
+    win->GetUpdateRegion().Clear();
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
@@ -277,109 +731,52 @@ static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle
 
 static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
 {
-    if (!win->HasVMT()) return FALSE;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 
 /*
     if (g_blockEventsOnDrag) return FALSE;
 
 /*
-    printf( "OnKeyPress from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
+    printf( "KeyDown-ScanCode is: %d.\n", gdk_event->keyval );
+    if (gdk_event->state & GDK_SHIFT_MASK)
+      printf( "ShiftDown.\n" );
+    else
+      printf( "ShiftUp.\n" );
+    if (gdk_event->state & GDK_CONTROL_MASK)
+      printf( "ControlDown.\n" );
+    else
+      printf( "ControlUp.\n" );
+    printf( "\n" );
 */
 */
+    int x = 0;
+    int y = 0;
+    GdkModifierType state;
+    if (gdk_event->window) gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
 
 
-    long key_code = 0;
-    switch (gdk_event->keyval)
-    {
-        case GDK_BackSpace:     key_code = WXK_BACK;        break;
-       case GDK_ISO_Left_Tab:
-        case GDK_KP_Tab:
-        case GDK_Tab:           key_code = WXK_TAB;         break;
-        case GDK_Linefeed:      key_code = WXK_RETURN;      break;
-        case GDK_Clear:         key_code = WXK_CLEAR;       break;
-        case GDK_Return:        key_code = WXK_RETURN;      break;
-        case GDK_Pause:         key_code = WXK_PAUSE;       break;
-        case GDK_Scroll_Lock:   key_code = WXK_SCROLL;      break;
-        case GDK_Escape:        key_code = WXK_ESCAPE;      break;
-        case GDK_Delete:        key_code = WXK_DELETE;      break;
-        case GDK_Home:          key_code = WXK_HOME;        break;
-        case GDK_Left:          key_code = WXK_LEFT;        break;
-        case GDK_Up:            key_code = WXK_UP;          break;
-        case GDK_Right:         key_code = WXK_RIGHT;       break;
-        case GDK_Down:          key_code = WXK_DOWN;        break;
-        case GDK_Prior:         key_code = WXK_PRIOR;       break;
-//      case GDK_Page_Up:       key_code = WXK_PAGEUP;      break;
-        case GDK_Next:          key_code = WXK_NEXT;        break;
-//      case GDK_Page_Down:     key_code = WXK_PAGEDOWN;    break;
-        case GDK_End:           key_code = WXK_END;         break;
-        case GDK_Begin:         key_code = WXK_HOME;        break;
-        case GDK_Select:        key_code = WXK_SELECT;      break;
-        case GDK_Print:         key_code = WXK_PRINT;       break;
-        case GDK_Execute:       key_code = WXK_EXECUTE;     break;
-        case GDK_Insert:        key_code = WXK_INSERT;      break;
-        case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;
-        case GDK_KP_Enter:      key_code = WXK_RETURN;      break;
-        case GDK_KP_Home:       key_code = WXK_HOME;        break;
-        case GDK_KP_Left:       key_code = WXK_LEFT;        break;
-        case GDK_KP_Up:         key_code = WXK_UP;          break;
-        case GDK_KP_Right:      key_code = WXK_RIGHT;       break;
-        case GDK_KP_Down:       key_code = WXK_DOWN;        break;
-        case GDK_KP_Prior:      key_code = WXK_PRIOR;       break;
-//      case GDK_KP_Page_Up:    key_code = WXK_PAGEUP;      break;
-        case GDK_KP_Next:       key_code = WXK_NEXT;        break;
-//      case GDK_KP_Page_Down:  key_code = WXK_PAGEDOWN;    break;
-        case GDK_KP_End:        key_code = WXK_END;         break;
-        case GDK_KP_Begin:      key_code = WXK_HOME;        break;
-        case GDK_KP_Insert:     key_code = WXK_INSERT;      break;
-        case GDK_KP_Delete:     key_code = WXK_DELETE;      break;
-        case GDK_KP_Multiply:   key_code = WXK_MULTIPLY;    break;
-        case GDK_KP_Add:        key_code = WXK_ADD;         break;
-        case GDK_KP_Separator:  key_code = WXK_SEPARATOR;   break;
-        case GDK_KP_Subtract:   key_code = WXK_SUBTRACT;    break;
-        case GDK_KP_Decimal:    key_code = WXK_DECIMAL;     break;
-        case GDK_KP_Divide:     key_code = WXK_DIVIDE;      break;
-        case GDK_KP_0:          key_code = WXK_NUMPAD0;     break;
-        case GDK_KP_1:          key_code = WXK_NUMPAD1;     break;
-        case GDK_KP_2:          key_code = WXK_NUMPAD2;     break;
-        case GDK_KP_3:          key_code = WXK_NUMPAD3;     break;
-        case GDK_KP_4:          key_code = WXK_NUMPAD4;     break;
-        case GDK_KP_5:          key_code = WXK_NUMPAD5;     break;
-        case GDK_KP_6:          key_code = WXK_NUMPAD6;     break;
-        case GDK_KP_7:          key_code = WXK_NUMPAD7;     break;
-        case GDK_KP_8:          key_code = WXK_NUMPAD7;     break;
-        case GDK_KP_9:          key_code = WXK_NUMPAD9;     break;
-        case GDK_F1:            key_code = WXK_F1;          break;
-        case GDK_F2:            key_code = WXK_F2;          break;
-        case GDK_F3:            key_code = WXK_F3;          break;
-        case GDK_F4:            key_code = WXK_F4;          break;
-        case GDK_F5:            key_code = WXK_F5;          break;
-        case GDK_F6:            key_code = WXK_F6;          break;
-        case GDK_F7:            key_code = WXK_F7;          break;
-        case GDK_F8:            key_code = WXK_F8;          break;
-        case GDK_F9:            key_code = WXK_F9;          break;
-        case GDK_F10:           key_code = WXK_F10;         break;
-        case GDK_F11:           key_code = WXK_F11;         break;
-        case GDK_F12:           key_code = WXK_F12;         break;
-        default:
-        {
-            if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
-                key_code = gdk_event->keyval;
-        }
-    }
+    long key_code = map_to_unmodified_wx_keysym( gdk_event->keyval );
+
+    /* sending unknown key events doesn't really make sense */
+    if (key_code == 0) return FALSE;
 
 
-    if (!key_code) return FALSE;
+    bool ret = FALSE;
 
     wxKeyEvent event( wxEVT_KEY_DOWN );
 
     wxKeyEvent event( wxEVT_KEY_DOWN );
+    event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
     event.m_keyCode = key_code;
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
     event.m_keyCode = key_code;
-    event.m_x = 0;
-    event.m_y = 0;
+    event.m_scanCode = gdk_event->keyval;
+    event.m_x = x;
+    event.m_y = y;
     event.SetEventObject( win );
     event.SetEventObject( win );
+    ret = win->GetEventHandler()->ProcessEvent( event );
 
 
-    bool ret = win->GetEventHandler()->ProcessEvent( event );
+    key_code = map_to_wx_keysym( gdk_event->keyval );
 
 
+#if wxUSE_ACCEL
     if (!ret)
     {
         wxWindow *ancestor = win;
     if (!ret)
     {
         wxWindow *ancestor = win;
@@ -395,29 +792,80 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
             ancestor = ancestor->GetParent();
         }
     }
             ancestor = ancestor->GetParent();
         }
     }
-
-    // win is a control: tab can be propagated up
-    if ( (!ret) && 
+#endif // wxUSE_ACCEL
+    /* wxMSW doesn't send char events with Alt pressed */
+    /* Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
+       will only be sent if it is not a menu accelerator. */
+    if ((key_code != 0) && ! ret )
+    {
+        wxKeyEvent event2( wxEVT_CHAR );
+        event2.SetTimestamp( gdk_event->time );
+        event2.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
+        event2.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
+        event2.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
+        event2.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
+        event2.m_keyCode = key_code;
+        event2.m_scanCode = gdk_event->keyval;
+        event2.m_x = x;
+        event2.m_y = y;
+        event2.SetEventObject( win );
+        ret = (ret || win->GetEventHandler()->ProcessEvent( event2 ));
+    }
+
+
+    /* win is a control: tab can be propagated up */
+    if ( (!ret) &&
          ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
          ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
-         ((win->m_windowStyle & wxTE_PROCESS_TAB) == 0))
+         (win->HasFlag(wxTE_PROCESS_TAB) == 0))
     {
         wxNavigationKeyEvent new_event;
     {
         wxNavigationKeyEvent new_event;
-       /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
+        /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
         new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
         new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
-       /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */ 
+        /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
         new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
         new_event.SetCurrentFocus( win );
         ret = win->GetEventHandler()->ProcessEvent( new_event );
     }
 
         new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
         new_event.SetCurrentFocus( win );
         ret = win->GetEventHandler()->ProcessEvent( new_event );
     }
 
-    if ( (!ret) && 
+    /* generate wxID_CANCEL if <esc> has been pressed (typically in dialogs) */
+    if ( (!ret) &&
          (gdk_event->keyval == GDK_Escape) )
     {
         wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
         new_event.SetEventObject( win );
         ret = win->GetEventHandler()->ProcessEvent( new_event );
     }
          (gdk_event->keyval == GDK_Escape) )
     {
         wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
         new_event.SetEventObject( win );
         ret = win->GetEventHandler()->ProcessEvent( new_event );
     }
-    
+
+#if (GTK_MINOR_VERSION > 0)
+    /* pressing F10 will activate the menu bar of the top frame */
+    if ( (!ret) &&
+         (gdk_event->keyval == GDK_F10) )
+    {
+        wxWindow *ancestor = win;
+        while (ancestor)
+        {
+            if (wxIsKindOf(ancestor,wxFrame))
+            {
+                wxFrame *frame = (wxFrame*) ancestor;
+                wxMenuBar *menubar = frame->GetMenuBar();
+                if (menubar)
+                {
+                    wxNode *node = menubar->GetMenus().First();
+                    if (node)
+                    {
+                        // doesn't work correctly
+            // wxMenu *firstMenu = (wxMenu*) node->Data();
+                        // gtk_menu_item_select( GTK_MENU_ITEM(firstMenu->m_owner) );
+                        // ret = TRUE;
+                        break;
+                    }
+                }
+            }
+            ancestor = ancestor->GetParent();
+        }
+    }
+#endif
+
 /*
     Damn, I forgot why this didn't work, but it didn't work.
 
 /*
     Damn, I forgot why this didn't work, but it didn't work.
 
@@ -444,7 +892,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
     if (ret)
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
     if (ret)
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
-       return TRUE;
+        return TRUE;
     }
 
     return FALSE;
     }
 
     return FALSE;
@@ -456,111 +904,51 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
 
 static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
 {
-    if (!win->HasVMT()) return FALSE;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 
 /*
     if (g_blockEventsOnDrag) return FALSE;
 
 /*
-    printf( "OnKeyRelease from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
+    printf( "KeyUp-ScanCode is: %d.\n", gdk_event->keyval );
+    if (gdk_event->state & GDK_SHIFT_MASK)
+      printf( "ShiftDown.\n" );
+    else
+      printf( "ShiftUp.\n" );
+    if (gdk_event->state & GDK_CONTROL_MASK)
+      printf( "ControlDown.\n" );
+    else
+      printf( "ControlUp.\n" );
+    printf( "\n" );
 */
 
 */
 
-    long key_code = 0;
-    switch (gdk_event->keyval)
-    {
-        case GDK_BackSpace:     key_code = WXK_BACK;        break;
-       case GDK_ISO_Left_Tab:
-        case GDK_KP_Tab:
-        case GDK_Tab:           key_code = WXK_TAB;         break;
-        case GDK_Linefeed:      key_code = WXK_RETURN;      break;
-        case GDK_Clear:         key_code = WXK_CLEAR;       break;
-        case GDK_Return:        key_code = WXK_RETURN;      break;
-        case GDK_Pause:         key_code = WXK_PAUSE;       break;
-        case GDK_Scroll_Lock:   key_code = WXK_SCROLL;      break;
-        case GDK_Escape:        key_code = WXK_ESCAPE;      break;
-        case GDK_Delete:        key_code = WXK_DELETE;      break;
-        case GDK_Home:          key_code = WXK_HOME;        break;
-        case GDK_Left:          key_code = WXK_LEFT;        break;
-        case GDK_Up:            key_code = WXK_UP;          break;
-        case GDK_Right:         key_code = WXK_RIGHT;       break;
-        case GDK_Down:          key_code = WXK_DOWN;        break;
-        case GDK_Prior:         key_code = WXK_PRIOR;       break;
-//      case GDK_Page_Up:       key_code = WXK_PAGEUP;      break;
-        case GDK_Next:          key_code = WXK_NEXT;        break;
-//      case GDK_Page_Down:     key_code = WXK_PAGEDOWN;    break;
-        case GDK_End:           key_code = WXK_END;         break;
-        case GDK_Begin:         key_code = WXK_HOME;        break;
-        case GDK_Select:        key_code = WXK_SELECT;      break;
-        case GDK_Print:         key_code = WXK_PRINT;       break;
-        case GDK_Execute:       key_code = WXK_EXECUTE;     break;
-        case GDK_Insert:        key_code = WXK_INSERT;      break;
-        case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;
-        case GDK_KP_Enter:      key_code = WXK_RETURN;      break;
-        case GDK_KP_Home:       key_code = WXK_HOME;        break;
-        case GDK_KP_Left:       key_code = WXK_LEFT;        break;
-        case GDK_KP_Up:         key_code = WXK_UP;          break;
-        case GDK_KP_Right:      key_code = WXK_RIGHT;       break;
-        case GDK_KP_Down:       key_code = WXK_DOWN;        break;
-        case GDK_KP_Prior:      key_code = WXK_PRIOR;       break;
-//      case GDK_KP_Page_Up:    key_code = WXK_PAGEUP;      break;
-        case GDK_KP_Next:       key_code = WXK_NEXT;        break;
-//      case GDK_KP_Page_Down:  key_code = WXK_PAGEDOWN;    break;
-        case GDK_KP_End:        key_code = WXK_END;         break;
-        case GDK_KP_Begin:      key_code = WXK_HOME;        break;
-        case GDK_KP_Insert:     key_code = WXK_INSERT;      break;
-        case GDK_KP_Delete:     key_code = WXK_DELETE;      break;
-        case GDK_KP_Multiply:   key_code = WXK_MULTIPLY;    break;
-        case GDK_KP_Add:        key_code = WXK_ADD;         break;
-        case GDK_KP_Separator:  key_code = WXK_SEPARATOR;   break;
-        case GDK_KP_Subtract:   key_code = WXK_SUBTRACT;    break;
-        case GDK_KP_Decimal:    key_code = WXK_DECIMAL;     break;
-        case GDK_KP_Divide:     key_code = WXK_DIVIDE;      break;
-        case GDK_KP_0:          key_code = WXK_NUMPAD0;     break;
-        case GDK_KP_1:          key_code = WXK_NUMPAD1;     break;
-        case GDK_KP_2:          key_code = WXK_NUMPAD2;     break;
-        case GDK_KP_3:          key_code = WXK_NUMPAD3;     break;
-        case GDK_KP_4:          key_code = WXK_NUMPAD4;     break;
-        case GDK_KP_5:          key_code = WXK_NUMPAD5;     break;
-        case GDK_KP_6:          key_code = WXK_NUMPAD6;     break;
-        case GDK_KP_7:          key_code = WXK_NUMPAD7;     break;
-        case GDK_KP_8:          key_code = WXK_NUMPAD7;     break;
-        case GDK_KP_9:          key_code = WXK_NUMPAD9;     break;
-        case GDK_F1:            key_code = WXK_F1;          break;
-        case GDK_F2:            key_code = WXK_F2;          break;
-        case GDK_F3:            key_code = WXK_F3;          break;
-        case GDK_F4:            key_code = WXK_F4;          break;
-        case GDK_F5:            key_code = WXK_F5;          break;
-        case GDK_F6:            key_code = WXK_F6;          break;
-        case GDK_F7:            key_code = WXK_F7;          break;
-        case GDK_F8:            key_code = WXK_F8;          break;
-        case GDK_F9:            key_code = WXK_F9;          break;
-        case GDK_F10:           key_code = WXK_F10;         break;
-        case GDK_F11:           key_code = WXK_F11;         break;
-        case GDK_F12:           key_code = WXK_F12;         break;
-        default:
-        {
-            if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
-                key_code = gdk_event->keyval;
-        }
-    }
+    long key_code = map_to_unmodified_wx_keysym( gdk_event->keyval );
 
 
-    if (!key_code) return FALSE;
+    /* sending unknown key events doesn't really make sense */
+    if (key_code == 0) return FALSE;
+
+    int x = 0;
+    int y = 0;
+    GdkModifierType state;
+    if (gdk_event->window) gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
 
     wxKeyEvent event( wxEVT_KEY_UP );
 
     wxKeyEvent event( wxEVT_KEY_UP );
+    event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
     event.m_keyCode = key_code;
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
     event.m_keyCode = key_code;
-    event.m_x = 0;
-    event.m_y = 0;
+    event.m_scanCode = gdk_event->keyval;
+    event.m_x = x;
+    event.m_y = y;
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
-       return TRUE;
+        return TRUE;
     }
 
     return FALSE;
     }
 
     return FALSE;
@@ -572,7 +960,16 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk
 
 static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 {
-    if (!win->HasVMT()) return FALSE;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+/*
+    wxPrintf( _T("1) OnButtonPress from ") );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        wxPrintf( win->GetClassInfo()->GetClassName() );
+    wxPrintf( _T(".\n") );
+*/
+    if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return TRUE;
     if (g_blockEventsOnScroll) return TRUE;
 
     if (g_blockEventsOnDrag) return TRUE;
     if (g_blockEventsOnScroll) return TRUE;
 
@@ -585,20 +982,20 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
             gtk_widget_grab_focus (win->m_wxwindow);
 
 /*
             gtk_widget_grab_focus (win->m_wxwindow);
 
 /*
-            printf( "GrabFocus from " );
+            wxPrintf( _T("GrabFocus from ") );
             if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
             if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-                printf( win->GetClassInfo()->GetClassName() );
-            printf( ".\n" );
+                wxPrintf( win->GetClassInfo()->GetClassName() );
+            wxPrintf( _T(".\n") );
 */
 
         }
     }
 
 /*
 */
 
         }
     }
 
 /*
-    printf( "OnButtonPress from " );
+    wxPrintf( _T("2) OnButtonPress from ") );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
+        wxPrintf( win->GetClassInfo()->GetClassName() );
+    wxPrintf( _T(".\n") );
 */
 
     wxEventType event_type = wxEVT_LEFT_DOWN;
 */
 
     wxEventType event_type = wxEVT_LEFT_DOWN;
@@ -632,6 +1029,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
     }
 
     wxMouseEvent event( event_type );
     }
 
     wxMouseEvent event( event_type );
+    event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
@@ -646,7 +1044,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
     // Some control don't have their own X window and thus cannot get
     // any events.
 
     // Some control don't have their own X window and thus cannot get
     // any events.
 
-    if (!g_capturing)
+    if (!g_captureWindow)
     {
         wxNode *node = win->GetChildren().First();
         while (node)
     {
         wxNode *node = win->GetChildren().First();
         while (node)
@@ -704,7 +1102,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
-       return TRUE;
+        return TRUE;
     }
 
     return FALSE;
     }
 
     return FALSE;
@@ -716,7 +1114,10 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
 
 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 {
-    if (!win->HasVMT()) return FALSE;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
     if (g_blockEventsOnScroll) return FALSE;
 
     if (g_blockEventsOnDrag) return FALSE;
     if (g_blockEventsOnScroll) return FALSE;
 
@@ -739,6 +1140,7 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
     }
 
     wxMouseEvent event( event_type );
     }
 
     wxMouseEvent event( event_type );
+    event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
@@ -752,7 +1154,7 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
     // Some control don't have their own X window and thus cannot get
     // any events.
 
     // Some control don't have their own X window and thus cannot get
     // any events.
 
-    if (!g_capturing)
+    if (!g_captureWindow)
     {
         wxNode *node = win->GetChildren().First();
         while (node)
     {
         wxNode *node = win->GetChildren().First();
         while (node)
@@ -808,7 +1210,7 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
-       return TRUE;
+        return TRUE;
     }
 
     return FALSE;
     }
 
     return FALSE;
@@ -820,7 +1222,10 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
 
 static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
 {
-    if (!win->HasVMT()) return FALSE;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
     if (g_blockEventsOnScroll) return FALSE;
 
     if (g_blockEventsOnDrag) return FALSE;
     if (g_blockEventsOnScroll) return FALSE;
 
@@ -845,6 +1250,7 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
 */
 
     wxMouseEvent event( wxEVT_MOTION );
 */
 
     wxMouseEvent event( wxEVT_MOTION );
+    event.SetTimestamp( gdk_event->time );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
@@ -859,7 +1265,7 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
     // Some control don't have their own X window and thus cannot get
     // any events.
 
     // Some control don't have their own X window and thus cannot get
     // any events.
 
-    if (!g_capturing)
+    if (!g_captureWindow)
     {
         wxNode *node = win->GetChildren().First();
         while (node)
     {
         wxNode *node = win->GetChildren().First();
         while (node)
@@ -915,7 +1321,7 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
-       return TRUE;
+        return TRUE;
     }
 
     return FALSE;
     }
 
     return FALSE;
@@ -927,7 +1333,10 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
 
 static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
 {
 
 static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
 {
-    if (!win->HasVMT()) return FALSE;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 
     g_focusWindow = win;
     if (g_blockEventsOnDrag) return FALSE;
 
     g_focusWindow = win;
@@ -964,7 +1373,7 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
         return TRUE;
     }
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
         return TRUE;
     }
-    
+
     return FALSE;
 }
 
     return FALSE;
 }
 
@@ -974,9 +1383,12 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
 
 static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
 {
 
 static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
 {
-    if (!win->HasVMT()) return FALSE;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
-    
+
     if (win->m_wxwindow)
     {
       if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
     if (win->m_wxwindow)
     {
       if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
@@ -998,7 +1410,7 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
         return TRUE;
     }
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
         return TRUE;
     }
-    
+
     return FALSE;
 }
 
     return FALSE;
 }
 
@@ -1008,22 +1420,18 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
 
 static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {
-    if (!win->HasVMT()) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
-    
-    if (widget->window != gdk_event->window) return FALSE;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
 
 
-    if ((widget->window) && (win->m_cursor))
-        gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
+    if (!win->m_hasVMT) return FALSE;
+    if (g_blockEventsOnDrag) return FALSE;
 
 
-/*
-    printf( "OnEnter from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
 
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
+#if (GTK_MINOR_VERSION > 0)
+    event.SetTimestamp( gdk_event->time );
+#endif
     event.SetEventObject( win );
 
     int x = 0;
     event.SetEventObject( win );
 
     int x = 0;
@@ -1048,7 +1456,7 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
        return TRUE;
     }
        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
        return TRUE;
     }
-    
+
     return FALSE;
 }
 
     return FALSE;
 }
 
@@ -1058,22 +1466,18 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {
-    if (!win->HasVMT()) return FALSE;
-    if (g_blockEventsOnDrag) return FALSE;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
 
 
-    if (widget->window != gdk_event->window) return FALSE;
-    
-    if ((widget->window) && (win->m_cursor))
-        gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
+    if (!win->m_hasVMT) return FALSE;
+    if (g_blockEventsOnDrag) return FALSE;
 
 
-/*
-    printf( "OnLeave from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
+#if (GTK_MINOR_VERSION > 0)
+    event.SetTimestamp( gdk_event->time );
+#endif
     event.SetEventObject( win );
 
     int x = 0;
     event.SetEventObject( win );
 
     int x = 0;
@@ -1098,7 +1502,7 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
         return TRUE;
     }
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
         return TRUE;
     }
-    
+
     return FALSE;
 }
 
     return FALSE;
 }
 
@@ -1108,16 +1512,12 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
 static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
 {
 
 static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
 {
-    if (g_blockEventsOnDrag) return;
+    if (g_isIdle)
+        wxapp_install_idle_handler();
 
 
-/*
-    printf( "OnVScroll from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    if (g_blockEventsOnDrag) return;
 
 
-    if (!win->HasVMT()) return;
+    if (!win->m_hasVMT) return;
 
     float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
     if (fabs(diff) < 0.2) return;
 
     float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
     if (fabs(diff) < 0.2) return;
@@ -1128,24 +1528,24 @@ static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
     float line_step = win->m_vAdjust->step_increment;
     float page_step = win->m_vAdjust->page_increment;
 
     float line_step = win->m_vAdjust->step_increment;
     float page_step = win->m_vAdjust->page_increment;
 
-    if (win->m_isScrolling)
+    if (win->IsScrolling())
     {
     {
-        command = wxEVT_SCROLL_THUMBTRACK;
+        command = wxEVT_SCROLLWIN_THUMBTRACK;
     }
     else
     {
     }
     else
     {
-        if (fabs(win->m_vAdjust->value-win->m_vAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM;
-        else if (fabs(win->m_vAdjust->value-win->m_vAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP;
-        else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
-        else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
-        else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
-        else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
-        else command = wxEVT_SCROLL_THUMBTRACK;
+        if (fabs(win->m_vAdjust->value-win->m_vAdjust->lower) < 0.2) command = wxEVT_SCROLLWIN_BOTTOM;
+        else if (fabs(win->m_vAdjust->value-win->m_vAdjust->upper) < 0.2) command = wxEVT_SCROLLWIN_TOP;
+        else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEDOWN;
+        else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEUP;
+        else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEDOWN;
+        else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEUP;
+        else command = wxEVT_SCROLLWIN_THUMBTRACK;
     }
 
     int value = (int)(win->m_vAdjust->value+0.5);
 
     }
 
     int value = (int)(win->m_vAdjust->value+0.5);
 
-    wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
+    wxScrollWinEvent event( command, value, wxVERTICAL );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 }
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 }
@@ -1156,16 +1556,11 @@ static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
 
 static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
 {
 
 static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
 {
-    if (g_blockEventsOnDrag) return;
-
-/*
-    printf( "OnHScroll from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    if (g_isIdle)
+        wxapp_install_idle_handler();
 
 
-    if (!win->HasVMT()) return;
+    if (g_blockEventsOnDrag) return;
+    if (!win->m_hasVMT) return;
 
     float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
     if (fabs(diff) < 0.2) return;
 
     float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
     if (fabs(diff) < 0.2) return;
@@ -1176,24 +1571,24 @@ static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
     float line_step = win->m_hAdjust->step_increment;
     float page_step = win->m_hAdjust->page_increment;
 
     float line_step = win->m_hAdjust->step_increment;
     float page_step = win->m_hAdjust->page_increment;
 
-    if (win->m_isScrolling)
+    if (win->IsScrolling())
     {
     {
-        command = wxEVT_SCROLL_THUMBTRACK;
+        command = wxEVT_SCROLLWIN_THUMBTRACK;
     }
     else
     {
     }
     else
     {
-        if (fabs(win->m_hAdjust->value-win->m_hAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM;
-        else if (fabs(win->m_hAdjust->value-win->m_hAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP;
-        else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
-        else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
-        else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
-        else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
-        else command = wxEVT_SCROLL_THUMBTRACK;
+        if (fabs(win->m_hAdjust->value-win->m_hAdjust->lower) < 0.2) command = wxEVT_SCROLLWIN_BOTTOM;
+        else if (fabs(win->m_hAdjust->value-win->m_hAdjust->upper) < 0.2) command = wxEVT_SCROLLWIN_TOP;
+        else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEDOWN;
+        else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEUP;
+        else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEDOWN;
+        else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEUP;
+        else command = wxEVT_SCROLLWIN_THUMBTRACK;
     }
 
     int value = (int)(win->m_hAdjust->value+0.5);
 
     }
 
     int value = (int)(win->m_hAdjust->value+0.5);
 
-    wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
+    wxScrollWinEvent event( command, value, wxHORIZONTAL );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 }
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 }
@@ -1204,21 +1599,16 @@ static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
 
 static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
 {
 
 static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
 {
-    if (g_blockEventsOnDrag) return;
-
-/*
-    printf( "OnVScroll change from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    if (g_isIdle)
+        wxapp_install_idle_handler();
 
 
-    if (!win->HasVMT()) return;
+    if (g_blockEventsOnDrag) return;
+    if (!win->m_hasVMT) return;
 
 
-    wxEventType command = wxEVT_SCROLL_THUMBTRACK;
+    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
     int value = (int)(win->m_vAdjust->value+0.5);
 
     int value = (int)(win->m_vAdjust->value+0.5);
 
-    wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
+    wxScrollWinEvent event( command, value, wxVERTICAL );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 }
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 }
@@ -1229,21 +1619,16 @@ static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxW
 
 static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
 {
 
 static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
 {
-    if (g_blockEventsOnDrag) return;
-
-/*
-    printf( "OnHScroll change from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+    if (g_isIdle)
+        wxapp_install_idle_handler();
 
 
-    if (!win->HasVMT()) return;
+    if (g_blockEventsOnDrag) return;
+    if (!win->m_hasVMT) return;
 
 
-    wxEventType command = wxEVT_SCROLL_THUMBTRACK;
+    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
     int value = (int)(win->m_hAdjust->value+0.5);
 
     int value = (int)(win->m_hAdjust->value+0.5);
 
-    wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
+    wxScrollWinEvent event( command, value, wxHORIZONTAL );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 }
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 }
@@ -1256,13 +1641,15 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
                                                  GdkEventButton *WXUNUSED(gdk_event),
                                                  wxWindow *win )
 {
                                                  GdkEventButton *WXUNUSED(gdk_event),
                                                  wxWindow *win )
 {
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
 //  don't test here as we can release the mouse while being over
 //  a different window then the slider
 //
 //    if (gdk_event->window != widget->slider) return FALSE;
 
 //  don't test here as we can release the mouse while being over
 //  a different window then the slider
 //
 //    if (gdk_event->window != widget->slider) return FALSE;
 
-    win->m_isScrolling = TRUE;
-    g_blockEventsOnScroll = TRUE;
+    win->SetScrolling( TRUE );
 
     return FALSE;
 }
 
     return FALSE;
 }
@@ -1281,19 +1668,28 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
 //
 //    if (gdk_event->window != widget->slider) return FALSE;
 
 //
 //    if (gdk_event->window != widget->slider) return FALSE;
 
-    GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(win->m_widget);
+    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
 
 
-    if (widget == GTK_RANGE(s_window->vscrollbar))
+    if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
         gtk_signal_emit_by_name( GTK_OBJECT(win->m_hAdjust), "value_changed" );
     else
         gtk_signal_emit_by_name( GTK_OBJECT(win->m_vAdjust), "value_changed" );
 
         gtk_signal_emit_by_name( GTK_OBJECT(win->m_hAdjust), "value_changed" );
     else
         gtk_signal_emit_by_name( GTK_OBJECT(win->m_vAdjust), "value_changed" );
 
-    win->m_isScrolling = FALSE;
-    g_blockEventsOnScroll = FALSE;
+    win->SetScrolling( FALSE );
 
     return FALSE;
 }
 
 
     return FALSE;
 }
 
+// ----------------------------------------------------------------------------
+// this wxWindowBase function is implemented here (in platform-specific file)
+// because it is static and so couldn't be made virtual
+// ----------------------------------------------------------------------------
+
+wxWindow *wxWindowBase::FindFocus()
+{
+    return g_focusWindow;
+}
+
 //-----------------------------------------------------------------------------
 // "realize" from m_widget
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // "realize" from m_widget
 //-----------------------------------------------------------------------------
@@ -1301,33 +1697,30 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
 /* we cannot set colours, fonts and cursors before the widget has
    been realized, so we do this directly after realization */
 
 /* we cannot set colours, fonts and cursors before the widget has
    been realized, so we do this directly after realization */
 
-static gint 
-gtk_window_realized_callback( GtkWidget *widget, wxWindow *win )
+static gint
+gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
 {
 {
-    if (win->m_font != *wxSWISS_FONT)
-    {
-        wxFont font( win->m_font );
-        win->m_font = wxNullFont;
-       win->SetFont( font );
-    }
-    
-    if (win->m_backgroundColour != wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ))
-    {
-        wxColour bg( win->m_backgroundColour );
-       win->SetBackgroundColour( wxNullColour );
-       win->SetBackgroundColour( bg );
-    }
-    
-    if (win->m_foregroundColour != *wxBLACK)
-    {
-        wxColour fg( win->m_foregroundColour );
-       win->SetForegroundColour( wxNullColour );
-       win->SetForegroundColour( fg );
-    }
-    
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+
+    if (win->m_delayedFont)
+        win->SetFont( win->GetFont() );
+
+    if (win->m_delayedBackgroundColour)
+        win->SetBackgroundColour( win->GetBackgroundColour() );
+
+    if (win->m_delayedForegroundColour)
+        win->SetForegroundColour( win->GetForegroundColour() );
+
+    win->SetCursor( win->GetCursor() );
+
+    wxWindowCreateEvent event( win );
+    event.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( event );
+
     return FALSE;
 }
     return FALSE;
 }
-    
+
 //-----------------------------------------------------------------------------
 // InsertChild for wxWindow.
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // InsertChild for wxWindow.
 //-----------------------------------------------------------------------------
@@ -1343,14 +1736,12 @@ static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 {
     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
                      GTK_WIDGET(child->m_widget),
 {
     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
                      GTK_WIDGET(child->m_widget),
-                       child->m_x,
-                     child->m_y );
+                     child->m_x,
+                     child->m_y,
+                     child->m_width,
+                     child->m_height );
 
 
-    gtk_widget_set_usize( GTK_WIDGET(child->m_widget),
-                          child->m_width,
-                          child->m_height );
-
-    if (parent->m_windowStyle & wxTAB_TRAVERSAL)
+    if (parent->HasFlag(wxTAB_TRAVERSAL))
     {
         /* we now allow a window to get the focus as long as it
            doesn't have any children. */
     {
         /* we now allow a window to get the focus as long as it
            doesn't have any children. */
@@ -1364,90 +1755,51 @@ static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 
 wxWindow* wxGetActiveWindow()
 {
 
 wxWindow* wxGetActiveWindow()
 {
-  return g_focusWindow;
+    return g_focusWindow;
 }
 
 //-----------------------------------------------------------------------------
 // wxWindow
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // wxWindow
 //-----------------------------------------------------------------------------
 
-IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler)
-
-BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
-    EVT_SIZE(wxWindow::OnSize)
-    EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
-    EVT_INIT_DIALOG(wxWindow::OnInitDialog)
-    EVT_KEY_DOWN(wxWindow::OnKeyDown)
-END_EVENT_TABLE()
+IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 
 void wxWindow::Init()
 {
 
 void wxWindow::Init()
 {
-    m_isWindow = TRUE;
+    // common init
+    InitBase();
 
 
+    // GTK specific
     m_widget = (GtkWidget *) NULL;
     m_wxwindow = (GtkWidget *) NULL;
     m_widget = (GtkWidget *) NULL;
     m_wxwindow = (GtkWidget *) NULL;
-    m_parent = (wxWindow *) NULL;
-    m_children.DeleteContents( FALSE );
 
 
+    // position/size
     m_x = 0;
     m_y = 0;
     m_width = 0;
     m_height = 0;
     m_x = 0;
     m_y = 0;
     m_width = 0;
     m_height = 0;
-    m_minWidth = -1;
-    m_minHeight = -1;
-    m_maxWidth = -1;
-    m_maxHeight = -1;
-
-    m_retCode = 0;
-
-    m_eventHandler = this;
-    m_windowValidator = (wxValidator *) NULL;
-
-    m_windowId = -1;
-
-    m_cursor = (wxCursor *) NULL;
-    m_font = *wxSWISS_FONT;
-    m_windowStyle = 0;
-    m_windowName = "noname";
-
-    m_constraints = (wxLayoutConstraints *) NULL;
-    m_constraintsInvolvedIn = (wxList *) NULL;
-    m_windowSizer = (wxSizer *) NULL;
-    m_sizerParent = (wxWindow *) NULL;
-    m_autoLayout = FALSE;
 
     m_sizeSet = FALSE;
     m_hasVMT = FALSE;
     m_needParent = TRUE;
 
     m_sizeSet = FALSE;
     m_hasVMT = FALSE;
     m_needParent = TRUE;
+    m_isBeingDeleted = FALSE;
 
     m_hasScrolling = FALSE;
     m_isScrolling = FALSE;
 
     m_hasScrolling = FALSE;
     m_isScrolling = FALSE;
+
     m_hAdjust = (GtkAdjustment*) NULL;
     m_vAdjust = (GtkAdjustment*) NULL;
     m_oldHorizontalPos = 0.0;
     m_oldVerticalPos = 0.0;
 
     m_hAdjust = (GtkAdjustment*) NULL;
     m_vAdjust = (GtkAdjustment*) NULL;
     m_oldHorizontalPos = 0.0;
     m_oldVerticalPos = 0.0;
 
-    m_isShown = FALSE;
-    m_isEnabled = TRUE;
-
-#if wxUSE_DRAG_AND_DROP
-    m_dropTarget = (wxDropTarget*) NULL;
-#endif
     m_resizing = FALSE;
     m_scrollGC = (GdkGC*) NULL;
     m_widgetStyle = (GtkStyle*) NULL;
 
     m_resizing = FALSE;
     m_scrollGC = (GdkGC*) NULL;
     m_widgetStyle = (GtkStyle*) NULL;
 
-    m_insertCallback = wxInsertChildInWindow;
-
-    m_clientObject = (wxClientData*) NULL;
-    m_clientData = NULL;
+    m_insertCallback = (wxInsertChildFunction) NULL;
 
     m_isStaticBox = FALSE;
     m_acceptsFocus = FALSE;
 
     m_isStaticBox = FALSE;
     m_acceptsFocus = FALSE;
-
-#if wxUSE_TOOLTIPS
-    m_toolTip = (wxToolTip*) NULL;
-#endif // wxUSE_TOOLTIPS
 }
 
 wxWindow::wxWindow()
 }
 
 wxWindow::wxWindow()
@@ -1468,39 +1820,48 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
                        const wxPoint &pos, const wxSize &size,
                        long style, const wxString &name  )
 {
                        const wxPoint &pos, const wxSize &size,
                        long style, const wxString &name  )
 {
-    wxASSERT_MSG( m_isWindow, _T("Init() must have been called before!") );
-
     PreCreation( parent, id, pos, size, style, name );
 
     PreCreation( parent, id, pos, size, style, name );
 
+    m_insertCallback = wxInsertChildInWindow;
+
     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
-    GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
+#ifdef __WXDEBUG__
+    debug_focus_in( m_widget, _T("wxWindow::m_widget"), name );
+#endif
+
+    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
+
+#ifdef __WXDEBUG__
+    debug_focus_in( scrolledWindow->hscrollbar, _T("wxWindow::hsrcollbar"), name );
+    debug_focus_in( scrolledWindow->vscrollbar, _T("wxWindow::vsrcollbar"), name );
+#endif
 
     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
     scroll_class->scrollbar_spacing = 0;
 
 
     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
     scroll_class->scrollbar_spacing = 0;
 
-    gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
-
-    m_oldHorizontalPos = 0.0;
-    m_oldVerticalPos = 0.0;
+    gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
 
 
-    m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) );
-    m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) );
+    m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
+    m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
 
     m_wxwindow = gtk_myfixed_new();
 
     m_wxwindow = gtk_myfixed_new();
-    gtk_widget_show( m_wxwindow );
+
+#ifdef __WXDEBUG__
+    debug_focus_in( m_wxwindow, _T("wxWindow::m_wxwindow"), name );
+#endif
 
     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
 
 #if (GTK_MINOR_VERSION > 0)
     GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
 
 
     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
 
 #if (GTK_MINOR_VERSION > 0)
     GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
 
-    if (m_windowStyle & wxRAISED_BORDER)
+    if (HasFlag(wxRAISED_BORDER))
     {
         gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_OUT );
     }
     {
         gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_OUT );
     }
-    else if (m_windowStyle & wxSUNKEN_BORDER)
+    else if (HasFlag(wxSUNKEN_BORDER))
     {
         gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_IN );
     }
     {
         gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_IN );
     }
@@ -1508,14 +1869,14 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     {
         gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_NONE );
     }
     {
         gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_NONE );
     }
-#else
-    GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
+#else // GTK_MINOR_VERSION == 0
+    GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
 
 
-    if (m_windowStyle & wxRAISED_BORDER)
+    if (HasFlag(wxRAISED_BORDER))
     {
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
     }
     {
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
     }
-    else if (m_windowStyle & wxSUNKEN_BORDER)
+    else if (HasFlag(wxSUNKEN_BORDER))
     {
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
     }
     {
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
     }
@@ -1523,9 +1884,9 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     {
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
     }
     {
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
     }
-#endif
+#endif // GTK_MINOR_VERSION
 
 
-    if (m_windowStyle & wxTAB_TRAVERSAL)
+    if (HasFlag(wxTAB_TRAVERSAL))
     {
         /* we now allow a window to get the focus as long as it
            doesn't have any children. */
     {
         /* we now allow a window to get the focus as long as it
            doesn't have any children. */
@@ -1542,7 +1903,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     // shut the viewport up
     gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
     gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
     // shut the viewport up
     gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
     gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
-#endif
+#endif // GTK_MINOR_VERSION == 0
 
     // I _really_ don't want scrollbars in the beginning
     m_vAdjust->lower = 0.0;
 
     // I _really_ don't want scrollbars in the beginning
     m_vAdjust->lower = 0.0;
@@ -1560,20 +1921,20 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     m_hAdjust->page_size = 5.0;
     gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
 
     m_hAdjust->page_size = 5.0;
     gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
 
-    // these handlers block mouse events to any window during scrolling
-    // such as motion events and prevent GTK and wxWindows from fighting
-    // over where the slider should be
+    // these handlers block mouse events to any window during scrolling such as
+    // motion events and prevent GTK and wxWindows from fighting over where the
+    // slider should be
 
 
-    gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_press_event",
+    gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
 
           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
 
-    gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_press_event",
+    gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
 
           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
 
-    gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_release_event",
+    gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
 
           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
 
-    gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event",
+    gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
 
     // these handlers get notified when screen updates are required either when
           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
 
     // these handlers get notified when screen updates are required either when
@@ -1590,9 +1951,10 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",
           (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
 
     gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",
           (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
 
-    if (m_parent) m_parent->AddChild( this );
+    gtk_widget_show( m_wxwindow );
 
 
-    (m_parent->m_insertCallback)( m_parent, this );
+    if (m_parent)
+        m_parent->DoAddChild( this );
 
     PostCreation();
 
 
     PostCreation();
 
@@ -1603,94 +1965,63 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
 wxWindow::~wxWindow()
 {
 
 wxWindow::~wxWindow()
 {
+    m_isBeingDeleted = TRUE;
     m_hasVMT = FALSE;
 
     m_hasVMT = FALSE;
 
-#if wxUSE_DRAG_AND_DROP
-    if (m_dropTarget)
-    {
-        delete m_dropTarget;
-       m_dropTarget = (wxDropTarget*) NULL;
-    }
-#endif
-
-#if wxUSE_TOOLTIPS
-    if (m_toolTip)
-    {
-        delete m_toolTip;
-       m_toolTip = (wxToolTip*) NULL;
-    }
-#endif // wxUSE_TOOLTIPS
-
-    if (m_widget) Show( FALSE );
+    if (m_widget)
+        Show( FALSE );
 
     DestroyChildren();
 
 
     DestroyChildren();
 
-    if (m_parent) m_parent->RemoveChild( this );
-    
-    if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
-
-    if (m_scrollGC) gdk_gc_unref( m_scrollGC );
-
-    if (m_wxwindow) gtk_widget_destroy( m_wxwindow );
-
-    if (m_widget) gtk_widget_destroy( m_widget );
-
-    if (m_cursor) delete m_cursor;
+    if (m_parent)
+        m_parent->RemoveChild( this );
 
 
-    DeleteRelatedConstraints();
-    if (m_constraints)
+    if (m_widgetStyle)
     {
     {
-        /* This removes any dangling pointers to this window
-         * in other windows' constraintsInvolvedIn lists. */
-        UnsetConstraints(m_constraints);
-        delete m_constraints;
-        m_constraints = (wxLayoutConstraints *) NULL;
+        gtk_style_unref( m_widgetStyle );
+        m_widgetStyle = (GtkStyle*) NULL;
     }
     }
-    
-    if (m_windowSizer)
+
+    if (m_scrollGC)
     {
     {
-        delete m_windowSizer;
-        m_windowSizer = (wxSizer *) NULL;
+        gdk_gc_unref( m_scrollGC );
+        m_scrollGC = (GdkGC*) NULL;
     }
     }
-    /* If this is a child of a sizer, remove self from parent */
-    if (m_sizerParent) m_sizerParent->RemoveChild((wxWindow *)this);
-
-    /* Just in case the window has been Closed, but
-     * we're then deleting immediately: don't leave
-     * dangling pointers. */
-    wxPendingDelete.DeleteObject(this);
-
-    /* Just in case we've loaded a top-level window via
-     * wxWindow::LoadNativeDialog but we weren't a dialog
-     * class */
-    wxTopLevelWindows.DeleteObject(this);
 
 
-    if (m_windowValidator) delete m_windowValidator;
+    if (m_wxwindow)
+    {
+        gtk_widget_destroy( m_wxwindow );
+        m_wxwindow = (GtkWidget*) NULL;
+    }
 
 
-    if (m_clientObject) delete m_clientObject;
+    if (m_widget)
+    {
+        gtk_widget_destroy( m_widget );
+        m_widget = (GtkWidget*) NULL;
+    }
 }
 
 }
 
-void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
-      const wxPoint &pos, const wxSize &size,
-      long style, const wxString &name )
+void wxWindow::PreCreation( wxWindow *parent,
+                            wxWindowID id,
+                            const wxPoint &pos,
+                            const wxSize &size,
+                            long style,
+                            const wxString &name )
 {
 {
-    wxASSERT_MSG( (!m_needParent) || (parent), _T("Need complete parent.") );
+    wxASSERT_MSG( !m_needParent || parent, _T("Need complete parent.") );
 
 
-    m_widget = (GtkWidget*) NULL;
-    m_wxwindow = (GtkWidget*) NULL;
-    m_hasVMT = FALSE;
-    m_parent = parent;
-    m_children.DeleteContents( FALSE );
+    if ( !CreateBase(parent, id, pos, size, style, name) )
+    {
+        wxFAIL_MSG(_T("window creation failed"));
+    }
 
 
-    m_width = size.x;
-    if (m_width == -1) m_width = 20;
-    m_height = size.y;
-    if (m_height == -1) m_height = 20;
+    m_width = WidthDefault(size.x);
+    m_height = HeightDefault(size.y);
 
     m_x = (int)pos.x;
     m_y = (int)pos.y;
 
 
     m_x = (int)pos.x;
     m_y = (int)pos.y;
 
-    if (!m_needParent)  /* some reasonable defaults */
+    if (!parent)  /* some reasonable defaults */
     {
         if (m_x == -1)
         {
     {
         if (m_x == -1)
         {
@@ -1703,65 +2034,12 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
             if (m_y < 10) m_y = 10;
         }
     }
             if (m_y < 10) m_y = 10;
         }
     }
-
-    m_minWidth = -1;
-    m_minHeight = -1;
-    m_maxWidth = -1;
-    m_maxHeight = -1;
-
-    m_retCode = 0;
-
-    m_eventHandler = this;
-
-    m_windowId = id == -1 ? wxNewId() : id;
-
-    m_sizeSet = FALSE;
-
-    m_cursor = new wxCursor( wxCURSOR_ARROW );
-    m_font = *wxSWISS_FONT;
-    m_backgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
-    m_foregroundColour = *wxBLACK;
-    m_windowStyle = style;
-    m_windowName = name;
-
-    m_constraints = (wxLayoutConstraints *) NULL;
-    m_constraintsInvolvedIn = (wxList *) NULL;
-    m_windowSizer = (wxSizer *) NULL;
-    m_sizerParent = (wxWindow *) NULL;
-    m_autoLayout = FALSE;
-
-    m_hasScrolling = FALSE;
-    m_isScrolling = FALSE;
-    m_hAdjust = (GtkAdjustment *) NULL;
-    m_vAdjust = (GtkAdjustment *) NULL;
-    m_oldHorizontalPos = 0.0;
-    m_oldVerticalPos = 0.0;
-
-    m_isShown = FALSE;
-    m_isEnabled = TRUE;
-
-#if wxUSE_DRAG_AND_DROP
-    m_dropTarget = (wxDropTarget *) NULL;
-#endif
-    m_resizing = FALSE;
-    m_windowValidator = (wxValidator *) NULL;
-    m_scrollGC = (GdkGC*) NULL;
-    m_widgetStyle = (GtkStyle*) NULL;
-
-    m_clientObject = (wxClientData*)NULL;
-    m_clientData = NULL;
-
-    m_isStaticBox = FALSE;
-
-#if wxUSE_TOOLTIPS
-    m_toolTip = (wxToolTip*) NULL;
-#endif // wxUSE_TOOLTIPS
 }
 
 void wxWindow::PostCreation()
 {
     wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
 }
 
 void wxWindow::PostCreation()
 {
     wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
-    
+
     if (m_wxwindow)
     {
         /* these get reported to wxWindows -> wxPaintEvent */
     if (m_wxwindow)
     {
         /* these get reported to wxWindows -> wxPaintEvent */
@@ -1770,9 +2048,9 @@ void wxWindow::PostCreation()
 
         gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
           GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
 
         gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
           GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
-         
+
 #if (GTK_MINOR_VERSION > 0)
 #if (GTK_MINOR_VERSION > 0)
-       /* these are called when the "sunken" or "raised" borders are drawn */
+        /* these are called when the "sunken" or "raised" borders are drawn */
         gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
           GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
 
         gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
           GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
 
@@ -1781,14 +2059,15 @@ void wxWindow::PostCreation()
 #endif
     }
 
 #endif
     }
 
-    ConnectWidget( GetConnectWidget() );
+    GtkWidget *connect_widget = GetConnectWidget();
+
+    ConnectWidget( connect_widget );
+
+   /*  we cannot set colours, fonts and cursors before the widget has
+       been realized, so we do this directly after realization */
+    gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
+                            GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
 
 
-/*  we cannot set colours, fonts and cursors before the widget has
-    been realized, so we do this directly after realization */
-   
-    gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
-                           GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
-                           
     m_hasVMT = TRUE;
 }
 
     m_hasVMT = TRUE;
 }
 
@@ -1822,51 +2101,13 @@ void wxWindow::ConnectWidget( GtkWidget *widget )
       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
 }
 
       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
 }
 
-bool wxWindow::HasVMT()
-{
-    return m_hasVMT;
-}
-
-bool wxWindow::Close( bool force )
-{
-    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
-
-    wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
-    event.SetEventObject(this);
-    event.SetCanVeto(!force);
-
-    /* return FALSE if window wasn't closed because the application vetoed the
-     * close event */
-    return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
-}
-
 bool wxWindow::Destroy()
 {
     wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
 
     m_hasVMT = FALSE;
 bool wxWindow::Destroy()
 {
     wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
 
     m_hasVMT = FALSE;
-    delete this;
-    return TRUE;
-}
-
-bool wxWindow::DestroyChildren()
-{
-    wxNode *node;
-    while ((node = m_children.First()) != (wxNode *)NULL)
-    {
-        wxWindow *child;
-        if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
-        {
-            delete child;
-            if (m_children.Member(child)) delete node;
-        }
-    }
-    return TRUE;
-}
 
 
-void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
-{
-    // are we to set fonts here ?
+    return wxWindowBase::Destroy();
 }
 
 void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 }
 
 void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
@@ -1887,10 +2128,7 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     }
     else
     {
     }
     else
     {
-        int old_width = m_width;
-        int old_height = m_height;
-
-        if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
+        if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
         {
             if (x != -1) m_x = x;
             if (y != -1) m_y = y;
         {
             if (x != -1) m_x = x;
             if (y != -1) m_y = y;
@@ -1920,22 +2158,43 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
         if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 
         if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 
-        if (GTK_WIDGET_HAS_DEFAULT(m_widget))
-       {
-           /* the default button has a border around it */
-           int border = 5;
-       
-            gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x-border, m_y-border );
+        int border = 0;
+        int bottom_border = 0;
 
 
-            gtk_widget_set_usize( m_widget, m_width+2*border, m_height+2*border );
-       }
-       else
-       {
-            gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x, m_y );
+        if (GTK_WIDGET_CAN_DEFAULT(m_widget))
+        {
+            /* the default button has a border around it */
+            border = 6;
+            bottom_border = 5;
+        }
 
 
-            if ((old_width != m_width) || (old_height != m_height))
-              gtk_widget_set_usize( m_widget, m_width, m_height );
-       }
+        /* this is the result of hours of debugging: the following code
+           means that if we have a m_wxwindow and we set the size of
+           m_widget, m_widget (which is a GtkScrolledWindow) does NOT
+           automatically propagate its size down to its m_wxwindow,
+           which is its client area. therefore, we have to tell the
+           client area directly that it has to resize itself.
+           this will lead to that m_widget (GtkScrolledWindow) will
+           calculate how much size it needs for scrollbars etc and
+           it will then call XXX_size_allocate of its child, which
+           is m_wxwindow. m_wxwindow in turn will do the same with its
+           children and so on. problems can arise if this happens
+           before all the children have been realized as some widgets
+           stupidy need to be realized during XXX_size_allocate (e.g.
+           GtkNotebook) and they will segv if called otherwise. this
+           emergency is tested in gtk_myfixed_size_allocate. Normally
+           this shouldn't be needed and only gtk_widget_queue_resize()
+           should be enough to provoke a resize at the next appropriate
+           moment, but this seems to fail, e.g. when a wxNotebook contains
+           a wxSplitterWindow: the splitter window's children won't
+           show up properly resized then. */
+
+        gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow),
+                              m_widget,
+                              m_x-border,
+                              m_y-border,
+                              m_width+2*border,
+                              m_height+border+bottom_border );
     }
 
     m_sizeSet = TRUE;
     }
 
     m_sizeSet = TRUE;
@@ -1949,10 +2208,38 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 
 void wxWindow::OnInternalIdle()
 {
 
 void wxWindow::OnInternalIdle()
 {
+    wxCursor cursor = m_cursor;
+    if (g_globalCursor.Ok()) cursor = g_globalCursor;
+
+    if (cursor.Ok() && m_currentGdkCursor != cursor)
+    {
+        m_currentGdkCursor = cursor;
+       
+        if (m_wxwindow)
+        {
+            GdkWindow *window = m_wxwindow->window;
+            if (window)
+                gdk_window_set_cursor( window, cursor.GetCursor() );
+
+            if (!g_globalCursor.Ok())
+                cursor = *wxSTANDARD_CURSOR;
+
+            window = m_widget->window;
+            if (window)
+                gdk_window_set_cursor( window, cursor.GetCursor() );
+        }
+        else
+        {
+            GdkWindow *window = m_widget->window;
+            if (window)
+               gdk_window_set_cursor( window, cursor.GetCursor() );
+        }
+    }
+
     UpdateWindowUI();
 }
 
     UpdateWindowUI();
 }
 
-void wxWindow::GetSize( int *width, int *height ) const
+void wxWindow::DoGetSize( int *width, int *height ) const
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
@@ -1973,41 +2260,42 @@ void wxWindow::DoSetClientSize( int width, int height )
         int dw = 0;
         int dh = 0;
 
         int dw = 0;
         int dh = 0;
 
-        if (!m_hasScrolling)
+#if (GTK_MINOR_VERSION == 0)
+        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
         {
         {
-            GtkStyleClass *window_class = m_wxwindow->style->klass;
-
-            if ((m_windowStyle & wxRAISED_BORDER) ||
-                (m_windowStyle & wxSUNKEN_BORDER))
+            if (HasScrolling())
             {
             {
-                dw += 2 * window_class->xthickness;
-                dh += 2 * window_class->ythickness;
-            }
-        }
-        else
-        {
-            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+                GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
+                GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 
 
-#if (GTK_MINOR_VERSION == 0)
-            GtkWidget *viewport = scroll_window->viewport;
-            GtkStyleClass *viewport_class = viewport->style->klass;
+                GtkWidget *viewport = scroll_window->viewport;
+                GtkStyleClass *viewport_class = viewport->style->klass;
 
 
-            if ((m_windowStyle & wxRAISED_BORDER) ||
-                (m_windowStyle & wxSUNKEN_BORDER))
-            {
                 dw += 2 * viewport_class->xthickness;
                 dh += 2 * viewport_class->ythickness;
             }
                 dw += 2 * viewport_class->xthickness;
                 dh += 2 * viewport_class->ythickness;
             }
+        }
+#else
+        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+        {
+            /* when using GTK 1.2 we set the border size to 2 */
+            dw += 2 * 2;
+            dh += 2 * 2;
+        }
 #endif
 
 #endif
 
+        if (HasScrolling())
+        {
 /*
             GtkWidget *hscrollbar = scroll_window->hscrollbar;
             GtkWidget *vscrollbar = scroll_window->vscrollbar;
 /*
             GtkWidget *hscrollbar = scroll_window->hscrollbar;
             GtkWidget *vscrollbar = scroll_window->vscrollbar;
-           
-           we use this instead:  range.slider_width = 11 + 2*2pts edge 
+
+            we use this instead:  range.slider_width = 11 + 2*2pts edge
 */
 
 */
 
+            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
+            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+
             if (scroll_window->vscrollbar_visible)
             {
                 dw += 15;   /* dw += vscrollbar->allocation.width; */
             if (scroll_window->vscrollbar_visible)
             {
                 dw += 15;   /* dw += vscrollbar->allocation.width; */
@@ -2017,7 +2305,7 @@ void wxWindow::DoSetClientSize( int width, int height )
             if (scroll_window->hscrollbar_visible)
             {
                 dh += 15;   /* dh += hscrollbar->allocation.height; */
             if (scroll_window->hscrollbar_visible)
             {
                 dh += 15;   /* dh += hscrollbar->allocation.height; */
-                dw += scroll_class->scrollbar_spacing;
+                dh += scroll_class->scrollbar_spacing;
             }
        }
 
             }
        }
 
@@ -2025,7 +2313,7 @@ void wxWindow::DoSetClientSize( int width, int height )
     }
 }
 
     }
 }
 
-void wxWindow::GetClientSize( int *width, int *height ) const
+void wxWindow::DoGetClientSize( int *width, int *height ) const
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
@@ -2039,40 +2327,41 @@ void wxWindow::GetClientSize( int *width, int *height ) const
         int dw = 0;
         int dh = 0;
 
         int dw = 0;
         int dh = 0;
 
-        if (!m_hasScrolling)
+#if (GTK_MINOR_VERSION == 0)
+        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
         {
         {
-            GtkStyleClass *window_class = m_wxwindow->style->klass;
-
-            if ((m_windowStyle & wxRAISED_BORDER) ||
-                (m_windowStyle & wxSUNKEN_BORDER))
+            if (HasScrolling())
             {
             {
-                dw += 2 * window_class->xthickness;
-                dh += 2 * window_class->ythickness;
-            }
-        }
-        else
-        {
-            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+                GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
+                GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 
 
-#if (GTK_MINOR_VERSION == 0)
-            GtkWidget *viewport = scroll_window->viewport;
-            GtkStyleClass *viewport_class = viewport->style->klass;
+                GtkWidget *viewport = scroll_window->viewport;
+                GtkStyleClass *viewport_class = viewport->style->klass;
 
 
-            if ((m_windowStyle & wxRAISED_BORDER) ||
-                (m_windowStyle & wxSUNKEN_BORDER))
-            {
                 dw += 2 * viewport_class->xthickness;
                 dh += 2 * viewport_class->ythickness;
             }
                 dw += 2 * viewport_class->xthickness;
                 dh += 2 * viewport_class->ythickness;
             }
+        }
+#else
+        if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+        {
+            /* when using GTK 1.2 we set the border size to 2 */
+            dw += 2 * 2;
+            dh += 2 * 2;
+        }
 #endif
 #endif
+        if (HasScrolling())
+        {
 /*
             GtkWidget *hscrollbar = scroll_window->hscrollbar;
             GtkWidget *vscrollbar = scroll_window->vscrollbar;
 /*
             GtkWidget *hscrollbar = scroll_window->hscrollbar;
             GtkWidget *vscrollbar = scroll_window->vscrollbar;
-           
-           we use this instead:  range.slider_width = 11 + 2*2pts edge 
+
+            we use this instead:  range.slider_width = 11 + 2*2pts edge
 */
 
 */
 
+            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
+            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+
             if (scroll_window->vscrollbar_visible)
             {
                 dw += 15;   /* dw += vscrollbar->allocation.width; */
             if (scroll_window->vscrollbar_visible)
             {
                 dw += 15;   /* dw += vscrollbar->allocation.width; */
@@ -2091,7 +2380,7 @@ void wxWindow::GetClientSize( int *width, int *height ) const
     }
 }
 
     }
 }
 
-void wxWindow::GetPosition( int *x, int *y ) const
+void wxWindow::DoGetPosition( int *x, int *y ) const
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
@@ -2099,7 +2388,7 @@ void wxWindow::GetPosition( int *x, int *y ) const
     if (y) (*y) = m_y;
 }
 
     if (y) (*y) = m_y;
 }
 
-void wxWindow::ClientToScreen( int *x, int *y )
+void wxWindow::DoClientToScreen( int *x, int *y ) const
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
@@ -2128,7 +2417,7 @@ void wxWindow::ClientToScreen( int *x, int *y )
     if (y) *y += org_y;
 }
 
     if (y) *y += org_y;
 }
 
-void wxWindow::ScreenToClient( int *x, int *y )
+void wxWindow::DoScreenToClient( int *x, int *y ) const
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
@@ -2157,91 +2446,39 @@ void wxWindow::ScreenToClient( int *x, int *y )
     if (y) *y -= org_y;
 }
 
     if (y) *y -= org_y;
 }
 
-void wxWindow::Centre( int direction )
-{
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
-
-    int x = m_x;
-    int y = m_y;
-
-    if (m_parent)
-    {
-        int p_w = 0;
-        int p_h = 0;
-        m_parent->GetSize( &p_w, &p_h );
-        if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2;
-        if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2;
-    }
-    else
-    {
-        if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
-        if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
-    }
-
-    Move( x, y );
-}
-
-void wxWindow::Fit()
-{
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
-
-    int maxX = 0;
-    int maxY = 0;
-    wxNode *node = m_children.First();
-    while (node)
-    {
-        wxWindow *win = (wxWindow *)node->Data();
-        int wx, wy, ww, wh;
-        win->GetPosition(&wx, &wy);
-        win->GetSize(&ww, &wh);
-        if (wx + ww > maxX) maxX = wx + ww;
-        if (wy + wh > maxY) maxY = wy + wh;
-
-        node = node->Next();
-    }
-
-    SetClientSize(maxX + 7, maxY + 14);
-}
-
-void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
-{
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
-
-    m_minWidth = minW;
-    m_minHeight = minH;
-    m_maxWidth = maxW;
-    m_maxHeight = maxH;
-}
-
-void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
-{
-//  if (GetAutoLayout()) Layout();
-}
-
 bool wxWindow::Show( bool show )
 {
     wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
 
 bool wxWindow::Show( bool show )
 {
     wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
 
-    if (show == m_isShown) return TRUE;
+    if (!wxWindowBase::Show(show))
+    {
+        // nothing to do
+        return FALSE;
+    }
 
     if (show)
         gtk_widget_show( m_widget );
     else
         gtk_widget_hide( m_widget );
 
 
     if (show)
         gtk_widget_show( m_widget );
     else
         gtk_widget_hide( m_widget );
 
-    m_isShown = show;
-
     return TRUE;
 }
 
     return TRUE;
 }
 
-void wxWindow::Enable( bool enable )
+bool wxWindow::Enable( bool enable )
 {
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
 
 
-    m_isEnabled = enable;
+    if (!wxWindowBase::Enable(enable))
+    {
+        // nothing to do
+        return FALSE;
+    }
 
     gtk_widget_set_sensitive( m_widget, enable );
 
     gtk_widget_set_sensitive( m_widget, enable );
-    if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
+    if ( m_wxwindow )
+        gtk_widget_set_sensitive( m_wxwindow, enable );
+
+    return TRUE;
 }
 
 int wxWindow::GetCharHeight() const
 }
 
 int wxWindow::GetCharHeight() const
@@ -2266,8 +2503,12 @@ int wxWindow::GetCharWidth() const
     return gdk_string_width( font, "H" );
 }
 
     return gdk_string_width( font, "H" );
 }
 
-void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
-  int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const
+void wxWindow::GetTextExtent( const wxString& string,
+                              int *x,
+                              int *y,
+                              int *descent,
+                              int *externalLeading,
+                              const wxFont *theFont ) const
 {
     wxFont fontToUse = m_font;
     if (theFont) fontToUse = *theFont;
 {
     wxFont fontToUse = m_font;
     if (theFont) fontToUse = *theFont;
@@ -2281,34 +2522,6 @@ void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
     if (externalLeading) (*externalLeading) = 0;  // ??
 }
 
     if (externalLeading) (*externalLeading) = 0;  // ??
 }
 
-void wxWindow::MakeModal( bool modal )
-{
-    return;
-
-    // Disable all other windows
-    if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
-    {
-        wxNode *node = wxTopLevelWindows.First();
-        while (node)
-        {
-            wxWindow *win = (wxWindow *)node->Data();
-            if (win != this) win->Enable(!modal);
-
-            node = node->Next();
-        }
-    }
-}
-
-void wxWindow::OnKeyDown( wxKeyEvent &event )
-{
-    event.SetEventType( wxEVT_CHAR );
-
-    if (!GetEventHandler()->ProcessEvent( event ))
-    {
-        event.Skip();
-    }
-}
-
 void wxWindow::SetFocus()
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 void wxWindow::SetFocus()
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
@@ -2330,57 +2543,47 @@ void wxWindow::SetFocus()
     }
 }
 
     }
 }
 
-wxWindow *wxWindow::FindFocus()
-{
-    return g_focusWindow;
-}
-
 bool wxWindow::AcceptsFocus() const
 {
 bool wxWindow::AcceptsFocus() const
 {
-    return IsEnabled() && IsShown() && m_acceptsFocus;
-}
-
-void wxWindow::AddChild( wxWindow *child )
-{
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
-    wxCHECK_RET( (child != NULL), _T("invalid child") );
-
-    m_children.Append( child );
+    return m_acceptsFocus && wxWindowBase::AcceptsFocus();
 }
 
 }
 
-wxWindow *wxWindow::ReParent( wxWindow *newParent )
+bool wxWindow::Reparent( wxWindow *newParent )
 {
 {
-    wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, _T("invalid window") );
+    wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
 
 
-    wxWindow *oldParent = GetParent();
+    wxWindow *oldParent = m_parent;
 
 
-    if (oldParent) oldParent->RemoveChild( this );
+    if ( !wxWindowBase::Reparent(newParent) )
+        return FALSE;
 
 
-    gtk_widget_unparent( m_widget );
+    if (oldParent)
+    {
+        gtk_container_remove( GTK_CONTAINER(oldParent->m_wxwindow), m_widget );
+    }
 
     if (newParent)
     {
 
     if (newParent)
     {
-        newParent->AddChild( this );
-        (newParent->m_insertCallback)( newParent, this );
+        /* insert GTK representation */
+        (*(newParent->m_insertCallback))(newParent, this);
     }
 
     }
 
-    return oldParent;
+    return TRUE;
 }
 
 }
 
-void wxWindow::RemoveChild( wxWindow *child )
+void wxWindow::DoAddChild(wxWindow *child)
 {
 {
-    m_children.DeleteObject( child );
-    child->m_parent = (wxWindow *) NULL;
-}
+    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
 
 
-void wxWindow::SetReturnCode( int retCode )
-{
-    m_retCode = retCode;
-}
+    wxASSERT_MSG( (child != NULL), _T("invalid child window") );
 
 
-int wxWindow::GetReturnCode()
-{
-    return m_retCode;
+    wxASSERT_MSG( (m_insertCallback != NULL), _T("invalid child insertion function") );
+
+    /* add to list */
+    AddChild( child );
+
+    /* insert GTK representation */
+    (*m_insertCallback)(this, child);
 }
 
 void wxWindow::Raise()
 }
 
 void wxWindow::Raise()
@@ -2389,7 +2592,7 @@ void wxWindow::Raise()
 
     if (!m_widget->window) return;
 
 
     if (!m_widget->window) return;
 
-    if (m_widget) gdk_window_raise( m_widget->window );
+    gdk_window_raise( m_widget->window );
 }
 
 void wxWindow::Lower()
 }
 
 void wxWindow::Lower()
@@ -2398,118 +2601,49 @@ void wxWindow::Lower()
 
     if (!m_widget->window) return;
 
 
     if (!m_widget->window) return;
 
-    if (m_widget) gdk_window_lower( m_widget->window );
-}
-
-wxEvtHandler *wxWindow::GetEventHandler() const
-{
-    return m_eventHandler;
-}
-
-void wxWindow::SetEventHandler( wxEvtHandler *handler )
-{
-    m_eventHandler = handler;
+    gdk_window_lower( m_widget->window );
 }
 
 }
 
-void wxWindow::PushEventHandler(wxEvtHandler *handler)
+bool wxWindow::SetCursor( const wxCursor &cursor )
 {
 {
-    handler->SetNextHandler(GetEventHandler());
-    SetEventHandler(handler);
-}
+    wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
 
 
-wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
-{
-    if (GetEventHandler())
+    if (!wxWindowBase::SetCursor(cursor))
     {
     {
-        wxEvtHandler *handlerA = GetEventHandler();
-        wxEvtHandler *handlerB = handlerA->GetNextHandler();
-        handlerA->SetNextHandler((wxEvtHandler *) NULL);
-        SetEventHandler(handlerB);
-        if (deleteHandler)
-        {
-            delete handlerA;
-            return (wxEvtHandler*) NULL;
-        }
-        else
-            return handlerA;
-     }
-     else
-        return (wxEvtHandler *) NULL;
-}
-
-wxValidator *wxWindow::GetValidator()
-{
-    return m_windowValidator;
-}
-
-void wxWindow::SetValidator( const wxValidator& validator )
-{
-    if (m_windowValidator) delete m_windowValidator;
-    m_windowValidator = validator.Clone();
-    if (m_windowValidator) m_windowValidator->SetWindow(this);
-}
-
-void wxWindow::SetClientObject( wxClientData *data )
-{
-    if (m_clientObject) delete m_clientObject;
-    m_clientObject = data;
-}
-
-wxClientData *wxWindow::GetClientObject()
-{
-    return m_clientObject;
-}
-
-void wxWindow::SetClientData( void *data )
-{
-    m_clientData = data;
-}
+        // don't leave if the GTK widget has just
+        // been realized
+        if (!m_delayedCursor) return FALSE;
+    }
 
 
-void *wxWindow::GetClientData()
-{
-    return m_clientData;
-}
+    GtkWidget *connect_widget = GetConnectWidget();
+    if (!connect_widget->window)
+    {
+        // indicate that a new style has been set
+        // but it couldn't get applied as the
+        // widget hasn't been realized yet.
+        m_delayedCursor = TRUE;
 
 
-bool wxWindow::IsBeingDeleted()
-{
-    return FALSE;
-}
+        // pretend we have done something
+        return TRUE;
+    }
 
 
-void wxWindow::SetId( wxWindowID id )
-{
-    m_windowId = id;
-}
+//    gdk_window_set_cursor( connect_widget->window, GetCursor().GetCursor() );
 
 
-wxWindowID wxWindow::GetId() const
-{
-    return m_windowId;
+    // cursor was set
+    return TRUE;
 }
 
 }
 
-void wxWindow::SetCursor( const wxCursor &cursor )
+void wxWindow::WarpPointer( int x, int y )
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
 
-    if (cursor.Ok())
-    {
-        if (cursor == *m_cursor) return;
-        *m_cursor = cursor;
-    }
-    else
+    GtkWidget *connect_widget = GetConnectWidget();
+    if (connect_widget->window)
     {
     {
-        *m_cursor = *wxSTANDARD_CURSOR;
+        /* we provide this function ourselves as it is
+           missing in GDK */
+        gdk_window_warp_pointer( connect_widget->window, x, y );
     }
     }
-
-    if (!m_widget->window) return;
-
-    gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
-
-    if ((m_wxwindow) && (m_wxwindow->window))
-         gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
-}
-
-void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) )
-{
-  // TODO
 }
 
 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
 }
 
 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
@@ -2554,31 +2688,6 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
     }
 }
 
     }
 }
 
-wxRegion wxWindow::GetUpdateRegion() const
-{
-  return m_updateRegion;
-}
-
-bool wxWindow::IsExposed( int x, int y) const
-{
-    return (m_updateRegion.Contains( x, y ) != wxOutRegion );
-}
-
-bool wxWindow::IsExposed( int x, int y, int w, int h ) const
-{
-    return (m_updateRegion.Contains( x, y, w, h ) != wxOutRegion );
-}
-
-bool wxWindow::IsExposed( const wxPoint& pt ) const
-{
-    return (m_updateRegion.Contains( pt.x, pt.y ) != wxOutRegion );
-}
-
-bool wxWindow::IsExposed( const wxRect& rect ) const
-{
-    return (m_updateRegion.Contains( rect.x, rect.y, rect.width, rect.height ) != wxOutRegion );
-}
-
 void wxWindow::Clear()
 {
     wxCHECK_RET( m_widget != NULL, _T("invalid window") );
 void wxWindow::Clear()
 {
     wxCHECK_RET( m_widget != NULL, _T("invalid window") );
@@ -2592,72 +2701,54 @@ void wxWindow::Clear()
 }
 
 #if wxUSE_TOOLTIPS
 }
 
 #if wxUSE_TOOLTIPS
-void wxWindow::SetToolTip( const wxString &tip )
-{
-    if (m_toolTip)
-    {
-        m_toolTip->SetTip( tip );
-    }
-    else
-    {
-        SetToolTip( new wxToolTip( tip ) );
-    }
-
-    // setting empty tooltip text does not remove the tooltip any more for
-    // wxMSW compatibility - use SetToolTip((wxToolTip *)NULL) for this
-}
-
-void wxWindow::SetToolTip( wxToolTip *tip )
+void wxWindow::DoSetToolTip( wxToolTip *tip )
 {
 {
-    if (m_toolTip)
-    {
-        m_toolTip->SetTip( (char*) NULL );
-        delete m_toolTip;
-    }
+    wxWindowBase::DoSetToolTip(tip);
 
 
-    m_toolTip = tip;
-
-    if (m_toolTip)
-        m_toolTip->Apply( this );
+    if (m_tooltip)
+        m_tooltip->Apply( this );
 }
 
 void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
 {
 }
 
 void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
 {
-    gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConv_current->cWX2MB(tip), (gchar*) NULL );
+    gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
 }
 #endif // wxUSE_TOOLTIPS
 
 }
 #endif // wxUSE_TOOLTIPS
 
-wxColour wxWindow::GetBackgroundColour() const
-{
-    return m_backgroundColour;
-}
-
-void wxWindow::SetBackgroundColour( const wxColour &colour )
+bool wxWindow::SetBackgroundColour( const wxColour &colour )
 {
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
 
 
-    if (m_backgroundColour == colour) return;
+    if (!wxWindowBase::SetBackgroundColour(colour))
+    {
+        // don't leave if the GTK widget has just
+        // been realized
+        if (!m_delayedBackgroundColour) return FALSE;
+    }
 
 
-    m_backgroundColour = colour;
-    if (!m_backgroundColour.Ok()) return;
+    GtkWidget *connect_widget = GetConnectWidget();
+    if (!connect_widget->window)
+    {
+        // indicate that a new style has been set
+        // but it couldn't get applied as the
+        // widget hasn't been realized yet.
+        m_delayedBackgroundColour = TRUE;
 
 
-    if (!m_widget->window) return;
+        // pretend we have done something
+        return TRUE;
+    }
 
     if (m_wxwindow && m_wxwindow->window)
     {
 
     if (m_wxwindow && m_wxwindow->window)
     {
-       /* wxMSW doesn't clear the window here. I don't do that
-          either to provide compatibility. call Clear() to do 
-          the job. */
-          
+        /* wxMSW doesn't clear the window here. I don't do that either to
+          provide compatibility. call Clear() to do the job. */
+
         m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_wxwindow->window ) );
         gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );
     }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
         m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_wxwindow->window ) );
         gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );
     }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
-    
-    if (sysbg.Red() == colour.Red() &&
-        sysbg.Green() == colour.Green() &&
-        sysbg.Blue() == colour.Blue())
+    if (sysbg == m_backgroundColour)
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
@@ -2667,28 +2758,35 @@ void wxWindow::SetBackgroundColour( const wxColour &colour )
     {
         ApplyWidgetStyle();
     }
     {
         ApplyWidgetStyle();
     }
-}
 
 
-wxColour wxWindow::GetForegroundColour() const
-{
-    return m_foregroundColour;
+    return TRUE;
 }
 
 }
 
-void wxWindow::SetForegroundColour( const wxColour &colour )
+bool wxWindow::SetForegroundColour( const wxColour &colour )
 {
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
 
 
-    if (m_foregroundColour == colour) return;
+    if (!wxWindowBase::SetForegroundColour(colour))
+    {
+        // don't leave if the GTK widget has just
+        // been realized
+        if (!m_delayedForegroundColour) return FALSE;
+    }
 
 
-    m_foregroundColour = colour;
-    if (!m_foregroundColour.Ok()) return;
+    GtkWidget *connect_widget = GetConnectWidget();
+    if (!connect_widget->window)
+    {
+        // indicate that a new style has been set
+        // but it couldn't get applied as the
+        // widget hasn't been realized yet.
+        m_delayedForegroundColour = TRUE;
 
 
-    if (!m_widget->window) return;
+        // pretend we have done something
+        return TRUE;
+    }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
-    if (sysbg.Red() == colour.Red() &&
-        sysbg.Green() == colour.Green() &&
-        sysbg.Blue() == colour.Blue())
+    if ( sysbg == m_backgroundColour )
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
@@ -2698,15 +2796,15 @@ void wxWindow::SetForegroundColour( const wxColour &colour )
     {
         ApplyWidgetStyle();
     }
     {
         ApplyWidgetStyle();
     }
+
+    return TRUE;
 }
 
 GtkStyle *wxWindow::GetWidgetStyle()
 {
     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
 
 }
 
 GtkStyle *wxWindow::GetWidgetStyle()
 {
     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
 
-    m_widgetStyle =
-      gtk_style_copy(
-        gtk_widget_get_style( m_widget ) );
+    m_widgetStyle = gtk_style_copy( gtk_widget_get_style( m_widget ) );
 
     return m_widgetStyle;
 }
 
     return m_widgetStyle;
 }
@@ -2723,97 +2821,25 @@ void wxWindow::SetWidgetStyle()
         m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
         style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
         style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
         m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
         style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
         style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
-        style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
-    }
-
-    if (m_backgroundColour.Ok())
-    {
-        m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
-        style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
-        style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
-        style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
-        style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
-        style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
-        style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
-        style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
-        style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
-    }
-}
-
-void wxWindow::ApplyWidgetStyle()
-{
-}
-
-bool wxWindow::Validate()
-{
-    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
-
-    wxNode *node = m_children.First();
-    while (node)
-    {
-        wxWindow *child = (wxWindow *)node->Data();
-        if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
-        {
-            return FALSE;
-        }
-        node = node->Next();
-    }
-    return TRUE;
-}
-
-bool wxWindow::TransferDataToWindow()
-{
-    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
-
-    wxNode *node = m_children.First();
-    while (node)
-    {
-        wxWindow *child = (wxWindow *)node->Data();
-        if (child->GetValidator() && /* child->GetValidator()->Ok() && */
-            !child->GetValidator()->TransferToWindow() )
-        {
-            wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION );
-            return FALSE;
-        }
-        node = node->Next();
-    }
-    return TRUE;
-}
-
-bool wxWindow::TransferDataFromWindow()
-{
-    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
-
-    wxNode *node = m_children.First();
-    while (node)
-    {
-        wxWindow *child = (wxWindow *)node->Data();
-        if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
-        {
-            return FALSE;
-        }
-        node = node->Next();
-    }
-    return TRUE;
-}
-
-void wxWindow::SetAcceleratorTable( const wxAcceleratorTable& accel )
-{
-    m_acceleratorTable = accel;
-}
+        style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
+    }
 
 
-void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
-{
-    TransferDataToWindow();
+    if (m_backgroundColour.Ok())
+    {
+        m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
+        style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
+        style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
+        style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
+        style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
+        style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
+        style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
+        style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
+        style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
+    }
 }
 
 }
 
-void wxWindow::InitDialog()
+void wxWindow::ApplyWidgetStyle()
 {
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
-
-    wxInitDialogEvent event(GetId());
-    event.SetEventObject( this );
-    GetEventHandler()->ProcessEvent(event);
 }
 
 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 }
 
 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
@@ -2834,7 +2860,9 @@ static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 static gint gs_pop_x = 0;
 static gint gs_pop_y = 0;
 
 static gint gs_pop_x = 0;
 static gint gs_pop_y = 0;
 
-static void pop_pos_callback( GtkMenu *menu, gint *x, gint *y, wxWindow *win )
+static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
+                              gint *x, gint *y,
+                              wxWindow *win )
 {
     win->ClientToScreen( &gs_pop_x, &gs_pop_y );
     *x = gs_pop_x;
 {
     win->ClientToScreen( &gs_pop_x, &gs_pop_y );
     *x = gs_pop_x;
@@ -2882,12 +2910,7 @@ void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
     if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
 }
 
     if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
 }
 
-wxDropTarget *wxWindow::GetDropTarget() const
-{
-    return m_dropTarget;
-}
-
-#endif
+#endif // wxUSE_DRAG_AND_DROP
 
 GtkWidget* wxWindow::GetConnectWidget()
 {
 
 GtkWidget* wxWindow::GetConnectWidget()
 {
@@ -2903,21 +2926,31 @@ bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
     return (window == m_widget->window);
 }
 
     return (window == m_widget->window);
 }
 
-void wxWindow::SetFont( const wxFont &font )
+bool wxWindow::SetFont( const wxFont &font )
 {
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
-    
-    if (m_font == font) return;
-    
-    if (((wxFont*)&font)->Ok())
-        m_font = font;
-    else
-        m_font = *wxSWISS_FONT;
+    wxCHECK_MSG( m_widget != NULL, FALSE, _T(        "invalid window") );
+
+    if (!wxWindowBase::SetFont(font))
+    {
+        // don't leave if the GTK widget has just
+        // been realized
+        if (!m_delayedFont) return FALSE;
+    }
+
+    GtkWidget *connect_widget = GetConnectWidget();
+    if (!connect_widget->window)
+    {
+        // indicate that a new style has been set
+        // but it couldn't get applied as the
+        // widget hasn't been realized yet.
+        m_delayedFont = TRUE;
+
+        // pretend we have done something
+        return TRUE;
+    }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
-    if (sysbg.Red() == m_backgroundColour.Red() &&
-        sysbg.Green() == m_backgroundColour.Green() &&
-        sysbg.Blue() == m_backgroundColour.Blue())
+    if ( sysbg == m_backgroundColour )
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
@@ -2927,115 +2960,48 @@ void wxWindow::SetFont( const wxFont &font )
     {
         ApplyWidgetStyle();
     }
     {
         ApplyWidgetStyle();
     }
-}
-
-void wxWindow::SetWindowStyleFlag( long flag )
-{
-    m_windowStyle = flag;
-}
 
 
-long wxWindow::GetWindowStyleFlag() const
-{
-    return m_windowStyle;
+    return TRUE;
 }
 
 void wxWindow::CaptureMouse()
 {
     wxCHECK_RET( m_widget != NULL, _T("invalid window") );
 
 }
 
 void wxWindow::CaptureMouse()
 {
     wxCHECK_RET( m_widget != NULL, _T("invalid window") );
 
-    wxCHECK_RET( g_capturing == FALSE, _T("CaptureMouse called twice") );
-
-    if (!m_widget->window) return;
+    wxCHECK_RET( g_captureWindow == NULL, _T("CaptureMouse called twice") );
 
     GtkWidget *connect_widget = GetConnectWidget();
 
     GtkWidget *connect_widget = GetConnectWidget();
-    gtk_grab_add( connect_widget );
+    if (!connect_widget->window) return;
+
     gdk_pointer_grab( connect_widget->window, FALSE,
                       (GdkEventMask)
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
                           GDK_POINTER_MOTION_MASK),
                       (GdkWindow *) NULL,
     gdk_pointer_grab( connect_widget->window, FALSE,
                       (GdkEventMask)
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
                           GDK_POINTER_MOTION_MASK),
                       (GdkWindow *) NULL,
-                      (GdkCursor *) NULL,
+                      m_cursor.GetCursor(),
                       GDK_CURRENT_TIME );
                       GDK_CURRENT_TIME );
-    g_capturing = TRUE;
+    g_captureWindow = this;
 }
 
 void wxWindow::ReleaseMouse()
 {
     wxCHECK_RET( m_widget != NULL, _T("invalid window") );
 
 }
 
 void wxWindow::ReleaseMouse()
 {
     wxCHECK_RET( m_widget != NULL, _T("invalid window") );
 
-    wxCHECK_RET( g_capturing == TRUE, _T("ReleaseMouse called twice") );
-
-    if (!m_widget->window) return;
+    wxCHECK_RET( g_captureWindow, _T("ReleaseMouse called twice") );
 
     GtkWidget *connect_widget = GetConnectWidget();
 
     GtkWidget *connect_widget = GetConnectWidget();
-    gtk_grab_remove( connect_widget );
-    gdk_pointer_ungrab ( GDK_CURRENT_TIME );
-    g_capturing = FALSE;
-}
-
-void wxWindow::SetTitle( const wxString &WXUNUSED(title) )
-{
-}
-
-wxString wxWindow::GetTitle() const
-{
-    return (wxString&)m_windowName;
-}
-
-wxString wxWindow::GetLabel() const
-{
-    return GetTitle();
-}
+    if (!connect_widget->window) return;
 
 
-void wxWindow::SetName( const wxString &name )
-{
-    m_windowName = name;
-}
-
-wxString wxWindow::GetName() const
-{
-    return (wxString&)m_windowName;
-}
-
-bool wxWindow::IsShown() const
-{
-    return m_isShown;
+    gdk_pointer_ungrab ( GDK_CURRENT_TIME );
+    g_captureWindow = (wxWindow*) NULL;
 }
 
 }
 
-bool wxWindow::IsRetained()
+bool wxWindow::IsRetained() const
 {
     return FALSE;
 }
 
 {
     return FALSE;
 }
 
-wxWindow *wxWindow::FindWindow( long id )
-{
-    if (id == m_windowId) return this;
-    wxNode *node = m_children.First();
-    while (node)
-    {
-        wxWindow *child = (wxWindow*)node->Data();
-        wxWindow *res = child->FindWindow( id );
-        if (res) return res;
-        node = node->Next();
-    }
-    return (wxWindow *) NULL;
-}
-
-wxWindow *wxWindow::FindWindow( const wxString& name )
-{
-    if (name == m_windowName) return this;
-    wxNode *node = m_children.First();
-    while (node)
-    {
-        wxWindow *child = (wxWindow*)node->Data();
-        wxWindow *res = child->FindWindow( name );
-        if (res) return res;
-        node = node->Next();
-    }
-    return (wxWindow *) NULL;
-}
-
 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
       int range, bool refresh )
 {
 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
       int range, bool refresh )
 {
@@ -3094,15 +3060,10 @@ void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
         m_vAdjust->page_size = fthumb;
     }
 
         m_vAdjust->page_size = fthumb;
     }
 
-    if (m_wxwindow)
-    {
-        if (orient == wxHORIZONTAL)
-            gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
-        else
-            gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
-
-        gtk_widget_set_usize( m_widget, m_width, m_height );
-    }
+    if (orient == wxHORIZONTAL)
+        gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
+    else
+        gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
 }
 
 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
 }
 
 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
@@ -3132,7 +3093,7 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
         m_vAdjust->value = fpos;
     }
 
         m_vAdjust->value = fpos;
     }
 
-    if (!m_isScrolling)
+    if (!m_isScrolling)  /* prevent recursion */
     {
         if (m_wxwindow->window)
         {
     {
         if (m_wxwindow->window)
         {
@@ -3186,496 +3147,58 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 
     wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
 
 
     wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
 
+    if (!m_scrollGC)
+    {
+        m_scrollGC = gdk_gc_new( m_wxwindow->window );
+        gdk_gc_set_exposures( m_scrollGC, TRUE );
+    }
+
     wxNode *node = m_children.First();
     while (node)
     {
         wxWindow *child = (wxWindow*) node->Data();
     wxNode *node = m_children.First();
     while (node)
     {
         wxWindow *child = (wxWindow*) node->Data();
-       child->Move( child->m_x + dx, child->m_y + dy );
-       node = node->Next();
+        int sx = 0;
+        int sy = 0;
+        child->GetSize( &sx, &sy );
+        child->SetSize( child->m_x + dx, child->m_y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
+        node = node->Next();
     }
 
     int cw = 0;
     int ch = 0;
     GetClientSize( &cw, &ch );
     }
 
     int cw = 0;
     int ch = 0;
     GetClientSize( &cw, &ch );
-
     int w = cw - abs(dx);
     int h = ch - abs(dy);
     int w = cw - abs(dx);
     int h = ch - abs(dy);
+
     if ((h < 0) || (w < 0))
     {
         Refresh();
     if ((h < 0) || (w < 0))
     {
         Refresh();
-        return;
-    }
-    int s_x = 0;
-    int s_y = 0;
-    if (dx < 0) s_x = -dx;
-    if (dy < 0) s_y = -dy;
-    int d_x = 0;
-    int d_y = 0;
-    if (dx > 0) d_x = dx;
-    if (dy > 0) d_y = dy;
-
-    if (!m_scrollGC)
-    {
-        m_scrollGC = gdk_gc_new( m_wxwindow->window );
-        gdk_gc_set_exposures( m_scrollGC, TRUE );
-    }
-
-    gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
-        m_wxwindow->window, s_x, s_y, w, h );
-
-    wxRect rect;
-    if (dx < 0) rect.x = cw+dx; else rect.x = 0;
-    if (dy < 0) rect.y = ch+dy; else rect.y = 0;
-    if (dy != 0) rect.width = cw; else rect.width = abs(dx);
-    if (dx != 0) rect.height = ch; else rect.height = abs(dy);
-
-    Refresh( TRUE, &rect );
-}
-
-//-------------------------------------------------------------------------------------
-//          Layout
-//-------------------------------------------------------------------------------------
-
-wxLayoutConstraints *wxWindow::GetConstraints() const
-{
-  return m_constraints;
-}
-
-void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
-{
-  if (m_constraints)
-  {
-    UnsetConstraints(m_constraints);
-    delete m_constraints;
-  }
-  m_constraints = constraints;
-  if (m_constraints)
-  {
-    // Make sure other windows know they're part of a 'meaningful relationship'
-    if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
-      m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-    if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
-      m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-    if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
-      m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-    if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
-      m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-    if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
-      m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-    if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
-      m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-    if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
-      m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-    if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
-      m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
-  }
-;
-}
-;
-
-void wxWindow::SetAutoLayout( bool autoLayout )
-{
-  m_autoLayout = autoLayout;
-}
-
-bool wxWindow::GetAutoLayout() const
-{
-  return m_autoLayout;
-}
-
-wxSizer *wxWindow::GetSizer() const
-{
-  return m_windowSizer;
-}
-
-void wxWindow::SetSizerParent( wxWindow *win )
-{
-  m_sizerParent = win;
-}
-
-wxWindow *wxWindow::GetSizerParent() const
-{
-  return m_sizerParent;
-}
-
-// This removes any dangling pointers to this window
-// in other windows' constraintsInvolvedIn lists.
-void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
-{
-  if (c)
-  {
-    if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
-      c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-    if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
-      c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-    if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
-      c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-    if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
-      c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-    if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
-      c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-    if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
-      c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-    if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
-      c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-    if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
-      c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
-  }
-}
-
-// Back-pointer to other windows we're involved with, so if we delete
-// this window, we must delete any constraints we're involved with.
-void wxWindow::AddConstraintReference(wxWindow *otherWin)
-{
-  if (!m_constraintsInvolvedIn)
-    m_constraintsInvolvedIn = new wxList;
-  if (!m_constraintsInvolvedIn->Member(otherWin))
-    m_constraintsInvolvedIn->Append(otherWin);
-}
-
-// REMOVE back-pointer to other windows we're involved with.
-void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
-{
-  if (m_constraintsInvolvedIn)
-    m_constraintsInvolvedIn->DeleteObject(otherWin);
-}
-
-// Reset any constraints that mention this window
-void wxWindow::DeleteRelatedConstraints()
-{
-  if (m_constraintsInvolvedIn)
-  {
-    wxNode *node = m_constraintsInvolvedIn->First();
-    while (node)
-    {
-      wxWindow *win = (wxWindow *)node->Data();
-      wxNode *next = node->Next();
-      wxLayoutConstraints *constr = win->GetConstraints();
-
-      // Reset any constraints involving this window
-      if (constr)
-      {
-        constr->left.ResetIfWin((wxWindow *)this);
-        constr->top.ResetIfWin((wxWindow *)this);
-        constr->right.ResetIfWin((wxWindow *)this);
-        constr->bottom.ResetIfWin((wxWindow *)this);
-        constr->width.ResetIfWin((wxWindow *)this);
-        constr->height.ResetIfWin((wxWindow *)this);
-        constr->centreX.ResetIfWin((wxWindow *)this);
-        constr->centreY.ResetIfWin((wxWindow *)this);
-      }
-      delete node;
-      node = next;
-    }
-    delete m_constraintsInvolvedIn;
-    m_constraintsInvolvedIn = (wxList *) NULL;
-  }
-}
-
-void wxWindow::SetSizer(wxSizer *sizer)
-{
-  m_windowSizer = sizer;
-  if (sizer)
-    sizer->SetSizerParent((wxWindow *)this);
-}
-
-/*
- * New version
- */
-
-bool wxWindow::Layout()
-{
-  if (GetConstraints())
-  {
-    int w, h;
-    GetClientSize(&w, &h);
-    GetConstraints()->width.SetValue(w);
-    GetConstraints()->height.SetValue(h);
-  }
-
-  // If top level (one sizer), evaluate the sizer's constraints.
-  if (GetSizer())
-  {
-    int noChanges;
-    GetSizer()->ResetConstraints();   // Mark all constraints as unevaluated
-    GetSizer()->LayoutPhase1(&noChanges);
-    GetSizer()->LayoutPhase2(&noChanges);
-    GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
-    return TRUE;
-  }
-  else
-  {
-    // Otherwise, evaluate child constraints
-    ResetConstraints();   // Mark all constraints as unevaluated
-    DoPhase(1);           // Just one phase need if no sizers involved
-    DoPhase(2);
-    SetConstraintSizes(); // Recursively set the real window sizes
-  }
-  return TRUE;
-}
-
-
-// Do a phase of evaluating constraints:
-// the default behaviour. wxSizers may do a similar
-// thing, but also impose their own 'constraints'
-// and order the evaluation differently.
-bool wxWindow::LayoutPhase1(int *noChanges)
-{
-  wxLayoutConstraints *constr = GetConstraints();
-  if (constr)
-  {
-    return constr->SatisfyConstraints((wxWindow *)this, noChanges);
-  }
-  else
-    return TRUE;
-}
-
-bool wxWindow::LayoutPhase2(int *noChanges)
-{
-  *noChanges = 0;
-
-  // Layout children
-  DoPhase(1);
-  DoPhase(2);
-  return TRUE;
-}
-
-// Do a phase of evaluating child constraints
-bool wxWindow::DoPhase(int phase)
-{
-  int noIterations = 0;
-  int maxIterations = 500;
-  int noChanges = 1;
-  int noFailures = 0;
-  wxList succeeded;
-  while ((noChanges > 0) && (noIterations < maxIterations))
-  {
-    noChanges = 0;
-    noFailures = 0;
-    wxNode *node = m_children.First();
-    while (node)
-    {
-      wxWindow *child = (wxWindow *)node->Data();
-      if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
-      {
-        wxLayoutConstraints *constr = child->GetConstraints();
-        if (constr)
-        {
-          if (succeeded.Member(child))
-          {
-          }
-          else
-          {
-            int tempNoChanges = 0;
-            bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
-            noChanges += tempNoChanges;
-            if (success)
-            {
-              succeeded.Append(child);
-            }
-          }
-        }
-      }
-      node = node->Next();
-    }
-    noIterations ++;
-  }
-  return TRUE;
-}
-
-void wxWindow::ResetConstraints()
-{
-  wxLayoutConstraints *constr = GetConstraints();
-  if (constr)
-  {
-    constr->left.SetDone(FALSE);
-    constr->top.SetDone(FALSE);
-    constr->right.SetDone(FALSE);
-    constr->bottom.SetDone(FALSE);
-    constr->width.SetDone(FALSE);
-    constr->height.SetDone(FALSE);
-    constr->centreX.SetDone(FALSE);
-    constr->centreY.SetDone(FALSE);
-  }
-  wxNode *node = m_children.First();
-  while (node)
-  {
-    wxWindow *win = (wxWindow *)node->Data();
-    if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
-      win->ResetConstraints();
-    node = node->Next();
-  }
-}
-
-// Need to distinguish between setting the 'fake' size for
-// windows and sizers, and setting the real values.
-void wxWindow::SetConstraintSizes(bool recurse)
-{
-  wxLayoutConstraints *constr = GetConstraints();
-  if (constr && constr->left.GetDone() && constr->right.GetDone() &&
-                constr->width.GetDone() && constr->height.GetDone())
-  {
-    int x = constr->left.GetValue();
-    int y = constr->top.GetValue();
-    int w = constr->width.GetValue();
-    int h = constr->height.GetValue();
-
-    // If we don't want to resize this window, just move it...
-    if ((constr->width.GetRelationship() != wxAsIs) ||
-        (constr->height.GetRelationship() != wxAsIs))
-    {
-      // Calls Layout() recursively. AAAGH. How can we stop that.
-      // Simply take Layout() out of non-top level OnSizes.
-      SizerSetSize(x, y, w, h);
     }
     else
     {
     }
     else
     {
-      SizerMove(x, y);
-    }
-  }
-  else if (constr)
-  {
-    wxChar *windowClass = this->GetClassInfo()->GetClassName();
-
-    wxString winName;
-  if (GetName() == _T(""))
-    winName = _T("unnamed");
-  else
-    winName = GetName();
-    wxLogDebug( _T("Constraint(s) not satisfied for window of type %s, name %s:\n"),
-                (const wxChar *)windowClass,
-                (const wxChar *)winName);
-    if (!constr->left.GetDone()) wxLogDebug( _T("  unsatisfied 'left' constraint.\n") );
-    if (!constr->right.GetDone()) wxLogDebug( _T("  unsatisfied 'right' constraint.\n") );
-    if (!constr->width.GetDone()) wxLogDebug( _T("  unsatisfied 'width' constraint.\n") );
-    if (!constr->height.GetDone())  wxLogDebug( _T("  unsatisfied 'height' constraint.\n") );
-    wxLogDebug( _T("Please check constraints: try adding AsIs() constraints.\n") );
-  }
-
-  if (recurse)
-  {
-    wxNode *node = m_children.First();
-    while (node)
-    {
-      wxWindow *win = (wxWindow *)node->Data();
-      if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
-        win->SetConstraintSizes();
-      node = node->Next();
-    }
-  }
-}
+        int s_x = 0;
+        int s_y = 0;
+        if (dx < 0) s_x = -dx;
+        if (dy < 0) s_y = -dy;
+        int d_x = 0;
+        int d_y = 0;
+        if (dx > 0) d_x = dx;
+        if (dy > 0) d_y = dy;
 
 
-// This assumes that all sizers are 'on' the same
-// window, i.e. the parent of this window.
-void wxWindow::TransformSizerToActual(int *x, int *y) const
-{
-  if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
-         m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
-    return;
-
-  int xp, yp;
-  m_sizerParent->GetPosition(&xp, &yp);
-  m_sizerParent->TransformSizerToActual(&xp, &yp);
-  *x += xp;
-  *y += yp;
-}
-
-void wxWindow::SizerSetSize(int x, int y, int w, int h)
-{
-  int xx = x;
-  int yy = y;
-  TransformSizerToActual(&xx, &yy);
-  SetSize(xx, yy, w, h);
-}
-
-void wxWindow::SizerMove(int x, int y)
-{
-  int xx = x;
-  int yy = y;
-  TransformSizerToActual(&xx, &yy);
-  Move(xx, yy);
-}
+        gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
+            m_wxwindow->window, s_x, s_y, w, h );
 
 
-// Only set the size/position of the constraint (if any)
-void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
-{
-  wxLayoutConstraints *constr = GetConstraints();
-  if (constr)
-  {
-    if (x != -1)
-    {
-      constr->left.SetValue(x);
-      constr->left.SetDone(TRUE);
-    }
-    if (y != -1)
-    {
-      constr->top.SetValue(y);
-      constr->top.SetDone(TRUE);
-    }
-    if (w != -1)
-    {
-      constr->width.SetValue(w);
-      constr->width.SetDone(TRUE);
-    }
-    if (h != -1)
-    {
-      constr->height.SetValue(h);
-      constr->height.SetDone(TRUE);
-    }
-  }
-}
+        wxRect rect;
+        if (dx < 0) rect.x = cw+dx; else rect.x = 0;
+        if (dy < 0) rect.y = ch+dy; else rect.y = 0;
+        if (dy != 0) rect.width = cw; else rect.width = abs(dx);
+        if (dx != 0) rect.height = ch; else rect.height = abs(dy);
 
 
-void wxWindow::MoveConstraint(int x, int y)
-{
-  wxLayoutConstraints *constr = GetConstraints();
-  if (constr)
-  {
-    if (x != -1)
-    {
-      constr->left.SetValue(x);
-      constr->left.SetDone(TRUE);
+        Refresh( TRUE, &rect );
     }
     }
-    if (y != -1)
-    {
-      constr->top.SetValue(y);
-      constr->top.SetDone(TRUE);
-    }
-  }
-}
-
-void wxWindow::GetSizeConstraint(int *w, int *h) const
-{
-  wxLayoutConstraints *constr = GetConstraints();
-  if (constr)
-  {
-    *w = constr->width.GetValue();
-    *h = constr->height.GetValue();
-  }
-  else
-    GetSize(w, h);
 }
 
 }
 
-void wxWindow::GetClientSizeConstraint(int *w, int *h) const
+void wxWindow::SetScrolling(bool scroll)
 {
 {
-  wxLayoutConstraints *constr = GetConstraints();
-  if (constr)
-  {
-    *w = constr->width.GetValue();
-    *h = constr->height.GetValue();
-  }
-  else
-    GetClientSize(w, h);
-}
-
-void wxWindow::GetPositionConstraint(int *x, int *y) const
-{
- wxLayoutConstraints *constr = GetConstraints();
-    if (constr)
-  {
-    *x = constr->left.GetValue();
-    *y = constr->top.GetValue();
-  }
-  else
-    GetPosition(x, y);
+    m_isScrolling = g_blockEventsOnScroll = scroll;
 }
 }
-
wxWidgets (Impactor)