1. status bar can now be positioned on top (and anywhere, in fact)

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

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index 805201a26c6fc6ce9522d953aa3b5b88af599b60..30618833e4c5c7f1016c52318200a3918893ab05 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -208,6 +208,8 @@ extern bool g_mainThreadLocked;
 // debug
 //-----------------------------------------------------------------------------
 
 // debug
 //-----------------------------------------------------------------------------
 

+#define DISABLE_STYLE_IF_BROKEN_THEME 1
+

 #ifdef __WXDEBUG__
 
 #if wxUSE_THREADS
 #ifdef __WXDEBUG__
 
 #if wxUSE_THREADS


@@ -379,10 +381,13 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
 // "expose_event" of m_widget
 //-----------------------------------------------------------------------------
 
 // "expose_event" of m_widget
 //-----------------------------------------------------------------------------
 

-static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
+gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )

 {
 {

-    if (gdk_event->count > 0) return;
+    if (gdk_event->count > 0) return FALSE;
+    

     draw_frame( widget, win );
     draw_frame( widget, win );

+    
+    return TRUE;

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


@@ -608,15 +613,15 @@ static long map_to_wx_keysym( KeySym keysym )
 // "expose_event" of m_wxwindow
 //-----------------------------------------------------------------------------
 
 // "expose_event" of m_wxwindow
 //-----------------------------------------------------------------------------
 

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

 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 

-    if (!win->m_hasVMT)
-        return;
-
+    if (g_isIdle)
+        wxapp_install_idle_handler();
+        

 /*
 /*

-    if (win->GetName() == wxT("columntitles"))
+    if (win->GetName() == wxT("htmlWindow"))

     {
         wxPrintf( wxT("OnExpose from ") );
         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
     {
         wxPrintf( wxT("OnExpose from ") );
         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())


@@ -628,40 +633,95 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
     }
 */
                                 
     }
 */
                                 

-    win->GetUpdateRegion().Union( gdk_event->area.x,
-                                  gdk_event->area.y,
-                                  gdk_event->area.width,
-                                  gdk_event->area.height );
+    if (!win->m_queuedFullRedraw)
+    {

 
 

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

 
 

-    if (gdk_event->count > 0)
-        return;
+        if (gdk_event->count == 0)
+        {
+            wxEraseEvent eevent( win->GetId() );
+            eevent.SetEventObject( win );
+            win->GetEventHandler()->ProcessEvent(eevent);

 
 

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

 
 

-    wxPaintEvent event( win->GetId() );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+            win->GetUpdateRegion().Clear();
+        }
+    
+        /* The following code will result in all window-less widgets
+           being redrawn if the wxWindows class is given a chance to
+           paint *anything* because it will then be allowed to paint
+           over the window-less widgets */
+       
+        GtkPizza *pizza = GTK_PIZZA (widget);
+        
+        GList *children = pizza->children;
+        while (children)
+        {
+            GtkPizzaChild *child = (GtkPizzaChild*) children->data;
+            children = children->next;
+
+            GdkEventExpose child_event = *gdk_event;

 
 

-    win->GetUpdateRegion().Clear();
+            if (GTK_WIDGET_NO_WINDOW (child->widget) &&
+                GTK_WIDGET_DRAWABLE (child->widget) /* &&
+                gtk_widget_intersect (child->widget, &gdk_event->area, &child_event.area)*/ )
+            {
+                child_event.area.x = child->widget->allocation.x;
+                child_event.area.y = child->widget->allocation.y;
+                child_event.area.width = child->widget->allocation.width;
+                child_event.area.height = child->widget->allocation.height;
+                gtk_widget_event (child->widget, (GdkEvent*) &child_event);
+            }
+        }
+    }
+        
+    return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// "event" of m_wxwindow
+//-----------------------------------------------------------------------------
+
+/* GTK thinks it is clever and filters out a certain amount of "unneeded"
+   expose events. We need them, of course, so we override the main event
+   procedure in GtkWidget by giving our own handler for all system events.
+   There, we look for expose events ourselves whereas all other events are
+   handled normally. */
+
+gint gtk_window_event_event_callback( GtkWidget *widget, GdkEventExpose *event, wxWindow *win )
+{
+    if (event->type == GDK_EXPOSE)
+    {
+        gint ret = gtk_window_expose_callback( widget, event, win );
+        return ret;
+    }
+
+    return FALSE;

 }
 
 //-----------------------------------------------------------------------------
 // "draw" of m_wxwindow
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "draw" of m_wxwindow
 //-----------------------------------------------------------------------------
 

-static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget),
-                                      GdkRectangle *rect, wxWindow *win )
+/* This callback is a complete replacement of the gtk_pizza_draw() function,
+   which disabled. */
+
+static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )

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

