X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/5e0201eaa1e299cb5c37246324464e6e2dce7584..d1b15f03b8e614c83541ca3487f847f61122b514:/src/gtk1/window.cpp

diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp
index dd4d3e4b9e..7e235b0c06 100644
--- a/src/gtk1/window.cpp
+++ b/src/gtk1/window.cpp
@@ -155,7 +155,7 @@ static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
         wxLog::AddTraceMask("focus");
         s_done = TRUE;
     }
-    wxLogTrace(_T("FOCUS NOW AT: %s"), name);
+    wxLogTrace(wxT("FOCUS NOW AT: %s"), name);
 */
 
     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;
-    tmp += _T(" FROM ");
+    tmp += wxT(" FROM ");
     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;
 
+//-----------------------------------------------------------------------------
+// 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
 //-----------------------------------------------------------------------------
@@ -564,108 +667,6 @@ static long map_to_wx_keysym( KeySym keysym )
     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;
-    }
-    
-    if (win->HasFlag(wxSIMPLE_BORDER))
-    {
-        GdkGC *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_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
 //-----------------------------------------------------------------------------
@@ -675,9 +676,6 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
     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,
@@ -686,10 +684,6 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
     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())
@@ -700,6 +694,10 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
                                 (int)gdk_event->area.height );
 */
 
+    wxPaintEvent event( win->GetId() );
+    event.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( event );
+
     win->GetUpdateRegion().Clear();
 }
 
@@ -707,7 +705,7 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
 // "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();
@@ -718,9 +716,6 @@ static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle
     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())
@@ -730,7 +725,9 @@ static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle
                                 (int)rect->width,
                                 (int)rect->height );
 */
-
+				
+    wxPaintEvent event( win->GetId() );
+    event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
 
     win->GetUpdateRegion().Clear();
@@ -974,10 +971,10 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
         wxapp_install_idle_handler();
 
 /*
-    wxPrintf( _T("1) OnButtonPress from ") );
+    wxPrintf( wxT("1) OnButtonPress from ") );
     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;
@@ -992,20 +989,20 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
             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() );
-            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() );
-    wxPrintf( _T(".\n") );
+    wxPrintf( wxT(".\n") );
 */
 
     wxEventType event_type = wxEVT_LEFT_DOWN;
@@ -1243,13 +1240,12 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
 
     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;
     }
 
 /*
@@ -1715,6 +1711,12 @@ gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
 
 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,
@@ -1764,6 +1766,8 @@ void wxWindow::Init()
     m_hasVMT = FALSE;
     m_needParent = TRUE;
     m_isBeingDeleted = FALSE;
+    
+    m_noExpose = FALSE;
 
     m_hasScrolling = FALSE;
     m_isScrolling = FALSE;
@@ -1774,7 +1778,6 @@ void wxWindow::Init()
     m_oldVerticalPos = 0.0;
 
     m_resizing = FALSE;
-    m_scrollGC = (GdkGC*) NULL;
     m_widgetStyle = (GtkStyle*) NULL;
 
     m_insertCallback = (wxInsertChildFunction) NULL;
@@ -1807,7 +1810,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     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;
     }
 
@@ -1817,14 +1820,14 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     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__
-    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 );
@@ -1838,7 +1841,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     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 );
@@ -1975,12 +1978,6 @@ wxWindow::~wxWindow()
         m_widgetStyle = (GtkStyle*) NULL;
     }
 
-    if (m_scrollGC)
-    {
-        gdk_gc_unref( m_scrollGC );
-        m_scrollGC = (GdkGC*) NULL;
-    }
-
     if (m_wxwindow)
     {
         gtk_widget_destroy( m_wxwindow );
@@ -1996,7 +1993,7 @@ wxWindow::~wxWindow()
 
 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
@@ -2028,19 +2025,22 @@ bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos,  const wxSize
 
 void wxWindow::PostCreation()
 {
-    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 
     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", "raised" or "simple" borders are drawn */
