Compile fix when not using WXR resources.

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

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index 748fa87aa0f849864fba8defe5241c298996cac6..38b3a20847411bd3d23381b98a33d79d77099177 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -54,8 +54,7 @@
 
 #include <math.h>
 
 
 #include <math.h>
 

-#include <gdk/gdk.h>
-#include <gtk/gtk.h>
+#include "wx/gtk/private.h"

 #include <gdk/gdkprivate.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 #include <gdk/gdkprivate.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>


@@ -65,6 +64,22 @@
 
 #include "wx/gtk/win_gtk.h"
 
 
 #include "wx/gtk/win_gtk.h"
 

+#ifdef __WXGTK20__
+    #define SET_CONTAINER_FOCUS(w, d) gtk_widget_child_focus((w), (d))
+#else
+    #define SET_CONTAINER_FOCUS(w, d) gtk_container_focus(GTK_CONTAINER(w), (d))
+#endif
+
+#ifdef __WXGTK20__
+    #ifdef HAVE_XIM
+        #undef HAVE_XIM
+    #endif
+#endif
+
+#ifdef __WXGTK20__
+extern GtkContainerClass *pizza_parent_class;
+#endif
+

 //-----------------------------------------------------------------------------
 // documentation on internals
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // documentation on internals
 //-----------------------------------------------------------------------------


@@ -204,6 +219,8 @@ extern bool       g_blockEventsOnDrag;
 extern bool       g_blockEventsOnScroll;
 extern wxCursor   g_globalCursor;
 
 extern bool       g_blockEventsOnScroll;
 extern wxCursor   g_globalCursor;
 

+static GdkGC *g_eraseGC = NULL;
+

 // mouse capture state: the window which has it and if the mouse is currently
 // inside it
 static wxWindowGTK  *g_captureWindow = (wxWindowGTK*) NULL;
 // mouse capture state: the window which has it and if the mouse is currently
 // inside it
 static wxWindowGTK  *g_captureWindow = (wxWindowGTK*) NULL;


@@ -372,7 +389,6 @@ static wxWindowGTK* wxGetTopLevelParent(wxWindowGTK *win)
     return p;
 }
 
     return p;
 }
 

-

 static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
 {
     // wxUniversal widgets draw the borders and scrollbars themselves
 static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
 {
     // wxUniversal widgets draw the borders and scrollbars themselves


@@ -468,6 +484,11 @@ gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_even
 
     draw_frame( widget, win );
 
 
     draw_frame( widget, win );
 

+#ifdef __WXGTK20__
+
+    (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
+    
+#endif    

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -475,11 +496,15 @@ gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_even
 // "draw" of m_widget
 //-----------------------------------------------------------------------------
 
 // "draw" of m_widget
 //-----------------------------------------------------------------------------
 

+#ifndef __WXGTK20__
+

 static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )
 {
     draw_frame( widget, win );
 }
 
 static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )
 {
     draw_frame( widget, win );
 }
 

+#endif
+

 //-----------------------------------------------------------------------------
 // key code mapping routines
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // key code mapping routines
 //-----------------------------------------------------------------------------


@@ -775,6 +800,7 @@ static int gtk_window_expose_callback( GtkWidget *widget,
     }
 */
 
     }
 */
 

+#ifndef __WXUNIVERSAL__

     GtkPizza *pizza = GTK_PIZZA (widget);
 
     if (win->GetThemeEnabled())
     GtkPizza *pizza = GTK_PIZZA (widget);
 
     if (win->GetThemeEnabled())


@@ -794,16 +820,21 @@ static int gtk_window_expose_callback( GtkWidget *widget,
                             (char *)"base",
                             0, 0, -1, -1);
     }
                             (char *)"base",
                             0, 0, -1, -1);
     }

+#endif

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

-    // Actually send the various events based on the
-    // current update region.
-    if (gdk_event->count == 0)
-        win->GtkSendPaintEvents();
+    // Actual redrawing takes place in idle time.
+    win->Update();
+    
+#ifdef __WXGTK20__
+
+    (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
+    
+#endif    

 
     return TRUE;
 }
 
     return TRUE;
 }


