thread fixes (compiles, but doesn't work yet)

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

diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp
index 0a7b3f3bc54538dcfaf4b5c924c4124ec47e2d8d..51302a0530b5ff0ddbfec64f43a5fe8ce8c880dd 100644 (file)
--- a/src/gtk1/window.cpp
+++ b/src/gtk1/window.cpp
@@ -21,17 +21,23 @@
 #include "wx/utils.h"
 #include "wx/dialog.h"
 #include "wx/msgdlg.h"
 #include "wx/utils.h"
 #include "wx/dialog.h"
 #include "wx/msgdlg.h"

-#include "wx/dcclient.h"
+#if wxUSE_DRAG_AND_DROP

 #include "wx/dnd.h"
 #include "wx/dnd.h"

+#endif

 #include "wx/menu.h"
 #include "wx/statusbr.h"
 #include "wx/intl.h"
 #include "wx/settings.h"
 #include "wx/menu.h"
 #include "wx/statusbr.h"
 #include "wx/intl.h"
 #include "wx/settings.h"

-#include "gdk/gdkprivate.h"
-#include "gdk/gdkkeysyms.h"
+#include "wx/log.h"

 
 #include <math.h>
 
 
 #include <math.h>
 

+#include "gdk/gdk.h"
+#include "gtk/gtk.h"
+#include "gdk/gdkprivate.h"
+#include "gdk/gdkkeysyms.h"
+#include "wx/gtk/win_gtk.h"
+

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


@@ -119,15 +125,51 @@
 #endif
 #endif
 
 #endif
 #endif
 

+//-----------------------------------------------------------------------------
+// (debug)
+//-----------------------------------------------------------------------------
+
+#ifdef __WXDEBUG__
+
+static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget), 
+                                         GdkEvent *WXUNUSED(event), 
+                                        const char *name )
+{
+    printf( "FOCUS NOW AT: " );
+    printf( name );
+    printf( "\n" );
+    
+    return FALSE;
+}
+
+void debug_focus_in( GtkWidget* widget, const char* name, const char *window )
+{
+    return;
+
+    wxString tmp = name;
+    tmp += " FROM ";
+    tmp += window;
+    
+    char *s = new char[tmp.Length()+1];
+    
+    strcpy( s, WXSTRINGCAST tmp );
+
+    gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
+      GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s );
+}
+
+#endif
+

 //-----------------------------------------------------------------------------
 // data
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // data
 //-----------------------------------------------------------------------------
 

-extern wxList wxPendingDelete;
-extern wxList wxTopLevelWindows;
-extern bool   g_blockEventsOnDrag;
-extern bool   g_blockEventsOnScroll;
-static bool   g_capturing = FALSE;
+extern wxList     wxPendingDelete;
+extern wxList     wxTopLevelWindows;
+extern bool       g_blockEventsOnDrag;
+extern bool       g_blockEventsOnScroll;
+static bool       g_capturing = FALSE;
+static wxWindow  *g_focusWindow = (wxWindow*) NULL;

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


@@ -180,7 +222,7 @@ static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------

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

 //-----------------------------------------------------------------------------
 
 static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
 //-----------------------------------------------------------------------------
 
 static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )


@@ -275,7 +317,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
 
     if (!key_code) return FALSE;
 
 
     if (!key_code) return FALSE;
 

-    wxKeyEvent event( wxEVT_CHAR );
+    wxKeyEvent event( wxEVT_KEY_DOWN );

     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);


@@ -302,11 +344,157 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
             ancestor = ancestor->GetParent();
         }
     }
             ancestor = ancestor->GetParent();
         }
     }

+    
+    // win is a control: tab can be propagated up
+    if ((!ret) && (gdk_event->keyval == GDK_Tab))
+    {
+        wxNavigationKeyEvent new_event;
+        new_event.SetDirection( !(gdk_event->state & GDK_SHIFT_MASK) );
+       new_event.SetWindowChange( FALSE );
+        new_event.SetCurrentFocus( win );
+       ret = win->GetEventHandler()->ProcessEvent( new_event );
+    }
+    
+/*
+    // win is a panel: up can be propagated to the panel
+    if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
+        (gdk_event->keyval == GDK_Up))
+    {
+        win->m_parent->SetFocus();
+       ret = TRUE;
+    }
+    
+    // win is a panel: left/right can be propagated to the panel
+    if ((!ret) && (win->m_wxwindow) && 
+        ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) || 
+         (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
+    {
+        wxNavigationKeyEvent new_event;
+        new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
+        new_event.SetCurrentFocus( win );
+       ret = win->GetEventHandler()->ProcessEvent( new_event );
+    }
+*/
+    
+    if (ret)
+    {
+        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+    }
+
+    return ret;
+}
+
+//-----------------------------------------------------------------------------
+// "key_release_event" from any window
+//-----------------------------------------------------------------------------
+
+static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
+{
+    if (!win->HasVMT()) return FALSE;
+    if (g_blockEventsOnDrag) return FALSE;
+
+/*
+    printf( "OnKeyRelease from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );
+*/
+
+    long key_code = 0;
+    switch (gdk_event->keyval)
+    {
+        case GDK_BackSpace:     key_code = WXK_BACK;        break;
+        case GDK_Tab:           key_code = WXK_TAB;         break;
+        case GDK_Linefeed:      key_code = WXK_RETURN;      break;
+        case GDK_Clear:         key_code = WXK_CLEAR;       break;
+        case GDK_Return:        key_code = WXK_RETURN;      break;
+        case GDK_Pause:         key_code = WXK_PAUSE;       break;
+        case GDK_Scroll_Lock:   key_code = WXK_SCROLL;      break;
+        case GDK_Escape:        key_code = WXK_ESCAPE;      break;
+        case GDK_Delete:        key_code = WXK_DELETE;      break;
+        case GDK_Home:          key_code = WXK_HOME;        break;
+        case GDK_Left:          key_code = WXK_LEFT;        break;
+        case GDK_Up:            key_code = WXK_UP;          break;
+        case GDK_Right:         key_code = WXK_RIGHT;       break;
+        case GDK_Down:          key_code = WXK_DOWN;        break;
+        case GDK_Prior:         key_code = WXK_PRIOR;       break;
+//      case GDK_Page_Up:       key_code = WXK_PAGEUP;      break;
+        case GDK_Next:          key_code = WXK_NEXT;        break;
+//      case GDK_Page_Down:     key_code = WXK_PAGEDOWN;    break;
+        case GDK_End:           key_code = WXK_END;         break;
+        case GDK_Begin:         key_code = WXK_HOME;        break;
+        case GDK_Select:        key_code = WXK_SELECT;      break;
+        case GDK_Print:         key_code = WXK_PRINT;       break;
+        case GDK_Execute:       key_code = WXK_EXECUTE;     break;
+        case GDK_Insert:        key_code = WXK_INSERT;      break;
+        case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;
+        case GDK_KP_Tab:        key_code = WXK_TAB;         break;
+        case GDK_KP_Enter:      key_code = WXK_RETURN;      break;
+        case GDK_KP_Home:       key_code = WXK_HOME;        break;
+        case GDK_KP_Left:       key_code = WXK_LEFT;        break;
+        case GDK_KP_Up:         key_code = WXK_UP;          break;
+        case GDK_KP_Right:      key_code = WXK_RIGHT;       break;
+        case GDK_KP_Down:       key_code = WXK_DOWN;        break;
+        case GDK_KP_Prior:      key_code = WXK_PRIOR;       break;
+//      case GDK_KP_Page_Up:    key_code = WXK_PAGEUP;      break;
+        case GDK_KP_Next:       key_code = WXK_NEXT;        break;
+//      case GDK_KP_Page_Down:  key_code = WXK_PAGEDOWN;    break;
+        case GDK_KP_End:        key_code = WXK_END;         break;
+        case GDK_KP_Begin:      key_code = WXK_HOME;        break;
+        case GDK_KP_Insert:     key_code = WXK_INSERT;      break;
+        case GDK_KP_Delete:     key_code = WXK_DELETE;      break;
+        case GDK_KP_Multiply:   key_code = WXK_MULTIPLY;    break;
+        case GDK_KP_Add:        key_code = WXK_ADD;         break;
+        case GDK_KP_Separator:  key_code = WXK_SEPARATOR;   break;
+        case GDK_KP_Subtract:   key_code = WXK_SUBTRACT;    break;
+        case GDK_KP_Decimal:    key_code = WXK_DECIMAL;     break;
+        case GDK_KP_Divide:     key_code = WXK_DIVIDE;      break;
+        case GDK_KP_0:          key_code = WXK_NUMPAD0;     break;
+        case GDK_KP_1:          key_code = WXK_NUMPAD1;     break;
+        case GDK_KP_2:          key_code = WXK_NUMPAD2;     break;
+        case GDK_KP_3:          key_code = WXK_NUMPAD3;     break;
+        case GDK_KP_4:          key_code = WXK_NUMPAD4;     break;
+        case GDK_KP_5:          key_code = WXK_NUMPAD5;     break;
+        case GDK_KP_6:          key_code = WXK_NUMPAD6;     break;
+        case GDK_KP_7:          key_code = WXK_NUMPAD7;     break;
+        case GDK_KP_8:          key_code = WXK_NUMPAD7;     break;
+        case GDK_KP_9:          key_code = WXK_NUMPAD9;     break;
+        case GDK_F1:            key_code = WXK_F1;          break;
+        case GDK_F2:            key_code = WXK_F2;          break;
+        case GDK_F3:            key_code = WXK_F3;          break;
+        case GDK_F4:            key_code = WXK_F4;          break;
+        case GDK_F5:            key_code = WXK_F5;          break;
+        case GDK_F6:            key_code = WXK_F6;          break;
+        case GDK_F7:            key_code = WXK_F7;          break;
+        case GDK_F8:            key_code = WXK_F8;          break;
+        case GDK_F9:            key_code = WXK_F9;          break;
+        case GDK_F10:           key_code = WXK_F10;         break;
+        case GDK_F11:           key_code = WXK_F11;         break;
+        case GDK_F12:           key_code = WXK_F12;         break;
+        default:
+        {
+            if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
+                key_code = gdk_event->keyval;
+        }
+    }
+
+    if (!key_code) return FALSE;
+
+    wxKeyEvent event( wxEVT_KEY_UP );
+    event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
+    event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
+    event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
+    event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
+    event.m_keyCode = key_code;
+    event.m_x = 0;
+    event.m_y = 0;
+    event.SetEventObject( win );
+
+    bool ret = win->GetEventHandler()->ProcessEvent( event );

 
     if (ret)
     {
 
     if (ret)
     {

-        if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
-            gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );

     }
 
     return ret;
     }
 
     return ret;


