(ugh, I need to get a faster computer)

[wxWidgets.git] / src / gtk / window.cpp

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index 69d0c5f2a913b8484e2000d2e8c7d13ec031d5d5..a84758ad857499ef211c6ea32599f99e7638b7a5 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -9,7 +9,7 @@
 
 
 #ifdef __GNUG__
 
 
 #ifdef __GNUG__

-#pragma implementation "window.h"
+    #pragma implementation "window.h"

 #endif
 
 #include "wx/defs.h"
 #endif
 
 #include "wx/defs.h"


@@ -21,10 +21,15 @@
 #include "wx/utils.h"
 #include "wx/dialog.h"
 #include "wx/msgdlg.h"
 #include "wx/utils.h"
 #include "wx/dialog.h"
 #include "wx/msgdlg.h"

+

 #if wxUSE_DRAG_AND_DROP
 #if wxUSE_DRAG_AND_DROP

-#include "wx/dnd.h"
+    #include "wx/dnd.h"
+#endif
+
+#if wxUSE_TOOLTIPS
+    #include "wx/tooltip.h"

 #endif
 #endif

-#include "wx/tooltip.h"
+

 #include "wx/menu.h"
 #include "wx/statusbr.h"
 #include "wx/intl.h"
 #include "wx/menu.h"
 #include "wx/statusbr.h"
 #include "wx/intl.h"


@@ -116,68 +121,112 @@
 
 */
 
 
 */
 

-//-------------------------------------------------------------------------
-// conditional compilation
-//-------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// data
+//-----------------------------------------------------------------------------

 
 

-#if (GTK_MINOR_VERSION == 1)
-#if (GTK_MICRO_VERSION >= 5)
-#define NEW_GTK_SCROLL_CODE
-#endif
-#endif
+extern wxList     wxPendingDelete;
+extern bool       g_blockEventsOnDrag;
+extern bool       g_blockEventsOnScroll;
+static bool       g_capturing = FALSE;
+static wxWindow  *g_focusWindow = (wxWindow*) NULL;
+
+/* hack: we need something to pass to gtk_menu_popup, so we store the time of
+   the last click here */
+static guint32 gs_timeLastClick = 0;
+
+#if (GTK_MINOR_VERSION > 0)

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// (debug)
+// local code (see below)

 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 

-#ifdef __WXDEBUG__
-
-static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget), 
-                                         GdkEvent *WXUNUSED(event), 
-                                        const char *name )
+static void draw_frame( GtkWidget *widget, wxWindow *win )

 {
 {

-    printf( "FOCUS NOW AT: " );
-    printf( name );
-    printf( "\n" );
+    if (!win->HasVMT()) return;
+
+    int dw = 0;
+    int dh = 0;

     
     

-    return FALSE;
-}
+    if (win->m_hasScrolling)
+    {
+        GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
+        GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget)->klass );

 
 

-void debug_focus_in( GtkWidget* widget, const char* name, const char *window )
-{
-    return;
+/*
+            GtkWidget *hscrollbar = scroll_window->hscrollbar;
+            GtkWidget *vscrollbar = scroll_window->vscrollbar;
+           
+           we use this instead:  range.slider_width = 11 + 2*2pts edge 
+*/
+
+        if (scroll_window->vscrollbar_visible)
+        {
+            dw += 15;   /* dw += vscrollbar->allocation.width; */
+            dw += scroll_class->scrollbar_spacing;
+        }

 
 

-    wxString tmp = name;
-    tmp += " FROM ";
-    tmp += window;
+        if (scroll_window->hscrollbar_visible)
+        {
+            dh += 15;   /* dh += hscrollbar->allocation.height; */
+            dw += scroll_class->scrollbar_spacing;
+        }
+    }
+    
+    int dx = 0;
+    int dy = 0;
+    if (GTK_WIDGET_NO_WINDOW (widget))
+    {
+        dx += widget->allocation.x;
+        dy += widget->allocation.y;
+    }

     
     

-    char *s = new char[tmp.Length()+1];
+    if (win->m_windowStyle & wxRAISED_BORDER)
+    {
+        gtk_draw_shadow( widget->style, 
+                         widget->window,
+                        GTK_STATE_NORMAL,
+                        GTK_SHADOW_OUT,
+                        dx, dy,
+                        win->m_width-dw, win->m_height-dh );
+       return;
+    } 

     
     

-    strcpy( s, WXSTRINGCAST tmp );
-
-    gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
-      GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s );
+    if (win->m_windowStyle & wxSUNKEN_BORDER)
+    {
+        gtk_draw_shadow( widget->style, 
+                         widget->window,
+                        GTK_STATE_NORMAL,
+                        GTK_SHADOW_IN,
+                        dx, dy, 
+                        win->m_width-dw, win->m_height-dh );
+       return;
+    }

 }
 
 }
 

-#endif
+//-----------------------------------------------------------------------------
+// "expose_event" of m_widget
+//-----------------------------------------------------------------------------
+
+static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
+{
+    if (gdk_event->count > 0) return;
+    draw_frame( widget, win );
+}

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// data
+// "draw" of m_wxwindow

 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 

-extern wxList     wxPendingDelete;
-extern wxList     wxTopLevelWindows;
-extern bool       g_blockEventsOnDrag;
-extern bool       g_blockEventsOnScroll;
-static bool       g_capturing = FALSE;
-static wxWindow  *g_focusWindow = (wxWindow*) NULL;
+static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win )
+{
+    draw_frame( widget, win );
+}

 
 

-// hack: we need something to pass to gtk_menu_popup, so we store the time of
-// the last click here
-static guint32 gs_timeLastClick = 0;
+#endif

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// "expose_event" (of m_wxwindow, not of m_widget)
+// "expose_event" of m_wxwindow

 //-----------------------------------------------------------------------------
 
 static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
 //-----------------------------------------------------------------------------
 
 static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )


@@ -206,7 +255,7 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------

-// "draw" (of m_wxwindow, not of m_widget)
+// "draw" of m_wxwindow

 //-----------------------------------------------------------------------------
 
 static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
 //-----------------------------------------------------------------------------
 
 static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )


@@ -242,6 +291,8 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
     switch (gdk_event->keyval)
     {
         case GDK_BackSpace:     key_code = WXK_BACK;        break;
     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_Tab:           key_code = WXK_TAB;         break;
         case GDK_Linefeed:      key_code = WXK_RETURN;      break;
         case GDK_Clear:         key_code = WXK_CLEAR;       break;


@@ -266,7 +317,6 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
         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_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_Tab:        key_code = WXK_TAB;         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_Enter:      key_code = WXK_RETURN;      break;
         case GDK_KP_Home:       key_code = WXK_HOME;        break;
         case GDK_KP_Left:       key_code = WXK_LEFT;        break;


@@ -345,44 +395,59 @@ 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
     // win is a control: tab can be propagated up

-    if ((!ret) && (gdk_event->keyval == GDK_Tab))
+    if ( (!ret) && 
+         ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
+         ((win->m_windowStyle & wxTE_PROCESS_TAB) == 0))

     {
         wxNavigationKeyEvent new_event;
     {
         wxNavigationKeyEvent new_event;

-        new_event.SetDirection( !(gdk_event->state & GDK_SHIFT_MASK) );
-       new_event.SetWindowChange( FALSE );
+       /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
+        new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
+       /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */ 
+        new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );

         new_event.SetCurrentFocus( win );
         new_event.SetCurrentFocus( win );

-       ret = win->GetEventHandler()->ProcessEvent( new_event );
+        ret = win->GetEventHandler()->ProcessEvent( new_event );
+    }
+
+    if ( (!ret) && 
+         (gdk_event->keyval == GDK_Escape) )
+    {
+        wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
+        new_event.SetEventObject( win );
+        ret = win->GetEventHandler()->ProcessEvent( new_event );

     }
     
 /*
     }
     
 /*

+    Damn, I forgot why this didn't work, but it didn't work.
+

     // win is a panel: up can be propagated to the panel
     if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
         (gdk_event->keyval == GDK_Up))
     {
         win->m_parent->SetFocus();
     // win is a panel: up can be propagated to the panel
     if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
         (gdk_event->keyval == GDK_Up))
     {
         win->m_parent->SetFocus();

-       ret = TRUE;
+        ret = TRUE;

     }
     }

-    
+

     // win is a panel: left/right can be propagated to the panel
     // win is a panel: left/right can be propagated to the panel

-    if ((!ret) && (win->m_wxwindow) && 
-        ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) || 
+    if ((!ret) && (win->m_wxwindow) &&
+        ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) ||

          (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
     {
         wxNavigationKeyEvent new_event;
         new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
         new_event.SetCurrentFocus( win );
          (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
     {
         wxNavigationKeyEvent new_event;
         new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
         new_event.SetCurrentFocus( win );

-       ret = win->GetEventHandler()->ProcessEvent( new_event );
+        ret = win->GetEventHandler()->ProcessEvent( new_event );

     }
 */
     }
 */

-    
+

     if (ret)
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
     if (ret)
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );

+       return TRUE;

     }
 
     }
 