@@ -835,8 +866,10 @@ gint gtk_window_event_event_callback( GtkWidget *widget,
 // "draw" of m_wxwindow
 //-----------------------------------------------------------------------------
 
 // "draw" of m_wxwindow
 //-----------------------------------------------------------------------------
 

+#ifndef __WXGTK20__
+

 // This callback is a complete replacement of the gtk_pizza_draw() function,
 // This callback is a complete replacement of the gtk_pizza_draw() function,

-// which disabled.
+// which is disabled.

 
 static void gtk_window_draw_callback( GtkWidget *widget,
                                       GdkRectangle *rect,
 
 static void gtk_window_draw_callback( GtkWidget *widget,
                                       GdkRectangle *rect,


@@ -868,6 +901,7 @@ static void gtk_window_draw_callback( GtkWidget *widget,
     }
 */
 
     }
 */
 

+#ifndef __WXUNIVERSAL__

     GtkPizza *pizza = GTK_PIZZA (widget);
 
     if (win->GetThemeEnabled())
     GtkPizza *pizza = GTK_PIZZA (widget);
 
     if (win->GetThemeEnabled())


@@ -895,13 +929,15 @@ static void gtk_window_draw_callback( GtkWidget *widget,
         gdk_window_clear_area( pizza->bin_window,
                                rect->x, rect->y, rect->width, rect->height);
     }
         gdk_window_clear_area( pizza->bin_window,
                                rect->x, rect->y, rect->width, rect->height);
     }

+#endif

 
     win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
 
 
     win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
 

-    // Actually send the various events based on the
-    // current update region.
-    win->GtkSendPaintEvents();
+    // Actual redrawing takes place in idle time.
+    
+    win->Update();

 
 

+#ifndef __WXUNIVERSAL__

     // Redraw child widgets
     GList *children = pizza->children;
     while (children)
     // Redraw child widgets
     GList *children = pizza->children;
     while (children)


@@ -915,8 +951,11 @@ static void gtk_window_draw_callback( GtkWidget *widget,
             gtk_widget_draw (child->widget, &child_area /* (GdkRectangle*) NULL*/ );
         }
     }
             gtk_widget_draw (child->widget, &child_area /* (GdkRectangle*) NULL*/ );
         }
     }

+#endif

 }
 
 }
 

+#endif
+

 //-----------------------------------------------------------------------------
 // "key_press_event" from any window
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // "key_press_event" from any window
 //-----------------------------------------------------------------------------


@@ -1208,20 +1247,15 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
 
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 
 
     if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
 

-    if (win->m_wxwindow)
+    if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus())

     {
     {

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

 /*
 /*

-            wxPrintf( wxT("GrabFocus from ") );
-            if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-                wxPrintf( win->GetClassInfo()->GetClassName() );
-            wxPrintf( wxT(".\n") );
+        wxPrintf( wxT("GrabFocus from ") );
+        if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+            wxPrintf( win->GetClassInfo()->GetClassName() );
+        wxPrintf( wxT(".\n") );

 */
 */

-
-        }

     }
 
     wxEventType event_type = wxEVT_NULL;
     }
 
     wxEventType event_type = wxEVT_NULL;


@@ -1644,10 +1678,7 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget,
     g_focusWindow = win;
 
 #if 0
     g_focusWindow = win;
 
 #if 0

-    wxPrintf( "OnSetFocus from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        wxPrintf( win->GetClassInfo()->GetClassName() );
-    wxPrintf( ".\n" );
+    wxLogDebug( wxT("OnSetFocus from %s\n"), win->GetName().c_str() );

 #endif
 
     // notify the parent keeping track of focus for the kbd navigation
 #endif
 
     // notify the parent keeping track of focus for the kbd navigation


@@ -1706,9 +1737,7 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget,
 // "focus_out_event"
 //-----------------------------------------------------------------------------
 
 // "focus_out_event"
 //-----------------------------------------------------------------------------
 

-static GtkWidget *gs_widgetLastFocus = NULL;
-
-static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindowGTK *win )
+static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )

 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 


