Disabled masked bitmaps under GTK 2.0 until I know

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

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index e7da1dd4e7db6c747a3c0f1aa8cc7f6035d875e3..d3fc1c023d09ade04e4a44011ee649b63a22bf88 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,18 @@
 
 #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
+

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


@@ -204,6 +215,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 +385,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


@@ -475,11 +487,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
 //-----------------------------------------------------------------------------


@@ -753,6 +769,10 @@ static void gtk_window_size_request_callback( GtkWidget *widget, GtkRequisition
 // "expose_event" of m_wxwindow
 //-----------------------------------------------------------------------------
 
 // "expose_event" of m_wxwindow
 //-----------------------------------------------------------------------------
 

+#ifdef __WXGTK20__
+extern GtkContainerClass *pizza_parent_class;
+#endif
+

 static int gtk_window_expose_callback( GtkWidget *widget,
                                        GdkEventExpose *gdk_event,
                                        wxWindow *win )
 static int gtk_window_expose_callback( GtkWidget *widget,
                                        GdkEventExpose *gdk_event,
                                        wxWindow *win )


@@ -775,6 +795,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,40 +815,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();
-
-    // 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.
-    GList *children = pizza->children;
-    while (children)
-    {
-        GtkPizzaChild *child = (GtkPizzaChild*) children->data;
-        children = children->next;
-
-        GdkEventExpose child_event = *gdk_event;
+    // Actual redrawing takes place in idle time.
+    win->Update();
+    
+#ifdef __WXGTK20__

 
 

-        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);
-        }
-    }
+    (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
+    
+#endif    

 
     return TRUE;
 }
 
     return TRUE;
 }


@@ -859,8 +861,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,


@@ -892,6 +896,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())


@@ -919,13 +924,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)


@@ -939,8 +946,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
 //-----------------------------------------------------------------------------


@@ -1232,20 +1242,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;


@@ -1668,10 +1673,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


@@ -1730,9 +1732,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
 


@@ -1742,17 +1742,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 )
     {


@@ -1778,13 +1770,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();


@@ -1902,7 +1887,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
 


@@ -1918,14 +1905,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);
 


@@ -1938,7 +1918,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
 


@@ -1951,16 +1933,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);
 


@@ -1984,7 +1959,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;
 }


@@ -2382,11 +2361,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))


@@ -2405,33 +2381,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;


@@ -2583,22 +2539,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


@@ -2606,12 +2568,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 );
 


@@ -2727,7 +2683,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;


@@ -2753,20 +2708,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,


@@ -3196,8 +3158,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);
         }
     }


@@ -3209,21 +3169,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


@@ -3320,8 +3272,8 @@ void wxWindowGTK::WarpPointer( int x, int y )
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 
 {
     wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
 

-    /* we provide this function ourselves as it is
-       missing in GDK (top of this file)  */
+    // We provide this function ourselves as it is
+    // missing in GDK (top of this file).

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


@@ -3338,146 +3290,116 @@ 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)
         {

-            gdk_window_clear_area( GTK_PIZZA(m_wxwindow)->bin_window,
-                                   rect->x, rect->y,
-                                   rect->width, rect->height );
+            // Schedule for later Updating in ::Update() or ::OnInternalIdle().
+            m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );

         }
         else
         {
         }
         else
         {

-            gdk_window_clear( GTK_PIZZA(m_wxwindow)->bin_window );
+            // Schedule for later Updating in ::Update() or ::OnInternalIdle().
+            m_clearRegion.Clear();
+            m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );

         }
     }
 
         }
     }
 

-    /* there is no GTK equivalent of "draw only, don't clear" so we
-       invent our own in the GtkPizza widget */
-
-    if (!rect)
+    if (rect)

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

-#if 0
-            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_pizza_set_clear( pizza, old_clear );
-#endif
-
-#if 1

             // Schedule for later Updating in ::Update() or ::OnInternalIdle().
             // Schedule for later Updating in ::Update() or ::OnInternalIdle().

-            m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
-#else
-            GdkEventExpose gdk_event;
-            gdk_event.type = GDK_EXPOSE;
-            gdk_event.window = GTK_PIZZA(m_wxwindow)->bin_window;
-            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, (wxWindow *)this );
-#endif
+            m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );

         }
         else
         {
         }
         else
         {

-            gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
+            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 );

         }
     }
     else
     {
         }
     }
     else
     {

-

         if (m_wxwindow)
         {
         if (m_wxwindow)
         {

-#if 0
-            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_window_draw_callback( m_wxwindow, &gdk_rect, this );
-
-            gtk_pizza_set_clear( pizza, old_clear );
-#endif
-
-#if 1

             // Schedule for later Updating in ::Update() or ::OnInternalIdle().
             // Schedule for later Updating in ::Update() or ::OnInternalIdle().

-            m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
-#else
-            GdkEventExpose gdk_event;
-            gdk_event.type = GDK_EXPOSE;
-            gdk_event.window = GTK_PIZZA(m_wxwindow)->bin_window;
-            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, (wxWindow *)this );
-#endif
+            m_updateRegion.Clear();
+            m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );

         }
         else
         }
         else

