Added wxMenu::Delete() and fixed some menu deleted memory

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

diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp
index fa872fc36fb8af5e7c906d80ec90d27ed70b6c36..7e235b0c06335305cd875a287ecbb6cc38bbbe66 100644 (file)
--- a/src/gtk1/window.cpp
+++ b/src/gtk1/window.cpp
@@ -132,7 +132,7 @@ extern bool       g_blockEventsOnDrag;
 extern bool       g_blockEventsOnScroll;
 extern wxCursor   g_globalCursor;
 static wxWindow  *g_captureWindow = (wxWindow*) NULL;
 extern bool       g_blockEventsOnScroll;
 extern wxCursor   g_globalCursor;
 static wxWindow  *g_captureWindow = (wxWindow*) NULL;

-wxWindow  *g_focusWindow = (wxWindow*) NULL;
+       wxWindow  *g_focusWindow = (wxWindow*) NULL;

 
 /* hack: we need something to pass to gtk_menu_popup, so we store the time of
    the last click here */
 
 /* hack: we need something to pass to gtk_menu_popup, so we store the time of
    the last click here */


@@ -146,7 +146,7 @@ static guint32 gs_timeLastClick = 0;
 
 static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
                                          GdkEvent *WXUNUSED(event),
 
 static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
                                          GdkEvent *WXUNUSED(event),

-                                         const wxChar *name )
+                                         const wxChar *WXUNUSED(name) )

 {
 /*
     static bool s_done = FALSE;
 {
 /*
     static bool s_done = FALSE;


@@ -155,7 +155,7 @@ static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
         wxLog::AddTraceMask("focus");
         s_done = TRUE;
     }
         wxLog::AddTraceMask("focus");
         s_done = TRUE;
     }

-    wxLogTrace(_T("FOCUS NOW AT: %s"), name);
+    wxLogTrace(wxT("FOCUS NOW AT: %s"), name);

 */
 
     return FALSE;
 */
 
     return FALSE;


@@ -164,7 +164,7 @@ static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
 void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window )
 {
     wxString tmp = name;
 void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window )
 {
     wxString tmp = name;

-    tmp += _T(" FROM ");
+    tmp += wxT(" FROM ");

     tmp += window;
 
     wxChar *s = new wxChar[tmp.Length()+1];
     tmp += window;
 
     wxChar *s = new wxChar[tmp.Length()+1];


@@ -210,6 +210,109 @@ gdk_window_warp_pointer (GdkWindow      *window,
 extern void wxapp_install_idle_handler();
 extern bool g_isIdle;
 
 extern void wxapp_install_idle_handler();
 extern bool g_isIdle;
 

+//-----------------------------------------------------------------------------
+// local code (see below)
+//-----------------------------------------------------------------------------
+
+#if (GTK_MINOR_VERSION > 0)
+
+static void draw_frame( GtkWidget *widget, wxWindow *win )
+{
+    if (!win->m_hasVMT)
+        return;
+
+    int dw = 0;
+    int dh = 0;
+
+    if (win->HasScrolling())
+    {
+        GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
+        GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget)->klass );
+
+/*
+            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;
+        }
+
+        if (scroll_window->hscrollbar_visible)
+        {
+            dh += 15;   /* dh += hscrollbar->allocation.height; */
+            dh += scroll_class->scrollbar_spacing;
+        }
+    }
+
+    int dx = 0;
+    int dy = 0;
+    if (GTK_WIDGET_NO_WINDOW (widget))
+    {
+        dx += widget->allocation.x;
+        dy += widget->allocation.y;
+    }
+
+    if (win->HasFlag(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;
+    }
+
+    if (win->HasFlag(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;
+    }
+    
+    if (win->HasFlag(wxSIMPLE_BORDER))
+    {
+        GdkGC *gc;
+       gc = gdk_gc_new( widget->window );
+        gdk_gc_set_foreground( gc, &widget->style->black );
+        gdk_draw_rectangle( widget->window, gc, FALSE, 
+                         dx, dy,
+                         win->m_width-dw-1, win->m_height-dh-1 );
+        gdk_gc_unref( gc );
+        return;
+    }
+}
+
+//-----------------------------------------------------------------------------
+// "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 );
+}
+
+//-----------------------------------------------------------------------------
+// "draw" of m_widget
+//-----------------------------------------------------------------------------
+
+static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win )
+{
+    draw_frame( widget, win );
+}
+
+#endif // GTK_MINOR_VERSION > 0
+

 //-----------------------------------------------------------------------------
 // key event conversion routines
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // key event conversion routines
 //-----------------------------------------------------------------------------


@@ -564,97 +667,6 @@ static long map_to_wx_keysym( KeySym keysym )
     return (key_code);
 }
 
     return (key_code);
 }
 

-//-----------------------------------------------------------------------------
-// local code (see below)
-//-----------------------------------------------------------------------------
-
-#if (GTK_MINOR_VERSION > 0)
-
-static void draw_frame( GtkWidget *widget, wxWindow *win )
-{
-    if (!win->m_hasVMT)
-        return;
-
-    int dw = 0;
-    int dh = 0;
-
-    if (win->HasScrolling())
-    {
-        GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
-        GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget)->klass );
-
-/*
-            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;
-        }
-
-        if (scroll_window->hscrollbar_visible)
-        {
-            dh += 15;   /* dh += hscrollbar->allocation.height; */
-            dh += scroll_class->scrollbar_spacing;
-        }
-    }
-
-    int dx = 0;
-    int dy = 0;
-    if (GTK_WIDGET_NO_WINDOW (widget))
-    {
-        dx += widget->allocation.x;
-        dy += widget->allocation.y;
-    }
-
-    if (win->HasFlag(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;
-    }
-
-    if (win->HasFlag(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;
-    }
-}
-
-//-----------------------------------------------------------------------------
-// "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 );
-}
-
-//-----------------------------------------------------------------------------
-// "draw" of m_wxwindow
-//-----------------------------------------------------------------------------
-
-static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win )
-{
-    draw_frame( widget, win );
-}
-
-#endif // GTK_MINOR_VERSION > 0
-

 //-----------------------------------------------------------------------------
 // "expose_event" of m_wxwindow
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // "expose_event" of m_wxwindow
 //-----------------------------------------------------------------------------


@@ -664,9 +676,6 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
     if (!win->m_hasVMT)
         return;
 
     if (!win->m_hasVMT)
         return;
 