@@ -1718,17 +1747,9 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 
     if (!win->m_hasVMT) return FALSE;
     if (g_blockEventsOnDrag) return FALSE;
 

-    // VZ: this is really weird but GTK+ seems to call us from inside
-    //     gtk_widget_grab_focus(), i.e. it first sends "focus_out" signal to
-    //     this widget and then "focus_in". This is totally unexpected and
-    //     completely breaks wxUniv code so ignore this dummy event (we can't
-    //     be losing focus if we're about to acquire it!)
-    if ( widget == gs_widgetLastFocus )
-    {
-        gs_widgetLastFocus = NULL;
-
-        return FALSE;
-    }
+#if 0
+    wxLogDebug( wxT("OnKillFocus from %s"), win->GetName().c_str() );
+#endif

 
     if ( !g_activeFrameLostFocus && g_activeFrame )
     {
 
     if ( !g_activeFrameLostFocus && g_activeFrame )
     {


@@ -1754,13 +1775,6 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
 
     g_focusWindow = (wxWindowGTK *)NULL;
 
 
     g_focusWindow = (wxWindowGTK *)NULL;
 

-#if 0
-    wxPrintf( "OnKillFocus from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        wxPrintf( win->GetClassInfo()->GetClassName() );
-    wxPrintf( ".\n" );
-#endif
-

 #ifdef HAVE_XIM
     if (win->m_ic)
         gdk_im_end();
 #ifdef HAVE_XIM
     if (win->m_ic)
         gdk_im_end();


@@ -1878,7 +1892,9 @@ 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( GtkAdjustment *adjust, wxWindowGTK *win )
+static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
+                                         SCROLLBAR_CBACK_ARG
+                                         wxWindowGTK *win )

 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 


@@ -1894,14 +1910,7 @@ static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win
 
     win->m_oldVerticalPos = adjust->value;
 
 
     win->m_oldVerticalPos = adjust->value;
 

-    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;
+    wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(win->m_widget));

 
     int value = (int)(adjust->value+0.5);
 
 
     int value = (int)(adjust->value+0.5);
 


@@ -1914,7 +1923,9 @@ static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win
 // "value_changed" from m_hAdjust
 //-----------------------------------------------------------------------------
 
 // "value_changed" from m_hAdjust
 //-----------------------------------------------------------------------------
 

-static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win )
+static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
+                                         SCROLLBAR_CBACK_ARG
+                                         wxWindowGTK *win )

 {
     DEBUG_MAIN_THREAD
 
 {
     DEBUG_MAIN_THREAD
 


@@ -1927,16 +1938,9 @@ static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win
     float diff = adjust->value - win->m_oldHorizontalPos;
     if (fabs(diff) < 0.2) return;
 
     float diff = adjust->value - win->m_oldHorizontalPos;
     if (fabs(diff) < 0.2) return;
 

-    win->m_oldHorizontalPos = adjust->value;
-
-    GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
-    GtkRange *range = GTK_RANGE( scrolledWindow->hscrollbar );
+    wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(win->m_widget));

 
 

-    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;
+    win->m_oldHorizontalPos = adjust->value;

 
     int value = (int)(adjust->value+0.5);
 
 
     int value = (int)(adjust->value+0.5);
 


@@ -1960,7 +1964,11 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
 
 
     g_blockEventsOnScroll = TRUE;
 
 
     g_blockEventsOnScroll = TRUE;

+
+    // FIXME: there is no 'slider' field in GTK+ 2.0 any more
+#ifndef __WXGTK20__

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

+#endif

 
     return FALSE;
 }
 
     return FALSE;
 }