-
+        

 /*
 /*

-    if ((win->GetName() == wxT("columntitles")) && (rect->x == 2))
+    if (win->GetName() == wxT("htmlWindow"))

     {
         wxPrintf( wxT("OnDraw from ") );
         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
     {
         wxPrintf( wxT("OnDraw from ") );
         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())


@@ -672,19 +732,48 @@ static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget),
                                          (int)rect->height );
     }
 */
                                          (int)rect->height );
     }
 */

-                                
-    win->GetUpdateRegion().Union( rect->x, rect->y,
-                                  rect->width, rect->height );
+   
+    GtkPizza *pizza = GTK_PIZZA (widget);
+        
+    if (!win->m_queuedFullRedraw)
+    {
+        if (!(GTK_WIDGET_APP_PAINTABLE (widget)) &&
+             (pizza->clear_on_draw))
+        {
+            gdk_window_clear_area( pizza->bin_window,
+                               rect->x, rect->y, rect->width, rect->height);
+        }
+    
+        win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );

 
 

-    wxEraseEvent eevent( win->GetId() );
-    eevent.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent(eevent);
+        win->m_clipPaintRegion = TRUE;
+    
+        wxEraseEvent eevent( win->GetId() );
+        eevent.SetEventObject( win );
+        win->GetEventHandler()->ProcessEvent(eevent);

 
 

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

 
 

-    win->GetUpdateRegion().Clear();
+        win->GetUpdateRegion().Clear();
+    
+        win->m_clipPaintRegion = FALSE;
+    
+    
+        GList *children = pizza->children;
+        while (children)
+        {
+            GtkPizzaChild *child = (GtkPizzaChild*) children->data;
+            children = children->next;
+
+            GdkRectangle child_area;
+            if (gtk_widget_intersect (child->widget, rect, &child_area))
+            {
+                gtk_widget_draw (child->widget, &child_area /* (GdkRectangle*) NULL*/ );
+            }
+        }
+    }

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


@@ -1637,6 +1726,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
     if (g_isIdle)
         wxapp_install_idle_handler();
 
     if (g_isIdle)
         wxapp_install_idle_handler();
 

+

     g_blockEventsOnScroll = TRUE;
     win->m_isScrolling = (gdk_event->window == widget->slider);
 
     g_blockEventsOnScroll = TRUE;
     win->m_isScrolling = (gdk_event->window == widget->slider);
 


@@ -1662,7 +1752,7 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
 
     if (win->m_isScrolling)
     {
 
     if (win->m_isScrolling)
     {

-        wxEventType command = wxEVT_SCROLL_THUMBRELEASE;
+        wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;

         int value = -1;
         int dir = -1;
 
         int value = -1;
         int dir = -1;
 


@@ -1833,8 +1923,8 @@ gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
     if ((colormap = gtk_widget_get_colormap (widget)) !=
            gtk_widget_get_default_colormap ())
     {
     if ((colormap = gtk_widget_get_colormap (widget)) !=
            gtk_widget_get_default_colormap ())
     {

-       attrmask |= GDK_IC_PREEDIT_COLORMAP;
-       attr->preedit_colormap = colormap;
+           attrmask |= GDK_IC_PREEDIT_COLORMAP;
+           attr->preedit_colormap = colormap;

     }
 
     attrmask |= GDK_IC_PREEDIT_FOREGROUND;
     }
 
     attrmask |= GDK_IC_PREEDIT_FOREGROUND;


@@ -1966,6 +2056,9 @@ void wxWindow::Init()
     m_isFrame = FALSE;
     m_acceptsFocus = FALSE;
 
     m_isFrame = FALSE;
     m_acceptsFocus = FALSE;
 

+    m_clipPaintRegion = FALSE;
+    m_queuedFullRedraw = FALSE;
+

     m_cursor = *wxSTANDARD_CURSOR;
 
 #ifdef HAVE_XIM
     m_cursor = *wxSTANDARD_CURSOR;
 
 #ifdef HAVE_XIM


@@ -2000,21 +2093,12 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     }
 
     m_insertCallback = wxInsertChildInWindow;
     }
 
     m_insertCallback = wxInsertChildInWindow;

-
+    

     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 

-#ifdef __WXDEBUG__
-    debug_focus_in( m_widget, wxT("wxWindow::m_widget"), name );
-#endif
-

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

-#ifdef __WXDEBUG__
-    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 );
     scroll_class->scrollbar_spacing = 0;
 
     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
     scroll_class->scrollbar_spacing = 0;
 