-    return ret;
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -405,6 +470,8 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk
     switch (gdk_event->keyval)
     {
         case GDK_BackSpace:     key_code = WXK_BACK;        break;
     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_Tab:           key_code = WXK_TAB;         break;
         case GDK_Linefeed:      key_code = WXK_RETURN;      break;
         case GDK_Clear:         key_code = WXK_CLEAR;       break;


@@ -429,7 +496,6 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk
         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_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_Tab:        key_code = WXK_TAB;         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_Enter:      key_code = WXK_RETURN;      break;
         case GDK_KP_Home:       key_code = WXK_HOME;        break;
         case GDK_KP_Left:       key_code = WXK_LEFT;        break;


@@ -491,14 +557,13 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk
     event.m_y = 0;
     event.SetEventObject( win );
 
     event.m_y = 0;
     event.SetEventObject( win );
 

-    bool ret = win->GetEventHandler()->ProcessEvent( event );
-
-    if (ret)
+    if (win->GetEventHandler()->ProcessEvent( event ))

     {
     {

-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
+       return TRUE;

     }
 
     }
 

-    return ret;
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -507,11 +572,12 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk
 
 static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 {

-    if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
-
+    if (!win->HasVMT()) return FALSE;

     if (g_blockEventsOnDrag) return TRUE;
     if (g_blockEventsOnScroll) return TRUE;
 
     if (g_blockEventsOnDrag) return TRUE;
     if (g_blockEventsOnScroll) return TRUE;
 

+    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
+

     if (win->m_wxwindow)
     {
         if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow) && !GTK_WIDGET_HAS_FOCUS (win->m_wxwindow) )
     if (win->m_wxwindow)
     {
         if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow) && !GTK_WIDGET_HAS_FOCUS (win->m_wxwindow) )


@@ -528,8 +594,6 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
         }
     }
 
         }
     }
 