@@ -2358,11 +2366,8 @@ bool wxWindowGTK::Create( wxWindow *parent,
     m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
 
     m_wxwindow = gtk_pizza_new();
     m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
 
     m_wxwindow = gtk_pizza_new();

-
-    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
-
+    

 #ifndef __WXUNIVERSAL__
 #ifndef __WXUNIVERSAL__

-#if (GTK_MINOR_VERSION > 0)

     GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
 
     if (HasFlag(wxRAISED_BORDER))
     GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
 
     if (HasFlag(wxRAISED_BORDER))


@@ -2381,33 +2386,13 @@ bool wxWindowGTK::Create( wxWindow *parent,
     {
         gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
     }
     {
         gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
     }

-#else // GTK_MINOR_VERSION == 0
-    GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
-
-    if (HasFlag(wxRAISED_BORDER))
-    {
-        gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
-    }
-    else if (HasFlag(wxSUNKEN_BORDER))
-    {
-        gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
-    }
-    else
-    {
-        gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
-    }
-#endif // GTK_MINOR_VERSION

 #endif // __WXUNIVERSAL__
 
 #endif // __WXUNIVERSAL__
 

+    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
+

     GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
     m_acceptsFocus = TRUE;
 
     GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
     m_acceptsFocus = TRUE;
 

-#if (GTK_MINOR_VERSION == 0)
-    // shut the viewport up
-    gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
-    gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
-#endif // GTK_MINOR_VERSION == 0
-

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


@@ -2559,22 +2544,28 @@ void wxWindowGTK::PostCreation()
             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 );
 

+#ifndef __WXGTK20__

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

-
+                

             if (HasFlag(wxNO_FULL_REPAINT_ON_RESIZE))
             {
                 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
                     GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
             }
             if (HasFlag(wxNO_FULL_REPAINT_ON_RESIZE))
             {
                 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
                     GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
             }

+#else
+            gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ) );
+#endif

         }
 
         }
 

-        // these are called when the "sunken" or "raised" 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 );
 
         gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
           GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
 

+#ifndef __WXGTK20__

         gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
           GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
         gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
           GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );

+#endif

     }
 
     // focus handling
     }
 
     // focus handling


@@ -2582,12 +2573,6 @@ void wxWindowGTK::PostCreation()
     if (m_focusWidget == NULL)
         m_focusWidget = m_widget;
 
     if (m_focusWidget == NULL)
         m_focusWidget = m_widget;
 

-#if 0
-    if (GetClassInfo() && GetClassInfo()->GetClassName())
-        wxPrintf( GetClassInfo()->GetClassName() );
-    wxPrintf( ".\n" );
-#endif
-

     gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
         GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
 
     gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
         GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
 


@@ -2703,7 +2688,6 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
     else
     {
         GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
     else
     {
         GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);

-

         if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
         {
             if (x != -1) m_x = x + pizza->xoffset;
         if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
         {
             if (x != -1) m_x = x + pizza->xoffset;


@@ -2729,20 +2713,27 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
              if (height == -1) m_height = 26;
         }
 
              if (height == -1) m_height = 26;
         }
 

-        if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
-        if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
-        if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
-        if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
+        int minWidth = GetMinWidth(),
+            minHeight = GetMinHeight(),
+            maxWidth = GetMaxWidth(),
+            maxHeight = GetMaxHeight();
+
+        if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
+        if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
+        if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
+        if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;

 
         int border = 0;
         int bottom_border = 0;
 
 
         int border = 0;
         int bottom_border = 0;
 

+#ifndef __WXGTK20__

         if (GTK_WIDGET_CAN_DEFAULT(m_widget))
         {
             /* the default button has a border around it */
             border = 6;
             bottom_border = 5;
         }
         if (GTK_WIDGET_CAN_DEFAULT(m_widget))
         {
             /* the default button has a border around it */
             border = 6;
             bottom_border = 5;
         }

+#endif

 
         DoMoveWindow( m_x-border,
                       m_y-border,
 
         DoMoveWindow( m_x-border,
                       m_y-border,


@@ -3172,8 +3163,6 @@ void wxWindowGTK::SetFocus()
     {
         if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
         {
     {
         if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
         {

-            // see comment in gtk_window_focus_out_callback()
-            gs_widgetLastFocus = m_wxwindow;

             gtk_widget_grab_focus (m_wxwindow);
         }
     }
             gtk_widget_grab_focus (m_wxwindow);
         }
     }


@@ -3185,21 +3174,13 @@ void wxWindowGTK::SetFocus()
         }
         else if (GTK_IS_CONTAINER(m_widget))
         {
         }
         else if (GTK_IS_CONTAINER(m_widget))
         {

-            gtk_container_focus( GTK_CONTAINER(m_widget), GTK_DIR_TAB_FORWARD );
+            SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD );

         }
         else
         {
            // ?
         }
     }
         }
         else
         {
            // ?
         }
     }