-    if (gdk_event->window != win->m_wxwindow->window)
-        return;
-

     win->GetUpdateRegion().Union( gdk_event->area.x,
                                   gdk_event->area.y,
                                   gdk_event->area.width,
     win->GetUpdateRegion().Union( gdk_event->area.x,
                                   gdk_event->area.y,
                                   gdk_event->area.width,


@@ -675,10 +684,6 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
     if (gdk_event->count > 0)
         return;
 
     if (gdk_event->count > 0)
         return;
 

-    wxPaintEvent event( win->GetId() );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
-

 /*
     wxPrintf( "OnExpose from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 /*
     wxPrintf( "OnExpose from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())


@@ -689,6 +694,10 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
                                 (int)gdk_event->area.height );
 */
 
                                 (int)gdk_event->area.height );
 */
 

+    wxPaintEvent event( win->GetId() );
+    event.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( event );
+

     win->GetUpdateRegion().Clear();
 }
 
     win->GetUpdateRegion().Clear();
 }
 


@@ -696,7 +705,7 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
 // "draw" of m_wxwindow
 //-----------------------------------------------------------------------------
 
 // "draw" of m_wxwindow
 //-----------------------------------------------------------------------------
 

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

 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 {
     if (g_isIdle)
         wxapp_install_idle_handler();


@@ -707,9 +716,6 @@ static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle
     win->GetUpdateRegion().Union( rect->x, rect->y,
                                   rect->width, rect->height );
 
     win->GetUpdateRegion().Union( rect->x, rect->y,
                                   rect->width, rect->height );
 

-    wxPaintEvent event( win->GetId() );
-    event.SetEventObject( win );
-

 /*
     wxPrintf( "OnDraw from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 /*
     wxPrintf( "OnDraw from " );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())


@@ -719,7 +725,9 @@ static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle
                                 (int)rect->width,
                                 (int)rect->height );
 */
                                 (int)rect->width,
                                 (int)rect->height );
 */

-
+                               
+    wxPaintEvent event( win->GetId() );
+    event.SetEventObject( win );

     win->GetEventHandler()->ProcessEvent( event );
 
     win->GetUpdateRegion().Clear();
     win->GetEventHandler()->ProcessEvent( event );
 
     win->GetUpdateRegion().Clear();


@@ -812,7 +820,6 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
         ret = (ret || win->GetEventHandler()->ProcessEvent( event2 ));
     }
 
         ret = (ret || win->GetEventHandler()->ProcessEvent( event2 ));
     }
 

-

     /* win is a control: tab can be propagated up */
     if ( (!ret) &&
          ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
     /* win is a control: tab can be propagated up */
     if ( (!ret) &&
          ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&


@@ -964,10 +971,10 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
         wxapp_install_idle_handler();
 
 /*
         wxapp_install_idle_handler();
 
 /*

-    wxPrintf( _T("1) OnButtonPress from ") );
+    wxPrintf( wxT("1) OnButtonPress from ") );

     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
         wxPrintf( win->GetClassInfo()->GetClassName() );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
         wxPrintf( win->GetClassInfo()->GetClassName() );

-    wxPrintf( _T(".\n") );
+    wxPrintf( wxT(".\n") );

 */
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return TRUE;
 */
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return TRUE;


@@ -982,20 +989,20 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
             gtk_widget_grab_focus (win->m_wxwindow);
 
 /*
             gtk_widget_grab_focus (win->m_wxwindow);
 
 /*

-            wxPrintf( _T("GrabFocus from ") );
+            wxPrintf( wxT("GrabFocus from ") );

             if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
                 wxPrintf( win->GetClassInfo()->GetClassName() );
             if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
                 wxPrintf( win->GetClassInfo()->GetClassName() );

-            wxPrintf( _T(".\n") );
+            wxPrintf( wxT(".\n") );

 */
 
         }
     }
 
 /*
 */
 
         }
     }
 
 /*

-    wxPrintf( _T("2) OnButtonPress from ") );
+    wxPrintf( wxT("2) OnButtonPress from ") );

     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
         wxPrintf( win->GetClassInfo()->GetClassName() );
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
         wxPrintf( win->GetClassInfo()->GetClassName() );

-    wxPrintf( _T(".\n") );
+    wxPrintf( wxT(".\n") );

 */
 
     wxEventType event_type = wxEVT_LEFT_DOWN;
 */
 
     wxEventType event_type = wxEVT_LEFT_DOWN;


@@ -1228,18 +1235,17 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
     if (g_blockEventsOnScroll) return FALSE;
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
     if (g_blockEventsOnScroll) return FALSE;

-
+    

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