@@ -2025,10 +2109,6 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
     m_wxwindow = gtk_pizza_new();
 
 
     m_wxwindow = gtk_pizza_new();
 

-#ifdef __WXDEBUG__
-    debug_focus_in( m_wxwindow, wxT("wxWindow::m_wxwindow"), name );
-#endif
-

     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
 
 #if (GTK_MINOR_VERSION > 0)
     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
 
 #if (GTK_MINOR_VERSION > 0)


@@ -2151,10 +2231,11 @@ wxWindow::~wxWindow()
 
     if (m_widgetStyle)
     {
 
     if (m_widgetStyle)
     {

+#if DISABLE_STYLE_IF_BROKEN_THEME

         // don't delete if it's a pixmap theme style
         if (!m_widgetStyle->engine_data)
             gtk_style_unref( m_widgetStyle );
         // don't delete if it's a pixmap theme style
         if (!m_widgetStyle->engine_data)
             gtk_style_unref( m_widgetStyle );

-            
+#endif            

         m_widgetStyle = (GtkStyle*) NULL;
     }
 
         m_widgetStyle = (GtkStyle*) NULL;
     }
 


@@ -2212,6 +2293,12 @@ void wxWindow::PostCreation()
         if (!m_noExpose)
         {
             /* these get reported to wxWindows -> wxPaintEvent */
         if (!m_noExpose)
         {
             /* these get reported to wxWindows -> wxPaintEvent */

+            
+            gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
+
+            gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
+                GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
+

             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), "expose_event",
                 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
 


@@ -2311,6 +2398,24 @@ bool wxWindow::Destroy()
 
 void wxWindow::DoMoveWindow(int x, int y, int width, int height)
 {
 
 void wxWindow::DoMoveWindow(int x, int y, int width, int height)
 {

+    if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
+    {
+        /* Normally, GTK will send expose events only for the regions
+           which actually got exposed. Sadly, wxMSW invalidates
+           the whole window so we have to do that, too. We could
+           simply add a complete refresh, but we would then get
+           the normal GTK expose events in surplus, so we shut
+           off the expose events and schedule a full redraw to
+           be done in OnInternalIdle, where we restore the handling
+           of expose events. */
+    
+        m_queuedFullRedraw = TRUE;
+        
+        GdkEventMask mask = gdk_window_get_events( GTK_PIZZA(m_wxwindow)->bin_window );
+        mask = (GdkEventMask)(mask & ~GDK_EXPOSURE_MASK);
+        gdk_window_set_events( GTK_PIZZA(m_wxwindow)->bin_window, mask );
+    }
+

     gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
 }
 
     gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
 }
 


@@ -2321,7 +2426,7 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 
     if (m_resizing) return; /* I don't like recursions */
     m_resizing = TRUE;
 
     if (m_resizing) return; /* I don't like recursions */
     m_resizing = TRUE;

-
+    

     if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
     {
         /* don't set the size for children of wxNotebook, just take the values. */
     if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
     {
         /* don't set the size for children of wxNotebook, just take the values. */


@@ -2382,6 +2487,12 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 
     if (m_hasScrolling)
     {
 
     if (m_hasScrolling)
     {

+        /* Sometimes the client area changes size without the 
+           whole windows's size changing, but if the whole
+           windows's size doesn't change, no wxSizeEvent will
+           normally be sent. Here we add an extra test if
+           the client test has been changed and this will
+           be used then. */

         GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
     }
 
         GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
     }
 


@@ -2452,6 +2563,27 @@ void wxWindow::OnInternalIdle()
     }
 
     UpdateWindowUI();
     }
 
     UpdateWindowUI();

+    
+    if (m_queuedFullRedraw)
+    {
+        /* See also wxWindow::DoMoveWindow for explanation of this code. What
+           we test here is if the requested size of the window is the same as 
+           the actual size of window, in which case all expose events that resulted
+           from resizing the window have been sent (and discarded) and we can
+           now do our full redraw and switch on expose event handling again. */
+           
+        if ((m_width == m_widget->allocation.width) && (m_height == m_widget->allocation.height))
+        {
+            m_queuedFullRedraw = FALSE;
+            m_updateRegion.Clear();
+            m_updateRegion.Union( 0,0,m_width,m_height );
+            gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
+
+            GdkEventMask mask = gdk_window_get_events( GTK_PIZZA(m_wxwindow)->bin_window );
+            mask = (GdkEventMask)(mask | GDK_EXPOSURE_MASK);
+            gdk_window_set_events( GTK_PIZZA(m_wxwindow)->bin_window, mask );
+        }
+    }

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


@@ -2889,37 +3021,65 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
     {
         if (m_wxwindow)
         {
     {
         if (m_wxwindow)
         {

+
+/*

             GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
             gboolean old_clear = pizza->clear_on_draw;
             gtk_pizza_set_clear( pizza, FALSE );
             GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
             gboolean old_clear = pizza->clear_on_draw;
             gtk_pizza_set_clear( pizza, FALSE );

-

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

-

             gtk_pizza_set_clear( pizza, old_clear );
             gtk_pizza_set_clear( pizza, old_clear );

+*/
+            GdkEventExpose gdk_event;
+            gdk_event.count = 0;
+            gdk_event.area.x = 0;
+            gdk_event.area.y = 0;
+            gdk_event.area.width = m_wxwindow->allocation.width;
+            gdk_event.area.height = m_wxwindow->allocation.height;
+            gtk_window_expose_callback( m_wxwindow, &gdk_event, this );
+

         }
         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)
         {

+/*

             GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
             gboolean old_clear = pizza->clear_on_draw;
             gtk_pizza_set_clear( pizza, FALSE );
 
             GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
             gboolean old_clear = pizza->clear_on_draw;
             gtk_pizza_set_clear( pizza, FALSE );
 

+            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_wxwindow, &gdk_rect );
             gtk_widget_draw( m_wxwindow, &gdk_rect );

+            gtk_window_draw_callback( m_wxwindow, &gdk_rect, this );

 
             gtk_pizza_set_clear( pizza, old_clear );
 
             gtk_pizza_set_clear( pizza, old_clear );

+*/
+            GdkEventExpose gdk_event;
+            gdk_event.count = 0;
+            gdk_event.area.x = rect->x;
+            gdk_event.area.y = rect->y;
+            gdk_event.area.width = rect->width;
+            gdk_event.area.height = rect->height;
+            gtk_window_expose_callback( m_wxwindow, &gdk_event, this );

         }
         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 );

+        }

     }
 }
 
     }
 }
 