-    if (!win->HasVMT()) return TRUE;
-

 /*
     printf( "OnButtonPress from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 /*
     printf( "OnButtonPress from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())


@@ -588,37 +652,37 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();

-           
-           if (child->m_isStaticBox)
-           {
-               // wxStaticBox is transparent in the box itself
-               int x = event.m_x;
-               int y = event.m_y;
-               int xx1 = child->m_x;
-               int yy1 = child->m_y;
-               int xx2 = child->m_x + child->m_width;
-               int yy2 = child->m_x + child->m_height;
-               
-               // left
-               if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
-               // right
-                   ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
-               // top
-                   ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
-               // bottom
-                   ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
-               {
+
+            if (child->m_isStaticBox)
+            {
+                // wxStaticBox is transparent in the box itself
+                int x = event.m_x;
+                int y = event.m_y;
+                int xx1 = child->m_x;
+                int yy1 = child->m_y;
+                int xx2 = child->m_x + child->m_width;
+                int yy2 = child->m_x + child->m_height;
+
+                // left
+                if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
+                // right
+                    ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
+                // top
+                    ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
+                // bottom
+                    ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
+                {

                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
-                   
-           }
-           else
-           {
+                }
+
+            }
+            else
+            {

                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&

-                   (child->m_x <= event.m_x) &&
+                    (child->m_x <= event.m_x) &&

                     (child->m_y <= event.m_y) &&
                     (child->m_x+child->m_width  >= event.m_x) &&
                     (child->m_y+child->m_height >= event.m_y))
                     (child->m_y <= event.m_y) &&
                     (child->m_x+child->m_width  >= event.m_x) &&
                     (child->m_y+child->m_height >= event.m_y))


@@ -627,24 +691,23 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
+                }

             }
             node = node->Next();
         }
     }
             }
             node = node->Next();
         }
     }

-    
-    wxPoint pt(win->GetClientAreaOrigin());
-    event.m_x -= pt.x;
-    event.m_y -= pt.y;

 
     event.SetEventObject( win );
 
     gs_timeLastClick = gdk_event->time;
 
     if (win->GetEventHandler()->ProcessEvent( event ))
 
     event.SetEventObject( win );
 
     gs_timeLastClick = gdk_event->time;
 
     if (win->GetEventHandler()->ProcessEvent( event ))

+    {

         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );

+       return TRUE;
+    }

 
 

-    return TRUE;
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -653,12 +716,11 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
 
 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 {

-    if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
-
-    if (g_blockEventsOnDrag) return TRUE;
-    if (g_blockEventsOnScroll) return TRUE;
+    if (!win->HasVMT()) return FALSE;
+    if (g_blockEventsOnDrag) return FALSE;
+    if (g_blockEventsOnScroll) return FALSE;

 
 

-    if (!win->HasVMT()) return TRUE;
+    if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;

 
 /*
     printf( "OnButtonRelease from " );
 
 /*
     printf( "OnButtonRelease from " );


@@ -696,37 +758,37 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();

-           
-           if (child->m_isStaticBox)
-           {
-               // wxStaticBox is transparent in the box itself
-               int x = event.m_x;
-               int y = event.m_y;
-               int xx1 = child->m_x;
-               int yy1 = child->m_y;
-               int xx2 = child->m_x + child->m_width;
-               int yy2 = child->m_x + child->m_height;
-               
-               // left
-               if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
-               // right
-                   ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
-               // top
-                   ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
-               // bottom
-                   ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
-               {
+
+            if (child->m_isStaticBox)
+            {
+                // wxStaticBox is transparent in the box itself
+                int x = event.m_x;
+                int y = event.m_y;
+                int xx1 = child->m_x;
+                int yy1 = child->m_y;
+                int xx2 = child->m_x + child->m_width;
+                int yy2 = child->m_x + child->m_height;
+
+                // left
+                if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
+                // right
+                    ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
+                // top
+                    ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
+                // bottom
+                    ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
+                {

                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
-                   
-           }
-           else
-           {
+                }
+
+            }
+            else
+            {

                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&

-                   (child->m_x <= event.m_x) &&
+                    (child->m_x <= event.m_x) &&

                     (child->m_y <= event.m_y) &&
                     (child->m_x+child->m_width  >= event.m_x) &&
                     (child->m_y+child->m_height >= event.m_y))
                     (child->m_y <= event.m_y) &&
                     (child->m_x+child->m_width  >= event.m_x) &&
                     (child->m_y+child->m_height >= event.m_y))


@@ -735,22 +797,21 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
+                }

             }
             node = node->Next();
         }
     }
 
             }
             node = node->Next();
         }
     }
 

-    wxPoint pt(win->GetClientAreaOrigin());
-    event.m_x -= pt.x;
-    event.m_y -= pt.y;
-

     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))

+    {

         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );

+       return TRUE;
+    }

 
 

-    return TRUE;
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -759,7 +820,13 @@ 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 (gdk_event->is_hint) 
+    if (!win->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)

     {
        int x = 0;
        int y = 0;
     {
        int x = 0;
        int y = 0;


@@ -769,13 +836,6 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
        gdk_event->y = y;
        gdk_event->state = state;
     }
        gdk_event->y = y;
        gdk_event->state = state;
     }

-    
-    if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
-
-    if (g_blockEventsOnDrag) return TRUE;
-    if (g_blockEventsOnScroll) return TRUE;
-
-    if (!win->HasVMT()) return TRUE;

 
 /*
     printf( "OnMotion from " );
 
 /*
     printf( "OnMotion from " );


@@ -805,37 +865,37 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();

-           
-           if (child->m_isStaticBox)
-           {
-               // wxStaticBox is transparent in the box itself
-               int x = event.m_x;
-               int y = event.m_y;
-               int xx1 = child->m_x;
-               int yy1 = child->m_y;
-               int xx2 = child->m_x + child->m_width;
-               int yy2 = child->m_x + child->m_height;
-               
-               // left
-               if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
-               // right
-                   ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
-               // top
-                   ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
-               // bottom
-                   ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
-               {
+
+            if (child->m_isStaticBox)
+            {
+                // wxStaticBox is transparent in the box itself
+                int x = event.m_x;
+                int y = event.m_y;
+                int xx1 = child->m_x;
+                int yy1 = child->m_y;
+                int xx2 = child->m_x + child->m_width;
+                int yy2 = child->m_x + child->m_height;
+
+                // left
+                if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
+                // right
+                    ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
+                // top
+                    ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
+                // bottom
+                    ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
+                {

                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
-                   
-           }
-           else
-           {
+                }
+
+            }
+            else
+            {

                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&

-                   (child->m_x <= event.m_x) &&
+                    (child->m_x <= event.m_x) &&

                     (child->m_y <= event.m_y) &&
                     (child->m_x+child->m_width  >= event.m_x) &&
                     (child->m_y+child->m_height >= event.m_y))
                     (child->m_y <= event.m_y) &&
                     (child->m_x+child->m_width  >= event.m_x) &&
                     (child->m_y+child->m_height >= event.m_y))


@@ -844,22 +904,21 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
+                }

             }
             node = node->Next();
         }
     }
 
             }
             node = node->Next();
         }
     }
 

-    wxPoint pt(win->GetClientAreaOrigin());
-    event.m_x -= pt.x;
-    event.m_y -= pt.y;
-

     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))

+    {

         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );

+       return TRUE;
+    }

 
 

-    return TRUE;
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -868,10 +927,11 @@ 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_blockEventsOnDrag) return TRUE;
-    
+    if (!win->HasVMT()) return FALSE;
+    if (g_blockEventsOnDrag) return FALSE;
+

     g_focusWindow = win;
     g_focusWindow = win;

-    
+

     if (win->m_wxwindow)
     {
         if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
     if (win->m_wxwindow)
     {
         if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))


@@ -886,7 +946,6 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
         }
     }
 
         }
     }
 

-    if (!win->HasVMT()) return TRUE;

 
 /*
     printf( "OnSetFocus from " );
 
 /*
     printf( "OnSetFocus from " );


@@ -901,9 +960,12 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))

+    {

         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );

-
-    return TRUE;
+        return TRUE;
+    }
+    
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -912,15 +974,15 @@ 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_blockEventsOnDrag) return TRUE;
+    if (!win->HasVMT()) return FALSE;
+    if (g_blockEventsOnDrag) return FALSE;
+    

     if (win->m_wxwindow)
     {
       if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
           GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
     }
 
     if (win->m_wxwindow)
     {
       if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
           GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
     }
 

-    if (!win->HasVMT()) return TRUE;
-

 /*
     printf( "OnKillFocus from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 /*
     printf( "OnKillFocus from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())


@@ -932,9 +994,12 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))

+    {

         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );

-
-    return TRUE;
+        return TRUE;
+    }
+    
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -943,15 +1008,14 @@ 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_blockEventsOnDrag) return TRUE;
+    if (!win->HasVMT()) return FALSE;
+    if (g_blockEventsOnDrag) return FALSE;
+    
+    if (widget->window != gdk_event->window) return FALSE;

 
     if ((widget->window) && (win->m_cursor))
         gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
 
 
     if ((widget->window) && (win->m_cursor))
         gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
 

-    if (widget->window != gdk_event->window) return TRUE;
-
-    if (!win->HasVMT()) return TRUE;
-

 /*
     printf( "OnEnter from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 /*
     printf( "OnEnter from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())


@@ -961,13 +1025,13 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     event.SetEventObject( win );
 
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     event.SetEventObject( win );

-    
+

     int x = 0;
     int y = 0;
     GdkModifierType state = (GdkModifierType)0;
     int x = 0;
     int y = 0;
     GdkModifierType state = (GdkModifierType)0;

-    
+

     gdk_window_get_pointer( widget->window, &x, &y, &state );
     gdk_window_get_pointer( widget->window, &x, &y, &state );

-    
+

     event.m_shiftDown = (state & GDK_SHIFT_MASK);
     event.m_controlDown = (state & GDK_CONTROL_MASK);
     event.m_altDown = (state & GDK_MOD1_MASK);
     event.m_shiftDown = (state & GDK_SHIFT_MASK);
     event.m_controlDown = (state & GDK_CONTROL_MASK);
     event.m_altDown = (state & GDK_MOD1_MASK);


@@ -978,15 +1042,14 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     event.m_x = (long)x;
     event.m_y = (long)y;
 
     event.m_x = (long)x;
     event.m_y = (long)y;

-    
-    wxPoint pt(win->GetClientAreaOrigin());
-    event.m_x -= pt.x;
-    event.m_y -= pt.y;

 
     if (win->GetEventHandler()->ProcessEvent( event ))
 
     if (win->GetEventHandler()->ProcessEvent( event ))

+    {

        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );

-
-    return TRUE;
+       return TRUE;
+    }
+    
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -995,15 +1058,14 @@ 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_blockEventsOnDrag) return TRUE;
+    if (!win->HasVMT()) return FALSE;
+    if (g_blockEventsOnDrag) return FALSE;

 
 

+    if (widget->window != gdk_event->window) return FALSE;
+    

     if ((widget->window) && (win->m_cursor))
         gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
 
     if ((widget->window) && (win->m_cursor))
         gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
 

-    if (widget->window != gdk_event->window) return TRUE;
-
-    if (!win->HasVMT()) return TRUE;
-

 /*
     printf( "OnLeave from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 /*
     printf( "OnLeave from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())


@@ -1017,9 +1079,9 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
     int x = 0;
     int y = 0;
     GdkModifierType state = (GdkModifierType)0;
     int x = 0;
     int y = 0;
     GdkModifierType state = (GdkModifierType)0;

-    
+

     gdk_window_get_pointer( widget->window, &x, &y, &state );
     gdk_window_get_pointer( widget->window, &x, &y, &state );

-    
+

     event.m_shiftDown = (state & GDK_SHIFT_MASK);
     event.m_controlDown = (state & GDK_CONTROL_MASK);
     event.m_altDown = (state & GDK_MOD1_MASK);
     event.m_shiftDown = (state & GDK_SHIFT_MASK);
     event.m_controlDown = (state & GDK_CONTROL_MASK);
     event.m_altDown = (state & GDK_MOD1_MASK);


@@ -1030,15 +1092,14 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     event.m_x = (long)x;
     event.m_y = (long)y;
 
     event.m_x = (long)x;
     event.m_y = (long)y;

-    
-    wxPoint pt(win->GetClientAreaOrigin());
-    event.m_x -= pt.x;
-    event.m_y -= pt.y;

 
     if (win->GetEventHandler()->ProcessEvent( event ))
 
     if (win->GetEventHandler()->ProcessEvent( event ))

+    {

         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );

-
-    return TRUE;
+        return TRUE;
+    }
+    
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -1060,6 +1121,7 @@ static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
 
     float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
     if (fabs(diff) < 0.2) return;
 
     float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
     if (fabs(diff) < 0.2) return;

+    win->m_oldVerticalPos = win->m_vAdjust->value;

 
     wxEventType command = wxEVT_NULL;
 
 
     wxEventType command = wxEVT_NULL;
 


@@ -1107,6 +1169,7 @@ static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
 
     float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
     if (fabs(diff) < 0.2) return;
 
     float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
     if (fabs(diff) < 0.2) return;

+    win->m_oldHorizontalPos = win->m_hAdjust->value;

 
     wxEventType command = wxEVT_NULL;
 
 
     wxEventType command = wxEVT_NULL;
 


@@ -1191,7 +1254,7 @@ static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxW
 
 static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
                                                  GdkEventButton *WXUNUSED(gdk_event),
 
 static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
                                                  GdkEventButton *WXUNUSED(gdk_event),

-                                                wxWindow *win )
+                                                 wxWindow *win )

 {
 //  don't test here as we can release the mouse while being over
 //  a different window then the slider
 {
 //  don't test here as we can release the mouse while being over
 //  a different window then the slider


@@ -1210,7 +1273,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
 
 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
                                                    GdkEventButton *WXUNUSED(gdk_event),
 
 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
                                                    GdkEventButton *WXUNUSED(gdk_event),

-                                                  wxWindow *win )
+                                                   wxWindow *win )

 {
 
 //  don't test here as we can release the mouse while being over
 {
 
 //  don't test here as we can release the mouse while being over


@@ -1246,23 +1309,18 @@ static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 {
     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
                      GTK_WIDGET(child->m_widget),
 {
     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
                      GTK_WIDGET(child->m_widget),

-                    child->m_x,
-                    child->m_y );
+                       child->m_x,
+                     child->m_y );

 
     gtk_widget_set_usize( GTK_WIDGET(child->m_widget),
                           child->m_width,
 
     gtk_widget_set_usize( GTK_WIDGET(child->m_widget),
                           child->m_width,

-                         child->m_height );
-                         
-    if (wxIS_KIND_OF(parent,wxFrame))
-    {
-        parent->m_sizeSet = FALSE;
-    }
-    
+                          child->m_height );
+

     if (parent->m_windowStyle & wxTAB_TRAVERSAL)
     {
         /* we now allow a window to get the focus as long as it
     if (parent->m_windowStyle & wxTAB_TRAVERSAL)
     {
         /* we now allow a window to get the focus as long as it

-          doesn't have any children. */
-        GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );  
+           doesn't have any children. */
+        GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );

     }
 }
 
     }
 }
 


@@ -1288,8 +1346,10 @@ BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
     EVT_KEY_DOWN(wxWindow::OnKeyDown)
 END_EVENT_TABLE()
 
     EVT_KEY_DOWN(wxWindow::OnKeyDown)
 END_EVENT_TABLE()
 