@@ -399,15 +587,46 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();

-            if ((child->m_x <= event.m_x) &&
-                (child->m_y <= event.m_y) &&
-                (child->m_x+child->m_width  >= event.m_x) &&
-                (child->m_y+child->m_height >= event.m_y))
-            {
-                win = child;
-                event.m_x -= child->m_x;
-                event.m_y -= child->m_y;
-                break;
+           
+           if (child->m_isStaticBox)
+           {
+               // wxStaticBox is transparent in the box itself
+               int x = event.m_x;
+               int y = event.m_y;
+               int xx1 = child->m_x;
+               int yy1 = child->m_y;
+               int xx2 = child->m_x + child->m_width;
+               int yy2 = child->m_x + child->m_height;
+               
+               // left
+               if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
+               // right
+                   ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
+               // top
+                   ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
+               // bottom
+                   ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
+               {
+                    win = child;
+                    event.m_x -= child->m_x;
+                    event.m_y -= child->m_y;
+                    break;
+               }
+                   
+           }
+           else
+           {
+                if ((child->m_wxwindow == (GtkWidget*) NULL) &&
+                   (child->m_x <= event.m_x) &&
+                    (child->m_y <= event.m_y) &&
+                    (child->m_x+child->m_width  >= event.m_x) &&
+                    (child->m_y+child->m_height >= event.m_y))
+                {
+                    win = child;
+                    event.m_x -= child->m_x;
+                    event.m_y -= child->m_y;
+                    break;
+               }

             }
             node = node->Next();
         }
             }
             node = node->Next();
         }


@@ -472,15 +691,46 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();

-            if ((child->m_x <= event.m_x) &&
-                (child->m_y <= event.m_y) &&
-                (child->m_x+child->m_width  >= event.m_x) &&
-                (child->m_y+child->m_height >= event.m_y))
-            {
-                win = child;
-                event.m_x -= child->m_x;
-                event.m_y -= child->m_y;
-                break;
+           
+           if (child->m_isStaticBox)
+           {
+               // wxStaticBox is transparent in the box itself
+               int x = event.m_x;
+               int y = event.m_y;
+               int xx1 = child->m_x;
+               int yy1 = child->m_y;
+               int xx2 = child->m_x + child->m_width;
+               int yy2 = child->m_x + child->m_height;
+               
+               // left
+               if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
+               // right
+                   ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
+               // top
+                   ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
+               // bottom
+                   ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
+               {
+                    win = child;
+                    event.m_x -= child->m_x;
+                    event.m_y -= child->m_y;
+                    break;
+               }
+                   
+           }
+           else
+           {
+                if ((child->m_wxwindow == (GtkWidget*) NULL) &&
+                   (child->m_x <= event.m_x) &&
+                    (child->m_y <= event.m_y) &&
+                    (child->m_x+child->m_width  >= event.m_x) &&
+                    (child->m_y+child->m_height >= event.m_y))
+                {
+                    win = child;
+                    event.m_x -= child->m_x;
+                    event.m_y -= child->m_y;
+                    break;
+               }

             }
             node = node->Next();
         }
             }
             node = node->Next();
         }


@@ -500,6 +750,17 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
 
 static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
 {

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

     if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
 
     if (g_blockEventsOnDrag) return TRUE;
     if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
 
     if (g_blockEventsOnDrag) return TRUE;


@@ -535,15 +796,46 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();

-            if ((child->m_x <= event.m_x) &&
-                (child->m_y <= event.m_y) &&
-                (child->m_x+child->m_width  >= event.m_x) &&
-                (child->m_y+child->m_height >= event.m_y))
-            {
-                win = child;
-                event.m_x -= child->m_x;
-                event.m_y -= child->m_y;
-                break;
+           
+           if (child->m_isStaticBox)
+           {
+               // wxStaticBox is transparent in the box itself
+               int x = event.m_x;
+               int y = event.m_y;
+               int xx1 = child->m_x;
+               int yy1 = child->m_y;
+               int xx2 = child->m_x + child->m_width;
+               int yy2 = child->m_x + child->m_height;
+               
+               // left
+               if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
+               // right
+                   ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
+               // top
+                   ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
+               // bottom
+                   ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
+               {
+                    win = child;
+                    event.m_x -= child->m_x;
+                    event.m_y -= child->m_y;
+                    break;
+               }
+                   
+           }
+           else
+           {
+                if ((child->m_wxwindow == (GtkWidget*) NULL) &&
+                   (child->m_x <= event.m_x) &&
+                    (child->m_y <= event.m_y) &&
+                    (child->m_x+child->m_width  >= event.m_x) &&
+                    (child->m_y+child->m_height >= event.m_y))
+                {
+                    win = child;
+                    event.m_x -= child->m_x;
+                    event.m_y -= child->m_y;
+                    break;
+               }

             }
             node = node->Next();
         }
             }
             node = node->Next();
         }


@@ -564,6 +856,9 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
 static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
 {
     if (g_blockEventsOnDrag) return TRUE;
 static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
 {
     if (g_blockEventsOnDrag) return TRUE;

+    
+    g_focusWindow = win;
+    

     if (win->m_wxwindow)
     {
         if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
     if (win->m_wxwindow)
     {
         if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))


@@ -635,10 +930,13 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
 
 static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {

-    if (widget->window != gdk_event->window) return TRUE;
-

     if (g_blockEventsOnDrag) return TRUE;
 
     if (g_blockEventsOnDrag) return TRUE;
 

+    if ((widget->window) && (win->m_cursor))
+        gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
+
+    if (widget->window != gdk_event->window) return TRUE;
+

     if (!win->HasVMT()) return TRUE;
 
 /*
     if (!win->HasVMT()) return TRUE;
 
 /*


@@ -648,12 +946,26 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
     printf( ".\n" );
 */
 
     printf( ".\n" );
 */
 

-    if ((widget->window) && (win->m_cursor))
-        gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
-

     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     event.SetEventObject( win );
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     event.SetEventObject( win );

-
+    
+    int x = 0;
+    int y = 0;
+    GdkModifierType state = (GdkModifierType)0;
+    
+    gdk_window_get_pointer( widget->window, &x, &y, &state );
+    
+    event.m_shiftDown = (state & GDK_SHIFT_MASK);
+    event.m_controlDown = (state & GDK_CONTROL_MASK);
+    event.m_altDown = (state & GDK_MOD1_MASK);
+    event.m_metaDown = (state & GDK_MOD2_MASK);
+    event.m_leftDown = (state & GDK_BUTTON1_MASK);
+    event.m_middleDown = (state & GDK_BUTTON2_MASK);
+    event.m_rightDown = (state & GDK_BUTTON3_MASK);
+
+    event.m_x = (long)x;
+    event.m_y = (long)y;
+    

     if (win->GetEventHandler()->ProcessEvent( event ))
        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
 


@@ -666,10 +978,13 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {
 
 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {

-    if (widget->window != gdk_event->window) return TRUE;
-

     if (g_blockEventsOnDrag) return TRUE;
 
     if (g_blockEventsOnDrag) return TRUE;
 

+    if ((widget->window) && (win->m_cursor))
+        gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
+
+    if (widget->window != gdk_event->window) return TRUE;
+

     if (!win->HasVMT()) return TRUE;
 
 /*
     if (!win->HasVMT()) return TRUE;
 
 /*


@@ -679,12 +994,26 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
     printf( ".\n" );
 */
 
     printf( ".\n" );
 */
 

-    if ((widget->window) && (win->m_cursor))
-        gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
-

     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
     event.SetEventObject( win );
 
     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
     event.SetEventObject( win );
 

+    int x = 0;
+    int y = 0;
+    GdkModifierType state = (GdkModifierType)0;
+    
+    gdk_window_get_pointer( widget->window, &x, &y, &state );
+    
+    event.m_shiftDown = (state & GDK_SHIFT_MASK);
+    event.m_controlDown = (state & GDK_CONTROL_MASK);
+    event.m_altDown = (state & GDK_MOD1_MASK);
+    event.m_metaDown = (state & GDK_MOD2_MASK);
+    event.m_leftDown = (state & GDK_BUTTON1_MASK);
+    event.m_middleDown = (state & GDK_BUTTON2_MASK);
+    event.m_rightDown = (state & GDK_BUTTON3_MASK);
+
+    event.m_x = (long)x;
+    event.m_y = (long)y;
+    

     if (win->GetEventHandler()->ProcessEvent( event ))
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
 


@@ -843,6 +1172,9 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
                                                  GdkEventButton *WXUNUSED(gdk_event),
                                                 wxWindow *win )
 {
                                                  GdkEventButton *WXUNUSED(gdk_event),
                                                 wxWindow *win )
 {

+//  don't test here as we can release the mouse while being over
+//  a different window then the slider
+//

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


@@ -860,7 +1192,7 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
                                                   wxWindow *win )
 {
 
                                                   wxWindow *win )
 {
 

-//  don't test here as we can reelase the mouse while being over
+//  don't test here as we can release the mouse while being over

 //  a different window then the slider
 //
 //    if (gdk_event->window != widget->slider) return FALSE;
 //  a different window then the slider
 //
 //    if (gdk_event->window != widget->slider) return FALSE;


@@ -886,8 +1218,8 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
 // C++ has no virtual methods in a constructor. We have to emulate a
 // virtual function here as wxNotebook requires a different way to insert
 // a child in it. I had opted for creating a wxNotebookPage window class
 // C++ has no virtual methods in a constructor. We have to emulate a
 // virtual function here as wxNotebook requires a different way to insert
 // a child in it. I had opted for creating a wxNotebookPage window class

-// which would have made this superflouus (such in the MDI window system),
-// but no-one is listening to me...
+// which would have made this superfluous (such in the MDI window system),
+// but no-one was listening to me...

 
 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 {
 
 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 {


@@ -901,6 +1233,15 @@ static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
                          child->m_height );
 }
 
                          child->m_height );
 }
 

+//-----------------------------------------------------------------------------
+// global functions
+//-----------------------------------------------------------------------------
+
+wxWindow* wxGetActiveWindow()
+{
+  return g_focusWindow;
+}
+

 //-----------------------------------------------------------------------------
 // wxWindow
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxWindow
 //-----------------------------------------------------------------------------


@@ -912,6 +1253,7 @@ BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
     EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
     EVT_INIT_DIALOG(wxWindow::OnInitDialog)
     EVT_IDLE(wxWindow::OnIdle)
     EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
     EVT_INIT_DIALOG(wxWindow::OnInitDialog)
     EVT_IDLE(wxWindow::OnIdle)

+    EVT_KEY_DOWN(wxWindow::OnKeyDown)

 END_EVENT_TABLE()
 
 wxWindow::wxWindow()
 END_EVENT_TABLE()
 
 wxWindow::wxWindow()


@@ -962,7 +1304,9 @@ wxWindow::wxWindow()
     m_isShown = FALSE;
     m_isEnabled = TRUE;
 
     m_isShown = FALSE;
     m_isEnabled = TRUE;
 

+#if wxUSE_DRAG_AND_DROP

     m_dropTarget = (wxDropTarget*) NULL;
     m_dropTarget = (wxDropTarget*) NULL;

+#endif

     m_resizing = FALSE;
     m_scrollGC = (GdkGC*) NULL;
     m_widgetStyle = (GtkStyle*) NULL;
     m_resizing = FALSE;
     m_scrollGC = (GdkGC*) NULL;
     m_widgetStyle = (GtkStyle*) NULL;


@@ -971,6 +1315,9 @@ wxWindow::wxWindow()
 
     m_clientObject = (wxClientData*) NULL;
     m_clientData = NULL;
 
     m_clientObject = (wxClientData*) NULL;
     m_clientData = NULL;

+    
+    m_isStaticBox = FALSE;
+    m_acceptsFocus = FALSE;

 }
 
 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
 }
 
 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,


@@ -993,9 +1340,18 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
     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, "wxWindow::m_widget", name );