@@ -3047,6 +3207,7 @@ GtkStyle *wxWindow::GetWidgetStyle()
 
 void wxWindow::SetWidgetStyle()
 {
 
 void wxWindow::SetWidgetStyle()
 {

+#if DISABLE_STYLE_IF_BROKEN_THEM

     if (m_widget->style->engine_data)
     {
         static bool s_warningPrinted = FALSE;
     if (m_widget->style->engine_data)
     {
         static bool s_warningPrinted = FALSE;


@@ -3058,6 +3219,7 @@ void wxWindow::SetWidgetStyle()
         m_widgetStyle = m_widget->style;
         return;
     }
         m_widgetStyle = m_widget->style;
         return;
     }

+#endif

 
     GtkStyle *style = GetWidgetStyle();
 
 
     GtkStyle *style = GetWidgetStyle();
 


@@ -3438,6 +3600,62 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
     wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
 
     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );

+    
+    if ((dx == 0) && (dy == 0)) return;

 
 

+    m_clipPaintRegion = TRUE;

     gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
     gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );

+    m_clipPaintRegion = FALSE;
+    
+/*    
+    if (m_children.GetCount() > 0)
+    {
+        gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
+    }
+    else
+    {
+        GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
+    
+        pizza->xoffset -= dx;
+        pizza->yoffset -= dy;
+        
+        GdkGC *m_scrollGC = gdk_gc_new( pizza->bin_window );
+        gdk_gc_set_exposures( m_scrollGC, TRUE );
+
+        int cw = 0;
+        int ch = 0;
+        GetClientSize( &cw, &ch );
+        int w = cw - abs(dx);
+        int h = ch - abs(dy);
+
+        if ((h < 0) || (w < 0))
+        {
+            Refresh();
+        } 
+        else
+        {
+            int s_x = 0;
+            int s_y = 0;
+            if (dx < 0) s_x = -dx;
+            if (dy < 0) s_y = -dy;
+            int d_x = 0;
+            int d_y = 0;
+            if (dx > 0) d_x = dx;
+            if (dy > 0) d_y = dy;
+
+            gdk_window_copy_area( pizza->bin_window, m_scrollGC, d_x, d_y,
+                pizza->bin_window, s_x, s_y, w, h );
+
+            wxRect rect;
+            if (dx < 0) rect.x = cw+dx; else rect.x = 0;
+            if (dy < 0) rect.y = ch+dy; else rect.y = 0;
+            if (dy != 0) rect.width = cw; else rect.width = abs(dx);
+            if (dx != 0) rect.height = ch; else rect.height = abs(dy);
+
+            Refresh( TRUE, &rect );
+        }
+        
+        gdk_gc_unref( m_scrollGC );
+    }
+*/

 }
 }