-wxWindow::wxWindow()
+void wxWindow::Init()

 {
 {

+    m_isWindow = TRUE;
+

     m_widget = (GtkWidget *) NULL;
     m_wxwindow = (GtkWidget *) NULL;
     m_parent = (wxWindow *) NULL;
     m_widget = (GtkWidget *) NULL;
     m_wxwindow = (GtkWidget *) NULL;
     m_parent = (wxWindow *) NULL;


@@ -1347,18 +1407,26 @@ wxWindow::wxWindow()
 
     m_clientObject = (wxClientData*) NULL;
     m_clientData = NULL;
 
     m_clientObject = (wxClientData*) NULL;
     m_clientData = NULL;

-    
+

     m_isStaticBox = FALSE;
     m_acceptsFocus = FALSE;
     m_isStaticBox = FALSE;
     m_acceptsFocus = FALSE;

-    
+
+#if wxUSE_TOOLTIPS

     m_toolTip = (wxToolTip*) NULL;
     m_toolTip = (wxToolTip*) NULL;

+#endif // wxUSE_TOOLTIPS
+}
+
+wxWindow::wxWindow()
+{
+    Init();

 }
 
 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
                     const wxPoint &pos, const wxSize &size,
                     long style, const wxString &name  )
 {
 }
 
 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
                     const wxPoint &pos, const wxSize &size,
                     long style, const wxString &name  )
 {

-    m_insertCallback = wxInsertChildInWindow;
+    Init();
+

     Create( parent, id, pos, size, style, name );
 }
 
     Create( parent, id, pos, size, style, name );
 }
 


@@ -1366,26 +1434,15 @@ 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  )
 {

-    m_isShown = FALSE;
-    m_isEnabled = TRUE;
-    m_needParent = TRUE;
+    wxASSERT_MSG( m_isWindow, _T("Init() must have been called before!") );

 
     PreCreation( parent, id, pos, size, style, name );
 
     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
     PreCreation( parent, id, pos, size, style, name );
 
     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, "wxWindow::m_widget", name );
-#endif

 
     GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
 
 
     GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
 

-#ifdef __WXDEBUG__
-    debug_focus_in( s_window->hscrollbar, "wxWindow::hsrcollbar", name );
-    debug_focus_in( s_window->vscrollbar, "wxWindow::vsrcollbar", name );
-#endif
-

     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
     scroll_class->scrollbar_spacing = 0;
 
     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
     scroll_class->scrollbar_spacing = 0;
 


@@ -1399,21 +1456,25 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
     m_wxwindow = gtk_myfixed_new();
 
 
     m_wxwindow = gtk_myfixed_new();
 

-#ifdef __WXDEBUG__
-    debug_focus_in( m_wxwindow, "wxWindow::m_wxwindow", name );
-#endif
+    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
+    
+#if (GTK_MINOR_VERSION > 0)
+    GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);

 
 

-#ifdef NEW_GTK_SCROLL_CODE
-    gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), m_wxwindow );
-    GtkViewport *viewport = GTK_VIEWPORT(s_window->child);
+    if (m_windowStyle & wxRAISED_BORDER)
+    {
+        gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_OUT );
+    }
+    else if (m_windowStyle & wxSUNKEN_BORDER)
+    {
+        gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_IN );
+    }
+    else
+    {
+        gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_NONE );
+    }

 #else
 #else

-    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );

     GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
     GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);

-#endif
-
-#ifdef __WXDEBUG__
-    debug_focus_in( GTK_WIDGET(viewport), "wxWindow::viewport", name );
-#endif

 
     if (m_windowStyle & wxRAISED_BORDER)
     {
 
     if (m_windowStyle & wxRAISED_BORDER)
     {


@@ -1427,12 +1488,13 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     {
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
     }
     {
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
     }

+#endif

 
     if (m_windowStyle & wxTAB_TRAVERSAL)
     {
         /* we now allow a window to get the focus as long as it
 
     if (m_windowStyle & wxTAB_TRAVERSAL)
     {
         /* we now allow a window to get the focus as long as it

-          doesn't have any children. */
-        GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );  
+           doesn't have any children. */
+        GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );

         m_acceptsFocus = FALSE;
     }
     else
         m_acceptsFocus = FALSE;
     }
     else


@@ -1441,9 +1503,11 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
         m_acceptsFocus = TRUE;
     }
 
         m_acceptsFocus = TRUE;
     }
 

+#if (GTK_MINOR_VERSION == 0)

     // shut the viewport up
     gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
     gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
     // shut the viewport up
     gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
     gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );

+#endif

 
     // I _really_ don't want scrollbars in the beginning
     m_vAdjust->lower = 0.0;
 
     // I _really_ don't want scrollbars in the beginning
     m_vAdjust->lower = 0.0;


@@ -1477,7 +1541,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event",
           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
 
     gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event",
           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
 

-    // these handers het notified when screen updates are required either when
+    // these handlers get notified when screen updates are required either when

     // scrolling or when the window size (and therefore scrollbar configuration)
     // has changed
 
     // scrolling or when the window size (and therefore scrollbar configuration)
     // has changed
 


@@ -1509,16 +1573,27 @@ wxWindow::~wxWindow()
     m_hasVMT = FALSE;
 
 #if wxUSE_DRAG_AND_DROP
     m_hasVMT = FALSE;
 
 #if wxUSE_DRAG_AND_DROP

-    if (m_dropTarget) delete m_dropTarget;
+    if (m_dropTarget)
+    {
+        delete m_dropTarget;
+       m_dropTarget = (wxDropTarget*) NULL;
+    }

 #endif
 
 #endif
 

-    if (m_toolTip) delete m_toolTip;
+#if wxUSE_TOOLTIPS
+    if (m_toolTip)
+    {
+        delete m_toolTip;
+       m_toolTip = (wxToolTip*) NULL;
+    }
+#endif // wxUSE_TOOLTIPS

 
 

-    if (m_parent) m_parent->RemoveChild( this );

     if (m_widget) Show( FALSE );
 
     DestroyChildren();
 
     if (m_widget) Show( FALSE );
 
     DestroyChildren();
 

+    if (m_parent) m_parent->RemoveChild( this );
+    

     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
 
     if (m_scrollGC) gdk_gc_unref( m_scrollGC );
     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
 
     if (m_scrollGC) gdk_gc_unref( m_scrollGC );


@@ -1532,28 +1607,29 @@ wxWindow::~wxWindow()
     DeleteRelatedConstraints();
     if (m_constraints)
     {
     DeleteRelatedConstraints();
     if (m_constraints)
     {

-        // This removes any dangling pointers to this window
-        // in other windows' constraintsInvolvedIn lists.
+        /* This removes any dangling pointers to this window
+         * in other windows' constraintsInvolvedIn lists. */

         UnsetConstraints(m_constraints);
         delete m_constraints;
         m_constraints = (wxLayoutConstraints *) NULL;
     }
         UnsetConstraints(m_constraints);
         delete m_constraints;
         m_constraints = (wxLayoutConstraints *) NULL;
     }

+    

     if (m_windowSizer)
     {
         delete m_windowSizer;
         m_windowSizer = (wxSizer *) NULL;
     }
     if (m_windowSizer)
     {
         delete m_windowSizer;
         m_windowSizer = (wxSizer *) NULL;
     }

-    // If this is a child of a sizer, remove self from parent
+    /* If this is a child of a sizer, remove self from parent */

     if (m_sizerParent) m_sizerParent->RemoveChild((wxWindow *)this);
 
     if (m_sizerParent) m_sizerParent->RemoveChild((wxWindow *)this);
 

-    // Just in case the window has been Closed, but
-    // we're then deleting immediately: don't leave
-    // dangling pointers.
+    /* Just in case the window has been Closed, but
+     * we're then deleting immediately: don't leave
+     * dangling pointers. */

     wxPendingDelete.DeleteObject(this);
 
     wxPendingDelete.DeleteObject(this);
 

-    // Just in case we've loaded a top-level window via
-    // wxWindow::LoadNativeDialog but we weren't a dialog
-    // class
+    /* Just in case we've loaded a top-level window via
+     * wxWindow::LoadNativeDialog but we weren't a dialog
+     * class */

     wxTopLevelWindows.DeleteObject(this);
 
     if (m_windowValidator) delete m_windowValidator;
     wxTopLevelWindows.DeleteObject(this);
 
     if (m_windowValidator) delete m_windowValidator;