-
-#if 0
-    wxPrintf( "SetFocus finished in " );
-    if (GetClassInfo() && GetClassInfo()->GetClassName())
-        wxPrintf( GetClassInfo()->GetClassName() );
-    wxPrintf( ".\n" );
-#endif
-

 }
 
 bool wxWindowGTK::AcceptsFocus() const
 }
 
 bool wxWindowGTK::AcceptsFocus() const


@@ -3314,12 +3295,7 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
     if (!m_widget) return;
     if (!m_widget->window) return;
 
     if (!m_widget) return;
     if (!m_widget->window) return;
 

-    // temporarily hide the caret to avoid nasty interactions between caret
-    // drawing and the window contents redraw
-#if 0 // def wxUSE_CARET -- doesn't seem to help :-(
-    wxCaretSuspend cs((wxWindow *)this);
-#endif // wxUSE_CARET
-
+#ifndef __WXGTK20__

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


@@ -3365,14 +3341,35 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
         }
     }
             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
         }
     }

+#else
+    if (m_wxwindow)
+    {
+        if (rect)
+        {
+            GdkRectangle gdk_rect;
+            gdk_rect.x = rect->x;
+            gdk_rect.y = rect->y;
+            gdk_rect.width = rect->width;
+            gdk_rect.height = rect->height;
+            gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE );
+        }
+        else
+        {
+            gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE );
+        }
+    }
+#endif

 }
 
 void wxWindowGTK::Update()
 {
 }
 
 void wxWindowGTK::Update()
 {

+#ifdef __WXGTK20__
+    if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
+        gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
+#endif
+

     if (!m_updateRegion.IsEmpty())
     if (!m_updateRegion.IsEmpty())

-    {

         GtkSendPaintEvents();
         GtkSendPaintEvents();

-    }

 }
 
 void wxWindowGTK::GtkSendPaintEvents()
 }
 
 void wxWindowGTK::GtkSendPaintEvents()


@@ -3386,7 +3383,7 @@ void wxWindowGTK::GtkSendPaintEvents()
 
     m_clipPaintRegion = TRUE;
 
 
     m_clipPaintRegion = TRUE;
 