+#endif

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

+#ifdef __WXDEBUG__
+    debug_focus_in( s_window->hscrollbar, "wxWindow::hsrcollbar", name );
+    debug_focus_in( s_window->vscrollbar, "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;
 


@@ -1009,6 +1365,10 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
     m_wxwindow = gtk_myfixed_new();
 
 
     m_wxwindow = gtk_myfixed_new();
 

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

 #ifdef NEW_GTK_SCROLL_CODE
     gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), m_wxwindow );
     GtkViewport *viewport = GTK_VIEWPORT(s_window->child);
 #ifdef NEW_GTK_SCROLL_CODE
     gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), m_wxwindow );
     GtkViewport *viewport = GTK_VIEWPORT(s_window->child);


@@ -1017,6 +1377,10 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
     GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
 #endif
 
     GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
 #endif
 

+#ifdef __WXDEBUG__
+    debug_focus_in( GTK_WIDGET(viewport), "wxWindow::viewport", name );
+#endif
+

     if (m_windowStyle & wxRAISED_BORDER)
     {
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
     if (m_windowStyle & wxRAISED_BORDER)
     {
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );


@@ -1030,10 +1394,16 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
     }
 
         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
     }
 

-    if (m_windowStyle & wxTAB_TRAVERSAL == wxTAB_TRAVERSAL)
+    if ((m_windowStyle & wxTAB_TRAVERSAL) != 0)
+    {

         GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
         GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );

+        m_acceptsFocus = FALSE;
+    }

     else
     else

+    {

         GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
         GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );

+        m_acceptsFocus = TRUE;
+    }

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


@@ -1102,7 +1472,9 @@ wxWindow::~wxWindow()
 {
     m_hasVMT = FALSE;
 
 {
     m_hasVMT = FALSE;
 

+#if wxUSE_DRAG_AND_DROP

     if (m_dropTarget) delete m_dropTarget;
     if (m_dropTarget) delete m_dropTarget;

+#endif

 
     if (m_parent) m_parent->RemoveChild( this );
     if (m_widget) Show( FALSE );
 
     if (m_parent) m_parent->RemoveChild( this );
     if (m_widget) Show( FALSE );


@@ -1155,8 +1527,7 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
       const wxPoint &pos, const wxSize &size,
       long style, const wxString &name )
 {
       const wxPoint &pos, const wxSize &size,
       long style, const wxString &name )
 {

-    if (m_needParent && (parent == NULL))
-        wxFatalError( "Need complete parent.", name );
+    wxASSERT_MSG( (!m_needParent) || (parent), "Need complete parent." );

 
     m_widget = (GtkWidget*) NULL;
     m_wxwindow = (GtkWidget*) NULL;
 
     m_widget = (GtkWidget*) NULL;
     m_wxwindow = (GtkWidget*) NULL;


@@ -1201,8 +1572,8 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
 
     m_cursor = new wxCursor( wxCURSOR_ARROW );
     m_font = *wxSWISS_FONT;
 
     m_cursor = new wxCursor( wxCURSOR_ARROW );
     m_font = *wxSWISS_FONT;

-//  m_backgroundColour = wxWHITE;
-//  m_foregroundColour = wxBLACK;
+    m_backgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
+    m_foregroundColour = *wxBLACK;

     m_windowStyle = style;
     m_windowName = name;
 
     m_windowStyle = style;
     m_windowName = name;
 


@@ -1222,7 +1593,9 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
     m_isShown = FALSE;
     m_isEnabled = TRUE;
 
     m_isShown = FALSE;
     m_isEnabled = TRUE;
 

+#if wxUSE_DRAG_AND_DROP

     m_dropTarget = (wxDropTarget *) NULL;
     m_dropTarget = (wxDropTarget *) NULL;

+#endif

     m_resizing = FALSE;
     m_windowValidator = (wxValidator *) NULL;
     m_scrollGC = (GdkGC*) NULL;
     m_resizing = FALSE;
     m_windowValidator = (wxValidator *) NULL;
     m_scrollGC = (GdkGC*) NULL;


@@ -1230,6 +1603,8 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
 
     m_clientObject = (wxClientData*)NULL;
     m_clientData = NULL;
 
     m_clientObject = (wxClientData*)NULL;
     m_clientData = NULL;

+    
+    m_isStaticBox = FALSE;

 }
 
 void wxWindow::PostCreation()
 }
 
 void wxWindow::PostCreation()


@@ -1259,6 +1634,9 @@ void wxWindow::ConnectWidget( GtkWidget *widget )
     gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
       GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
 
     gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
       GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
 

+    gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
+      GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
+

     gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
       GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
 
     gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
       GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
 


@@ -1389,8 +1767,8 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
 
         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_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_minWidth;
-        if ((m_maxHeight != -1) && (m_height > m_maxHeight)) 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;

 
         wxPoint pt( m_parent->GetClientAreaOrigin() );
         gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y );
 
         wxPoint pt( m_parent->GetClientAreaOrigin() );
         gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y );