@@ -1565,7 +1641,7 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
       const wxPoint &pos, const wxSize &size,
       long style, const wxString &name )
 {
       const wxPoint &pos, const wxSize &size,
       long style, const wxString &name )
 {

-    wxASSERT_MSG( (!m_needParent) || (parent), "Need complete parent." );
+    wxASSERT_MSG( (!m_needParent) || (parent), _T("Need complete parent.") );

 
     m_widget = (GtkWidget*) NULL;
     m_wxwindow = (GtkWidget*) NULL;
 
     m_widget = (GtkWidget*) NULL;
     m_wxwindow = (GtkWidget*) NULL;


@@ -1581,7 +1657,7 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
     m_x = (int)pos.x;
     m_y = (int)pos.y;
 
     m_x = (int)pos.x;
     m_y = (int)pos.y;
 

-    if (!m_needParent)  // some reasonable defaults
+    if (!m_needParent)  /* some reasonable defaults */

     {
         if (m_x == -1)
         {
     {
         if (m_x == -1)
         {


@@ -1641,25 +1717,41 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
 
     m_clientObject = (wxClientData*)NULL;
     m_clientData = NULL;
 
     m_clientObject = (wxClientData*)NULL;
     m_clientData = NULL;

-    
+

     m_isStaticBox = FALSE;
     m_isStaticBox = FALSE;

+
+#if wxUSE_TOOLTIPS

     m_toolTip = (wxToolTip*) NULL;
     m_toolTip = (wxToolTip*) NULL;

+#endif // wxUSE_TOOLTIPS

 }
 
 void wxWindow::PostCreation()
 {
 }
 
 void wxWindow::PostCreation()
 {

+    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+    

     if (m_wxwindow)
     {
     if (m_wxwindow)
     {

-      gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
-        GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
+        /* 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",
+          GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );

 
 

-      gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
-        GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
+        gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
+          GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
+#endif

     }
 
     ConnectWidget( GetConnectWidget() );
 
     }
 
     ConnectWidget( GetConnectWidget() );
 

-    if (m_widget && m_parent) gtk_widget_realize( m_widget );
+    /* we force the creation of wxFrame and wxDialog in the respective code */
+    if (m_parent) gtk_widget_realize( m_widget );

 
     if (m_wxwindow) gtk_widget_realize( m_wxwindow );
 
 
     if (m_wxwindow) gtk_widget_realize( m_wxwindow );
 


@@ -1705,18 +1797,20 @@ bool wxWindow::HasVMT()
 
 bool wxWindow::Close( bool force )
 {
 
 bool wxWindow::Close( bool force )
 {

-    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );

 
     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
     event.SetEventObject(this);
 
     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
     event.SetEventObject(this);

-    event.SetForce(force);
+    event.SetCanVeto(!force);

 
 

-    return GetEventHandler()->ProcessEvent(event);
+    /* return FALSE if window wasn't closed because the application vetoed the
+     * close event */
+    return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();

 }
 
 bool wxWindow::Destroy()
 {
 }
 
 bool wxWindow::Destroy()
 {

-    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );

 
     m_hasVMT = FALSE;
     delete this;
 
     m_hasVMT = FALSE;
     delete this;


@@ -1743,32 +1837,17 @@ void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
     // are we to set fonts here ?
 }
 
     // are we to set fonts here ?
 }
 

-wxPoint wxWindow::GetClientAreaOrigin() const
-{
-    return wxPoint(0,0);
-}
-
-void wxWindow::AdjustForParentClientOrigin( int& x, int& y, int sizeFlags )
-{
-    if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
-    {
-        wxPoint pt(GetParent()->GetClientAreaOrigin());
-        x += pt.x;
-        y += pt.y;
-    }
-}
-
-void wxWindow::SetSize( 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), "invalid window" );
-    wxASSERT_MSG( (m_parent != NULL), "wxWindow::SetSize requires parent.\n" );
+    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+    wxASSERT_MSG( (m_parent != NULL), _T("wxWindow::SetSize requires parent.\n") );

 
 

-    if (m_resizing) return; // I don't like recursions
+    if (m_resizing) return; /* I don't like recursions */

     m_resizing = TRUE;
 
     m_resizing = TRUE;
 

-    if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
+    if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */

     {
     {

-        // don't set the size for children of wxNotebook, just take the values.
+        /* don't set the size for children of wxNotebook, just take the values. */

         m_x = x;
         m_y = y;
         m_width = width;
         m_x = x;
         m_y = y;
         m_width = width;


@@ -1809,11 +1888,22 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
         if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 
         if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 

-        wxPoint pt( m_parent->GetClientAreaOrigin() );
-        gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y );
+        if (GTK_WIDGET_HAS_DEFAULT(m_widget))
+       {
+           /* the default button has a border around it */
+           int border = 5;
+       
+            gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x-border, m_y-border );
+
+            gtk_widget_set_usize( m_widget, m_width+2*border, m_height+2*border );
+       }
+       else
+       {
+            gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x, m_y );

 
 

-        if ((old_width != m_width) || (old_height != m_height))
-             gtk_widget_set_usize( m_widget, m_width, m_height );
+            if ((old_width != m_width) || (old_height != m_height))
+              gtk_widget_set_usize( m_widget, m_width, m_height );
+       }

     }
 
     m_sizeSet = TRUE;
     }
 
     m_sizeSet = TRUE;


@@ -1830,27 +1920,17 @@ void wxWindow::OnInternalIdle()
     UpdateWindowUI();
 }
 
     UpdateWindowUI();
 }
 

-void wxWindow::SetSize( int width, int height )
-{
-    SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
-}
-
-void wxWindow::Move( int x, int y )
-{
-    SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
-}
-

 void wxWindow::GetSize( int *width, int *height ) const
 {
 void wxWindow::GetSize( int *width, int *height ) const
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     if (width) (*width) = m_width;
     if (height) (*height) = m_height;
 }
 
 
     if (width) (*width) = m_width;
     if (height) (*height) = m_height;
 }
 

-void wxWindow::SetClientSize( int width, int height )
+void wxWindow::DoSetClientSize( int width, int height )

 {
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     if (!m_wxwindow)
     {
 
     if (!m_wxwindow)
     {


@@ -1877,44 +1957,45 @@ void wxWindow::SetClientSize( int width, int height )
             GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 
             GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 

-#ifdef NEW_GTK_SCROLL_CODE
-            GtkWidget *viewport = scroll_window->child;
-#else
+#if (GTK_MINOR_VERSION == 0)

             GtkWidget *viewport = scroll_window->viewport;
             GtkWidget *viewport = scroll_window->viewport;

-#endif
-

             GtkStyleClass *viewport_class = viewport->style->klass;
 
             GtkStyleClass *viewport_class = viewport->style->klass;
 

-            GtkWidget *hscrollbar = scroll_window->hscrollbar;
-            GtkWidget *vscrollbar = scroll_window->vscrollbar;
-

             if ((m_windowStyle & wxRAISED_BORDER) ||
                 (m_windowStyle & wxSUNKEN_BORDER))
             {
                 dw += 2 * viewport_class->xthickness;
                 dh += 2 * viewport_class->ythickness;
             }
             if ((m_windowStyle & wxRAISED_BORDER) ||
                 (m_windowStyle & wxSUNKEN_BORDER))
             {
                 dw += 2 * viewport_class->xthickness;
                 dh += 2 * viewport_class->ythickness;
             }

+#endif
+
+/*
+            GtkWidget *hscrollbar = scroll_window->hscrollbar;
+            GtkWidget *vscrollbar = scroll_window->vscrollbar;
+           
+           we use this instead:  range.slider_width = 11 + 2*2pts edge 
+*/

 
             if (scroll_window->vscrollbar_visible)
             {
 
             if (scroll_window->vscrollbar_visible)
             {

-                dw += vscrollbar->allocation.width;
+                dw += 15;   /* dw += vscrollbar->allocation.width; */

                 dw += scroll_class->scrollbar_spacing;
             }
 
             if (scroll_window->hscrollbar_visible)
             {
                 dw += scroll_class->scrollbar_spacing;
             }
 
             if (scroll_window->hscrollbar_visible)
             {

-                dh += hscrollbar->allocation.height;
+                dh += 15;   /* dh += hscrollbar->allocation.height; */

                 dw += scroll_class->scrollbar_spacing;
             }
        }
 
                 dw += scroll_class->scrollbar_spacing;
             }
        }
 

-      SetSize( width+dw, height+dh );
+       SetSize( width+dw, height+dh );

     }
 }
 
 void wxWindow::GetClientSize( int *width, int *height ) const
 {
     }
 }
 
 void wxWindow::GetClientSize( int *width, int *height ) const
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     if (!m_wxwindow)
     {
 
     if (!m_wxwindow)
     {


@@ -1942,12 +2023,8 @@ void wxWindow::GetClientSize( int *width, int *height ) const
             GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 
             GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 

-#ifdef NEW_GTK_SCROLL_CODE
-            GtkWidget *viewport = scroll_window->child;
-#else
+#if (GTK_MINOR_VERSION == 0)

             GtkWidget *viewport = scroll_window->viewport;
             GtkWidget *viewport = scroll_window->viewport;

-#endif
-

             GtkStyleClass *viewport_class = viewport->style->klass;
 
             if ((m_windowStyle & wxRAISED_BORDER) ||
             GtkStyleClass *viewport_class = viewport->style->klass;
 
             if ((m_windowStyle & wxRAISED_BORDER) ||


@@ -1956,18 +2033,23 @@ void wxWindow::GetClientSize( int *width, int *height ) const
                 dw += 2 * viewport_class->xthickness;
                 dh += 2 * viewport_class->ythickness;
             }
                 dw += 2 * viewport_class->xthickness;
                 dh += 2 * viewport_class->ythickness;
             }

+#endif
+/*
+            GtkWidget *hscrollbar = scroll_window->hscrollbar;
+            GtkWidget *vscrollbar = scroll_window->vscrollbar;
+           
+           we use this instead:  range.slider_width = 11 + 2*2pts edge 
+*/

 
             if (scroll_window->vscrollbar_visible)
             {
 
             if (scroll_window->vscrollbar_visible)
             {

-//              dw += vscrollbar->allocation.width;
-                dw += 15;                               // range.slider_width = 11 + 2*2pts edge
+                dw += 15;   /* dw += vscrollbar->allocation.width; */

                 dw += scroll_class->scrollbar_spacing;
             }
 
             if (scroll_window->hscrollbar_visible)
             {
                 dw += scroll_class->scrollbar_spacing;
             }
 
             if (scroll_window->hscrollbar_visible)
             {

-//              dh += hscrollbar->allocation.height;
-                dh += 15;
+                dh += 15;   /* dh += hscrollbar->allocation.height; */

                 dh += scroll_class->scrollbar_spacing;
             }
         }
                 dh += scroll_class->scrollbar_spacing;
             }
         }