-    if (!m_clearRegion.IsEmpty())
+    // if (!m_clearRegion.IsEmpty())   // always send an erase event

     {
         wxWindowDC dc( (wxWindow*)this );
         dc.SetClippingRegion( m_clearRegion );
     {
         wxWindowDC dc( (wxWindow*)this );
         dc.SetClippingRegion( m_clearRegion );


@@ -3396,10 +3393,12 @@ void wxWindowGTK::GtkSendPaintEvents()
     
         if (!GetEventHandler()->ProcessEvent(erase_event))
         {
     
         if (!GetEventHandler()->ProcessEvent(erase_event))
         {

+            gdk_gc_set_foreground( g_eraseGC, m_backgroundColour.GetColor() );
+        

             wxRegionIterator upd( m_clearRegion );
             while (upd)
             {
             wxRegionIterator upd( m_clearRegion );
             while (upd)
             {

-                gdk_window_clear_area( GTK_PIZZA(m_wxwindow)->bin_window,
+                gdk_draw_rectangle( GTK_PIZZA(m_wxwindow)->bin_window, g_eraseGC, 0,

                                        upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
                 upd ++;
             }
                                        upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
                 upd ++;
             }


@@ -3417,34 +3416,51 @@ void wxWindowGTK::GtkSendPaintEvents()
 
     m_clipPaintRegion = FALSE;
 
 
     m_clipPaintRegion = FALSE;
 

+#ifndef __WXUNIVERSAL__
+#ifndef __WXGTK20__
+    // The following code will result in all window-less widgets
+    // being redrawn because the wxWindows class is allowed to
+    // paint over the window-less widgets.
+    

     GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
     GtkPizza *pizza = GTK_PIZZA(m_wxwindow);

-    if (g_list_length(pizza->children) > 0)
+    
+    GList *children = pizza->children;
+    while (children)

     {
     {

-        // The following code will result in all window-less widgets
-        // being redrawn because the wxWindows class is allowed to
-        // paint over the window-less widgets.
-        GList *children = pizza->children;
-        while (children)
-        {
-            GtkPizzaChild *child = (GtkPizzaChild*) children->data;
-            children = children->next;
+        GtkPizzaChild *child = (GtkPizzaChild*) children->data;
+        children = children->next;

 
 

-            if (GTK_WIDGET_NO_WINDOW (child->widget) &&
-                GTK_WIDGET_DRAWABLE (child->widget))
+        if (GTK_WIDGET_NO_WINDOW (child->widget) &&
+            GTK_WIDGET_DRAWABLE (child->widget))
+        {
+            // Get intersection of widget area and update region
+            wxRegion region( m_updateRegion );
+            
+            GdkEventExpose gdk_event;
+            gdk_event.type = GDK_EXPOSE;
+            gdk_event.window = pizza->bin_window;
+            gdk_event.count = 0;
+            
+            wxRegionIterator upd( m_updateRegion );
+            while (upd)

             {
             {

-                // Get intersection of widget area and update region
-                wxRegion region( m_updateRegion );
-                region.Intersect( child->widget->allocation.x,
-                                  child->widget->allocation.y,
-                                  child->widget->allocation.width,
-                                  child->widget->allocation.height );
+                GdkRectangle rect;
+                rect.x = upd.GetX();
+                rect.y = upd.GetY();
+                rect.width = upd.GetWidth();
+                rect.height = upd.GetHeight();
+                
+                if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
+                {
+                    gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
+                }

                 
                 

-                // Redraw the whole widget anyway
-                if (!region.IsEmpty())
-                    gtk_widget_draw( child->widget, NULL );
+                upd ++;

             }
         }
     }
             }
         }
     }

+#endif
+#endif

 
     m_updateRegion.Clear();
 }
 
     m_updateRegion.Clear();
 }


@@ -3552,10 +3568,9 @@ GtkStyle *wxWindowGTK::GetWidgetStyle()
     if (m_widgetStyle)
     {
         GtkStyle *remake = gtk_style_copy( m_widgetStyle );
     if (m_widgetStyle)
     {
         GtkStyle *remake = gtk_style_copy( m_widgetStyle );

-#ifdef __WXGTK20__
-        /* FIXME: is this necessary? */
-        _G_TYPE_IGC(remake, GtkObjectClass) = _G_TYPE_IGC(m_widgetStyle, GtkObjectClass);
-#else
+
+        // FIXME: no more klass in 2.0
+#ifndef __WXGTK20__

         remake->klass = m_widgetStyle->klass;
 #endif
 
         remake->klass = m_widgetStyle->klass;
 #endif
 


@@ -3570,10 +3585,9 @@ GtkStyle *wxWindowGTK::GetWidgetStyle()
             def = gtk_widget_get_default_style();
 
         m_widgetStyle = gtk_style_copy( def );
             def = gtk_widget_get_default_style();
 
         m_widgetStyle = gtk_style_copy( def );

-#ifdef __WXGTK20__
-        /* FIXME: is this necessary? */
-        _G_TYPE_IGC(m_widgetStyle, GtkObjectClass) = _G_TYPE_IGC(def, GtkObjectClass);
-#else
+
+        // FIXME: no more klass in 2.0
+#ifndef __WXGTK20__

         m_widgetStyle->klass = def->klass;
 #endif
     }
         m_widgetStyle->klass = def->klass;
 #endif
     }


@@ -3583,7 +3597,7 @@ GtkStyle *wxWindowGTK::GetWidgetStyle()
 
 void wxWindowGTK::SetWidgetStyle()
 {
 
 void wxWindowGTK::SetWidgetStyle()
 {

-#if DISABLE_STYLE_IF_BROKEN_THEM
+#if DISABLE_STYLE_IF_BROKEN_THEME

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


@@ -3601,8 +3615,7 @@ void wxWindowGTK::SetWidgetStyle()
 
     if (m_font != wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ))
     {
 
     if (m_font != wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ))
     {

-        gdk_font_unref( style->font );
-        style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
+        SET_STYLE_FONT(style, m_font.GetInternalFont( 1.0 ));

     }
 
     if (m_foregroundColour.Ok())
     }
 
     if (m_foregroundColour.Ok())


@@ -3712,6 +3725,9 @@ static gint gs_pop_y = 0;
 
 extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
                                              gint *x, gint *y,
 
 extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
                                              gint *x, gint *y,

+#ifdef __WXGTK20__
+                                             gboolean * WXUNUSED(whatever),
+#endif

                                              gpointer WXUNUSED(user_data) )
 {
     // ensure that the menu appears entirely on screen
                                              gpointer WXUNUSED(user_data) )
 {
     // ensure that the menu appears entirely on screen


@@ -4048,6 +4064,7 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
     // No scrolling requested.
     if ((dx == 0) && (dy == 0)) return;
     
     // No scrolling requested.
     if ((dx == 0) && (dy == 0)) return;
     

+#ifndef __WXGTK20__

     if (!m_updateRegion.IsEmpty())
     {
         m_updateRegion.Offset( dx, dy );
     if (!m_updateRegion.IsEmpty())
     {
         m_updateRegion.Offset( dx, dy );


@@ -4068,68 +4085,23 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
         m_clearRegion.Intersect( 0, 0, cw, ch );
     }
     
         m_clearRegion.Intersect( 0, 0, cw, ch );
     }
     

-#if 1
-

     m_clipPaintRegion = TRUE;
     
     gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
     
     m_clipPaintRegion = FALSE;
     m_clipPaintRegion = TRUE;
     
     gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
     
     m_clipPaintRegion = FALSE;

-

 #else
 
 #else
 

-    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 );
-    }
-#endif
+    gdk_window_scroll( GTK_PIZZA(m_wxwindow)->bin_window, dx, dy );
+    
+    GTK_PIZZA(m_wxwindow)->xoffset += dx;
+    GTK_PIZZA(m_wxwindow)->yoffset += dy;
+    
+#endif    
+   

 }
 
 }
 

+

 // Find the wxWindow at the current mouse position, also returning the mouse
 // position.
 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
 // Find the wxWindow at the current mouse position, also returning the mouse
 // position.
 wxWindow* wxFindWindowAtPointer(wxPoint& pt)


@@ -4171,3 +4143,32 @@ wxPoint wxGetMousePosition()
 
 }
 
 
 }
 

+// ----------------------------------------------------------------------------
+// wxDCModule
+// ----------------------------------------------------------------------------
+
+class wxWinModule : public wxModule
+{
+public:
+    bool OnInit();
+    void OnExit();
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxWinModule)
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
+
+bool wxWinModule::OnInit()
+{
+    g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
+    gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
+    
+    return TRUE;
+}
+
+void wxWinModule::OnExit()
+{
+    gdk_gc_unref( g_eraseGC );
+}
+