-       int x = 0;
-       int y = 0;
-       GdkModifierType state;
-       gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
-       gdk_event->x = x;
-       gdk_event->y = y;
-       gdk_event->state = state;
+        int x = 0;
+        int y = 0;
+        GdkModifierType state;
+        gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
+        gdk_event->x = x;
+        gdk_event->y = y;

     }
 
 /*
     }
 
 /*


@@ -1510,7 +1516,7 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 // "value_changed" from m_vAdjust
 //-----------------------------------------------------------------------------
 
 // "value_changed" from m_vAdjust
 //-----------------------------------------------------------------------------
 

-static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindow *win )

 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 {
     if (g_isIdle)
         wxapp_install_idle_handler();


@@ -1518,32 +1524,22 @@ static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
     if (g_blockEventsOnDrag) return;
 
     if (!win->m_hasVMT) return;
     if (g_blockEventsOnDrag) return;
 
     if (!win->m_hasVMT) return;

-
-    float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
+    
+    float diff = adjust->value - win->m_oldVerticalPos;

     if (fabs(diff) < 0.2) return;
     if (fabs(diff) < 0.2) return;

-    win->m_oldVerticalPos = win->m_vAdjust->value;
-
-    wxEventType command = wxEVT_NULL;
-
-    float line_step = win->m_vAdjust->step_increment;
-    float page_step = win->m_vAdjust->page_increment;
-
-    if (win->IsScrolling())
-    {
-        command = wxEVT_SCROLLWIN_THUMBTRACK;
-    }
-    else
-    {
-        if (fabs(win->m_vAdjust->value-win->m_vAdjust->lower) < 0.2) command = wxEVT_SCROLLWIN_BOTTOM;
-        else if (fabs(win->m_vAdjust->value-win->m_vAdjust->upper) < 0.2) command = wxEVT_SCROLLWIN_TOP;
-        else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEDOWN;
-        else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEUP;
-        else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEDOWN;
-        else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEUP;
-        else command = wxEVT_SCROLLWIN_THUMBTRACK;
-    }
+    
+    win->m_oldVerticalPos = adjust->value;

 
 

-    int value = (int)(win->m_vAdjust->value+0.5);
+    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
+    GtkRange *range = GTK_RANGE( scrolledWindow->vscrollbar );
+    
+    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
+    if      (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP;
+    else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD)  command = wxEVT_SCROLLWIN_LINEDOWN;
+    else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP;
+    else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD)  command = wxEVT_SCROLLWIN_PAGEDOWN;
+    
+    int value = (int)(adjust->value+0.5);

 
     wxScrollWinEvent event( command, value, wxVERTICAL );
     event.SetEventObject( win );
 
     wxScrollWinEvent event( command, value, wxVERTICAL );
     event.SetEventObject( win );


@@ -1554,7 +1550,7 @@ static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
 // "value_changed" from m_hAdjust
 //-----------------------------------------------------------------------------
 
 // "value_changed" from m_hAdjust
 //-----------------------------------------------------------------------------
 

-static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindow *win )

 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 {
     if (g_isIdle)
         wxapp_install_idle_handler();


@@ -1562,31 +1558,21 @@ static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
     if (g_blockEventsOnDrag) return;
     if (!win->m_hasVMT) return;
 
     if (g_blockEventsOnDrag) return;
     if (!win->m_hasVMT) return;
 

-    float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
+    float diff = adjust->value - win->m_oldHorizontalPos;

     if (fabs(diff) < 0.2) return;
     if (fabs(diff) < 0.2) return;

-    win->m_oldHorizontalPos = win->m_hAdjust->value;
-
-    wxEventType command = wxEVT_NULL;
-
-    float line_step = win->m_hAdjust->step_increment;
-    float page_step = win->m_hAdjust->page_increment;
-
-    if (win->IsScrolling())
-    {
-        command = wxEVT_SCROLLWIN_THUMBTRACK;
-    }
-    else
-    {
-        if (fabs(win->m_hAdjust->value-win->m_hAdjust->lower) < 0.2) command = wxEVT_SCROLLWIN_BOTTOM;
-        else if (fabs(win->m_hAdjust->value-win->m_hAdjust->upper) < 0.2) command = wxEVT_SCROLLWIN_TOP;
-        else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEDOWN;
-        else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEUP;
-        else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEDOWN;
-        else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEUP;
-        else command = wxEVT_SCROLLWIN_THUMBTRACK;
-    }
+    
+    win->m_oldHorizontalPos = adjust->value;

 
 

-    int value = (int)(win->m_hAdjust->value+0.5);
+    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
+    GtkRange *range = GTK_RANGE( scrolledWindow->hscrollbar );
+    
+    wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
+    if      (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP;
+    else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD)  command = wxEVT_SCROLLWIN_LINEDOWN;
+    else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP;
+    else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD)  command = wxEVT_SCROLLWIN_PAGEDOWN;
+    
+    int value = (int)(adjust->value+0.5);

 
     wxScrollWinEvent event( command, value, wxHORIZONTAL );
     event.SetEventObject( win );
 
     wxScrollWinEvent event( command, value, wxHORIZONTAL );
     event.SetEventObject( win );


@@ -1645,7 +1631,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
         wxapp_install_idle_handler();
 
 //  don't test here as we can release the mouse while being over
         wxapp_install_idle_handler();
 
 //  don't test here as we can release the mouse while being over

-//  a different window then the slider
+//  a different window than the slider

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


@@ -1658,23 +1644,16 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
 // "button_release_event" from scrollbar
 //-----------------------------------------------------------------------------
 
 // "button_release_event" from scrollbar
 //-----------------------------------------------------------------------------
 

-static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
+static gint gtk_scrollbar_button_release_callback( GtkRange *WXUNUSED(widget),

                                                    GdkEventButton *WXUNUSED(gdk_event),
                                                    wxWindow *win )
 {
 
 //  don't test here as we can release the mouse while being over
                                                    GdkEventButton *WXUNUSED(gdk_event),
                                                    wxWindow *win )
 {
 
 //  don't test here as we can release the mouse while being over

-//  a different window then the slider
+//  a different window than the slider

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

-    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
-
-    if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
-        gtk_signal_emit_by_name( GTK_OBJECT(win->m_hAdjust), "value_changed" );
-    else
-        gtk_signal_emit_by_name( GTK_OBJECT(win->m_vAdjust), "value_changed" );
-

     win->SetScrolling( FALSE );
 
     return FALSE;
     win->SetScrolling( FALSE );
 
     return FALSE;


@@ -1694,7 +1673,7 @@ wxWindow *wxWindowBase::FindFocus()
 // "realize" from m_widget
 //-----------------------------------------------------------------------------
 
 // "realize" from m_widget
 //-----------------------------------------------------------------------------
 

-/* we cannot set colours, fonts and cursors before the widget has
+/* we cannot set colours and fonts before the widget has

    been realized, so we do this directly after realization */
 
 static gint
    been realized, so we do this directly after realization */
 
 static gint


@@ -1712,8 +1691,6 @@ gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
     if (win->m_delayedForegroundColour)
         win->SetForegroundColour( win->GetForegroundColour() );
 
     if (win->m_delayedForegroundColour)
         win->SetForegroundColour( win->GetForegroundColour() );
 

-    win->SetCursor( win->GetCursor() );
-

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


