]> 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
Added wxMenu::Delete() and fixed some menu deleted memory
[wxWidgets.git] / src / gtk1 / window.cpp
diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp
index 50d64dbc9167a40e18bef2e9532f63164232b3b4..7e235b0c06335305cd875a287ecbb6cc38bbbe66 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,8 +130,9 @@
 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;
-static wxWindow  *g_focusWindow = (wxWindow*) NULL;
+extern wxCursor   g_globalCursor;
+static wxWindow  *g_captureWindow = (wxWindow*) NULL;
+       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 */
 
 /* hack: we need something to pass to gtk_menu_popup, so we store the time of
    the last click here */
@@ -143,18 +146,17 @@ static guint32 gs_timeLastClick = 0;
 
 static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
                                          GdkEvent *WXUNUSED(event),
 
 static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
                                          GdkEvent *WXUNUSED(event),
-                                         const wxChar *name )
+                                         const wxChar *WXUNUSED(name) )
 {
 {
-    // to enable logging of the focus events replace 0 with 1
-#if 0
+/*
     static bool s_done = FALSE;
     if ( !s_done )
     {
         wxLog::AddTraceMask("focus");
         s_done = TRUE;
     }
     static bool s_done = FALSE;
     if ( !s_done )
     {
         wxLog::AddTraceMask("focus");
         s_done = TRUE;
     }
-#endif
-    wxLogTrace(_T("FOCUS NOW AT: %s"), name);
+    wxLogTrace(wxT("FOCUS NOW AT: %s"), name);
+*/
 
     return FALSE;
 }
 
     return FALSE;
 }
@@ -162,7 +164,7 @@ static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
 void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window )
 {
     wxString tmp = name;
 void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window )
 {
     wxString tmp = name;
-    tmp += _T(" FROM ");
+    tmp += wxT(" FROM ");
     tmp += window;
 
     wxChar *s = new wxChar[tmp.Length()+1];
     tmp += window;
 
     wxChar *s = new wxChar[tmp.Length()+1];
@@ -175,6 +177,32 @@ void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window
 
 #endif // Debug
 
 
 #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
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // idle system
 //-----------------------------------------------------------------------------
@@ -217,7 +245,7 @@ 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;
         }
     }
 
         }
     }
 
@@ -250,6 +278,18 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
                          win->m_width-dw, win->m_height-dh );
         return;
     }
                          win->m_width-dw, win->m_height-dh );
         return;
     }
+    
+    if (win->HasFlag(wxSIMPLE_BORDER))
+    {
+        GdkGC *gc;
+       gc = gdk_gc_new( widget->window );
+        gdk_gc_set_foreground( gc, &widget->style->black );
+        gdk_draw_rectangle( widget->window, gc, FALSE, 
+                         dx, dy,
+                         win->m_width-dw-1, win->m_height-dh-1 );
+        gdk_gc_unref( gc );
+        return;
+    }
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
@@ -263,7 +303,7 @@ static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *g
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
-// "draw" of m_wxwindow
+// "draw" of m_widget
 //-----------------------------------------------------------------------------
 
 static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win )
 //-----------------------------------------------------------------------------
 
 static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win )
@@ -273,13 +313,367 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU
 
 #endif // GTK_MINOR_VERSION > 0
 
 
 #endif // GTK_MINOR_VERSION > 0
 
+//-----------------------------------------------------------------------------
+// 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);
+}
+
 //-----------------------------------------------------------------------------
 // "expose_event" of m_wxwindow
 //-----------------------------------------------------------------------------
 
 static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
 {
 //-----------------------------------------------------------------------------
 // "expose_event" of m_wxwindow
 //-----------------------------------------------------------------------------
 
 static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
 {
-    if ( !win->m_hasVMT )
+    if (!win->m_hasVMT)
         return;
 
     win->GetUpdateRegion().Union( gdk_event->area.x,
         return;
 
     win->GetUpdateRegion().Union( gdk_event->area.x,
@@ -287,14 +681,17 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
                                   gdk_event->area.width,
                                   gdk_event->area.height );
 
                                   gdk_event->area.width,
                                   gdk_event->area.height );
 
-    if ( gdk_event->count > 0 )
+    if (gdk_event->count > 0)
         return;
 
 /*
         return;
 
 /*
-    printf( "OnExpose from " );
+    wxPrintf( "OnExpose from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
+        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 );
 */
 
     wxPaintEvent event( win->GetId() );
 */
 
     wxPaintEvent event( win->GetId() );
@@ -308,9 +705,9 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
 // "draw" of m_wxwindow
 //-----------------------------------------------------------------------------
 
 // "draw" of m_wxwindow
 //-----------------------------------------------------------------------------
 
-static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
+static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
 {
 {
-    if (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT)
@@ -319,6 +716,16 @@ static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle
     win->GetUpdateRegion().Union( rect->x, rect->y,
                                   rect->width, rect->height );
 
     win->GetUpdateRegion().Union( rect->x, rect->y,
                                   rect->width, rect->height );
 
+/*
+    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 );
+*/
+                               
     wxPaintEvent event( win->GetId() );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
     wxPaintEvent event( win->GetId() );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
@@ -332,7 +739,7 @@ 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 (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
@@ -350,87 +757,17 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
       printf( "ControlUp.\n" );
     printf( "\n" );
 */
       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 );
 
 
-    if (!key_code) return FALSE;
+    /* sending unknown key events doesn't really make sense */
+    if (key_code == 0) return FALSE;
+
+    bool ret = FALSE;
 
     wxKeyEvent event( wxEVT_KEY_DOWN );
     event.SetTimestamp( gdk_event->time );
 
     wxKeyEvent event( wxEVT_KEY_DOWN );
     event.SetTimestamp( gdk_event->time );
@@ -439,12 +776,15 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
     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_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;
@@ -460,8 +800,27 @@ 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
+#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)) &&
          (win->HasFlag(wxTE_PROCESS_TAB) == 0))
     if ( (!ret) &&
          ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
          (win->HasFlag(wxTE_PROCESS_TAB) == 0))
@@ -475,6 +834,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
         ret = win->GetEventHandler()->ProcessEvent( new_event );
     }
 
         ret = win->GetEventHandler()->ProcessEvent( new_event );
     }
 
+    /* generate wxID_CANCEL if <esc> has been pressed (typically in dialogs) */
     if ( (!ret) &&
          (gdk_event->keyval == GDK_Escape) )
     {
     if ( (!ret) &&
          (gdk_event->keyval == GDK_Escape) )
     {
@@ -483,6 +843,36 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
         ret = win->GetEventHandler()->ProcessEvent( new_event );
     }
 
         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.
 
@@ -521,7 +911,7 @@ 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 (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
@@ -540,86 +930,15 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk
     printf( "\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 );
     event.SetTimestamp( gdk_event->time );
 
     wxKeyEvent event( wxEVT_KEY_UP );
     event.SetTimestamp( gdk_event->time );
@@ -628,8 +947,9 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk
     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_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 ))
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
@@ -647,16 +967,15 @@ 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 (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
 /*
         wxapp_install_idle_handler();
 
 /*
-    wxPrintf( _T("1) OnButtonPress from ") );
+    wxPrintf( wxT("1) OnButtonPress from ") );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
         wxPrintf( win->GetClassInfo()->GetClassName() );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
         wxPrintf( win->GetClassInfo()->GetClassName() );
-    wxPrintf( _T(".\n") );
+    wxPrintf( wxT(".\n") );
 */
 */
-
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return TRUE;
     if (g_blockEventsOnScroll) return TRUE;
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return TRUE;
     if (g_blockEventsOnScroll) return TRUE;
@@ -670,20 +989,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);
 
 /*
-            wxPrintf( _T("GrabFocus from ") );
+            wxPrintf( wxT("GrabFocus from ") );
             if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
                 wxPrintf( win->GetClassInfo()->GetClassName() );
             if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
                 wxPrintf( win->GetClassInfo()->GetClassName() );
-            wxPrintf( _T(".\n") );
+            wxPrintf( wxT(".\n") );
 */
 
         }
     }
 
 /*
 */
 
         }
     }
 
 /*
-    wxPrintf( _T("2) OnButtonPress from ") );
+    wxPrintf( wxT("2) OnButtonPress from ") );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
         wxPrintf( win->GetClassInfo()->GetClassName() );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
         wxPrintf( win->GetClassInfo()->GetClassName() );
-    wxPrintf( _T(".\n") );
+    wxPrintf( wxT(".\n") );
 */
 
     wxEventType event_type = wxEVT_LEFT_DOWN;
 */
 
     wxEventType event_type = wxEVT_LEFT_DOWN;