+        {
+            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;
         {
             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 );
+            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()
 {

-    m_clipPaintRegion = TRUE;
+    if (!m_wxwindow)
+    {
+        m_clearRegion.Clear();
+        m_updateRegion.Clear();
+        return;
+    }

 
 

-    wxWindowDC dc( this );
-    dc.SetClippingRegion( m_updateRegion );
-    wxEraseEvent erase_event( GetId(), &dc );
-    erase_event.SetEventObject( this );
+    m_clipPaintRegion = TRUE;

 
 

-#if 1
-    GetEventHandler()->ProcessEvent( erase_event );
-#else
-    if (!GetEventHandler()->ProcessEvent(erase_event))
+    // if (!m_clearRegion.IsEmpty())   // always send an erase event

     {
     {

+        wxWindowDC dc( (wxWindow*)this );
+        dc.SetClippingRegion( m_clearRegion );
+        
+        wxEraseEvent erase_event( GetId(), &dc );
+        erase_event.SetEventObject( this );
+    

         if (!GetEventHandler()->ProcessEvent(erase_event))
         {
         if (!GetEventHandler()->ProcessEvent(erase_event))
         {

-            wxClientDC dc( this );
-            dc.SetBrush( wxBrush( GetBackgroundColour(), wxSOLID ) );
-            dc.SetPen( *wxTRANSPARENT_PEN );
-
-            wxRegionIterator upd( m_updateRegion );
+            gdk_gc_set_foreground( g_eraseGC, m_backgroundColour.GetColor() );
+        
+            wxRegionIterator upd( m_clearRegion );

             while (upd)
             {
             while (upd)
             {

-                dc.DrawRectangle( upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
+                gdk_draw_rectangle( GTK_PIZZA(m_wxwindow)->bin_window, g_eraseGC, 0,
+                                       upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );

                 upd ++;
             }
         }
                 upd ++;
             }
         }

+        m_clearRegion.Clear();

     }
     }

-#endif

 
     wxNcPaintEvent nc_paint_event( GetId() );
     nc_paint_event.SetEventObject( this );
 
     wxNcPaintEvent nc_paint_event( GetId() );
     nc_paint_event.SetEventObject( this );


@@ -3487,9 +3409,55 @@ void wxWindowGTK::GtkSendPaintEvents()
     paint_event.SetEventObject( this );
     GetEventHandler()->ProcessEvent( paint_event );
 
     paint_event.SetEventObject( this );
     GetEventHandler()->ProcessEvent( paint_event );
 

-    m_updateRegion.Clear();
-

     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);
+    
+    GList *children = pizza->children;
+    while (children)
+    {
+        GtkPizzaChild *child = (GtkPizzaChild*) children->data;
+        children = children->next;
+
+        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)
+            {
+                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);
+                }
+                
+                upd ++;
+            }
+        }
+    }
+#endif
+#endif
+
+    m_updateRegion.Clear();

 }
 
 void wxWindowGTK::Clear()
 }
 
 void wxWindowGTK::Clear()


@@ -3595,10 +3563,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
 


@@ -3613,10 +3580,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
     }


@@ -3626,7 +3592,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;


@@ -3644,8 +3610,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())


@@ -3755,6 +3720,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


@@ -4088,65 +4056,47 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 
     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
 
 
     wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
 

+    // No scrolling requested.

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

-
-    m_clipPaintRegion = TRUE;
-    gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
-    m_clipPaintRegion = FALSE;
-
-/*
-    if (m_children.GetCount() > 0)
+    
+#ifndef __WXGTK20__
+    if (!m_updateRegion.IsEmpty())

     {
     {

-        gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
+        m_updateRegion.Offset( dx, dy );
+        
+        int cw = 0;
+        int ch = 0;
+        GetClientSize( &cw, &ch );
+        m_updateRegion.Intersect( 0, 0, cw, ch );

     }
     }

-    else
+    
+    if (!m_clearRegion.IsEmpty())

     {
     {

-        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 );
-
+        m_clearRegion.Offset( dx, dy );
+        

         int cw = 0;
         int ch = 0;
         GetClientSize( &cw, &ch );
         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 );
+        m_clearRegion.Intersect( 0, 0, cw, ch );

     }
     }

-*/
+    
+    m_clipPaintRegion = TRUE;
+    
+    gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
+    
+    m_clipPaintRegion = FALSE;
+#else
+
+    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)


@@ -4188,3 +4138,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 );
+}
+