@@ -1979,7 +2061,7 @@ void wxWindow::GetClientSize( int *width, int *height ) const
 
 void wxWindow::GetPosition( int *x, int *y ) const
 {
 
 void wxWindow::GetPosition( int *x, int *y ) const
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     if (x) (*x) = m_x;
     if (y) (*y) = m_y;
 
     if (x) (*x) = m_x;
     if (y) (*y) = m_y;


@@ -1987,7 +2069,7 @@ void wxWindow::GetPosition( int *x, int *y ) const
 
 void wxWindow::ClientToScreen( int *x, int *y )
 {
 
 void wxWindow::ClientToScreen( int *x, int *y )
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)


@@ -2008,17 +2090,13 @@ void wxWindow::ClientToScreen( int *x, int *y )
         }
     }
 
         }
     }
 

-    wxPoint pt(GetClientAreaOrigin());
-    org_x += pt.x;
-    org_y += pt.y;
-

     if (x) *x += org_x;
     if (y) *y += org_y;
 }
 
 void wxWindow::ScreenToClient( int *x, int *y )
 {
     if (x) *x += org_x;
     if (y) *y += org_y;
 }
 
 void wxWindow::ScreenToClient( int *x, int *y )
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)


@@ -2039,17 +2117,13 @@ void wxWindow::ScreenToClient( int *x, int *y )
         }
     }
 
         }
     }
 

-    wxPoint pt(GetClientAreaOrigin());
-    org_x -= pt.x;
-    org_y -= pt.y;
-

     if (x) *x -= org_x;
     if (y) *y -= org_y;
 }
 
 void wxWindow::Centre( int direction )
 {
     if (x) *x -= org_x;
     if (y) *y -= org_y;
 }
 
 void wxWindow::Centre( int direction )
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     int x = m_x;
     int y = m_y;
 
     int x = m_x;
     int y = m_y;


@@ -2073,7 +2147,7 @@ void wxWindow::Centre( int direction )
 
 void wxWindow::Fit()
 {
 
 void wxWindow::Fit()
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     int maxX = 0;
     int maxY = 0;
 
     int maxX = 0;
     int maxY = 0;


@@ -2089,13 +2163,13 @@ void wxWindow::Fit()
 
         node = node->Next();
     }
 
         node = node->Next();
     }

-    
+

     SetClientSize(maxX + 7, maxY + 14);
 }
 
 void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
 {
     SetClientSize(maxX + 7, maxY + 14);
 }
 
 void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     m_minWidth = minW;
     m_minHeight = minH;
 
     m_minWidth = minW;
     m_minHeight = minH;


@@ -2110,47 +2184,49 @@ void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
 
 bool wxWindow::Show( bool show )
 {
 
 bool wxWindow::Show( bool show )
 {

-    wxCHECK_MSG( (m_widget != NULL), FALSE, "invalid window" );
+    wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
+
+    if (show == m_isShown) return TRUE;

 
     if (show)
         gtk_widget_show( m_widget );
     else
         gtk_widget_hide( m_widget );
 
     if (show)
         gtk_widget_show( m_widget );
     else
         gtk_widget_hide( m_widget );

-       
+

     m_isShown = show;
     m_isShown = show;

-    
+

     return TRUE;
 }
 
 void wxWindow::Enable( bool enable )
 {
     return TRUE;
 }
 
 void wxWindow::Enable( bool enable )
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     m_isEnabled = enable;
 
     m_isEnabled = enable;

-    
+

     gtk_widget_set_sensitive( m_widget, enable );
     if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
 }
 
 int wxWindow::GetCharHeight() const
 {
     gtk_widget_set_sensitive( m_widget, enable );
     if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
 }
 
 int wxWindow::GetCharHeight() const
 {

-    wxCHECK_MSG( (m_widget != NULL), 12, "invalid window" );
+    wxCHECK_MSG( (m_widget != NULL), 12, _T("invalid window") );

 
 

-    wxCHECK_MSG( m_font.Ok(), 12, "invalid font" );
+    wxCHECK_MSG( m_font.Ok(), 12, _T("invalid font") );

 
     GdkFont *font = m_font.GetInternalFont( 1.0 );
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );

-    
+

     return font->ascent + font->descent;
 }
 
 int wxWindow::GetCharWidth() const
 {
     return font->ascent + font->descent;
 }
 
 int wxWindow::GetCharWidth() const
 {

-    wxCHECK_MSG( (m_widget != NULL), 8, "invalid window" );
+    wxCHECK_MSG( (m_widget != NULL), 8, _T("invalid window") );

 
 

-    wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );
+    wxCHECK_MSG( m_font.Ok(), 8, _T("invalid font") );

 
     GdkFont *font = m_font.GetInternalFont( 1.0 );
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );

-    
+

     return gdk_string_width( font, "H" );
 }
 
     return gdk_string_width( font, "H" );
 }
 


@@ -2160,10 +2236,10 @@ void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
     wxFont fontToUse = m_font;
     if (theFont) fontToUse = *theFont;
 
     wxFont fontToUse = m_font;
     if (theFont) fontToUse = *theFont;
 

-    wxCHECK_RET( fontToUse.Ok(), "invalid font" );
+    wxCHECK_RET( fontToUse.Ok(), _T("invalid font") );

 
     GdkFont *font = fontToUse.GetInternalFont( 1.0 );
 
     GdkFont *font = fontToUse.GetInternalFont( 1.0 );

-    if (x) (*x) = gdk_string_width( font, string );
+    if (x) (*x) = gdk_string_width( font, string.mbc_str() );

     if (y) (*y) = font->ascent + font->descent;
     if (descent) (*descent) = font->descent;
     if (externalLeading) (*externalLeading) = 0;  // ??
     if (y) (*y) = font->ascent + font->descent;
     if (descent) (*descent) = font->descent;
     if (externalLeading) (*externalLeading) = 0;  // ??