@@ -732,7 +1051,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)
@@ -802,7 +1121,7 @@ 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 (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
@@ -842,7 +1161,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)
@@ -910,24 +1229,23 @@ 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 (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
     if (g_blockEventsOnScroll) return FALSE;
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
     if (g_blockEventsOnScroll) return FALSE;
-
+    
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
     if (gdk_event->is_hint)
     {
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
     if (gdk_event->is_hint)
     {
-       int x = 0;
-       int y = 0;
-       GdkModifierType state;
-       gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
-       gdk_event->x = x;
-       gdk_event->y = y;
-       gdk_event->state = state;
+        int x = 0;
+        int y = 0;
+        GdkModifierType state;
+        gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
+        gdk_event->x = x;
+        gdk_event->y = y;
     }
 
 /*
     }
 
 /*
@@ -953,7 +1271,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)
@@ -1021,7 +1339,7 @@ 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 (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
@@ -1071,7 +1389,7 @@ 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 (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
@@ -1108,7 +1426,7 @@ 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 (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
@@ -1116,11 +1434,10 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
 
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
-    if (widget->window && win->GetCursor().Ok() )
-        gdk_window_set_cursor( widget->window, win->GetCursor().GetCursor() );
-
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
+#if (GTK_MINOR_VERSION > 0)
     event.SetTimestamp( gdk_event->time );
     event.SetTimestamp( gdk_event->time );
+#endif
     event.SetEventObject( win );
 
     int x = 0;
     event.SetEventObject( win );
 
     int x = 0;
@@ -1155,19 +1472,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 (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
         wxapp_install_idle_handler();
 
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
-    
-    if (widget->window && win->GetCursor().Ok() )
-        gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
+#if (GTK_MINOR_VERSION > 0)
     event.SetTimestamp( gdk_event->time );
     event.SetTimestamp( gdk_event->time );
+#endif
     event.SetEventObject( win );
 
     int x = 0;
     event.SetEventObject( win );
 
     int x = 0;
@@ -1200,42 +1516,32 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 // "value_changed" from m_vAdjust
 //-----------------------------------------------------------------------------
 
 // "value_changed" from m_vAdjust
 //-----------------------------------------------------------------------------
 
-static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindow *win )
 {
 {
-    if (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_blockEventsOnDrag) return;
 
     if (!win->m_hasVMT) return;
         wxapp_install_idle_handler();
 
     if (g_blockEventsOnDrag) return;
 
     if (!win->m_hasVMT) return;
-
-    float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
+    
+    float diff = adjust->value - win->m_oldVerticalPos;
     if (fabs(diff) < 0.2) return;
     if (fabs(diff) < 0.2) return;
-    win->m_oldVerticalPos = win->m_vAdjust->value;
-
-    wxEventType command = wxEVT_NULL;
-
-    float line_step = win->m_vAdjust->step_increment;
-    float page_step = win->m_vAdjust->page_increment;
-
-    if (win->IsScrolling())
-    {
-        command = wxEVT_SCROLL_THUMBTRACK;
-    }
-    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;
-    }
+    
+    win->m_oldVerticalPos = adjust->value;
 
 
-    int value = (int)(win->m_vAdjust->value+0.5);
+    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
+    GtkRange *range = GTK_RANGE( scrolledWindow->vscrollbar );
+    
+    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
+    if      (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP;
+    else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD)  command = wxEVT_SCROLLWIN_LINEDOWN;
+    else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP;
+    else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD)  command = wxEVT_SCROLLWIN_PAGEDOWN;
+    
+    int value = (int)(adjust->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 );
 }
@@ -1244,41 +1550,31 @@ static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
 // "value_changed" from m_hAdjust
 //-----------------------------------------------------------------------------
 
 // "value_changed" from m_hAdjust
 //-----------------------------------------------------------------------------
 
-static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindow *win )
 {
 {
-    if (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_blockEventsOnDrag) return;
     if (!win->m_hasVMT) return;
 
         wxapp_install_idle_handler();
 
     if (g_blockEventsOnDrag) return;
     if (!win->m_hasVMT) return;
 
-    float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
+    float diff = adjust->value - win->m_oldHorizontalPos;
     if (fabs(diff) < 0.2) return;
     if (fabs(diff) < 0.2) return;
-    win->m_oldHorizontalPos = win->m_hAdjust->value;
-
-    wxEventType command = wxEVT_NULL;
-
-    float line_step = win->m_hAdjust->step_increment;
-    float page_step = win->m_hAdjust->page_increment;
-
-    if (win->IsScrolling())
-    {
-        command = wxEVT_SCROLL_THUMBTRACK;
-    }
-    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;
-    }
+    
+    win->m_oldHorizontalPos = adjust->value;
 
 
-    int value = (int)(win->m_hAdjust->value+0.5);
+    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
+    GtkRange *range = GTK_RANGE( scrolledWindow->hscrollbar );
+    
+    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
+    if      (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP;
+    else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD)  command = wxEVT_SCROLLWIN_LINEDOWN;
+    else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP;
+    else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD)  command = wxEVT_SCROLLWIN_PAGEDOWN;
+    
+    int value = (int)(adjust->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 );
 }
@@ -1289,16 +1585,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_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_blockEventsOnDrag) return;
     if (!win->m_hasVMT) return;
 
         wxapp_install_idle_handler();
 
     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 );
 }
@@ -1309,16 +1605,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_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_blockEventsOnDrag) return;
     if (!win->m_hasVMT) return;
 
         wxapp_install_idle_handler();
 
     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 );
 }
@@ -1331,11 +1627,11 @@ 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) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
 //  don't test here as we can release the mouse while being over
         wxapp_install_idle_handler();
 
 //  don't test here as we can release the mouse while being over
-//  a different window then the slider
+//  a different window than the slider
 //
 //    if (gdk_event->window != widget->slider) return FALSE;
 
 //
 //    if (gdk_event->window != widget->slider) return FALSE;
 
@@ -1348,23 +1644,16 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
 // "button_release_event" from scrollbar
 //-----------------------------------------------------------------------------
 
 // "button_release_event" from scrollbar
 //-----------------------------------------------------------------------------
 
-static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
+static gint gtk_scrollbar_button_release_callback( GtkRange *WXUNUSED(widget),
                                                    GdkEventButton *WXUNUSED(gdk_event),
                                                    wxWindow *win )
 {
 
 //  don't test here as we can release the mouse while being over
                                                    GdkEventButton *WXUNUSED(gdk_event),
                                                    wxWindow *win )
 {
 
 //  don't test here as we can release the mouse while being over
-//  a different window then the slider
+//  a different window than the slider
 //
 //    if (gdk_event->window != widget->slider) return FALSE;
 
 //
 //    if (gdk_event->window != widget->slider) return FALSE;
 
-    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
-
-    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" );
-
     win->SetScrolling( FALSE );
 
     return FALSE;
     win->SetScrolling( FALSE );
 
     return FALSE;
@@ -1384,13 +1673,13 @@ wxWindow *wxWindowBase::FindFocus()
 // "realize" from m_widget
 //-----------------------------------------------------------------------------
 
 // "realize" from m_widget
 //-----------------------------------------------------------------------------
 
-/* we cannot set colours, fonts and cursors before the widget has
+/* we cannot set colours and fonts before the widget has
    been realized, so we do this directly after realization */
 
 static gint
 gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
 {
    been realized, so we do this directly after realization */
 
 static gint
 gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
 {
-    if (g_isIdle) 
+    if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (win->m_delayedFont)
         wxapp_install_idle_handler();
 
     if (win->m_delayedFont)
@@ -1402,7 +1691,9 @@ gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
     if (win->m_delayedForegroundColour)
         win->SetForegroundColour( win->GetForegroundColour() );
 
     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;
 }
@@ -1420,6 +1711,12 @@ gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
 
 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 {
 
 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 {
+    /* the window might have been scrolled already, do we
+       have to adapt the position */
+    GtkMyFixed *myfixed = GTK_MYFIXED(parent->m_wxwindow);
+    child->m_x += myfixed->xoffset;
+    child->m_y += myfixed->yoffset;
+    
     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
                      GTK_WIDGET(child->m_widget),
                      child->m_x,
     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
                      GTK_WIDGET(child->m_widget),
                      child->m_x,
@@ -1450,10 +1747,6 @@ wxWindow* wxGetActiveWindow()
 
 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 
-BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
-    EVT_KEY_DOWN(wxWindow::OnKeyDown)
-END_EVENT_TABLE()
-
 void wxWindow::Init()
 {
     // common init
 void wxWindow::Init()
 {
     // common init
@@ -1473,6 +1766,8 @@ void wxWindow::Init()
     m_hasVMT = FALSE;
     m_needParent = TRUE;
     m_isBeingDeleted = FALSE;
     m_hasVMT = FALSE;
     m_needParent = TRUE;
     m_isBeingDeleted = FALSE;
+    
+    m_noExpose = FALSE;
 
     m_hasScrolling = FALSE;
     m_isScrolling = FALSE;
 
     m_hasScrolling = FALSE;
     m_isScrolling = FALSE;
@@ -1483,13 +1778,15 @@ void wxWindow::Init()
     m_oldVerticalPos = 0.0;
 
     m_resizing = FALSE;
     m_oldVerticalPos = 0.0;
 
     m_resizing = FALSE;
-    m_scrollGC = (GdkGC*) NULL;
     m_widgetStyle = (GtkStyle*) NULL;
 
     m_widgetStyle = (GtkStyle*) NULL;
 
-    m_insertCallback = wxInsertChildInWindow;
+    m_insertCallback = (wxInsertChildFunction) NULL;
 
     m_isStaticBox = FALSE;
 
     m_isStaticBox = FALSE;
+    m_isRadioButton = FALSE;
     m_acceptsFocus = FALSE;
     m_acceptsFocus = FALSE;
+    
+    m_cursor = *wxSTANDARD_CURSOR;
 }
 
 wxWindow::wxWindow()
 }
 
 wxWindow::wxWindow()
@@ -1510,20 +1807,27 @@ 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  )
 {
-    PreCreation( parent, id, pos, size, style, name );
+    if (!PreCreation( parent, pos, size ) ||
+        !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
+    {
+        wxFAIL_MSG( wxT("wxWindow creation failed") );
+       return FALSE;
+    }
+
+    m_insertCallback = wxInsertChildInWindow;
 
     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
 #ifdef __WXDEBUG__
 
     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
 #ifdef __WXDEBUG__
-    debug_focus_in( m_widget, _T("wxWindow::m_widget"), name );
+    debug_focus_in( m_widget, wxT("wxWindow::m_widget"), name );
 #endif
 
     GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
 
 #ifdef __WXDEBUG__
 #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 );
+    debug_focus_in( scrolledWindow->hscrollbar, wxT("wxWindow::hsrcollbar"), name );
+    debug_focus_in( scrolledWindow->vscrollbar, wxT("wxWindow::vsrcollbar"), name );
 #endif
 
     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 #endif
 
     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
@@ -1537,7 +1841,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     m_wxwindow = gtk_myfixed_new();
 
 #ifdef __WXDEBUG__
     m_wxwindow = gtk_myfixed_new();
 
 #ifdef __WXDEBUG__
-    debug_focus_in( m_wxwindow, _T("wxWindow::m_wxwindow"), name );
+    debug_focus_in( m_wxwindow, wxT("wxWindow::m_wxwindow"), name );
 #endif
 
     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
 #endif
 
     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
@@ -1547,15 +1851,19 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
     if (HasFlag(wxRAISED_BORDER))
     {
 
     if (HasFlag(wxRAISED_BORDER))
     {
-        gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_OUT );
+        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_OUT );
     }
     else if (HasFlag(wxSUNKEN_BORDER))
     {
     }
     else if (HasFlag(wxSUNKEN_BORDER))
     {
-        gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_IN );
+        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_IN );
+    }
+    else if (HasFlag(wxSIMPLE_BORDER))
+    {
+        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_THIN );
     }
     else
     {
     }
     else
     {
-        gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_NONE );
+        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_NONE );
     }
 #else // GTK_MINOR_VERSION == 0
     GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
     }
 #else // GTK_MINOR_VERSION == 0
     GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