@@ -1734,6 +1711,12 @@ gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
 
 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 {
 
 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 {

+    /* the window might have been scrolled already, do we
+       have to adapt the position */
+    GtkMyFixed *myfixed = GTK_MYFIXED(parent->m_wxwindow);
+    child->m_x += myfixed->xoffset;
+    child->m_y += myfixed->yoffset;
+    

     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
                      GTK_WIDGET(child->m_widget),
                      child->m_x,
     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
                      GTK_WIDGET(child->m_widget),
                      child->m_x,


@@ -1783,6 +1766,8 @@ void wxWindow::Init()
     m_hasVMT = FALSE;
     m_needParent = TRUE;
     m_isBeingDeleted = FALSE;
     m_hasVMT = FALSE;
     m_needParent = TRUE;
     m_isBeingDeleted = FALSE;

+    
+    m_noExpose = FALSE;

 
     m_hasScrolling = FALSE;
     m_isScrolling = FALSE;
 
     m_hasScrolling = FALSE;
     m_isScrolling = FALSE;


@@ -1793,7 +1778,6 @@ void wxWindow::Init()
     m_oldVerticalPos = 0.0;
 
     m_resizing = FALSE;
     m_oldVerticalPos = 0.0;
 
     m_resizing = FALSE;

-    m_scrollGC = (GdkGC*) NULL;

     m_widgetStyle = (GtkStyle*) NULL;
 
     m_insertCallback = (wxInsertChildFunction) NULL;
     m_widgetStyle = (GtkStyle*) NULL;
 
     m_insertCallback = (wxInsertChildFunction) NULL;


@@ -1801,6 +1785,8 @@ void wxWindow::Init()
     m_isStaticBox = FALSE;
     m_isRadioButton = FALSE;
     m_acceptsFocus = FALSE;
     m_isStaticBox = FALSE;
     m_isRadioButton = FALSE;
     m_acceptsFocus = FALSE;

+    
+    m_cursor = *wxSTANDARD_CURSOR;

 }
 
 wxWindow::wxWindow()
 }
 
 wxWindow::wxWindow()


@@ -1824,7 +1810,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     if (!PreCreation( parent, pos, size ) ||
         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
     {
     if (!PreCreation( parent, pos, size ) ||
         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
     {

-        wxFAIL_MSG( _T("wxWindow creation failed") );
+        wxFAIL_MSG( wxT("wxWindow creation failed") );

        return FALSE;
     }
 
        return FALSE;
     }
 


@@ -1834,14 +1820,14 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
 #ifdef __WXDEBUG__
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
 #ifdef __WXDEBUG__

-    debug_focus_in( m_widget, _T("wxWindow::m_widget"), name );
+    debug_focus_in( m_widget, wxT("wxWindow::m_widget"), name );

 #endif
 
     GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
 
 #ifdef __WXDEBUG__
 #endif
 
     GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
 
 #ifdef __WXDEBUG__

-    debug_focus_in( scrolledWindow->hscrollbar, _T("wxWindow::hsrcollbar"), name );
-    debug_focus_in( scrolledWindow->vscrollbar, _T("wxWindow::vsrcollbar"), name );
+    debug_focus_in( scrolledWindow->hscrollbar, wxT("wxWindow::hsrcollbar"), name );
+    debug_focus_in( scrolledWindow->vscrollbar, wxT("wxWindow::vsrcollbar"), name );

 #endif
 
     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 #endif
 
     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );


@@ -1855,7 +1841,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     m_wxwindow = gtk_myfixed_new();
 
 #ifdef __WXDEBUG__
     m_wxwindow = gtk_myfixed_new();
 
 #ifdef __WXDEBUG__

-    debug_focus_in( m_wxwindow, _T("wxWindow::m_wxwindow"), name );
+    debug_focus_in( m_wxwindow, wxT("wxWindow::m_wxwindow"), name );

 #endif
 
     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
 #endif
 
     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );


@@ -1865,15 +1851,19 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
     if (HasFlag(wxRAISED_BORDER))
     {
 
     if (HasFlag(wxRAISED_BORDER))
     {

-        gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_OUT );
+        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_OUT );

     }
     else if (HasFlag(wxSUNKEN_BORDER))
     {
     }
     else if (HasFlag(wxSUNKEN_BORDER))
     {

-        gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_IN );
+        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_IN );
+    }
+    else if (HasFlag(wxSIMPLE_BORDER))
+    {
+        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_THIN );

     }
     else
     {
     }
     else
     {

-        gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_NONE );
+        gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_NONE );

     }
 #else // GTK_MINOR_VERSION == 0
     GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
     }
 #else // GTK_MINOR_VERSION == 0
     GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);


@@ -1988,12 +1978,6 @@ wxWindow::~wxWindow()
         m_widgetStyle = (GtkStyle*) NULL;
     }
 
         m_widgetStyle = (GtkStyle*) NULL;
     }
 

-    if (m_scrollGC)
-    {
-        gdk_gc_unref( m_scrollGC );
-        m_scrollGC = (GdkGC*) NULL;
-    }
-

     if (m_wxwindow)
     {
         gtk_widget_destroy( m_wxwindow );
     if (m_wxwindow)
     {
         gtk_widget_destroy( m_wxwindow );


@@ -2009,7 +1993,7 @@ wxWindow::~wxWindow()
 
 bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos,  const wxSize &size )
 {
 
 bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos,  const wxSize &size )
 {

-    wxCHECK_MSG( !m_needParent || parent, FALSE, _T("Need complete parent.") );
+    wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );

 
     /* this turns -1 into 20 so that a minimal window is
        visible even although -1,-1 has been given as the
 
     /* this turns -1 into 20 so that a minimal window is
        visible even although -1,-1 has been given as the


@@ -2041,17 +2025,20 @@ bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos,  const wxSize
 
 void wxWindow::PostCreation()
 {
 
 void wxWindow::PostCreation()
 {

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

 
     if (m_wxwindow)
     {
 
     if (m_wxwindow)
     {

-        /* these get reported to wxWindows -> wxPaintEvent */
-        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
-          GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
-
-        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
-          GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
+        if (!m_noExpose)
+       {
+            /* these get reported to wxWindows -> wxPaintEvent */
+            gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
+                GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );

 
 

+            gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
+                GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
+       }
+         

 #if (GTK_MINOR_VERSION > 0)
         /* these are called when the "sunken" or "raised" borders are drawn */
         gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
 #if (GTK_MINOR_VERSION > 0)
         /* these are called when the "sunken" or "raised" borders are drawn */
         gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",