+        /* these are called when the "sunken" or "raised" borders are drawn */
         gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
           GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
 
@@ -2093,7 +2093,7 @@ void wxWindow::ConnectWidget( GtkWidget *widget )
 
 bool wxWindow::Destroy()
 {
-    wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+    wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
 
     m_hasVMT = FALSE;
 
@@ -2102,8 +2102,8 @@ bool wxWindow::Destroy()
 
 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;
@@ -2118,17 +2118,19 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
     }
     else
     {
+        GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
+	
         if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
         {
-            if (x != -1) m_x = x;
-            if (y != -1) m_y = y;
+            if (x != -1) m_x = x + myfixed->xoffset;
+            if (y != -1) m_y = y + myfixed->yoffset;
             if (width != -1) m_width = width;
             if (height != -1) m_height = height;
         }
         else
         {
-            m_x = x;
-            m_y = y;
+            m_x = x + myfixed->xoffset;
+            m_y = y + myfixed->yoffset;
             m_width = width;
             m_height = height;
         }
@@ -2158,27 +2160,6 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
             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,
@@ -2201,13 +2182,16 @@ void wxWindow::OnInternalIdle()
     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)
         {
-            GdkWindow *window = m_wxwindow->window;
+            GdkWindow *window = GTK_MYFIXED(m_wxwindow)->bin_window;
             if (window)
                 gdk_window_set_cursor( window, cursor.GetCursor() );
 
@@ -2234,7 +2218,7 @@ void wxWindow::OnInternalIdle()
 
 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;
@@ -2242,7 +2226,7 @@ void wxWindow::DoGetSize( int *width, int *height ) const
 
 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)
     {
@@ -2316,7 +2300,7 @@ void wxWindow::DoSetClientSize( int width, int height )
 
 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)
     {
@@ -2391,21 +2375,30 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
 
 void wxWindow::DoGetPosition( int *x, int *y ) const
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+    int dx = 0;
+    int dy = 0;
+    if (m_parent && m_parent->m_wxwindow)
+    {
+        GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
+	dx = myfixed->xoffset;
+	dy = myfixed->yoffset;
+    }
 
-    if (x) (*x) = m_x;
-    if (y) (*y) = m_y;
+    if (x) (*x) = m_x - dx;
+    if (y) (*y) = m_y - dy;
 }
 
 void wxWindow::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)
-        source = m_wxwindow->window;
+        source = GTK_MYFIXED(m_wxwindow)->bin_window;
     else
         source = m_widget->window;
 
@@ -2428,13 +2421,13 @@ void wxWindow::DoClientToScreen( 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)
-        source = m_wxwindow->window;
+        source = GTK_MYFIXED(m_wxwindow)->bin_window;
     else
         source = m_widget->window;
 
@@ -2457,7 +2450,7 @@ void wxWindow::DoScreenToClient( int *x, int *y ) const
 
 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))
     {
@@ -2475,7 +2468,7 @@ bool wxWindow::Show( bool show )
 
 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))
     {
@@ -2492,9 +2485,9 @@ bool wxWindow::Enable( bool enable )
 
 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 );
 
@@ -2503,9 +2496,9 @@ int wxWindow::GetCharHeight() 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 );
 
@@ -2522,7 +2515,7 @@ void wxWindow::GetTextExtent( const wxString& string,
     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() );
@@ -2533,7 +2526,7 @@ void wxWindow::GetTextExtent( const wxString& string,
 
 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)
@@ -2559,7 +2552,7 @@ bool wxWindow::AcceptsFocus() const
 
 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;
@@ -2595,11 +2588,11 @@ bool wxWindow::Reparent( wxWindowBase *newParentBase )
 
 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 );
@@ -2610,7 +2603,7 @@ void wxWindow::DoAddChild(wxWindow *child)
 
 void wxWindow::Raise()
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     if (!m_widget->window) return;
 
@@ -2619,7 +2612,7 @@ void wxWindow::Raise()
 
 void wxWindow::Lower()
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     if (!m_widget->window) return;
 