@@ -1667,49 +1975,38 @@ wxWindow::~wxWindow()
     if (m_widgetStyle)
     {
         gtk_style_unref( m_widgetStyle );
     if (m_widgetStyle)
     {
         gtk_style_unref( m_widgetStyle );
-       m_widgetStyle = (GtkStyle*) NULL;
-    }
-
-    if (m_scrollGC)
-    {
-        gdk_gc_unref( m_scrollGC );
-       m_scrollGC = (GdkGC*) NULL;
+        m_widgetStyle = (GtkStyle*) NULL;
     }
 
     if (m_wxwindow)
     {
         gtk_widget_destroy( m_wxwindow );
     }
 
     if (m_wxwindow)
     {
         gtk_widget_destroy( m_wxwindow );
-       m_wxwindow = (GtkWidget*) NULL;
+        m_wxwindow = (GtkWidget*) NULL;
     }
 
     if (m_widget)
     {
         gtk_widget_destroy( m_widget );
     }
 
     if (m_widget)
     {
         gtk_widget_destroy( m_widget );
-       m_widget = (GtkWidget*) NULL;
+        m_widget = (GtkWidget*) NULL;
     }
 }
 
     }
 }
 
-void wxWindow::PreCreation( wxWindow *parent,
-                            wxWindowID id,
-                            const wxPoint &pos,
-                            const wxSize &size,
-                            long style,
-                            const wxString &name )
+bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos,  const wxSize &size )
 {
 {
-    wxASSERT_MSG( !m_needParent || parent, _T("Need complete parent.") );
-
-    if ( !CreateBase(parent, id, pos, size, style, name) )
-    {
-        wxFAIL_MSG(_T("window creation failed"));
-    }
+    wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
 
 
+    /* this turns -1 into 20 so that a minimal window is
+       visible even although -1,-1 has been given as the
+       size of the window. the same trick is used in other
+       ports and should make debugging easier */
     m_width = WidthDefault(size.x);
     m_height = HeightDefault(size.y);
 
     m_x = (int)pos.x;
     m_y = (int)pos.y;
 
     m_width = WidthDefault(size.x);
     m_height = HeightDefault(size.y);
 
     m_x = (int)pos.x;
     m_y = (int)pos.y;
 
-    if (!parent)  /* some reasonable defaults */
+    /* some reasonable defaults */
+    if (!parent)  
     {
         if (m_x == -1)
         {
     {
         if (m_x == -1)
         {
@@ -1722,21 +2019,26 @@ void wxWindow::PreCreation( wxWindow *parent,
             if (m_y < 10) m_y = 10;
         }
     }
             if (m_y < 10) m_y = 10;
         }
     }
+    
+    return TRUE;
 }
 
 void wxWindow::PostCreation()
 {
 }
 
 void wxWindow::PostCreation()
 {
-    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 
     if (m_wxwindow)
     {
 
     if (m_wxwindow)
     {
-        /* these get reported to wxWindows -> wxPaintEvent */
-        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
-          GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
-
-        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
-          GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
+        if (!m_noExpose)
+       {
+            /* these get reported to wxWindows -> wxPaintEvent */
+            gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
+                GTK_SIGNAL_FUNC(gtk_window_expose_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)
         /* these are called when the "sunken" or "raised" borders are drawn */
         gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
 #if (GTK_MINOR_VERSION > 0)
         /* these are called when the "sunken" or "raised" borders are drawn */
         gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
@@ -1754,7 +2056,7 @@ void wxWindow::PostCreation()
    /*  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",
    /*  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 );
+                            GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
 
     m_hasVMT = TRUE;
 }
 
     m_hasVMT = TRUE;
 }
@@ -1791,7 +2093,7 @@ void wxWindow::ConnectWidget( GtkWidget *widget )
 
 bool wxWindow::Destroy()
 {
 
 bool wxWindow::Destroy()
 {
-    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 
     m_hasVMT = FALSE;
 
 
     m_hasVMT = FALSE;
 
@@ -1800,8 +2102,8 @@ bool wxWindow::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 )
 {
-    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
-    wxASSERT_MSG( (m_parent != NULL), _T("wxWindow::SetSize requires parent.\n") );
+    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
+    wxASSERT_MSG( (m_parent != NULL), wxT("wxWindow::SetSize requires parent.\n") );
 
     if (m_resizing) return; /* I don't like recursions */
     m_resizing = TRUE;
 
     if (m_resizing) return; /* I don't like recursions */
     m_resizing = TRUE;
@@ -1816,17 +2118,19 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     }
     else
     {
     }
     else
     {
-        if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
+        GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
+       
+        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 + myfixed->xoffset;
+            if (y != -1) m_y = y + myfixed->yoffset;
             if (width != -1) m_width = width;
             if (height != -1) m_height = height;
         }
         else
         {
             if (width != -1) m_width = width;
             if (height != -1) m_height = height;
         }
         else
         {
-            m_x = x;
-            m_y = y;
+            m_x = x + myfixed->xoffset;
+            m_y = y + myfixed->yoffset;
             m_width = width;
             m_height = height;
         }
             m_width = width;
             m_height = height;
         }
@@ -1847,40 +2151,21 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 
         int border = 0;
         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 
         int border = 0;
+        int bottom_border = 0;
 
 
-        if (GTK_WIDGET_HAS_DEFAULT(m_widget))
-       {
-           /* the default button has a border around it */
-           border = 5;
-       }
+        if (GTK_WIDGET_CAN_DEFAULT(m_widget))
+        {
+            /* the default button has a border around it */
+            border = 6;
+            bottom_border = 5;
+        }
 
 
-       /* 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+2*border );
+        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;
@@ -1894,12 +2179,46 @@ 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())
+    {
+        /* I now set the cursor the anew in every OnInternalIdle call
+          as setting the cursor in a parent window also effects the
+          windows above so that checking for the current cursor is
+          not possible. */
+       
+        if (m_wxwindow)
+        {
+            GdkWindow *window = GTK_MYFIXED(m_wxwindow)->bin_window;
+            if (window)
+                gdk_window_set_cursor( window, cursor.GetCursor() );
+
+            if (!g_globalCursor.Ok())
+                cursor = *wxSTANDARD_CURSOR;
+
+            window = m_widget->window;
+            if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
+                gdk_window_set_cursor( window, cursor.GetCursor() );
+
+        }
+        else
+        {
+
+            GdkWindow *window = m_widget->window;
+            if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
+               gdk_window_set_cursor( window, cursor.GetCursor() );
+
+        }
+    }
+
     UpdateWindowUI();
 }
 
 void wxWindow::DoGetSize( int *width, int *height ) const
 {
     UpdateWindowUI();
 }
 
 void wxWindow::DoGetSize( int *width, int *height ) const
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     if (width) (*width) = m_width;
     if (height) (*height) = m_height;
 
     if (width) (*width) = m_width;
     if (height) (*height) = m_height;
@@ -1907,7 +2226,7 @@ void wxWindow::DoGetSize( int *width, int *height ) const
 
 void wxWindow::DoSetClientSize( int width, int height )
 {
 
 void wxWindow::DoSetClientSize( int width, int height )
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     if (!m_wxwindow)
     {
 
     if (!m_wxwindow)
     {
@@ -1918,32 +2237,40 @@ 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 (HasFlag(wxRAISED_BORDER) || HasFlag(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);
+#if 0 // unused - if this is ok, just remove this line (VZ)
+                GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+#endif // 0
 
 
-#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 (HasFlag(wxRAISED_BORDER) || HasFlag(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 shadow border size to 2 */
+            dw += 2 * 2;
+            dh += 2 * 2;
+        }
+        if (HasFlag(wxSIMPLE_BORDER))
+        {
+            /* when using GTK 1.2 we set the simple border size to 1 */
+            dw += 1 * 2;
+            dh += 1 * 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;
@@ -1951,6 +2278,9 @@ void wxWindow::DoSetClientSize( int width, int height )
             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; */
@@ -1960,7 +2290,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;
             }
        }
 
             }
        }
 
@@ -1970,7 +2300,7 @@ void wxWindow::DoSetClientSize( int width, int height )
 
 void wxWindow::DoGetClientSize( 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), wxT("invalid window") );
 
     if (!m_wxwindow)
     {
 
     if (!m_wxwindow)
     {
@@ -1982,31 +2312,39 @@ void wxWindow::DoGetClientSize( 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 (HasFlag(wxRAISED_BORDER) || HasFlag(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);
+#if 0 // unused - if this is ok, just remove this line (VZ)
+                GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+#endif // 0
 
 
-#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 ( HasFlag(wxRAISED_BORDER) || HasFlag(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 shadow border size to 2 */
+            dw += 2 * 2;
+            dh += 2 * 2;
+        }
+        if (HasFlag(wxSIMPLE_BORDER))
+        {
+            /* when using GTK 1.2 we set the simple border size to 1 */
+            dw += 1 * 2;
+            dh += 1 * 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;
@@ -2014,6 +2352,9 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
             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; */
@@ -2034,21 +2375,30 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
 
 void wxWindow::DoGetPosition( 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), wxT("invalid window") );
+
+    int dx = 0;
+    int dy = 0;
+    if (m_parent && m_parent->m_wxwindow)
+    {
+        GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
+       dx = myfixed->xoffset;
+       dy = myfixed->yoffset;
+    }
 
 
-    if (x) (*x) = m_x;
-    if (y) (*y) = m_y;
+    if (x) (*x) = m_x - dx;
+    if (y) (*y) = m_y - dy;
 }
 
 }
 
-void wxWindow::ClientToScreen( int *x, int *y ) const
+void wxWindow::DoClientToScreen( int *x, int *y ) const
 {
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     if (!m_widget->window) return;
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
 
     if (!m_widget->window) return;
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
-        source = m_wxwindow->window;
+        source = GTK_MYFIXED(m_wxwindow)->bin_window;
     else
         source = m_widget->window;
 
     else
         source = m_widget->window;
 
@@ -2069,15 +2419,15 @@ void wxWindow::ClientToScreen( int *x, int *y ) const
     if (y) *y += org_y;
 }
 
     if (y) *y += org_y;
 }
 
-void wxWindow::ScreenToClient( int *x, int *y ) const
+void wxWindow::DoScreenToClient( int *x, int *y ) const
 {
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     if (!m_widget->window) return;
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
 
     if (!m_widget->window) return;
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
-        source = m_wxwindow->window;
+        source = GTK_MYFIXED(m_wxwindow)->bin_window;
     else
         source = m_widget->window;
 
     else
         source = m_widget->window;
 
@@ -2100,7 +2450,7 @@ void wxWindow::ScreenToClient( int *x, int *y ) const
 
 bool wxWindow::Show( bool show )
 {
 
 bool wxWindow::Show( bool show )
 {
-    wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
+    wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
 
     if (!wxWindowBase::Show(show))
     {
 
     if (!wxWindowBase::Show(show))
     {
@@ -2118,7 +2468,7 @@ bool wxWindow::Show( bool show )
 
 bool wxWindow::Enable( bool enable )
 {
 
 bool wxWindow::Enable( bool enable )
 {
-    wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
+    wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
 
     if (!wxWindowBase::Enable(enable))
     {
 
     if (!wxWindowBase::Enable(enable))
     {
@@ -2135,9 +2485,9 @@ bool wxWindow::Enable( bool enable )
 
 int wxWindow::GetCharHeight() const
 {
 
 int wxWindow::GetCharHeight() const
 {
-    wxCHECK_MSG( (m_widget != NULL), 12, _T("invalid window") );
+    wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
 
 
-    wxCHECK_MSG( m_font.Ok(), 12, _T("invalid font") );
+    wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );
 
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );
 
@@ -2146,9 +2496,9 @@ int wxWindow::GetCharHeight() const
 
 int wxWindow::GetCharWidth() const
 {
 
 int wxWindow::GetCharWidth() const
 {
-    wxCHECK_MSG( (m_widget != NULL), 8, _T("invalid window") );
+    wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
 
 
-    wxCHECK_MSG( m_font.Ok(), 8, _T("invalid font") );
+    wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );
 
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );
 
@@ -2165,7 +2515,7 @@ void wxWindow::GetTextExtent( const wxString& string,
     wxFont fontToUse = m_font;
     if (theFont) fontToUse = *theFont;
 
     wxFont fontToUse = m_font;
     if (theFont) fontToUse = *theFont;
 
-    wxCHECK_RET( fontToUse.Ok(), _T("invalid font") );
+    wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
 
     GdkFont *font = fontToUse.GetInternalFont( 1.0 );
     if (x) (*x) = gdk_string_width( font, string.mbc_str() );
 
     GdkFont *font = fontToUse.GetInternalFont( 1.0 );
     if (x) (*x) = gdk_string_width( font, string.mbc_str() );
@@ -2174,19 +2524,9 @@ void wxWindow::GetTextExtent( const wxString& string,
     if (externalLeading) (*externalLeading) = 0;  // ??
 }
 
     if (externalLeading) (*externalLeading) = 0;  // ??
 }
 
-void wxWindow::OnKeyDown( wxKeyEvent &event )
-{
-    event.SetEventType( wxEVT_CHAR );
-
-    if (!GetEventHandler()->ProcessEvent( event ))
-    {
-        event.Skip();
-    }
-}
-
 void wxWindow::SetFocus()
 {
 void wxWindow::SetFocus()
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     GtkWidget *connect_widget = GetConnectWidget();
     if (connect_widget)
 
     GtkWidget *connect_widget = GetConnectWidget();
     if (connect_widget)
@@ -2210,21 +2550,60 @@ bool wxWindow::AcceptsFocus() const
     return m_acceptsFocus && wxWindowBase::AcceptsFocus();
 }
 
     return m_acceptsFocus && wxWindowBase::AcceptsFocus();
 }
 
-bool wxWindow::Reparent( wxWindow *newParent )
+bool wxWindow::Reparent( wxWindowBase *newParentBase )
 {
 {
-    wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, _T("invalid window") );
+    wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
 
 
-    gtk_widget_unparent( m_widget );
+    wxWindow *oldParent = m_parent,
+             *newParent = (wxWindow *)newParentBase;
+
+    wxASSERT( GTK_IS_WIDGET(m_widget) );
 
     if ( !wxWindowBase::Reparent(newParent) )
         return FALSE;
 
 
     if ( !wxWindowBase::Reparent(newParent) )
         return FALSE;
 
+    wxASSERT( GTK_IS_WIDGET(m_widget) );
+
+    /* prevent GTK from deleting the widget arbitrarily */
+    gtk_widget_ref( m_widget );
+
+    if (oldParent)
+    {
+        gtk_container_remove( GTK_CONTAINER(oldParent->m_wxwindow), m_widget );
+    }
+
+    wxASSERT( GTK_IS_WIDGET(m_widget) );
+
+    if (newParent)
+    {
+        /* insert GTK representation */
+        (*(newParent->m_insertCallback))(newParent, this);
+    }
+
+    /* reverse: prevent GTK from deleting the widget arbitrarily */
+    gtk_widget_unref( m_widget );
+    
     return TRUE;
 }
 
     return TRUE;
 }
 
+void wxWindow::DoAddChild(wxWindow *child)
+{
+    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
+
+    wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
+
+    wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
+
+    /* add to list */
+    AddChild( child );
+
+    /* insert GTK representation */
+    (*m_insertCallback)(this, child);
+}
+
 void wxWindow::Raise()
 {
 void wxWindow::Raise()
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     if (!m_widget->window) return;
 
 
     if (!m_widget->window) return;
 
@@ -2233,7 +2612,7 @@ void wxWindow::Raise()
 
 void wxWindow::Lower()
 {
 
 void wxWindow::Lower()
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     if (!m_widget->window) return;
 
 
     if (!m_widget->window) return;
 
@@ -2242,45 +2621,31 @@ void wxWindow::Lower()
 
 bool wxWindow::SetCursor( const wxCursor &cursor )
 {
 
 bool wxWindow::SetCursor( const wxCursor &cursor )
 {
-    wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
+    wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
 
 
-    if (!wxWindowBase::SetCursor(cursor))
-    {
-        // don't leave if the GTK widget has just
-        // been realized
-        if (!m_delayedCursor) 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_delayedCursor = TRUE;
-       
-       // pretend we have done something
-        return TRUE;
-    }
-
-        if ((m_widget) && (m_widget->window))
-             gdk_window_set_cursor( m_widget->window, GetCursor().GetCursor() );
-
-        if ((m_wxwindow) && (m_wxwindow->window))
-             gdk_window_set_cursor( m_wxwindow->window, GetCursor().GetCursor() );
-
-    // cursor was set
-    return TRUE;
+    return wxWindowBase::SetCursor( cursor );
 }
 
 }
 
-void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) )
+void wxWindow::WarpPointer( int x, int y )
 {
 {
-    // TODO
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+    /* we provide this function ourselves as it is
+       missing in GDK (top of this file)  */
+    
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (window)
+        gdk_window_warp_pointer( window, x, y );
 }
 
 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
 {
 }
 
 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     if (!m_widget->window) return;
 
 
     if (!m_widget->window) return;
 
@@ -2288,41 +2653,66 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
     {
         if (rect)
         {
     {
         if (rect)
         {
-            gdk_window_clear_area( m_wxwindow->window,
+            gdk_window_clear_area( GTK_MYFIXED(m_wxwindow)->bin_window,
                                    rect->x, rect->y,
                                    rect->width, rect->height );
         }
         else
         {
                                    rect->x, rect->y,
                                    rect->width, rect->height );
         }
         else
         {
-            gdk_window_clear( m_wxwindow->window );
+            gdk_window_clear( GTK_MYFIXED(m_wxwindow)->bin_window );
         }
     }
 
     if (!rect)
     {
         if (m_wxwindow)
         }
     }
 
     if (!rect)
     {
         if (m_wxwindow)
-            gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
+       {
+           /* call the callback directly for preventing GTK from
+              clearing the background */
+           int w = 0;
+           int h = 0;
+           GetClientSize( &w, &h );
+           
+            GetUpdateRegion().Union( 0, 0, w, h );
+            wxPaintEvent event( GetId() );
+            event.SetEventObject( this );
+            GetEventHandler()->ProcessEvent( event );
+            GetUpdateRegion().Clear();
+       }
         else
         else
+       {
             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
+       }
     }
     else
     {
     }
     else
     {
-        GdkRectangle gdk_rect;
-        gdk_rect.x = rect->x;
-        gdk_rect.y = rect->y;
-        gdk_rect.width = rect->width;
-        gdk_rect.height = rect->height;
 
         if (m_wxwindow)
 
         if (m_wxwindow)
-            gtk_widget_draw( m_wxwindow, &gdk_rect );
+       {
+           /* call the callback directly for preventing GTK from
+              clearing the background */
+            GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
+            wxPaintEvent event( GetId() );
+            event.SetEventObject( this );
+            GetEventHandler()->ProcessEvent( event );
+            GetUpdateRegion().Clear();
+       }
         else
         else
+       {
+            GdkRectangle gdk_rect;
+            gdk_rect.x = rect->x;
+            gdk_rect.y = rect->y;
+            gdk_rect.width = rect->width;
+            gdk_rect.height = rect->height;
+           
             gtk_widget_draw( m_widget, &gdk_rect );
             gtk_widget_draw( m_widget, &gdk_rect );
+       }
     }
 }
 
 void wxWindow::Clear()
 {
     }
 }
 
 void wxWindow::Clear()
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
     if (!m_widget->window) return;
 
 
     if (!m_widget->window) return;
 
@@ -2343,13 +2733,13 @@ void wxWindow::DoSetToolTip( wxToolTip *tip )
 
 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
 
 bool wxWindow::SetBackgroundColour( const wxColour &colour )
 {
 }
 #endif // wxUSE_TOOLTIPS
 
 bool wxWindow::SetBackgroundColour( const wxColour &colour )
 {
-    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
+    wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
 
     if (!wxWindowBase::SetBackgroundColour(colour))
     {
 
     if (!wxWindowBase::SetBackgroundColour(colour))
     {
@@ -2357,30 +2747,34 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
         // been realized
         if (!m_delayedBackgroundColour) return FALSE;
     }
         // been realized
         if (!m_delayedBackgroundColour) return FALSE;
     }
-    
-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window)
+
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (!window)
     {
         // indicate that a new style has been set
     {
         // 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;
-       
-       // pretend we have done something
+        // but it couldn't get applied as the
+        // widget hasn't been realized yet.
+        m_delayedBackgroundColour = TRUE;
+
+        // pretend we have done something
         return TRUE;
     }
 
         return TRUE;
     }
 
-    if (m_wxwindow && m_wxwindow->window)
+    if (m_wxwindow)
     {
         /* 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() );
+        m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
+        gdk_window_set_background( window, m_backgroundColour.GetColor() );
     }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
     }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
-
     if (sysbg == m_backgroundColour)
     {
         m_backgroundColour = wxNullColour;
     if (sysbg == m_backgroundColour)
     {
         m_backgroundColour = wxNullColour;
@@ -2397,7 +2791,7 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
 
 bool wxWindow::SetForegroundColour( const wxColour &colour )
 {
 
 bool wxWindow::SetForegroundColour( const wxColour &colour )
 {
-    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
+    wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
 
     if (!wxWindowBase::SetForegroundColour(colour))
     {
 
     if (!wxWindowBase::SetForegroundColour(colour))
     {
@@ -2405,21 +2799,26 @@ bool wxWindow::SetForegroundColour( const wxColour &colour )
         // been realized
         if (!m_delayedForegroundColour) return FALSE;
     }
         // been realized
         if (!m_delayedForegroundColour) return FALSE;
     }
-    
-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window)
+
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (!window)
     {
         // indicate that a new style has been set
     {
         // 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;
-       
-       // pretend we have done something
+        // but it couldn't get applied as the
+        // widget hasn't been realized yet.
+        m_delayedForegroundColour = TRUE;
+
+        // pretend we have done something
         return TRUE;
     }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
         return TRUE;
     }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
-    if (sysbg == m_foregroundColour)
+    if ( sysbg == m_backgroundColour )
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
@@ -2475,6 +2874,15 @@ void wxWindow::ApplyWidgetStyle()
 {
 }
 
 {
 }
 
+//-----------------------------------------------------------------------------
+// Pop-up menu stuff
+//-----------------------------------------------------------------------------
+
+static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting  )
+{
+    *is_waiting = FALSE;
+}
+
 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 {
     menu->SetInvokingWindow( win );
 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 {
     menu->SetInvokingWindow( win );
@@ -2502,11 +2910,11 @@ static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
     *y = gs_pop_y;
 }
 
     *y = gs_pop_y;
 }
 
-bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
+bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
 {
 {
-    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
+    wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
 
 
-    wxCHECK_MSG( menu != NULL, FALSE, _T("invalid popup-menu") );
+    wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
 
     SetInvokingWindow( menu, this );
 
 
     SetInvokingWindow( menu, this );
 
@@ -2515,6 +2923,11 @@ bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
     gs_pop_x = x;
     gs_pop_y = y;
 
     gs_pop_x = x;
     gs_pop_y = y;
 
+    bool is_waiting = TRUE;
+    
+    gtk_signal_connect( GTK_OBJECT(menu->m_menu), "hide",
+      GTK_SIGNAL_FUNC(gtk_pop_hide_callback), (gpointer)&is_waiting );
+
     gtk_menu_popup(
                   GTK_MENU(menu->m_menu),
                   (GtkWidget *) NULL,          // parent menu shell
     gtk_menu_popup(
                   GTK_MENU(menu->m_menu),
                   (GtkWidget *) NULL,          // parent menu shell
@@ -2524,6 +2937,13 @@ bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
                   0,                           // button used to activate it
                   0 //gs_timeLastClick         // the time of activation
                 );
                   0,                           // button used to activate it
                   0 //gs_timeLastClick         // the time of activation
                 );
+               
+    while (is_waiting)
+    {
+        while (gtk_events_pending())
+            gtk_main_iteration();
+    }
+
     return TRUE;
 }
 
     return TRUE;
 }
 
@@ -2531,7 +2951,7 @@ bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
 
 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 {
 
 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
     GtkWidget *dnd_widget = GetConnectWidget();
 
 
     GtkWidget *dnd_widget = GetConnectWidget();
 
@@ -2555,13 +2975,15 @@ GtkWidget* wxWindow::GetConnectWidget()
 
 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 {
 
 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 {
-    if (m_wxwindow) return (window == m_wxwindow->window);
+    if (m_wxwindow) 
+        return (window == GTK_MYFIXED(m_wxwindow)->bin_window);
+    
     return (window == m_widget->window);
 }
 
 bool wxWindow::SetFont( const wxFont &font )
 {
     return (window == m_widget->window);
 }
 
 bool wxWindow::SetFont( const wxFont &font )
 {
-    wxCHECK_MSG( m_widget != NULL, FALSE, _T(  "invalid window") );
+    wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
 
     if (!wxWindowBase::SetFont(font))
     {
 
     if (!wxWindowBase::SetFont(font))
     {
@@ -2569,16 +2991,21 @@ bool wxWindow::SetFont( const wxFont &font )
         // been realized
         if (!m_delayedFont) return FALSE;
     }
         // been realized
         if (!m_delayedFont) return FALSE;
     }
-    
-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window)
+
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (!window)
     {
         // indicate that a new style has been set
     {
         // 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
+        // but it couldn't get applied as the
+        // widget hasn't been realized yet.
+        m_delayedFont = TRUE;
+
+        // pretend we have done something
         return TRUE;
     }
 
         return TRUE;
     }
 
@@ -2599,37 +3026,46 @@ bool wxWindow::SetFont( const wxFont &font )
 
 void wxWindow::CaptureMouse()
 {
 
 void wxWindow::CaptureMouse()
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
 
-    wxCHECK_RET( g_capturing == FALSE, _T("CaptureMouse called twice") );
+    wxCHECK_RET( g_captureWindow == NULL, wxT("CaptureMouse called twice") );
 
 
-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window) return;
-    
-    gtk_grab_add( connect_widget );
-    gdk_pointer_grab( connect_widget->window, FALSE,
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (!window) return;
+
+    gdk_pointer_grab( window, FALSE,
                       (GdkEventMask)
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
                       (GdkEventMask)
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
+                          GDK_POINTER_MOTION_HINT_MASK | 
                           GDK_POINTER_MOTION_MASK),
                       (GdkWindow *) NULL,
                           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()
 {
 }
 
 void wxWindow::ReleaseMouse()
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
 
-    wxCHECK_RET( g_capturing == TRUE, _T("ReleaseMouse called twice") );
+    wxCHECK_RET( g_captureWindow, wxT("ReleaseMouse called twice") );
+
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (!window) return;
 
 
-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window) return;
-    
-    gtk_grab_remove( connect_widget );
     gdk_pointer_ungrab ( GDK_CURRENT_TIME );
     gdk_pointer_ungrab ( GDK_CURRENT_TIME );
-    g_capturing = FALSE;
+    g_captureWindow = (wxWindow*) NULL;
 }
 
 bool wxWindow::IsRetained() const
 }
 
 bool wxWindow::IsRetained() const
@@ -2640,9 +3076,9 @@ bool wxWindow::IsRetained() const
 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 )
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
 
-    wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
+    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
 
     m_hasScrolling = TRUE;
 
 
     m_hasScrolling = TRUE;
 
@@ -2703,9 +3139,9 @@ void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
 
 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
 {
 
 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
 
-    wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
+    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
 
     if (orient == wxHORIZONTAL)
     {
 
     if (orient == wxHORIZONTAL)
     {
@@ -2728,8 +3164,10 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
         m_vAdjust->value = fpos;
     }
 
         m_vAdjust->value = fpos;
     }
 
-    if (!m_isScrolling)  /* prevent recursion */
+/*
+    if (!m_isScrolling)
     {
     {
+*/
         if (m_wxwindow->window)
         {
             if (orient == wxHORIZONTAL)
         if (m_wxwindow->window)
         {
             if (orient == wxHORIZONTAL)
@@ -2737,14 +3175,16 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
             else
                 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
         }
             else
                 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
         }
+/*
     }
     }
+*/
 }
 
 int wxWindow::GetScrollThumb( int orient ) const
 {
 }
 
 int wxWindow::GetScrollThumb( int orient ) const
 {
-    wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
+    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
 
 
-    wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
+    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->page_size+0.5);
 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->page_size+0.5);
@@ -2754,9 +3194,9 @@ int wxWindow::GetScrollThumb( int orient ) const
 
 int wxWindow::GetScrollPos( int orient ) const
 {
 
 int wxWindow::GetScrollPos( int orient ) const
 {
-    wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
+    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
 
 
-    wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
+    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->value+0.5);
 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->value+0.5);
@@ -2766,9 +3206,9 @@ int wxWindow::GetScrollPos( int orient ) const
 
 int wxWindow::GetScrollRange( int orient ) const
 {
 
 int wxWindow::GetScrollRange( int orient ) const
 {
-    wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
+    wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
 
 
-    wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
+    wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->upper+0.5);
 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->upper+0.5);
@@ -2778,22 +3218,36 @@ int wxWindow::GetScrollRange( int orient ) const
 
 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 {
 
 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
+
+    wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
 
 
-    wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
+    gtk_myfixed_scroll( GTK_MYFIXED(m_wxwindow), -dx, -dy );
 
 
+/*
     if (!m_scrollGC)
     {
         m_scrollGC = gdk_gc_new( m_wxwindow->window );
         gdk_gc_set_exposures( m_scrollGC, TRUE );
     }
 
     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();
+        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 w = cw - abs(dx);
     int h = ch - abs(dy);
     int cw = 0;
     int ch = 0;
     GetClientSize( &cw, &ch );
     int w = cw - abs(dx);
     int h = ch - abs(dy);
-    
+
     if ((h < 0) || (w < 0))
     {
         Refresh();
     if ((h < 0) || (w < 0))
     {
         Refresh();
@@ -2820,14 +3274,7 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 
         Refresh( TRUE, &rect );
     }
 
         Refresh( TRUE, &rect );
     }
-    
-    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();
-    }
+*/
 }
 
 void wxWindow::SetScrolling(bool scroll)
 }
 
 void wxWindow::SetScrolling(bool scroll)
wxWidgets (Impactor)