@@ -2106,7 +2093,7 @@ void wxWindow::ConnectWidget( GtkWidget *widget )
 
 bool wxWindow::Destroy()
 {
 
 bool wxWindow::Destroy()
 {

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

 
     m_hasVMT = FALSE;
 
 
     m_hasVMT = FALSE;
 


@@ -2115,8 +2102,8 @@ bool wxWindow::Destroy()
 
 void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 {
 
 void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 {

-    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
-    wxASSERT_MSG( (m_parent != NULL), _T("wxWindow::SetSize requires parent.\n") );
+    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
+    wxASSERT_MSG( (m_parent != NULL), wxT("wxWindow::SetSize requires parent.\n") );

 
     if (m_resizing) return; /* I don't like recursions */
     m_resizing = TRUE;
 
     if (m_resizing) return; /* I don't like recursions */
     m_resizing = TRUE;


@@ -2131,17 +2118,19 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     }
     else
     {
     }
     else
     {

+        GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
+       

         if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
         {
         if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
         {

-            if (x != -1) m_x = x;
-            if (y != -1) m_y = y;
+            if (x != -1) m_x = x + myfixed->xoffset;
+            if (y != -1) m_y = y + myfixed->yoffset;

             if (width != -1) m_width = width;
             if (height != -1) m_height = height;
         }
         else
         {
             if (width != -1) m_width = width;
             if (height != -1) m_height = height;
         }
         else
         {

-            m_x = x;
-            m_y = y;
+            m_x = x + myfixed->xoffset;
+            m_y = y + myfixed->yoffset;

             m_width = width;
             m_height = height;
         }
             m_width = width;
             m_height = height;
         }


@@ -2171,27 +2160,6 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
             bottom_border = 5;
         }
 
             bottom_border = 5;
         }
 

-        /* this is the result of hours of debugging: the following code
-           means that if we have a m_wxwindow and we set the size of
-           m_widget, m_widget (which is a GtkScrolledWindow) does NOT
-           automatically propagate its size down to its m_wxwindow,
-           which is its client area. therefore, we have to tell the
-           client area directly that it has to resize itself.
-           this will lead to that m_widget (GtkScrolledWindow) will
-           calculate how much size it needs for scrollbars etc and
-           it will then call XXX_size_allocate of its child, which
-           is m_wxwindow. m_wxwindow in turn will do the same with its
-           children and so on. problems can arise if this happens
-           before all the children have been realized as some widgets
-           stupidy need to be realized during XXX_size_allocate (e.g.
-           GtkNotebook) and they will segv if called otherwise. this
-           emergency is tested in gtk_myfixed_size_allocate. Normally
-           this shouldn't be needed and only gtk_widget_queue_resize()
-           should be enough to provoke a resize at the next appropriate
-           moment, but this seems to fail, e.g. when a wxNotebook contains
-           a wxSplitterWindow: the splitter window's children won't
-           show up properly resized then. */
-

         gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow),
                               m_widget,
                               m_x-border,
         gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow),
                               m_widget,
                               m_x-border,


@@ -2214,13 +2182,16 @@ void wxWindow::OnInternalIdle()
     wxCursor cursor = m_cursor;
     if (g_globalCursor.Ok()) cursor = g_globalCursor;
 
     wxCursor cursor = m_cursor;
     if (g_globalCursor.Ok()) cursor = g_globalCursor;
 

-    if (cursor.Ok() && m_currentGdkCursor != cursor)
+    if (cursor.Ok())

     {
     {

-        m_currentGdkCursor = cursor;
+        /* I now set the cursor the anew in every OnInternalIdle call
+          as setting the cursor in a parent window also effects the
+          windows above so that checking for the current cursor is
+          not possible. */

        
         if (m_wxwindow)
         {
        
         if (m_wxwindow)
         {

-            GdkWindow *window = m_wxwindow->window;
+            GdkWindow *window = GTK_MYFIXED(m_wxwindow)->bin_window;

             if (window)
                 gdk_window_set_cursor( window, cursor.GetCursor() );
 
             if (window)
                 gdk_window_set_cursor( window, cursor.GetCursor() );
 


@@ -2228,14 +2199,17 @@ void wxWindow::OnInternalIdle()
                 cursor = *wxSTANDARD_CURSOR;
 
             window = m_widget->window;
                 cursor = *wxSTANDARD_CURSOR;
 
             window = m_widget->window;

-            if (window)
+            if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))

                 gdk_window_set_cursor( window, cursor.GetCursor() );
                 gdk_window_set_cursor( window, cursor.GetCursor() );

+

         }
         else
         {
         }
         else
         {

+

             GdkWindow *window = m_widget->window;
             GdkWindow *window = m_widget->window;

-            if (window)
+            if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))

                gdk_window_set_cursor( window, cursor.GetCursor() );
                gdk_window_set_cursor( window, cursor.GetCursor() );

+

         }
     }
 
         }
     }
 