@@ -1420,7 +1798,7 @@ void wxWindow::Move( int x, int y )
 
 void wxWindow::GetSize( int *width, int *height ) const
 {
 
 void wxWindow::GetSize( int *width, int *height ) const
 {

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

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


@@ -1428,136 +1806,136 @@ void wxWindow::GetSize( int *width, int *height ) const
 
 void wxWindow::SetClientSize( int width, int height )
 {
 
 void wxWindow::SetClientSize( int width, int height )
 {

-  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
-
-  if (!m_wxwindow)
-  {
-    SetSize( width, height );
-  }
-  else
-  {
-    int dw = 0;
-    int dh = 0;
+    wxCHECK_RET( (m_widget != NULL), "invalid window" );

 
 

-    if (!m_hasScrolling)
+    if (!m_wxwindow)

     {
     {

-      GtkStyleClass *window_class = m_wxwindow->style->klass;
-
-      if ((m_windowStyle & wxRAISED_BORDER) ||
-          (m_windowStyle & wxSUNKEN_BORDER))
-      {
-        dw += 2 * window_class->xthickness;
-        dh += 2 * window_class->ythickness;
-      }
+        SetSize( width, height );

     }
     else
     {
     }
     else
     {

-      GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-      GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+        int dw = 0;
+        int dh = 0;
+
+        if (!m_hasScrolling)
+        {
+            GtkStyleClass *window_class = m_wxwindow->style->klass;
+
+            if ((m_windowStyle & wxRAISED_BORDER) ||
+                (m_windowStyle & wxSUNKEN_BORDER))
+            {
+                dw += 2 * window_class->xthickness;
+                dh += 2 * window_class->ythickness;
+            }
+        }
+        else
+        {
+            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
+            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );

 
 #ifdef NEW_GTK_SCROLL_CODE
 
 #ifdef NEW_GTK_SCROLL_CODE

-      GtkWidget *viewport = scroll_window->child;
+            GtkWidget *viewport = scroll_window->child;

 #else
 #else

-      GtkWidget *viewport = scroll_window->viewport;
+            GtkWidget *viewport = scroll_window->viewport;

 #endif
 
 #endif
 

-      GtkStyleClass *viewport_class = viewport->style->klass;
+            GtkStyleClass *viewport_class = viewport->style->klass;

 
 

-      GtkWidget *hscrollbar = scroll_window->hscrollbar;
-      GtkWidget *vscrollbar = scroll_window->vscrollbar;
+            GtkWidget *hscrollbar = scroll_window->hscrollbar;
+            GtkWidget *vscrollbar = scroll_window->vscrollbar;

 
 

-      if ((m_windowStyle & wxRAISED_BORDER) ||
-          (m_windowStyle & wxSUNKEN_BORDER))
-      {
-        dw += 2 * viewport_class->xthickness;
-        dh += 2 * viewport_class->ythickness;
-      }
+            if ((m_windowStyle & wxRAISED_BORDER) ||
+                (m_windowStyle & wxSUNKEN_BORDER))
+            {
+                dw += 2 * viewport_class->xthickness;
+                dh += 2 * viewport_class->ythickness;
+            }

 
 

-      if (scroll_window->vscrollbar_visible)
-      {
-        dw += vscrollbar->allocation.width;
-        dw += scroll_class->scrollbar_spacing;
-      }
+            if (scroll_window->vscrollbar_visible)
+            {
+                dw += vscrollbar->allocation.width;
+                dw += scroll_class->scrollbar_spacing;
+            }

 
 

-      if (scroll_window->hscrollbar_visible)
-      {
-        dh += hscrollbar->allocation.height;
-        dw += scroll_class->scrollbar_spacing;
-      }
-    }
+            if (scroll_window->hscrollbar_visible)
+            {
+                dh += hscrollbar->allocation.height;
+                dw += scroll_class->scrollbar_spacing;
+            }
+       }

 
 

-    SetSize( width+dw, height+dh );
-  }
+      SetSize( width+dw, height+dh );
+    }

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

-  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
-
-  if (!m_wxwindow)
-  {
-    if (width) (*width) = m_width;
-    if (height) (*height) = m_height;
-  }
-  else
-  {
-    int dw = 0;
-    int dh = 0;
+    wxCHECK_RET( (m_widget != NULL), "invalid window" );

 
 

-    if (!m_hasScrolling)
+    if (!m_wxwindow)

     {
     {

-      GtkStyleClass *window_class = m_wxwindow->style->klass;
-
-      if ((m_windowStyle & wxRAISED_BORDER) ||
-          (m_windowStyle & wxSUNKEN_BORDER))
-      {
-        dw += 2 * window_class->xthickness;
-        dh += 2 * window_class->ythickness;
-      }
+        if (width) (*width) = m_width;
+        if (height) (*height) = m_height;

     }
     else
     {
     }
     else
     {

-      GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-      GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+        int dw = 0;
+        int dh = 0;
+
+        if (!m_hasScrolling)
+        {
+            GtkStyleClass *window_class = m_wxwindow->style->klass;
+
+            if ((m_windowStyle & wxRAISED_BORDER) ||
+                (m_windowStyle & wxSUNKEN_BORDER))
+            {
+                dw += 2 * window_class->xthickness;
+                dh += 2 * window_class->ythickness;
+            }
+        }
+        else
+        {
+            GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
+            GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );

 
 #ifdef NEW_GTK_SCROLL_CODE
 
 #ifdef NEW_GTK_SCROLL_CODE

-      GtkWidget *viewport = scroll_window->child;
+            GtkWidget *viewport = scroll_window->child;

 #else
 #else

-      GtkWidget *viewport = scroll_window->viewport;
+            GtkWidget *viewport = scroll_window->viewport;

 #endif
 
 #endif
 

-      GtkStyleClass *viewport_class = viewport->style->klass;
+            GtkStyleClass *viewport_class = viewport->style->klass;

 
 

-      if ((m_windowStyle & wxRAISED_BORDER) ||
-          (m_windowStyle & wxSUNKEN_BORDER))
-      {
-        dw += 2 * viewport_class->xthickness;
-        dh += 2 * viewport_class->ythickness;
-      }
+            if ((m_windowStyle & wxRAISED_BORDER) ||
+                (m_windowStyle & wxSUNKEN_BORDER))
+            {
+                dw += 2 * viewport_class->xthickness;
+                dh += 2 * viewport_class->ythickness;
+            }

 
 

-      if (scroll_window->vscrollbar_visible)
-      {
-//        dw += vscrollbar->allocation.width;
-        dw += 15;                               // range.slider_width = 11 + 2*2pts edge
-        dw += scroll_class->scrollbar_spacing;
-      }
+            if (scroll_window->vscrollbar_visible)
+            {
+//              dw += vscrollbar->allocation.width;
+                dw += 15;                               // range.slider_width = 11 + 2*2pts edge
+                dw += scroll_class->scrollbar_spacing;
+            }

 
 

-      if (scroll_window->hscrollbar_visible)
-      {
-//        dh += hscrollbar->allocation.height;
-        dh += 15;
-        dh += scroll_class->scrollbar_spacing;
-      }
-    }
+            if (scroll_window->hscrollbar_visible)
+            {
+//              dh += hscrollbar->allocation.height;
+                dh += 15;
+                dh += scroll_class->scrollbar_spacing;
+            }
+        }

 
 

-    if (width) (*width) = m_width - dw;
-    if (height) (*height) = m_height - dh;
-  }
+        if (width) (*width) = m_width - dw;
+        if (height) (*height) = m_height - dh;
+    }

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

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

 
     if (x) (*x) = m_x;
     if (y) (*y) = m_y;
 
     if (x) (*x) = m_x;
     if (y) (*y) = m_y;


@@ -1565,7 +1943,7 @@ void wxWindow::GetPosition( int *x, int *y ) const
 
 void wxWindow::ClientToScreen( int *x, int *y )
 {
 
 void wxWindow::ClientToScreen( int *x, int *y )
 {

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

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


@@ -1596,90 +1974,89 @@ void wxWindow::ClientToScreen( int *x, int *y )
 
 void wxWindow::ScreenToClient( int *x, int *y )
 {
 
 void wxWindow::ScreenToClient( int *x, int *y )
 {

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

 
 

-  GdkWindow *source = (GdkWindow *) NULL;
-  if (m_wxwindow)
-    source = m_wxwindow->window;
-  else
-    source = m_widget->window;
+    GdkWindow *source = (GdkWindow *) NULL;
+    if (m_wxwindow)
+        source = m_wxwindow->window;
+    else
+        source = m_widget->window;

 
 

-  int org_x = 0;
-  int org_y = 0;
-  gdk_window_get_origin( source, &org_x, &org_y );
+    int org_x = 0;
+    int org_y = 0;
+    gdk_window_get_origin( source, &org_x, &org_y );

 
 

-  if (!m_wxwindow)
-  {
-    if (GTK_WIDGET_NO_WINDOW (m_widget))
+    if (!m_wxwindow)

     {
     {

-      org_x += m_widget->allocation.x;
-      org_y += m_widget->allocation.y;
+        if (GTK_WIDGET_NO_WINDOW (m_widget))
+        {
+            org_x += m_widget->allocation.x;
+            org_y += m_widget->allocation.y;
+        }

     }
     }

-  }

 
 

-  wxPoint pt(GetClientAreaOrigin());
-  org_x -= pt.x;
-  org_y -= pt.y;
+    wxPoint pt(GetClientAreaOrigin());
+    org_x -= pt.x;
+    org_y -= pt.y;

 
 

-  if (x) *x -= org_x;
-  if (y) *y -= org_y;
+    if (x) *x -= org_x;
+    if (y) *y -= org_y;

 }
 
 void wxWindow::Centre( int direction )
 {
 }
 
 void wxWindow::Centre( int direction )
 {

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

 
 

-  int x = m_x;
-  int y = m_y;
+    int x = m_x;
+    int y = m_y;

 
 

-  if (m_parent)
-  {
-      int p_w = 0;
-      int p_h = 0;
-      m_parent->GetSize( &p_w, &p_h );
-      if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2;
-      if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2;
-  }
-  else
-  {
-      if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
-      if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
-  }
+    if (m_parent)
+    {
+        int p_w = 0;
+        int p_h = 0;
+        m_parent->GetSize( &p_w, &p_h );
+        if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2;
+        if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2;
+    }
+    else
+    {
+        if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
+        if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
+    }

 
 

-  Move( x, y );
+    Move( x, y );

 }
 
 void wxWindow::Fit()
 {
 }
 
 void wxWindow::Fit()
 {

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

 
 

-  int maxX = 0;
-  int maxY = 0;
-  wxNode *node = m_children.First();
-  while ( node )
-  {
-    wxWindow *win = (wxWindow *)node->Data();
-    int wx, wy, ww, wh;
-    win->GetPosition(&wx, &wy);
-    win->GetSize(&ww, &wh);
-    if ( wx + ww > maxX )
-      maxX = wx + ww;
-    if ( wy + wh > maxY )
-      maxY = wy + wh;
-
-    node = node->Next();
-  }
-  SetClientSize(maxX + 5, maxY + 10);
+    int maxX = 0;
+    int maxY = 0;
+    wxNode *node = m_children.First();
+    while (node)
+    {
+        wxWindow *win = (wxWindow *)node->Data();
+        int wx, wy, ww, wh;
+        win->GetPosition(&wx, &wy);
+        win->GetSize(&ww, &wh);
+        if (wx + ww > maxX) maxX = wx + ww;
+        if (wy + wh > maxY) maxY = wy + wh;
+
+        node = node->Next();
+    }
+    
+    SetClientSize(maxX + 7, maxY + 14);

 }
 
 void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
 {
 }
 
 void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
 {

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

 
 

-  m_minWidth = minW;
-  m_minHeight = minH;
-  m_maxWidth = maxW;
-  m_maxHeight = maxH;
+    m_minWidth = minW;
+    m_minHeight = minH;
+    m_maxWidth = maxW;
+    m_maxHeight = maxH;

 }
 
 void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
 }
 
 void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )


@@ -1689,67 +2066,57 @@ void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
 
 bool wxWindow::Show( bool show )
 {
 
 bool wxWindow::Show( bool show )
 {

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

 
 

-  if (show)
-    gtk_widget_show( m_widget );
-  else
-    gtk_widget_hide( m_widget );
-  m_isShown = show;
-  return TRUE;
+    if (show)
+        gtk_widget_show( m_widget );
+    else
+        gtk_widget_hide( m_widget );
+       
+    m_isShown = show;
+    
+    return TRUE;

 }
 
 void wxWindow::Enable( bool enable )
 {
 }
 
 void wxWindow::Enable( bool enable )
 {

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

 
 

-  m_isEnabled = enable;
-  gtk_widget_set_sensitive( m_widget, enable );
-  if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
+    m_isEnabled = enable;
+    
+    gtk_widget_set_sensitive( m_widget, enable );
+    if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );

 }
 
 int wxWindow::GetCharHeight() const
 {
 }
 
 int wxWindow::GetCharHeight() const
 {

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

 
 

-  if (!m_font.Ok())
-  {
-    wxFAIL_MSG( "invalid font" );
-    return -1;
-  }
+    wxCHECK_MSG( m_font.Ok(), 12, "invalid font" );

 
 

-  GdkFont *font = m_font.GetInternalFont( 1.0 );
-  return font->ascent + font->descent;
+    GdkFont *font = m_font.GetInternalFont( 1.0 );
+    
+    return font->ascent + font->descent;

 }
 
 int wxWindow::GetCharWidth() const
 {
 }
 
 int wxWindow::GetCharWidth() const
 {

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

 
 

-    if (!m_font.Ok())
-    {
-      wxFAIL_MSG( "invalid font" );
-      return -1;
-    }
+    wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );

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

+    

     return gdk_string_width( font, "H" );
 }
 
 void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
   int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const
 {
     return gdk_string_width( font, "H" );
 }
 
 void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
   int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const
 {

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

     wxFont fontToUse = m_font;
     if (theFont) fontToUse = *theFont;
 
     wxFont fontToUse = m_font;
     if (theFont) fontToUse = *theFont;
 

-    if (!fontToUse.Ok())
-    {
-      wxFAIL_MSG( "invalid font" );
-      return;
-    }
-    wxASSERT_MSG( (m_font.Ok()), "invalid font" );
+    wxCHECK_RET( fontToUse.Ok(), "invalid font" );

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


@@ -1760,36 +2127,63 @@ void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
 
 void wxWindow::MakeModal( bool modal )
 {
 
 void wxWindow::MakeModal( bool modal )
 {

-  return;
-  // Disable all other windows
-  if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
-  {
-    wxNode *node = wxTopLevelWindows.First();
-    while (node)
+    return;
+    
+    // Disable all other windows
+    if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))

     {
     {

-      wxWindow *win = (wxWindow *)node->Data();
-      if (win != this)
-        win->Enable(!modal);
+        wxNode *node = wxTopLevelWindows.First();
+        while (node)
+        {
+            wxWindow *win = (wxWindow *)node->Data();
+            if (win != this) win->Enable(!modal);

 
 

-      node = node->Next();
+            node = node->Next();
+        }

     }
     }

-  }

 }
 
 }
 

-void wxWindow::SetFocus()
+void wxWindow::OnKeyDown( wxKeyEvent &event )

 {
 {

-    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+    event.SetEventType( wxEVT_CHAR );
+    
+    if (!GetEventHandler()->ProcessEvent( event ))
+    {
+        event.Skip();
+    }
+}

 
 

+void wxWindow::SetFocus()
+{
+    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    

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

-        if (GTK_WIDGET_CAN_FOCUS(connect_widget) && !GTK_WIDGET_HAS_FOCUS (connect_widget) )
+        if (GTK_WIDGET_CAN_FOCUS(connect_widget) /*&& !GTK_WIDGET_HAS_FOCUS (connect_widget)*/ )

         {
             gtk_widget_grab_focus (connect_widget);
         }
         {
             gtk_widget_grab_focus (connect_widget);
         }

+       else if (GTK_IS_CONTAINER(connect_widget))
+       {
+           gtk_container_focus( GTK_CONTAINER(connect_widget), GTK_DIR_TAB_FORWARD );
+       }
+       else
+       {
+       }

     }
 }
 
     }
 }
 