@@ -2628,27 +2621,31 @@ void wxWindow::Lower()
 
 bool wxWindow::SetCursor( const wxCursor &cursor )
 {
-    wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
+    wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
 
     return wxWindowBase::SetCursor( cursor );
 }
 
 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 )
 {
-    wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+    wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
     if (!m_widget->window) return;
 
@@ -2656,13 +2653,13 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *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
         {
-            gdk_window_clear( m_wxwindow->window );
+            gdk_window_clear( GTK_MYFIXED(m_wxwindow)->bin_window );
         }
     }
 
@@ -2671,16 +2668,16 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
         if (m_wxwindow)
 	{
 	    /* call the callback directly for preventing GTK from
-	       clearing the bakground */
+	       clearing the background */
 	    int w = 0;
 	    int h = 0;
 	    GetClientSize( &w, &h );
-            GdkRectangle gdk_rect;
-            gdk_rect.x = 0;
-            gdk_rect.y = 0;
-            gdk_rect.width = w;
-            gdk_rect.height = h;
-            gtk_window_draw_callback( m_wxwindow, &gdk_rect, this );
+	    
+            GetUpdateRegion().Union( 0, 0, w, h );
+            wxPaintEvent event( GetId() );
+            event.SetEventObject( this );
+            GetEventHandler()->ProcessEvent( event );
+            GetUpdateRegion().Clear();
 	}
         else
 	{
@@ -2689,20 +2686,25 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
     }
     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)
 	{
 	    /* call the callback directly for preventing GTK from
-	       clearing the bakground */
-            gtk_window_draw_callback( m_wxwindow, &gdk_rect, this );
+	       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
 	{
+            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 );
 	}
     }
@@ -2710,7 +2712,7 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
 
 void wxWindow::Clear()
 {
-    wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+    wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
     if (!m_widget->window) return;
 
@@ -2737,7 +2739,7 @@ void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
 
 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))
     {
@@ -2746,8 +2748,13 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
         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
@@ -2758,13 +2765,13 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
         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. */
 
-        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 );
@@ -2784,7 +2791,7 @@ bool wxWindow::SetBackgroundColour( 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))
     {
@@ -2793,8 +2800,13 @@ bool wxWindow::SetForegroundColour( const wxColour &colour )
         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
@@ -2900,9 +2912,9 @@ static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
 
 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 );
 
@@ -2939,7 +2951,7 @@ bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
 
 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();
 
@@ -2963,13 +2975,15 @@ GtkWidget* wxWindow::GetConnectWidget()
 
 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 )
 {
-    wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
+    wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
 
     if (!wxWindowBase::SetFont(font))
     {
@@ -2978,8 +2992,13 @@ bool wxWindow::SetFont( const wxFont &font )
         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
@@ -3007,17 +3026,23 @@ bool wxWindow::SetFont( const wxFont &font )
 
 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 |
+                          GDK_POINTER_MOTION_HINT_MASK | 
                           GDK_POINTER_MOTION_MASK),
                       (GdkWindow *) NULL,
                       m_cursor.GetCursor(),
@@ -3027,12 +3052,17 @@ void wxWindow::CaptureMouse()
 
 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;
@@ -3046,9 +3076,9 @@ bool wxWindow::IsRetained() const
 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;
 
@@ -3109,9 +3139,9 @@ void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
 
 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)
     {
@@ -3152,9 +3182,9 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
 
 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);
@@ -3164,9 +3194,9 @@ int wxWindow::GetScrollThumb( 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);
@@ -3176,9 +3206,9 @@ int wxWindow::GetScrollPos( 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);
@@ -3188,10 +3218,13 @@ int wxWindow::GetScrollRange( int orient ) const
 
 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 );
@@ -3241,6 +3274,7 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 
         Refresh( TRUE, &rect );
     }
+*/
 }
 
 void wxWindow::SetScrolling(bool scroll)