@@ -2244,7 +2218,7 @@ void wxWindow::OnInternalIdle()
 
 void wxWindow::DoGetSize( int *width, int *height ) const
 {
 
 void wxWindow::DoGetSize( int *width, int *height ) const
 {

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

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


@@ -2252,7 +2226,7 @@ void wxWindow::DoGetSize( int *width, int *height ) const
 
 void wxWindow::DoSetClientSize( int width, int height )
 {
 
 void wxWindow::DoSetClientSize( int width, int height )
 {

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

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


@@ -2269,7 +2243,9 @@ void wxWindow::DoSetClientSize( int width, int height )
             if (HasScrolling())
             {
                 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
             if (HasScrolling())
             {
                 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);

+#if 0 // unused - if this is ok, just remove this line (VZ)

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

+#endif // 0

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


@@ -2281,10 +2257,16 @@ void wxWindow::DoSetClientSize( int width, int height )
 #else
         if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
         {
 #else
         if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
         {

-            /* when using GTK 1.2 we set the border size to 2 */
+            /* when using GTK 1.2 we set the shadow border size to 2 */

             dw += 2 * 2;
             dh += 2 * 2;
         }
             dw += 2 * 2;
             dh += 2 * 2;
         }

+        if (HasFlag(wxSIMPLE_BORDER))
+        {
+            /* when using GTK 1.2 we set the simple border size to 1 */
+            dw += 1 * 2;
+            dh += 1 * 2;
+        }

 #endif
 
         if (HasScrolling())
 #endif
 
         if (HasScrolling())


@@ -2318,7 +2300,7 @@ void wxWindow::DoSetClientSize( int width, int height )
 
 void wxWindow::DoGetClientSize( int *width, int *height ) const
 {
 
 void wxWindow::DoGetClientSize( int *width, int *height ) const
 {

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

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


@@ -2336,7 +2318,9 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
             if (HasScrolling())
             {
                 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
             if (HasScrolling())
             {
                 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);

+#if 0 // unused - if this is ok, just remove this line (VZ)

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

+#endif // 0

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


@@ -2348,10 +2332,16 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
 #else
         if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
         {
 #else
         if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
         {

-            /* when using GTK 1.2 we set the border size to 2 */
+            /* when using GTK 1.2 we set the shadow border size to 2 */

             dw += 2 * 2;
             dh += 2 * 2;
         }
             dw += 2 * 2;
             dh += 2 * 2;
         }

+        if (HasFlag(wxSIMPLE_BORDER))
+        {
+            /* when using GTK 1.2 we set the simple border size to 1 */
+            dw += 1 * 2;
+            dh += 1 * 2;
+        }

 #endif
         if (HasScrolling())
         {
 #endif
         if (HasScrolling())
         {


@@ -2385,21 +2375,30 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
 
 void wxWindow::DoGetPosition( int *x, int *y ) const
 {
 
 void wxWindow::DoGetPosition( int *x, int *y ) const
 {

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

 
 

-    if (x) (*x) = m_x;
-    if (y) (*y) = m_y;
+    int dx = 0;
+    int dy = 0;
+    if (m_parent && m_parent->m_wxwindow)
+    {
+        GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
+       dx = myfixed->xoffset;
+       dy = myfixed->yoffset;
+    }
+
+    if (x) (*x) = m_x - dx;
+    if (y) (*y) = m_y - dy;

 }
 
 void wxWindow::DoClientToScreen( int *x, int *y ) const
 {
 }
 
 void wxWindow::DoClientToScreen( int *x, int *y ) const
 {

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

 
     if (!m_widget->window) return;
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
 
     if (!m_widget->window) return;
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)

-        source = m_wxwindow->window;
+        source = GTK_MYFIXED(m_wxwindow)->bin_window;

     else
         source = m_widget->window;
 
     else
         source = m_widget->window;
 


@@ -2422,13 +2421,13 @@ void wxWindow::DoClientToScreen( int *x, int *y ) const
 
 void wxWindow::DoScreenToClient( int *x, int *y ) const
 {
 
 void wxWindow::DoScreenToClient( int *x, int *y ) const
 {

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

 
     if (!m_widget->window) return;
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)
 
     if (!m_widget->window) return;
 
     GdkWindow *source = (GdkWindow *) NULL;
     if (m_wxwindow)

-        source = m_wxwindow->window;
+        source = GTK_MYFIXED(m_wxwindow)->bin_window;

     else
         source = m_widget->window;
 
     else
         source = m_widget->window;
 


@@ -2451,7 +2450,7 @@ void wxWindow::DoScreenToClient( int *x, int *y ) const
 
 bool wxWindow::Show( bool show )
 {
 
 bool wxWindow::Show( bool show )
 {

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

 
     if (!wxWindowBase::Show(show))
     {
 
     if (!wxWindowBase::Show(show))
     {


@@ -2469,7 +2468,7 @@ bool wxWindow::Show( bool show )
 
 bool wxWindow::Enable( bool enable )
 {
 
 bool wxWindow::Enable( bool enable )
 {

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

 
     if (!wxWindowBase::Enable(enable))
     {
 
     if (!wxWindowBase::Enable(enable))
     {


@@ -2486,9 +2485,9 @@ bool wxWindow::Enable( bool enable )
 
 int wxWindow::GetCharHeight() const
 {
 
 int wxWindow::GetCharHeight() const
 {

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

 
 

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

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


@@ -2497,9 +2496,9 @@ int wxWindow::GetCharHeight() const
 
 int wxWindow::GetCharWidth() const
 {
 
 int wxWindow::GetCharWidth() const
 {

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

 
 

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

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


@@ -2516,7 +2515,7 @@ void wxWindow::GetTextExtent( const wxString& string,
     wxFont fontToUse = m_font;
     if (theFont) fontToUse = *theFont;
 
     wxFont fontToUse = m_font;
     if (theFont) fontToUse = *theFont;
 

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

 
     GdkFont *font = fontToUse.GetInternalFont( 1.0 );
     if (x) (*x) = gdk_string_width( font, string.mbc_str() );
 
     GdkFont *font = fontToUse.GetInternalFont( 1.0 );
     if (x) (*x) = gdk_string_width( font, string.mbc_str() );


@@ -2527,7 +2526,7 @@ void wxWindow::GetTextExtent( const wxString& string,
 
 void wxWindow::SetFocus()
 {
 
 void wxWindow::SetFocus()
 {

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

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


@@ -2551,36 +2550,49 @@ bool wxWindow::AcceptsFocus() const
     return m_acceptsFocus && wxWindowBase::AcceptsFocus();
 }
 
     return m_acceptsFocus && wxWindowBase::AcceptsFocus();
 }
 

-bool wxWindow::Reparent( wxWindow *newParent )
+bool wxWindow::Reparent( wxWindowBase *newParentBase )

 {
 {

-    wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
+    wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
+
+    wxWindow *oldParent = m_parent,
+             *newParent = (wxWindow *)newParentBase;

 
 

-    wxWindow *oldParent = m_parent;
+    wxASSERT( GTK_IS_WIDGET(m_widget) );

 
     if ( !wxWindowBase::Reparent(newParent) )
         return FALSE;
 
 
     if ( !wxWindowBase::Reparent(newParent) )
         return FALSE;
 

+    wxASSERT( GTK_IS_WIDGET(m_widget) );
+
+    /* prevent GTK from deleting the widget arbitrarily */
+    gtk_widget_ref( m_widget );
+

     if (oldParent)
     {
         gtk_container_remove( GTK_CONTAINER(oldParent->m_wxwindow), m_widget );
     }
 
     if (oldParent)
     {
         gtk_container_remove( GTK_CONTAINER(oldParent->m_wxwindow), m_widget );
     }
 

+    wxASSERT( GTK_IS_WIDGET(m_widget) );
+

     if (newParent)
     {
         /* insert GTK representation */
         (*(newParent->m_insertCallback))(newParent, this);
     }
 
     if (newParent)
     {
         /* insert GTK representation */
         (*(newParent->m_insertCallback))(newParent, this);
     }
 

+    /* reverse: prevent GTK from deleting the widget arbitrarily */
+    gtk_widget_unref( m_widget );
+    

     return TRUE;
 }
 
 void wxWindow::DoAddChild(wxWindow *child)
 {
     return TRUE;
 }
 
 void wxWindow::DoAddChild(wxWindow *child)
 {

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

 
 

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

 
 

-    wxASSERT_MSG( (m_insertCallback != NULL), _T("invalid child insertion function") );
+    wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );

 
     /* add to list */
     AddChild( child );
 
     /* add to list */
     AddChild( child );


@@ -2591,7 +2603,7 @@ void wxWindow::DoAddChild(wxWindow *child)
 
 void wxWindow::Raise()
 {
 
 void wxWindow::Raise()
 {

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

 
     if (!m_widget->window) return;
 
 
     if (!m_widget->window) return;
 


@@ -2600,7 +2612,7 @@ void wxWindow::Raise()
 
 void wxWindow::Lower()
 {
 
 void wxWindow::Lower()
 {

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

 
     if (!m_widget->window) return;
 
 
     if (!m_widget->window) return;
 


@@ -2609,49 +2621,31 @@ void wxWindow::Lower()
 
 bool wxWindow::SetCursor( const wxCursor &cursor )
 {
 
 bool wxWindow::SetCursor( const wxCursor &cursor )
 {

-    wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
-
-    if (!wxWindowBase::SetCursor(cursor))
-    {
-        // don't leave if the GTK widget has just
-        // been realized
-        if (!m_delayedCursor) return FALSE;
-    }
-
-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window)
-    {
-        // indicate that a new style has been set
-        // but it couldn't get applied as the
-        // widget hasn't been realized yet.
-        m_delayedCursor = TRUE;
+    wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );

 
 

-        // pretend we have done something
-        return TRUE;
-    }
-
-//    gdk_window_set_cursor( connect_widget->window, GetCursor().GetCursor() );
-
-    // cursor was set
-    return TRUE;
+    return wxWindowBase::SetCursor( cursor );

 }
 
 void wxWindow::WarpPointer( int x, int y )
 {
 }
 
 void wxWindow::WarpPointer( int x, int y )
 {

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

 
 

-    GtkWidget *connect_widget = GetConnectWidget();
-    if (connect_widget->window)
-    {
-        /* we provide this function ourselves as it is
-           missing in GDK */
-        gdk_window_warp_pointer( connect_widget->window, x, y );
-    }
+    /* we provide this function ourselves as it is
+       missing in GDK (top of this file)  */
+    
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (window)
+        gdk_window_warp_pointer( window, x, y );

 }
 
 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
 {
 }
 
 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
 {

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

 
     if (!m_widget->window) return;
 
 
     if (!m_widget->window) return;
 


@@ -2659,41 +2653,66 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
     {
         if (rect)
         {
     {
         if (rect)
         {

-            gdk_window_clear_area( m_wxwindow->window,
+            gdk_window_clear_area( GTK_MYFIXED(m_wxwindow)->bin_window,

                                    rect->x, rect->y,
                                    rect->width, rect->height );
         }
         else
         {
                                    rect->x, rect->y,
                                    rect->width, rect->height );
         }
         else
         {

-            gdk_window_clear( m_wxwindow->window );
+            gdk_window_clear( GTK_MYFIXED(m_wxwindow)->bin_window );

         }
     }
 
     if (!rect)
     {
         if (m_wxwindow)
         }
     }
 
     if (!rect)
     {
         if (m_wxwindow)

-            gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
+       {
+           /* call the callback directly for preventing GTK from
+              clearing the background */
+           int w = 0;
+           int h = 0;
+           GetClientSize( &w, &h );
+           
+            GetUpdateRegion().Union( 0, 0, w, h );
+            wxPaintEvent event( GetId() );
+            event.SetEventObject( this );
+            GetEventHandler()->ProcessEvent( event );
+            GetUpdateRegion().Clear();
+       }

         else
         else

+       {

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

+       }

     }
     else
     {
     }
     else
     {

-        GdkRectangle gdk_rect;
-        gdk_rect.x = rect->x;
-        gdk_rect.y = rect->y;
-        gdk_rect.width = rect->width;
-        gdk_rect.height = rect->height;

 
         if (m_wxwindow)
 
         if (m_wxwindow)

-            gtk_widget_draw( m_wxwindow, &gdk_rect );
+       {
+           /* call the callback directly for preventing GTK from
+              clearing the background */
+            GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
+            wxPaintEvent event( GetId() );
+            event.SetEventObject( this );
+            GetEventHandler()->ProcessEvent( event );
+            GetUpdateRegion().Clear();
+       }

         else
         else

+       {
+            GdkRectangle gdk_rect;
+            gdk_rect.x = rect->x;
+            gdk_rect.y = rect->y;
+            gdk_rect.width = rect->width;
+            gdk_rect.height = rect->height;
+           

             gtk_widget_draw( m_widget, &gdk_rect );
             gtk_widget_draw( m_widget, &gdk_rect );

+       }

     }
 }
 
 void wxWindow::Clear()
 {
     }
 }
 
 void wxWindow::Clear()
 {

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

 
     if (!m_widget->window) return;
 
 
     if (!m_widget->window) return;
 


@@ -2720,7 +2739,7 @@ void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
 
 bool wxWindow::SetBackgroundColour( const wxColour &colour )
 {
 
 bool wxWindow::SetBackgroundColour( const wxColour &colour )
 {

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

 
     if (!wxWindowBase::SetBackgroundColour(colour))
     {
 
     if (!wxWindowBase::SetBackgroundColour(colour))
     {


@@ -2729,8 +2748,13 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
         if (!m_delayedBackgroundColour) return FALSE;
     }
 
         if (!m_delayedBackgroundColour) return FALSE;
     }
 

-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window)
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (!window)

     {
         // indicate that a new style has been set
         // but it couldn't get applied as the
     {
         // indicate that a new style has been set
         // but it couldn't get applied as the


@@ -2741,13 +2765,13 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
         return TRUE;
     }
 
         return TRUE;
     }
 

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

     {
         /* wxMSW doesn't clear the window here. I don't do that either to
           provide compatibility. call Clear() to do the job. */
 
     {
         /* wxMSW doesn't clear the window here. I don't do that either to
           provide compatibility. call Clear() to do the job. */
 

-        m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_wxwindow->window ) );
-        gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );
+        m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
+        gdk_window_set_background( window, m_backgroundColour.GetColor() );

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


@@ -2767,7 +2791,7 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
 
 bool wxWindow::SetForegroundColour( const wxColour &colour )
 {
 
 bool wxWindow::SetForegroundColour( const wxColour &colour )
 {

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

 
     if (!wxWindowBase::SetForegroundColour(colour))
     {
 
     if (!wxWindowBase::SetForegroundColour(colour))
     {


@@ -2776,8 +2800,13 @@ bool wxWindow::SetForegroundColour( const wxColour &colour )
         if (!m_delayedForegroundColour) return FALSE;
     }
 
         if (!m_delayedForegroundColour) return FALSE;
     }
 

-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window)
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (!window)

     {
         // indicate that a new style has been set
         // but it couldn't get applied as the
     {
         // indicate that a new style has been set
         // but it couldn't get applied as the


@@ -2883,9 +2912,9 @@ static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
 
 bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
 {
 
 bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
 {

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

 
 

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

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


@@ -2922,7 +2951,7 @@ bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
 
 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 {
 
 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 {

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

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


@@ -2946,13 +2975,15 @@ GtkWidget* wxWindow::GetConnectWidget()
 
 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 {
 
 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 {

-    if (m_wxwindow) return (window == m_wxwindow->window);
+    if (m_wxwindow) 
+        return (window == GTK_MYFIXED(m_wxwindow)->bin_window);
+    

     return (window == m_widget->window);
 }
 
 bool wxWindow::SetFont( const wxFont &font )
 {
     return (window == m_widget->window);
 }
 
 bool wxWindow::SetFont( const wxFont &font )
 {

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

 
     if (!wxWindowBase::SetFont(font))
     {
 
     if (!wxWindowBase::SetFont(font))
     {


@@ -2961,8 +2992,13 @@ bool wxWindow::SetFont( const wxFont &font )
         if (!m_delayedFont) return FALSE;
     }
 
         if (!m_delayedFont) return FALSE;
     }
 

-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window)
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (!window)

     {
         // indicate that a new style has been set
         // but it couldn't get applied as the
     {
         // indicate that a new style has been set
         // but it couldn't get applied as the


@@ -2990,17 +3026,23 @@ bool wxWindow::SetFont( const wxFont &font )
 
 void wxWindow::CaptureMouse()
 {
 
 void wxWindow::CaptureMouse()
 {

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

 
 

-    wxCHECK_RET( g_captureWindow == NULL, _T("CaptureMouse called twice") );
+    wxCHECK_RET( g_captureWindow == NULL, wxT("CaptureMouse called twice") );

 
 

-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window) return;
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (!window) return;

 
 

-    gdk_pointer_grab( connect_widget->window, FALSE,
+    gdk_pointer_grab( window, FALSE,

                       (GdkEventMask)
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
                       (GdkEventMask)
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |

+                          GDK_POINTER_MOTION_HINT_MASK | 

                           GDK_POINTER_MOTION_MASK),
                       (GdkWindow *) NULL,
                       m_cursor.GetCursor(),
                           GDK_POINTER_MOTION_MASK),
                       (GdkWindow *) NULL,
                       m_cursor.GetCursor(),


@@ -3010,12 +3052,17 @@ void wxWindow::CaptureMouse()
 
 void wxWindow::ReleaseMouse()
 {
 
 void wxWindow::ReleaseMouse()
 {

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

 
 

-    wxCHECK_RET( g_captureWindow, _T("ReleaseMouse called twice") );
+    wxCHECK_RET( g_captureWindow, wxT("ReleaseMouse called twice") );

 
 

-    GtkWidget *connect_widget = GetConnectWidget();
-    if (!connect_widget->window) return;
+    GdkWindow *window = (GdkWindow*) NULL;
+    if (m_wxwindow)
+        window = GTK_MYFIXED(m_wxwindow)->bin_window;
+    else
+        window = GetConnectWidget()->window;
+       
+    if (!window) return;

 
     gdk_pointer_ungrab ( GDK_CURRENT_TIME );
     g_captureWindow = (wxWindow*) NULL;
 
     gdk_pointer_ungrab ( GDK_CURRENT_TIME );
     g_captureWindow = (wxWindow*) NULL;


@@ -3029,9 +3076,9 @@ bool wxWindow::IsRetained() const
 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
       int range, bool refresh )
 {
 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
       int range, bool refresh )
 {

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

 
 

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

 
     m_hasScrolling = TRUE;
 
 
     m_hasScrolling = TRUE;
 


@@ -3092,9 +3139,9 @@ void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
 
 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
 {
 
 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
 {

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

 
 

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

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


@@ -3117,8 +3164,10 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
         m_vAdjust->value = fpos;
     }
 
         m_vAdjust->value = fpos;
     }
 

-    if (!m_isScrolling)  /* prevent recursion */
+/*
+    if (!m_isScrolling)

     {
     {

+*/

         if (m_wxwindow->window)
         {
             if (orient == wxHORIZONTAL)
         if (m_wxwindow->window)
         {
             if (orient == wxHORIZONTAL)


@@ -3126,14 +3175,16 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
             else
                 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
         }
             else
                 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
         }

+/*

     }
     }

+*/

 }
 
 int wxWindow::GetScrollThumb( int orient ) const
 {
 }
 
 int wxWindow::GetScrollThumb( int orient ) const
 {

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

 
 

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

 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->page_size+0.5);
 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->page_size+0.5);


@@ -3143,9 +3194,9 @@ int wxWindow::GetScrollThumb( int orient ) const
 
 int wxWindow::GetScrollPos( int orient ) const
 {
 
 int wxWindow::GetScrollPos( int orient ) const
 {

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

 
 

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

 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->value+0.5);
 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->value+0.5);


@@ -3155,9 +3206,9 @@ int wxWindow::GetScrollPos( int orient ) const
 
 int wxWindow::GetScrollRange( int orient ) const
 {
 
 int wxWindow::GetScrollRange( int orient ) const
 {

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

 
 

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

 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->upper+0.5);
 
     if (orient == wxHORIZONTAL)
         return (int)(m_hAdjust->upper+0.5);


@@ -3167,10 +3218,13 @@ int wxWindow::GetScrollRange( int orient ) const
 
 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 {
 
 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 {

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

 
 

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

 
 

+/*

     if (!m_scrollGC)
     {
         m_scrollGC = gdk_gc_new( m_wxwindow->window );
     if (!m_scrollGC)
     {
         m_scrollGC = gdk_gc_new( m_wxwindow->window );


@@ -3220,6 +3274,7 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 
         Refresh( TRUE, &rect );
     }
 
         Refresh( TRUE, &rect );
     }

+*/

 }
 
 void wxWindow::SetScrolling(bool scroll)
 }
 
 void wxWindow::SetScrolling(bool scroll)