+wxWindow *wxWindow::FindFocus()
+{
+    return g_focusWindow;
+}
+
+bool wxWindow::AcceptsFocus() const
+{
+    return IsEnabled() && IsShown() && m_acceptsFocus;
+}
+

 bool wxWindow::OnClose()
 {
     return TRUE;
 bool wxWindow::OnClose()
 {
     return TRUE;


@@ -1797,27 +2191,29 @@ bool wxWindow::OnClose()
 
 void wxWindow::AddChild( wxWindow *child )
 {
 
 void wxWindow::AddChild( wxWindow *child )
 {

-    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
-    wxASSERT_MSG( (child != NULL), "invalid child" );
+    wxCHECK_RET( (m_widget != NULL), "invalid window" );
+    wxCHECK_RET( (child != NULL), "invalid child" );

 
     m_children.Append( child );
 }
 
 wxWindow *wxWindow::ReParent( wxWindow *newParent )
 {
 
     m_children.Append( child );
 }
 
 wxWindow *wxWindow::ReParent( wxWindow *newParent )
 {

-  wxWindow *oldParent = GetParent();
+    wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );
+    
+    wxWindow *oldParent = GetParent();

 
 

-  if (oldParent) oldParent->RemoveChild( this );
+    if (oldParent) oldParent->RemoveChild( this );

 
 

-  gtk_widget_unparent( m_widget );
+    gtk_widget_unparent( m_widget );

 
 

-  if (newParent)
-  {
-     newParent->AddChild( this );
-     (newParent->m_insertCallback)( newParent, this );
-  }
+    if (newParent)
+    {
+        newParent->AddChild( this );
+        (newParent->m_insertCallback)( newParent, this );
+    }

 
 

-  return oldParent;
+    return oldParent;

 }
 
 void wxWindow::RemoveChild( wxWindow *child )
 }
 
 void wxWindow::RemoveChild( wxWindow *child )


@@ -1838,14 +2234,14 @@ int wxWindow::GetReturnCode()
 
 void wxWindow::Raise()
 {
 
 void wxWindow::Raise()
 {

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

 
     if (m_widget) gdk_window_raise( m_widget->window );
 }
 
 void wxWindow::Lower()
 {
 
     if (m_widget) gdk_window_raise( m_widget->window );
 }
 
 void wxWindow::Lower()
 {

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

 
     if (m_widget) gdk_window_lower( m_widget->window );
 }
 
     if (m_widget) gdk_window_lower( m_widget->window );
 }


@@ -1893,119 +2289,112 @@ wxValidator *wxWindow::GetValidator()
 
 void wxWindow::SetValidator( const wxValidator& validator )
 {
 
 void wxWindow::SetValidator( const wxValidator& validator )
 {

-  if (m_windowValidator) delete m_windowValidator;
-  m_windowValidator = validator.Clone();
-  if (m_windowValidator) m_windowValidator->SetWindow(this);
+    if (m_windowValidator) delete m_windowValidator;
+    m_windowValidator = validator.Clone();
+    if (m_windowValidator) m_windowValidator->SetWindow(this);

 }
 
 void wxWindow::SetClientObject( wxClientData *data )
 {
 }
 
 void wxWindow::SetClientObject( wxClientData *data )
 {

-  if (m_clientObject) delete m_clientObject;
-  m_clientObject = data;
+    if (m_clientObject) delete m_clientObject;
+    m_clientObject = data;

 }
 
 wxClientData *wxWindow::GetClientObject()
 {
 }
 
 wxClientData *wxWindow::GetClientObject()
 {

-  return m_clientObject;
+    return m_clientObject;

 }
 
 void wxWindow::SetClientData( void *data )
 {
 }
 
 void wxWindow::SetClientData( void *data )
 {

-  m_clientData = data;
+    m_clientData = data;

 }
 
 void *wxWindow::GetClientData()
 {
 }
 
 void *wxWindow::GetClientData()
 {

-  return m_clientData;
+    return m_clientData;

 }
 
 bool wxWindow::IsBeingDeleted()
 {
 }
 
 bool wxWindow::IsBeingDeleted()
 {

-  return FALSE;
+    return FALSE;

 }
 
 void wxWindow::SetId( wxWindowID id )
 {
 }
 
 void wxWindow::SetId( wxWindowID id )
 {

-  m_windowId = id;
+    m_windowId = id;

 }
 
 wxWindowID wxWindow::GetId() const
 {
 }
 
 wxWindowID wxWindow::GetId() const
 {

-  return m_windowId;
+    return m_windowId;

 }
 
 void wxWindow::SetCursor( const wxCursor &cursor )
 {
 }
 
 void wxWindow::SetCursor( const wxCursor &cursor )
 {

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

 
 

-  if (m_cursor == NULL)
-  {
-    wxFAIL_MSG( "wxWindow::SetCursor m_cursor == NULL" );
-    m_cursor = new wxCursor( wxCURSOR_ARROW );
-  }
+    if (cursor.Ok())
+    {
+        if (cursor == *m_cursor) return;
+        *m_cursor = cursor;
+    }
+    else
+    {
+        *m_cursor = *wxSTANDARD_CURSOR;
+    }

 
 

-  if (cursor.Ok())
-  {
-    if ( cursor == *m_cursor )
-        return;
-    *m_cursor = cursor;
-  }
-  else
-  {
-    *m_cursor = *wxSTANDARD_CURSOR;
-  }
+    if ((m_widget) && (m_widget->window))
+         gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );

 
 

-  if ((m_widget) && (m_widget->window))
-    gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
+    if ((m_wxwindow) && (m_wxwindow->window))
+         gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
+}

 
 

-  if ((m_wxwindow) && (m_wxwindow->window))
-    gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
+void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) )
+{
+  // TODO

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

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

 
 

-  if (eraseBackground && m_wxwindow && m_wxwindow->window)
-  {
-    if (rect)
-      gdk_window_clear_area( m_wxwindow->window,
-        rect->x,
-        rect->y,
-        rect->width,
-        rect->height );
-    else
-      Clear();
-  }
-  if (!rect)
-  {
-    if (m_wxwindow)
+    if (eraseBackground && m_wxwindow && m_wxwindow->window)

     {
     {

-      int w = 0;
-      int h = 0;
-      GetClientSize( &w, &h );
-
-      GdkRectangle gdk_rect;
-      gdk_rect.x = 0;
-      gdk_rect.y = 0;
-      gdk_rect.width = w;
-      gdk_rect.height = h;
-      gtk_widget_draw( m_wxwindow, &gdk_rect );
+        if (rect)
+        {
+            gdk_window_clear_area( m_wxwindow->window,
+                                   rect->x, rect->y,
+                                   rect->width,
+                                   rect->height );
+        }
+        else
+        {
+            Clear();
+        }
+    }
+    
+    if (!rect)
+    {
+        if (m_wxwindow)
+            gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
+       else
+            gtk_widget_draw( m_widget, (GdkRectangle*) NULL );

     }
     }

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

     else
     else

-      gtk_widget_draw( m_widget, &gdk_rect );
-  }
+    {
+        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)
+            gtk_widget_draw( m_wxwindow, &gdk_rect );
+        else
+            gtk_widget_draw( m_widget, &gdk_rect );
+    }

 }
 
 wxRegion wxWindow::GetUpdateRegion() const
 }
 
 wxRegion wxWindow::GetUpdateRegion() const