@@ -2172,7 +2248,7 @@ void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
 void wxWindow::MakeModal( bool modal )
 {
     return;
 void wxWindow::MakeModal( bool modal )
 {
     return;

-    
+

     // Disable all other windows
     if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
     {
     // Disable all other windows
     if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
     {


@@ -2190,7 +2266,7 @@ void wxWindow::MakeModal( bool modal )
 void wxWindow::OnKeyDown( wxKeyEvent &event )
 {
     event.SetEventType( wxEVT_CHAR );
 void wxWindow::OnKeyDown( wxKeyEvent &event )
 {
     event.SetEventType( wxEVT_CHAR );

-    
+

     if (!GetEventHandler()->ProcessEvent( event ))
     {
         event.Skip();
     if (!GetEventHandler()->ProcessEvent( event ))
     {
         event.Skip();


@@ -2199,8 +2275,8 @@ void wxWindow::OnKeyDown( wxKeyEvent &event )
 
 void wxWindow::SetFocus()
 {
 
 void wxWindow::SetFocus()
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
-    
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+

     GtkWidget *connect_widget = GetConnectWidget();
     if (connect_widget)
     {
     GtkWidget *connect_widget = GetConnectWidget();
     if (connect_widget)
     {


@@ -2208,13 +2284,13 @@ void wxWindow::SetFocus()
         {
             gtk_widget_grab_focus (connect_widget);
         }
         {
             gtk_widget_grab_focus (connect_widget);
         }

-       else if (GTK_IS_CONTAINER(connect_widget))
-       {
-           gtk_container_focus( GTK_CONTAINER(connect_widget), GTK_DIR_TAB_FORWARD );
-       }
-       else
-       {
-       }
+        else if (GTK_IS_CONTAINER(connect_widget))
+        {
+            gtk_container_focus( GTK_CONTAINER(connect_widget), GTK_DIR_TAB_FORWARD );
+        }
+        else
+        {
+        }

     }
 }
 
     }
 }
 


@@ -2228,23 +2304,18 @@ bool wxWindow::AcceptsFocus() const
     return IsEnabled() && IsShown() && m_acceptsFocus;
 }
 
     return IsEnabled() && IsShown() && m_acceptsFocus;
 }
 

-bool wxWindow::OnClose()
-{
-    return TRUE;
-}
-

 void wxWindow::AddChild( wxWindow *child )
 {
 void wxWindow::AddChild( wxWindow *child )
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
-    wxCHECK_RET( (child != NULL), "invalid child" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (child != NULL), _T("invalid child") );

 
     m_children.Append( child );
 }
 
 wxWindow *wxWindow::ReParent( wxWindow *newParent )
 {
 
     m_children.Append( child );
 }
 
 wxWindow *wxWindow::ReParent( wxWindow *newParent )
 {

-    wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );
-    
+    wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, _T("invalid window") );
+

     wxWindow *oldParent = GetParent();
 
     if (oldParent) oldParent->RemoveChild( this );
     wxWindow *oldParent = GetParent();
 
     if (oldParent) oldParent->RemoveChild( this );


@@ -2278,14 +2349,14 @@ int wxWindow::GetReturnCode()
 
 void wxWindow::Raise()
 {
 
 void wxWindow::Raise()
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     if (m_widget) gdk_window_raise( m_widget->window );
 }
 
 void wxWindow::Lower()
 {
 
     if (m_widget) gdk_window_raise( m_widget->window );
 }
 
 void wxWindow::Lower()
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     if (m_widget) gdk_window_lower( m_widget->window );
 }
 
     if (m_widget) gdk_window_lower( m_widget->window );
 }


@@ -2376,7 +2447,7 @@ wxWindowID wxWindow::GetId() const
 
 void wxWindow::SetCursor( const wxCursor &cursor )
 {
 
 void wxWindow::SetCursor( const wxCursor &cursor )
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     if (cursor.Ok())
     {
 
     if (cursor.Ok())
     {


@@ -2402,7 +2473,7 @@ void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) )
 
 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
 {
 
 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
 {

-    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );

 
     if (eraseBackground && m_wxwindow && m_wxwindow->window)
     {
 
     if (eraseBackground && m_wxwindow && m_wxwindow->window)
     {


@@ -2410,20 +2481,19 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
         {
             gdk_window_clear_area( m_wxwindow->window,
                                    rect->x, rect->y,
         {
             gdk_window_clear_area( m_wxwindow->window,
                                    rect->x, rect->y,

-                                   rect->width,
-                                   rect->height );
+                                   rect->width, rect->height );

         }
         else
         {
         }
         else
         {

-            Clear();
+            gdk_window_clear( m_wxwindow->window );

         }
     }
         }
     }

-    
+

     if (!rect)
     {
         if (m_wxwindow)
             gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
     if (!rect)
     {
         if (m_wxwindow)
             gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );

-       else
+        else

             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
     }
     else
             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
     }
     else


@@ -2468,11 +2538,15 @@ bool wxWindow::IsExposed( const wxRect& rect ) const
 
 void wxWindow::Clear()
 {
 
 void wxWindow::Clear()
 {

-    wxCHECK_RET( m_widget != NULL, "invalid window" );
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );

 
 

-    if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
+    if (m_wxwindow && m_wxwindow->window)
+    {
+        gdk_window_clear( m_wxwindow->window );
+    }

 }
 
 }
 

+#if wxUSE_TOOLTIPS

 void wxWindow::SetToolTip( const wxString &tip )
 {
     if (m_toolTip)
 void wxWindow::SetToolTip( const wxString &tip )
 {
     if (m_toolTip)


@@ -2481,15 +2555,11 @@ void wxWindow::SetToolTip( const wxString &tip )
     }
     else
     {
     }
     else
     {

-        m_toolTip = new wxToolTip( tip );
-       m_toolTip->Apply( this );
-    }
-    
-    if (tip.IsEmpty())
-    {
-        delete m_toolTip;
-       m_toolTip = (wxToolTip*) NULL;
+        SetToolTip( new wxToolTip( tip ) );

     }
     }

+
+    // setting empty tooltip text does not remove the tooltip any more for
+    // wxMSW compatibility - use SetToolTip((wxToolTip *)NULL) for this

 }
 
 void wxWindow::SetToolTip( wxToolTip *tip )
 }
 
 void wxWindow::SetToolTip( wxToolTip *tip )


@@ -2499,21 +2569,18 @@ void wxWindow::SetToolTip( wxToolTip *tip )
         m_toolTip->SetTip( (char*) NULL );
         delete m_toolTip;
     }
         m_toolTip->SetTip( (char*) NULL );
         delete m_toolTip;
     }

-    
+

     m_toolTip = tip;
     m_toolTip = tip;

-    
-    if (m_toolTip) m_toolTip->Apply( this );
-}

 
 

-void wxWindow::ApplyToolTip( GtkTooltips *tips, const char *tip )
-{
-    gtk_tooltips_set_tip( tips, GetConnectWidget(), tip, (gchar*) NULL );
+    if (m_toolTip)
+        m_toolTip->Apply( this );

 }
 
 }
 

-wxToolTip* wxWindow::GetToolTip()
+void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )

 {
 {

-    return m_toolTip;
+    gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConv_current->cWX2MB(tip), (gchar*) NULL );

 }
 }

+#endif // wxUSE_TOOLTIPS

 
 wxColour wxWindow::GetBackgroundColour() const
 {
 
 wxColour wxWindow::GetBackgroundColour() const
 {


@@ -2522,30 +2589,33 @@ wxColour wxWindow::GetBackgroundColour() const
 
 void wxWindow::SetBackgroundColour( const wxColour &colour )
 {
 
 void wxWindow::SetBackgroundColour( const wxColour &colour )
 {

-    wxCHECK_RET( m_widget != NULL, "invalid window" );
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );

 
     if (m_backgroundColour == colour) return;
 
     m_backgroundColour = colour;
     if (!m_backgroundColour.Ok()) return;
 
 
     if (m_backgroundColour == colour) return;
 
     m_backgroundColour = colour;
     if (!m_backgroundColour.Ok()) return;
 

-    if (m_wxwindow)
+    if (m_wxwindow && m_wxwindow->window)

     {
     {

-        GdkWindow *window = m_wxwindow->window;
-        m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
-        gdk_window_set_background( window, m_backgroundColour.GetColor() );
-        gdk_window_clear( window );
+       /* wxMSW doesn't clear the window here. I don't do that
+          either to provide compatibility. call Clear() to do 
+          the job. */
+          
+        m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_wxwindow->window ) );
+        gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );

     }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
     }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );

-    if (sysbg.Red() == colour.Red() && 
-        sysbg.Green() == colour.Green() && 
+    
+    if (sysbg.Red() == colour.Red() &&
+        sysbg.Green() == colour.Green() &&

         sysbg.Blue() == colour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
         sysbg.Blue() == colour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();

-       m_backgroundColour = sysbg;
-    } 
+        m_backgroundColour = sysbg;
+    }

     else
     {
         ApplyWidgetStyle();
     else
     {
         ApplyWidgetStyle();


@@ -2559,7 +2629,7 @@ wxColour wxWindow::GetForegroundColour() const
 
 void wxWindow::SetForegroundColour( const wxColour &colour )
 {
 
 void wxWindow::SetForegroundColour( const wxColour &colour )
 {

-    wxCHECK_RET( m_widget != NULL, "invalid window" );
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );

 
     if (m_foregroundColour == colour) return;
 
 
     if (m_foregroundColour == colour) return;
 


@@ -2567,14 +2637,14 @@ void wxWindow::SetForegroundColour( const wxColour &colour )
     if (!m_foregroundColour.Ok()) return;
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
     if (!m_foregroundColour.Ok()) return;
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );

-    if (sysbg.Red() == colour.Red() && 
-        sysbg.Green() == colour.Green() && 
+    if (sysbg.Red() == colour.Red() &&
+        sysbg.Green() == colour.Green() &&

         sysbg.Blue() == colour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
         sysbg.Blue() == colour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();

-       m_backgroundColour = sysbg;
-    } 
+        m_backgroundColour = sysbg;
+    }

     else
     {
         ApplyWidgetStyle();
     else
     {
         ApplyWidgetStyle();


@@ -2627,16 +2697,16 @@ void wxWindow::ApplyWidgetStyle()
 
 bool wxWindow::Validate()
 {
 
 bool wxWindow::Validate()
 {

-    wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );

 
     wxNode *node = m_children.First();
     while (node)
     {
         wxWindow *child = (wxWindow *)node->Data();
         if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
 
     wxNode *node = m_children.First();
     while (node)
     {
         wxWindow *child = (wxWindow *)node->Data();
         if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))

-        { 
-           return FALSE; 
-       }
+        {
+            return FALSE;
+        }

         node = node->Next();
     }
     return TRUE;
         node = node->Next();
     }
     return TRUE;


@@ -2644,7 +2714,7 @@ bool wxWindow::Validate()
 
 bool wxWindow::TransferDataToWindow()
 {
 
 bool wxWindow::TransferDataToWindow()
 {

-    wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );

 
     wxNode *node = m_children.First();
     while (node)
 
     wxNode *node = m_children.First();
     while (node)


@@ -2663,16 +2733,16 @@ bool wxWindow::TransferDataToWindow()
 
 bool wxWindow::TransferDataFromWindow()
 {
 
 bool wxWindow::TransferDataFromWindow()
 {

-    wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );

 
     wxNode *node = m_children.First();
     while (node)
     {
         wxWindow *child = (wxWindow *)node->Data();
         if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
 
     wxNode *node = m_children.First();
     while (node)
     {
         wxWindow *child = (wxWindow *)node->Data();
         if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )

-        { 
-           return FALSE; 
-       }
+        {
+            return FALSE;
+        }

         node = node->Next();
     }
     return TRUE;
         node = node->Next();
     }
     return TRUE;


@@ -2690,7 +2760,7 @@ void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
 
 void wxWindow::InitDialog()
 {
 
 void wxWindow::InitDialog()
 {

-    wxCHECK_RET( m_widget != NULL, "invalid window" );
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );

 
     wxInitDialogEvent event(GetId());
     event.SetEventObject( this );
 
     wxInitDialogEvent event(GetId());
     event.SetEventObject( this );


@@ -2700,14 +2770,14 @@ void wxWindow::InitDialog()
 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 {
     menu->SetInvokingWindow( win );
 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 {
     menu->SetInvokingWindow( win );

-    wxNode *node = menu->m_items.First();
+    wxNode *node = menu->GetItems().First();

     while (node)
     {
         wxMenuItem *menuitem = (wxMenuItem*)node->Data();
         if (menuitem->IsSubMenu())
         {
     while (node)
     {
         wxMenuItem *menuitem = (wxMenuItem*)node->Data();
         if (menuitem->IsSubMenu())
         {

-           SetInvokingWindow( menuitem->GetSubMenu(), win );
-       }
+            SetInvokingWindow( menuitem->GetSubMenu(), win );
+        }

         node = node->Next();
     }
 }
         node = node->Next();
     }
 }


@@ -2724,15 +2794,17 @@ static void pop_pos_callback( GtkMenu *menu, gint *x, gint *y, wxWindow *win )
 
 bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
 {
 
 bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
 {

-    wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );

 
 

-    wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" );
+    wxCHECK_MSG( menu != NULL, FALSE, _T("invalid popup-menu") );

 
     SetInvokingWindow( menu, this );
 
     SetInvokingWindow( menu, this );

-    
+
+    menu->UpdateUI();
+

     gs_pop_x = x;
     gs_pop_y = y;
     gs_pop_x = x;
     gs_pop_y = y;

-    
+

     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


@@ -2749,7 +2821,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, "invalid window" );
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );

 
     GtkWidget *dnd_widget = GetConnectWidget();
 
 
     GtkWidget *dnd_widget = GetConnectWidget();
 


@@ -2784,22 +2856,24 @@ bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 
 void wxWindow::SetFont( const wxFont &font )
 {
 
 void wxWindow::SetFont( const wxFont &font )
 {

-    wxCHECK_RET( m_widget != NULL, "invalid window" );
-
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    
+    if (m_font == font) return;
+    

     if (((wxFont*)&font)->Ok())
         m_font = font;
     else
         m_font = *wxSWISS_FONT;
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
     if (((wxFont*)&font)->Ok())
         m_font = font;
     else
         m_font = *wxSWISS_FONT;
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );

-    if (sysbg.Red() == m_backgroundColour.Red() && 
-        sysbg.Green() == m_backgroundColour.Green() && 
+    if (sysbg.Red() == m_backgroundColour.Red() &&
+        sysbg.Green() == m_backgroundColour.Green() &&

         sysbg.Blue() == m_backgroundColour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
         sysbg.Blue() == m_backgroundColour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();

-       m_backgroundColour = sysbg;
-    } 
+        m_backgroundColour = sysbg;
+    }

     else
     {
         ApplyWidgetStyle();
     else
     {
         ApplyWidgetStyle();


@@ -2818,9 +2892,9 @@ long wxWindow::GetWindowStyleFlag() const
 
 void wxWindow::CaptureMouse()
 {
 
 void wxWindow::CaptureMouse()
 {

-    wxCHECK_RET( m_widget != NULL, "invalid window" );
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );

 
 

-    wxCHECK_RET( g_capturing == FALSE, "CaptureMouse called twice" );
+    wxCHECK_RET( g_capturing == FALSE, _T("CaptureMouse called twice") );

 
     GtkWidget *connect_widget = GetConnectWidget();
     gtk_grab_add( connect_widget );
 
     GtkWidget *connect_widget = GetConnectWidget();
     gtk_grab_add( connect_widget );


@@ -2829,17 +2903,17 @@ void wxWindow::CaptureMouse()
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
                           GDK_POINTER_MOTION_MASK),
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
                           GDK_POINTER_MOTION_MASK),

-                      (GdkWindow *) NULL, 
-                     (GdkCursor *) NULL, 
-                     GDK_CURRENT_TIME );
+                      (GdkWindow *) NULL,
+                      (GdkCursor *) NULL,
+                      GDK_CURRENT_TIME );

     g_capturing = TRUE;
 }
 
 void wxWindow::ReleaseMouse()
 {
     g_capturing = TRUE;
 }
 
 void wxWindow::ReleaseMouse()
 {

-    wxCHECK_RET( m_widget != NULL, "invalid window" );
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );

 
 

-    wxCHECK_RET( g_capturing == TRUE, "ReleaseMouse called twice" );
+    wxCHECK_RET( g_capturing == TRUE, _T("ReleaseMouse called twice") );

 
     GtkWidget *connect_widget = GetConnectWidget();
     gtk_grab_remove( connect_widget );
 
     GtkWidget *connect_widget = GetConnectWidget();
     gtk_grab_remove( connect_widget );


@@ -2912,9 +2986,9 @@ wxWindow *wxWindow::FindWindow( const wxString& name )
 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, "invalid window" );
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );

 
 

-    wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
+    wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );

 
     m_hasScrolling = TRUE;
 
 
     m_hasScrolling = TRUE;
 


@@ -2980,9 +3054,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, "invalid window" );
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );

 
 

-    wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
+    wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );

 
     if (orient == wxHORIZONTAL)
     {
 
     if (orient == wxHORIZONTAL)
     {


@@ -3000,7 +3074,7 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
         if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
         if (fpos < 0.0) fpos = 0.0;
         m_oldVerticalPos = fpos;
         if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
         if (fpos < 0.0) fpos = 0.0;
         m_oldVerticalPos = fpos;

-    
+

         if (fabs(fpos-m_vAdjust->value) < 0.2) return;
         m_vAdjust->value = fpos;
     }
         if (fabs(fpos-m_vAdjust->value) < 0.2) return;
         m_vAdjust->value = fpos;
     }


@@ -3019,9 +3093,9 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
 
 int wxWindow::GetScrollThumb( int orient ) const
 {
 
 int wxWindow::GetScrollThumb( int orient ) const
 {

-    wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
+    wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );

 
 

-    wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
+    wxCHECK_MSG( m_wxwindow != NULL, 0, _T("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);


@@ -3031,9 +3105,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, "invalid window" );
+    wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );

 
 

-    wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
+    wxCHECK_MSG( m_wxwindow != NULL, 0, _T("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);


@@ -3043,9 +3117,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, "invalid window" );
+    wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );

 
 

-    wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
+    wxCHECK_MSG( m_wxwindow != NULL, 0, _T("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);


@@ -3055,9 +3129,17 @@ 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, "invalid window" );
+    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+
+    wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );

 
 

-    wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
+    wxNode *node = m_children.First();
+    while (node)
+    {
+        wxWindow *child = (wxWindow*) node->Data();
+       child->Move( child->m_x + dx, child->m_y + dy );
+       node = node->Next();
+    }

 
     int cw = 0;
     int ch = 0;
 
     int cw = 0;
     int ch = 0;


@@ -3400,21 +3482,21 @@ void wxWindow::SetConstraintSizes(bool recurse)
   }
   else if (constr)
   {
   }
   else if (constr)
   {

-    char *windowClass = this->GetClassInfo()->GetClassName();
+    wxChar *windowClass = this->GetClassInfo()->GetClassName();

 
     wxString winName;
 
     wxString winName;

-  if (GetName() == "")
-    winName = "unnamed";
+  if (GetName() == _T(""))
+    winName = _T("unnamed");

   else
     winName = GetName();
   else
     winName = GetName();

-    wxLogDebug( "Constraint(s) not satisfied for window of type %s, name %s:\n", 
-                (const char *)windowClass, 
-               (const char *)winName);
-    if (!constr->left.GetDone()) wxLogDebug( "  unsatisfied 'left' constraint.\n" );
-    if (!constr->right.GetDone()) wxLogDebug( "  unsatisfied 'right' constraint.\n" );
-    if (!constr->width.GetDone()) wxLogDebug( "  unsatisfied 'width' constraint.\n" );
-    if (!constr->height.GetDone())  wxLogDebug( "  unsatisfied 'height' constraint.\n" );
-    wxLogDebug( "Please check constraints: try adding AsIs() constraints.\n" );
+    wxLogDebug( _T("Constraint(s) not satisfied for window of type %s, name %s:\n"),
+                (const wxChar *)windowClass,
+                (const wxChar *)winName);
+    if (!constr->left.GetDone()) wxLogDebug( _T("  unsatisfied 'left' constraint.\n") );
+    if (!constr->right.GetDone()) wxLogDebug( _T("  unsatisfied 'right' constraint.\n") );
+    if (!constr->width.GetDone()) wxLogDebug( _T("  unsatisfied 'width' constraint.\n") );
+    if (!constr->height.GetDone())  wxLogDebug( _T("  unsatisfied 'height' constraint.\n") );
+    wxLogDebug( _T("Please check constraints: try adding AsIs() constraints.\n") );

   }
 
   if (recurse)
   }
 
   if (recurse)