@@ -2015,22 +2404,22 @@ wxRegion wxWindow::GetUpdateRegion() const
 
 bool wxWindow::IsExposed( int x, int y) const
 {
 
 bool wxWindow::IsExposed( int x, int y) const
 {

-  return (m_updateRegion.Contains( x, y ) != wxOutRegion );
+    return (m_updateRegion.Contains( x, y ) != wxOutRegion );

 }
 
 bool wxWindow::IsExposed( int x, int y, int w, int h ) const
 {
 }
 
 bool wxWindow::IsExposed( int x, int y, int w, int h ) const
 {

-  return (m_updateRegion.Contains( x, y, w, h ) != wxOutRegion );
+    return (m_updateRegion.Contains( x, y, w, h ) != wxOutRegion );

 }
 
 bool wxWindow::IsExposed( const wxPoint& pt ) const
 {
 }
 
 bool wxWindow::IsExposed( const wxPoint& pt ) const
 {

-  return (m_updateRegion.Contains( pt.x, pt.y ) != wxOutRegion );
+    return (m_updateRegion.Contains( pt.x, pt.y ) != wxOutRegion );

 }
 
 bool wxWindow::IsExposed( const wxRect& rect ) const
 {
 }
 
 bool wxWindow::IsExposed( const wxRect& rect ) const
 {

-  return (m_updateRegion.Contains( rect.x, rect.y, rect.width, rect.height ) != wxOutRegion );
+    return (m_updateRegion.Contains( rect.x, rect.y, rect.width, rect.height ) != wxOutRegion );

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


@@ -2051,9 +2440,6 @@ void wxWindow::SetBackgroundColour( const wxColour &colour )
 
     if (m_backgroundColour == colour) return;
 
 
     if (m_backgroundColour == colour) return;
 

-    if (!m_backgroundColour.Ok())
-        if (wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ) == colour) return;
-

     m_backgroundColour = colour;
     if (!m_backgroundColour.Ok()) return;
 
     m_backgroundColour = colour;
     if (!m_backgroundColour.Ok()) return;
 


@@ -2065,7 +2451,19 @@ void wxWindow::SetBackgroundColour( const wxColour &colour )
         gdk_window_clear( window );
     }
 
         gdk_window_clear( window );
     }
 

-    ApplyWidgetStyle();
+    wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
+    if (sysbg.Red() == colour.Red() && 
+        sysbg.Green() == colour.Green() && 
+        sysbg.Blue() == colour.Blue())
+    {
+        m_backgroundColour = wxNullColour;
+        ApplyWidgetStyle();
+       m_backgroundColour = sysbg;
+    } 
+    else
+    {
+        ApplyWidgetStyle();
+    }

 }
 
 wxColour wxWindow::GetForegroundColour() const
 }
 
 wxColour wxWindow::GetForegroundColour() const


@@ -2082,47 +2480,59 @@ void wxWindow::SetForegroundColour( const wxColour &colour )
     m_foregroundColour = colour;
     if (!m_foregroundColour.Ok()) return;
 
     m_foregroundColour = colour;
     if (!m_foregroundColour.Ok()) return;
 

-    ApplyWidgetStyle();
+    wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
+    if (sysbg.Red() == colour.Red() && 
+        sysbg.Green() == colour.Green() && 
+        sysbg.Blue() == colour.Blue())
+    {
+        m_backgroundColour = wxNullColour;
+        ApplyWidgetStyle();
+       m_backgroundColour = sysbg;
+    } 
+    else
+    {
+        ApplyWidgetStyle();
+    }

 }
 
 GtkStyle *wxWindow::GetWidgetStyle()
 {
 }
 
 GtkStyle *wxWindow::GetWidgetStyle()
 {

-  if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
+    if (m_widgetStyle) gtk_style_unref( m_widgetStyle );

 
 

-  m_widgetStyle =
-    gtk_style_copy(
-      gtk_widget_get_style( m_widget ) );
+    m_widgetStyle =
+      gtk_style_copy(
+        gtk_widget_get_style( m_widget ) );

 
 

-  return m_widgetStyle;
+    return m_widgetStyle;

 }
 
 void wxWindow::SetWidgetStyle()
 {
 }
 
 void wxWindow::SetWidgetStyle()
 {

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

 
 

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

 
 

-  if (m_foregroundColour.Ok())
-  {
-    m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
-    style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
-    style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
-    style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
-  }
+    if (m_foregroundColour.Ok())
+    {
+        m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
+        style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
+        style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
+        style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
+    }

 
 

-  if (m_backgroundColour.Ok())
-  {
-    m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
-    style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
-    style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
-    style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
-    style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
-    style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
-    style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
-    style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
-    style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
-  }
+    if (m_backgroundColour.Ok())
+    {
+        m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
+        style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
+        style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
+        style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
+        style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
+        style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
+        style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
+        style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
+        style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
+    }

 }
 
 void wxWindow::ApplyWidgetStyle()
 }
 
 void wxWindow::ApplyWidgetStyle()


@@ -2131,93 +2541,99 @@ void wxWindow::ApplyWidgetStyle()
 
 bool wxWindow::Validate()
 {
 
 bool wxWindow::Validate()
 {

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

 
 

-  wxNode *node = m_children.First();
-  while (node)
-  {
-    wxWindow *child = (wxWindow *)node->Data();
-    if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
-      { return FALSE; }
-    node = node->Next();
-  }
-  return TRUE;
+    wxNode *node = m_children.First();
+    while (node)
+    {
+        wxWindow *child = (wxWindow *)node->Data();
+        if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
+        { 
+           return FALSE; 
+       }
+        node = node->Next();
+    }
+    return TRUE;

 }
 
 bool wxWindow::TransferDataToWindow()
 {
 }
 
 bool wxWindow::TransferDataToWindow()
 {

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

 
 

-  wxNode *node = m_children.First();
-  while (node)
-  {
-    wxWindow *child = (wxWindow *)node->Data();
-    if (child->GetValidator() && /* child->GetValidator()->Ok() && */
-  !child->GetValidator()->TransferToWindow() )
+    wxNode *node = m_children.First();
+    while (node)

     {
     {

-      wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION );
-      return FALSE;
+        wxWindow *child = (wxWindow *)node->Data();
+        if (child->GetValidator() && /* child->GetValidator()->Ok() && */
+            !child->GetValidator()->TransferToWindow() )
+        {
+            wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION );
+            return FALSE;
+        }
+        node = node->Next();

     }
     }

-    node = node->Next();
-  }
-  return TRUE;
+    return TRUE;

 }
 
 bool wxWindow::TransferDataFromWindow()
 {
 }
 
 bool wxWindow::TransferDataFromWindow()
 {

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

 
 

-  wxNode *node = m_children.First();
-  while (node)
-  {
-    wxWindow *child = (wxWindow *)node->Data();
-    if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
-      { return FALSE; }
-   node = node->Next();
-  }
-  return TRUE;
+    wxNode *node = m_children.First();
+    while (node)
+    {
+        wxWindow *child = (wxWindow *)node->Data();
+        if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
+        { 
+           return FALSE; 
+       }
+        node = node->Next();
+    }
+    return TRUE;

 }
 
 void wxWindow::SetAcceleratorTable( const wxAcceleratorTable& accel )
 {
 }
 
 void wxWindow::SetAcceleratorTable( const wxAcceleratorTable& accel )
 {

-  m_acceleratorTable = accel;
+    m_acceleratorTable = accel;

 }
 
 void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
 {
 }
 
 void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
 {

-  TransferDataToWindow();
+    TransferDataToWindow();

 }
 
 void wxWindow::InitDialog()
 {
 }
 
 void wxWindow::InitDialog()
 {

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

 
 

-  wxInitDialogEvent event(GetId());
-  event.SetEventObject( this );
-  GetEventHandler()->ProcessEvent(event);
+    wxInitDialogEvent event(GetId());
+    event.SetEventObject( this );
+    GetEventHandler()->ProcessEvent(event);

 }
 
 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 {
 }
 
 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 {

-  menu->SetInvokingWindow( win );
-  wxNode *node = menu->m_items.First();
-  while (node)
-  {
-    wxMenuItem *menuitem = (wxMenuItem*)node->Data();
-    if (menuitem->IsSubMenu())
-      SetInvokingWindow( menuitem->GetSubMenu(), win );
-    node = node->Next();
-  }
+    menu->SetInvokingWindow( win );
+    wxNode *node = menu->m_items.First();
+    while (node)
+    {
+        wxMenuItem *menuitem = (wxMenuItem*)node->Data();
+        if (menuitem->IsSubMenu())
+        {
+           SetInvokingWindow( menuitem->GetSubMenu(), win );
+       }
+        node = node->Next();
+    }

 }
 
 bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) )
 {
 }
 
 bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) )
 {

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

 
 

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

 
 

-  SetInvokingWindow( menu, this );
-  gtk_menu_popup(
+    SetInvokingWindow( menu, this );
+    gtk_menu_popup(

                   GTK_MENU(menu->m_menu),
                   (GtkWidget *)NULL,          // parent menu shell
                   (GtkWidget *)NULL,          // parent menu item
                   GTK_MENU(menu->m_menu),
                   (GtkWidget *)NULL,          // parent menu shell
                   (GtkWidget *)NULL,          // parent menu item


@@ -2226,91 +2642,109 @@ bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) )
                   0,                          // button used to activate it
                   0//gs_timeLastClick            // the time of activation
                 );
                   0,                          // button used to activate it
                   0//gs_timeLastClick            // the time of activation
                 );

-  return TRUE;
+    return TRUE;

 }
 
 }
 

+#if wxUSE_DRAG_AND_DROP
+

 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 {
 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 {

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

 
 

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

 
 

-  if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
+    if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );

 
 

-  if (m_dropTarget) delete m_dropTarget;
-  m_dropTarget = dropTarget;
+    if (m_dropTarget) delete m_dropTarget;
+    m_dropTarget = dropTarget;

 
 

-  if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
+    if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );

 }
 
 wxDropTarget *wxWindow::GetDropTarget() const
 {
 }
 
 wxDropTarget *wxWindow::GetDropTarget() const
 {

-  return m_dropTarget;
+    return m_dropTarget;

 }
 
 }
 

+#endif
+

 GtkWidget* wxWindow::GetConnectWidget()
 {
 GtkWidget* wxWindow::GetConnectWidget()
 {

-  GtkWidget *connect_widget = m_widget;
-  if (m_wxwindow) connect_widget = m_wxwindow;
+    GtkWidget *connect_widget = m_widget;
+    if (m_wxwindow) connect_widget = m_wxwindow;

 
 

-  return connect_widget;
+    return connect_widget;

 }
 
 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 {
 }
 
 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 {

-  if (m_wxwindow) return (window == m_wxwindow->window);
-  return (window == m_widget->window);
+    if (m_wxwindow) return (window == m_wxwindow->window);
+    return (window == m_widget->window);

 }
 
 void wxWindow::SetFont( const wxFont &font )
 {
 }
 
 void wxWindow::SetFont( const wxFont &font )
 {

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

 
 

-  if (((wxFont*)&font)->Ok())
-    m_font = font;
-  else
-    m_font = *wxSWISS_FONT;
+    if (((wxFont*)&font)->Ok())
+        m_font = font;
+    else
+        m_font = *wxSWISS_FONT;

 
 

-  ApplyWidgetStyle();
+    wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
+    if (sysbg.Red() == m_backgroundColour.Red() && 
+        sysbg.Green() == m_backgroundColour.Green() && 
+        sysbg.Blue() == m_backgroundColour.Blue())
+    {
+        m_backgroundColour = wxNullColour;
+        ApplyWidgetStyle();
+       m_backgroundColour = sysbg;
+    } 
+    else
+    {
+        ApplyWidgetStyle();
+    }

 }
 
 void wxWindow::SetWindowStyleFlag( long flag )
 {
 }
 
 void wxWindow::SetWindowStyleFlag( long flag )
 {

-  m_windowStyle = flag;
+    m_windowStyle = flag;

 }
 
 long wxWindow::GetWindowStyleFlag() const
 {
 }
 
 long wxWindow::GetWindowStyleFlag() const
 {

-  return m_windowStyle;
+    return m_windowStyle;

 }
 
 void wxWindow::CaptureMouse()
 {
 }
 
 void wxWindow::CaptureMouse()
 {

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

 
 

-  wxCHECK_RET( g_capturing == FALSE, "CaptureMouse called twice" );
+    wxCHECK_RET( g_capturing == FALSE, "CaptureMouse called twice" );

 
 

-  GtkWidget *connect_widget = GetConnectWidget();
-  gtk_grab_add( connect_widget );
-  gdk_pointer_grab ( connect_widget->window, FALSE,
-                    (GdkEventMask)
-        (GDK_BUTTON_PRESS_MASK |
-        GDK_BUTTON_RELEASE_MASK |
-        GDK_POINTER_MOTION_MASK),
-        (GdkWindow *) NULL, (GdkCursor *) NULL, GDK_CURRENT_TIME );
-  g_capturing = TRUE;
+    GtkWidget *connect_widget = GetConnectWidget();
+    gtk_grab_add( connect_widget );
+    gdk_pointer_grab( connect_widget->window, FALSE,
+                      (GdkEventMask)
+                         (GDK_BUTTON_PRESS_MASK |
+                          GDK_BUTTON_RELEASE_MASK |
+                          GDK_POINTER_MOTION_MASK),
+                      (GdkWindow *) NULL, 
+                     (GdkCursor *) NULL, 
+                     GDK_CURRENT_TIME );
+    g_capturing = TRUE;

 }
 
 void wxWindow::ReleaseMouse()
 {
 }
 
 void wxWindow::ReleaseMouse()
 {

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

 
 

-  wxCHECK_RET( g_capturing == TRUE, "ReleaseMouse called twice" );
+    wxCHECK_RET( g_capturing == TRUE, "ReleaseMouse called twice" );

 
 

-  GtkWidget *connect_widget = GetConnectWidget();
-  gtk_grab_remove( connect_widget );
-  gdk_pointer_ungrab ( GDK_CURRENT_TIME );
-  g_capturing = FALSE;
+    GtkWidget *connect_widget = GetConnectWidget();
+    gtk_grab_remove( connect_widget );
+    gdk_pointer_ungrab ( GDK_CURRENT_TIME );
+    g_capturing = FALSE;

 }
 
 void wxWindow::SetTitle( const wxString &WXUNUSED(title) )
 }
 
 void wxWindow::SetTitle( const wxString &WXUNUSED(title) )


@@ -2319,214 +2753,211 @@ void wxWindow::SetTitle( const wxString &WXUNUSED(title) )
 
 wxString wxWindow::GetTitle() const
 {
 
 wxString wxWindow::GetTitle() const
 {

-  return (wxString&)m_windowName;
+    return (wxString&)m_windowName;

 }
 
 wxString wxWindow::GetLabel() const
 {
 }
 
 wxString wxWindow::GetLabel() const
 {

-  return GetTitle();
+    return GetTitle();

 }
 
 void wxWindow::SetName( const wxString &name )
 {
 }
 
 void wxWindow::SetName( const wxString &name )
 {

-  m_windowName = name;
+    m_windowName = name;

 }
 
 wxString wxWindow::GetName() const
 {
 }
 
 wxString wxWindow::GetName() const
 {

-  return (wxString&)m_windowName;
+    return (wxString&)m_windowName;

 }
 
 bool wxWindow::IsShown() const
 {
 }
 
 bool wxWindow::IsShown() const
 {

-  return m_isShown;
+    return m_isShown;

 }
 
 bool wxWindow::IsRetained()
 {
 }
 
 bool wxWindow::IsRetained()
 {

-  return FALSE;
+    return FALSE;

 }
 
 wxWindow *wxWindow::FindWindow( long id )
 {
 }
 
 wxWindow *wxWindow::FindWindow( long id )
 {

-  if (id == m_windowId) return this;
-  wxNode *node = m_children.First();
-  while (node)
-  {
-    wxWindow *child = (wxWindow*)node->Data();
-    wxWindow *res = child->FindWindow( id );
-    if (res) return res;
-    node = node->Next();
-  }
-  return (wxWindow *) NULL;
+    if (id == m_windowId) return this;
+    wxNode *node = m_children.First();
+    while (node)
+    {
+        wxWindow *child = (wxWindow*)node->Data();
+        wxWindow *res = child->FindWindow( id );
+        if (res) return res;
+        node = node->Next();
+    }
+    return (wxWindow *) NULL;

 }
 
 wxWindow *wxWindow::FindWindow( const wxString& name )
 {
 }
 
 wxWindow *wxWindow::FindWindow( const wxString& name )
 {

-  if (name == m_windowName) return this;
-  wxNode *node = m_children.First();
-  while (node)
-  {
-    wxWindow *child = (wxWindow*)node->Data();
-    wxWindow *res = child->FindWindow( name );
-    if (res) return res;
-    node = node->Next();
-  }
-  return (wxWindow *) NULL;
+    if (name == m_windowName) return this;
+    wxNode *node = m_children.First();
+    while (node)
+    {
+        wxWindow *child = (wxWindow*)node->Data();
+        wxWindow *res = child->FindWindow( name );
+        if (res) return res;
+        node = node->Next();
+    }
+    return (wxWindow *) NULL;

 }
 
 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
       int range, bool refresh )
 {
 }
 
 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
       int range, bool refresh )
 {

-  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
-
-  wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+    wxCHECK_RET( m_widget != NULL, "invalid window" );

 
 

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

 
 

-  m_hasScrolling = TRUE;
+    m_hasScrolling = TRUE;

 
 

-  if (orient == wxHORIZONTAL)
-  {
-    float fpos = (float)pos;
-    float frange = (float)range;
-    float fthumb = (float)thumbVisible;
-
-    if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
-        (fabs(fthumb-m_hAdjust->page_size) < 0.2))
+    if (orient == wxHORIZONTAL)

     {
     {

-      SetScrollPos( orient, pos, refresh );
-      return;
-    }
-
-    m_oldHorizontalPos = fpos;
+        float fpos = (float)pos;
+        float frange = (float)range;
+        float fthumb = (float)thumbVisible;
+        if (fpos > frange-fthumb) fpos = frange-fthumb;
+        if (fpos < 0.0) fpos = 0.0;
+
+        if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
+            (fabs(fthumb-m_hAdjust->page_size) < 0.2))
+        {
+            SetScrollPos( orient, pos, refresh );
+            return;
+        }

 
 

-    m_hAdjust->lower = 0.0;
-    m_hAdjust->upper = frange;
-    m_hAdjust->value = fpos;
-    m_hAdjust->step_increment = 1.0;
-    m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
-    m_hAdjust->page_size = fthumb;
-  }
-  else
-  {
-    float fpos = (float)pos;
-    float frange = (float)range;
-    float fthumb = (float)thumbVisible;
+        m_oldHorizontalPos = fpos;

 
 

-    if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
-        (fabs(fthumb-m_vAdjust->page_size) < 0.2))
-    {
-      SetScrollPos( orient, pos, refresh );
-      return;
+        m_hAdjust->lower = 0.0;
+        m_hAdjust->upper = frange;
+        m_hAdjust->value = fpos;
+        m_hAdjust->step_increment = 1.0;
+        m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
+        m_hAdjust->page_size = fthumb;

     }
     }

+    else
+    {
+        float fpos = (float)pos;
+        float frange = (float)range;
+        float fthumb = (float)thumbVisible;
+        if (fpos > frange-fthumb) fpos = frange-fthumb;
+        if (fpos < 0.0) fpos = 0.0;
+
+        if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
+            (fabs(fthumb-m_vAdjust->page_size) < 0.2))
+        {
+            SetScrollPos( orient, pos, refresh );
+            return;
+        }

 
 

-    m_oldVerticalPos = fpos;
+        m_oldVerticalPos = fpos;

 
 

-    m_vAdjust->lower = 0.0;
-    m_vAdjust->upper = frange;
-    m_vAdjust->value = fpos;
-    m_vAdjust->step_increment = 1.0;
-    m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
-    m_vAdjust->page_size = fthumb;
-  }
+        m_vAdjust->lower = 0.0;
+        m_vAdjust->upper = frange;
+        m_vAdjust->value = fpos;
+        m_vAdjust->step_increment = 1.0;
+        m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
+        m_vAdjust->page_size = fthumb;
+    }

 
 

-  if (m_wxwindow->window)
-  {
-    if (orient == wxHORIZONTAL)
-      gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
-    else
-      gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
+    if (m_wxwindow->window)
+    {
+        if (orient == wxHORIZONTAL)
+            gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
+        else
+            gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );

 
 

-    gtk_widget_set_usize( m_widget, m_width, m_height );
-  }
+        gtk_widget_set_usize( m_widget, m_width, m_height );
+    }

 }
 
 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
 {
 }
 
 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
 {

-  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
-
-  wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+    wxCHECK_RET( m_widget != NULL, "invalid window" );

 
 

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

 
 

-  if (orient == wxHORIZONTAL)
-  {
-    float fpos = (float)pos;
-    m_oldHorizontalPos = fpos;
+    if (orient == wxHORIZONTAL)
+    {
+        float fpos = (float)pos;
+        if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
+        if (fpos < 0.0) fpos = 0.0;
+        m_oldHorizontalPos = fpos;

 
 

-    if (fabs(fpos-m_hAdjust->value) < 0.2) return;
-    m_hAdjust->value = fpos;
-  }
-  else
-  {
-    float fpos = (float)pos;
-    m_oldVerticalPos = fpos;
-    if (fabs(fpos-m_vAdjust->value) < 0.2) return;
-    m_vAdjust->value = fpos;
-  }
+        if (fabs(fpos-m_hAdjust->value) < 0.2) return;
+        m_hAdjust->value = fpos;
+    }
+    else
+    {
+        float fpos = (float)pos;
+        if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
+        if (fpos < 0.0) fpos = 0.0;
+        m_oldVerticalPos = fpos;
+    
+        if (fabs(fpos-m_vAdjust->value) < 0.2) return;
+        m_vAdjust->value = fpos;
+    }

 
 

-  if (!m_isScrolling)
-  {
-    if (m_wxwindow->window)
+    if (!m_isScrolling)

     {
     {

-      if (orient == wxHORIZONTAL)
-        gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
-      else
-        gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
+        if (m_wxwindow->window)
+        {
+            if (orient == wxHORIZONTAL)
+                gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
+            else
+                gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
+        }

     }
     }

-  }

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

-  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
-
-  wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+    wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );

 
 

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

 
 

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

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

-  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
-
-  wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+    wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );

 
 

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

 
 

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

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

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

 
 

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

 
 

-  if (!m_wxwindow) return 0;
-
-  if (orient == wxHORIZONTAL)
-    return (int)(m_hAdjust->upper+0.5);
-  else
-    return (int)(m_vAdjust->upper+0.5);
+    if (orient == wxHORIZONTAL)
+        return (int)(m_hAdjust->upper+0.5);
+    else
+        return (int)(m_vAdjust->upper+0.5);

 }
 
 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 {
 }
 
 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 {

-  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
-
-  wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+    wxCHECK_RET( m_widget != NULL, "invalid window" );

 
 

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

 
     int cw = 0;
     int ch = 0;
 
     int cw = 0;
     int ch = 0;


@@ -2536,8 +2967,8 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
     int h = ch - abs(dy);
     if ((h < 0) || (w < 0))
     {
     int h = ch - abs(dy);
     if ((h < 0) || (w < 0))
     {

-      Refresh();
-      return;
+        Refresh();
+        return;

     }
     int s_x = 0;
     int s_y = 0;
     }
     int s_x = 0;
     int s_y = 0;


@@ -2550,12 +2981,12 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 
     if (!m_scrollGC)
     {
 
     if (!m_scrollGC)
     {

-      m_scrollGC = gdk_gc_new( m_wxwindow->window );
-      gdk_gc_set_exposures( m_scrollGC, TRUE );
+        m_scrollGC = gdk_gc_new( m_wxwindow->window );
+        gdk_gc_set_exposures( m_scrollGC, TRUE );

     }
 
     gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
     }
 
     gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,

-      m_wxwindow->window, s_x, s_y, w, h );
+        m_wxwindow->window, s_x, s_y, w, h );

 
     wxRect rect;
     if (dx < 0) rect.x = cw+dx; else rect.x = 0;
 
     wxRect rect;
     if (dx < 0) rect.x = cw+dx; else rect.x = 0;


@@ -2873,19 +3304,17 @@ void wxWindow::SetConstraintSizes(bool recurse)
 
     wxString winName;
   if (GetName() == "")
 
     wxString winName;
   if (GetName() == "")

-    winName = _("unnamed");
+    winName = "unnamed";

   else
     winName = GetName();
   else
     winName = GetName();

-    wxDebugMsg(_("Constraint(s) not satisfied for window of type %s, name %s:\n"), (const char *)windowClass, (const char *)winName);
-    if (!constr->left.GetDone())
-      wxDebugMsg(_("  unsatisfied 'left' constraint.\n"));
-    if (!constr->right.GetDone())
-      wxDebugMsg(_("  unsatisfied 'right' constraint.\n"));
-    if (!constr->width.GetDone())
-      wxDebugMsg(_("  unsatisfied 'width' constraint.\n"));
-    if (!constr->height.GetDone())
-      wxDebugMsg(_("  unsatisfied 'height' constraint.\n"));
-    wxDebugMsg(_("Please check constraints: try adding AsIs() constraints.\n"));
+    wxLogDebug( "Constraint(s) not satisfied for window of type %s, name %s:\n", 
+                (const char *)windowClass, 
+               (const char *)winName);
+    if (!constr->left.GetDone()) wxLogDebug( "  unsatisfied 'left' constraint.\n" );
+    if (!constr->right.GetDone()) wxLogDebug( "  unsatisfied 'right' constraint.\n" );
+    if (!constr->width.GetDone()) wxLogDebug( "  unsatisfied 'width' constraint.\n" );
+    if (!constr->height.GetDone())  wxLogDebug( "  unsatisfied 'height' constraint.\n" );
+    wxLogDebug( "Please check constraints: try adding AsIs() constraints.\n" );

   }
 
   if (recurse)
   }
 
   if (recurse)


@@ -3005,8 +3434,8 @@ void wxWindow::GetClientSizeConstraint(int *w, int *h) const
 
 void wxWindow::GetPositionConstraint(int *x, int *y) const
 {
 
 void wxWindow::GetPositionConstraint(int *x, int *y) const
 {

-  wxLayoutConstraints *constr = GetConstraints();
-  if (constr)
+ wxLayoutConstraints *constr = GetConstraints();
+    if (constr)

   {
     *x = constr->left.GetValue();
     *y = constr->top.GetValue();
   {
     *x = constr->left.GetValue();
     *y = constr->top.GetValue();


@@ -3015,12 +3444,7 @@ void wxWindow::GetPositionConstraint(int *x, int *y) const
     GetPosition(x, y);
 }
 
     GetPosition(x, y);
 }
 

-bool wxWindow::AcceptsFocus() const
-{
-  return IsEnabled() && IsShown();
-}
-

 void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) )
 {
 void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) )
 {

-  UpdateWindowUI();
+    UpdateWindowUI();

 }
 }