another API change fix

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

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index d65fec1d0906395e8589bcb80d3f352555209a4b..0a7b3f3bc54538dcfaf4b5c924c4124ec47e2d8d 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -2,9 +2,8 @@
 // Name:        window.cpp
 // Purpose:
 // Author:      Robert Roebling
 // Name:        window.cpp
 // Purpose:
 // Author:      Robert Roebling

-// Created:     01/02/97
-// Id:
-// Copyright:   (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Id:          $Id$
+// Copyright:   (c) 1998 Robert Roebling, Julian Smart

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 


@@ -24,14 +23,101 @@
 #include "wx/msgdlg.h"
 #include "wx/dcclient.h"
 #include "wx/dnd.h"
 #include "wx/msgdlg.h"
 #include "wx/dcclient.h"
 #include "wx/dnd.h"

-#include "wx/mdi.h"
-#include "wx/notebook.h"
+#include "wx/menu.h"

 #include "wx/statusbr.h"
 #include "wx/statusbr.h"

-//#include "wx/treectrl.h"
+#include "wx/intl.h"
+#include "wx/settings.h"
+#include "gdk/gdkprivate.h"

 #include "gdk/gdkkeysyms.h"
 #include "gdk/gdkkeysyms.h"

+

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

-#include "wx/gtk/win_gtk.h"
-#include "gdk/gdkprivate.h"
+
+//-----------------------------------------------------------------------------
+// documentation on internals
+//-----------------------------------------------------------------------------
+
+/*
+   I have been asked several times about writing some documentation about
+   the GTK port of wxWindows, especially its internal structures. Obviously,
+   you cannot understand wxGTK without knowing a little about the GTK, but
+   some more information about what the wxWindow, which is the base class
+   for all other window classes, does seems required as well.
+
+   What does wxWindow do? It contains the common interface for the following
+   jobs of its descendants:
+
+   1) Define the rudimentary behaviour common to all window classes, such as
+   resizing, intercepting user input (so as to make it possible to use these
+   events for special purposes in a derived class), window names etc.
+
+   2) Provide the possibility to contain and manage children, if the derived
+   class is allowed to contain children, which holds true for those window
+   classes which do not display a native GTK widget. To name them, these
+   classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
+   work classes are a special case and are handled a bit differently from
+   the rest. The same holds true for the wxNotebook class.
+
+   3) Provide the possibility to draw into a client area of a window. This,
+   too, only holds true for classes that do not display a native GTK widget
+   as above.
+
+   4) Provide the entire mechanism for scrolling widgets. This actual inter-
+   face for this is usually in wxScrolledWindow, but the GTK implementation
+   is in this class.
+
+   5) A multitude of helper or extra methods for special purposes, such as
+   Drag'n'Drop, managing validators etc.
+
+   Normally one might expect, that one wxWindows window would always correspond
+   to one GTK widget. Under GTK, there is no such allround widget that has all
+   the functionality. Moreover, the GTK defines a client area as a different
+   widget from the actual widget you are handling. Last but not least some
+   special classes (e.g. wxFrame) handle different categories of widgets and
+   still have the possibility to draw something in the client area.
+   It was therefore required to write a special purpose GTK widget, that would
+   represent a client area in the sense of wxWindows capable to do the jobs
+   2), 3) and 4). I have written this class and it resides in win_gtk.c of
+   this directory.
+
+   All windows must have a widget, with which they interact with other under-
+   lying GTK widgets. It is this widget, e.g. that has to be resized etc and
+   thw wxWindow class has a member variable called m_widget which holds a
+   pointer to this widget. When the window class represents a GTK native widget,
+   this is (in most cases) the only GTK widget the class manages. E.g. the
+   wxStatitText class handles only a GtkLabel widget a pointer to which you
+   can find in m_widget (defined in wxWindow)
+
+   When the class has a client area for drawing into and for containing children
+   it has to handle the client area widget (of the type GtkMyFixed, defined in
+   win_gtk.c), but there could be any number of widgets, handled by a class
+   The common rule for all windows is only, that the widget that interacts with
+   the rest of GTK must be referenced in m_widget and all other widgets must be
+   children of this widget on the GTK level. The top-most widget, which also
+   represents the client area, must be in the m_wxwindow field and must be of
+   the type GtkMyFixed.
+
+   As I said, the window classes that display a GTK native widget only have
+   one widget, so in the case of e.g. the wxButton class m_widget holds a
+   pointer to a GtkButton widget. But windows with client areas (for drawing
+   and children) have a m_widget field that is a pointer to a GtkScrolled-
+   Window and a m_wxwindow field that is pointer to a GtkMyFixed and this
+   one is (in the GTK sense) a child of the GtkScrolledWindow.
+
+   If the m_wxwindow field is set, then all input to this widget is inter-
+   cepted and sent to the wxWindows class. If not, all input to the widget
+   that gets pointed to by m_widget gets intercepted and sent to the class.
+
+*/
+
+//-------------------------------------------------------------------------
+// conditional compilation
+//-------------------------------------------------------------------------
+
+#if (GTK_MINOR_VERSION == 1)
+#if (GTK_MICRO_VERSION >= 5)
+#define NEW_GTK_SCROLL_CODE
+#endif
+#endif

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


@@ -40,1122 +126,1310 @@
 extern wxList wxPendingDelete;
 extern wxList wxTopLevelWindows;
 extern bool   g_blockEventsOnDrag;
 extern wxList wxPendingDelete;
 extern wxList wxTopLevelWindows;
 extern bool   g_blockEventsOnDrag;

+extern bool   g_blockEventsOnScroll;
+static bool   g_capturing = FALSE;
+
+// hack: we need something to pass to gtk_menu_popup, so we store the time of
+// the last click here
+static guint32 gs_timeLastClick = 0;

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// GTK callbacks for wxWindows event system
+// "expose_event" (of m_wxwindow, not of m_widget)

 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 

-//-----------------------------------------------------------------------------
-// expose (of m_wxwindow, not of m_widget)
+static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
+{
+    if (!win->HasVMT()) return;
+
+    win->m_updateRegion.Union( gdk_event->area.x,
+                               gdk_event->area.y,
+                               gdk_event->area.width,
+                               gdk_event->area.height );
+
+    if (gdk_event->count > 0) return;

 
 

-void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
-{ 
-  if (!win->HasVMT()) return;
-  if (g_blockEventsOnDrag) return;
-  

 /*
 /*

- if (IS_KIND_OF(win,wxTreeCtrl))
- {

     printf( "OnExpose from " );
     printf( "OnExpose from " );

-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
-  
-  printf( "x: %d \n", gdk_event->area.x );
-  printf( "y: %d \n", gdk_event->area.y );
-  printf( "w: %d \n", gdk_event->area.width );
-  printf( "h: %d \n", gdk_event->area.height );
-}
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 
 */
 

-  win->m_updateRegion.Union( gdk_event->area.x,
-                             gdk_event->area.y,
-           gdk_event->area.width,
-           gdk_event->area.height );
-           
-  if (gdk_event->count > 0) return;
+    wxPaintEvent event( win->GetId() );
+    event.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( event );

 
 

-  wxPaintEvent event( win->GetId() );
-  event.SetEventObject( win );
-  win->ProcessEvent( event );
-  
-  win->m_updateRegion.Clear();
-};
+    win->m_updateRegion.Clear();
+}

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// draw (of m_wxwindow, not of m_widget)
-
-void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
-{ 
-  if (!win->HasVMT()) return;
-  if (g_blockEventsOnDrag) return;
-  
-/*
-  printf( "OnDraw from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
-  
-  printf( "x: %d \n", rect->x );
-  printf( "y: %d \n", rect->y );
-  printf( "w: %d \n", rect->width );
-  printf( "h: %d \n", rect->height );
-*/
+// "draw" (of m_wxwindow, not of m_widget)
+//-----------------------------------------------------------------------------

 
 

-  win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
-           
-  wxPaintEvent event( win->GetId() );
-  event.SetEventObject( win );
-  win->ProcessEvent( event );
-  
-  win->m_updateRegion.Clear();
-};
+static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
+{
+    if (!win->HasVMT()) return;

 
 

-//-----------------------------------------------------------------------------
-// size 
-//      I don't any longer intercept GTK's internal resize events, except 
-//      for frames and from within MDI and tabbed windows (client area
-//      size determined internally by GTK, not wxWin).
+    win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );

 
 

-/*
-void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxWindow *win )
-{ 
-  if (!win->HasVMT()) return;
-  if (g_blockEventsOnDrag) return;
-  
-  return;
+    wxPaintEvent event( win->GetId() );
+    event.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( event );

 
 

-  if ((win->m_x == alloc->x) &&
-      (win->m_y == alloc->y) &&
-      (win->m_width == alloc->width) &&
-      (win->m_height == alloc->height))
-  {
-    return;
-  };
-  
-  printf( "OnResize from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( " .\n" );
-    
-  printf( "  Old: X: %d  Y: %d ", win->m_x, win->m_y );
-  printf( "  W: %d  H: %d ", win->m_width, win->m_height );
-  printf( " .\n" );
-    
-  printf( "  New: X: %d  Y: %d ", alloc->x, alloc->y );
-  printf( "  W: %d  H: %d ", alloc->width, alloc->height );
-  printf( " .\n" );
-  
-  wxSizeEvent event( wxSize( alloc->width, alloc->height), win->GetId() );
-  event.SetEventObject( win );
-  win->ProcessEvent( event );
-};
-*/
+    win->m_updateRegion.Clear();
+}

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// key_press
+// "key_press_event"
+//-----------------------------------------------------------------------------

 
 

-gint gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), GdkEventKey *gdk_event, wxWindow *win )
-{ 
-  if (!win->HasVMT()) return FALSE;
-  if (g_blockEventsOnDrag) return FALSE;
+static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
+{
+    if (!win->HasVMT()) return FALSE;
+    if (g_blockEventsOnDrag) return FALSE;

 
 /*
 
 /*

-  printf( "OnKeyPress from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
+    printf( "OnKeyPress 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:
+    long key_code = 0;
+    switch (gdk_event->keyval)

     {
     {

-      if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF)) 
-        key_code = gdk_event->keyval;
-    };
-  };
-
-  if (!key_code) return FALSE;
-  
-  wxKeyEvent event( wxEVT_CHAR );
-  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->ProcessEvent( event );
-/*
-  if (ret) printf( "found.\n") ;
-*/
-  return ret;
-};
+        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_CHAR );
+    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)
+    {
+        wxWindow *ancestor = win;
+        while (ancestor)
+        {
+            int command = ancestor->GetAcceleratorTable()->GetCommand( event );
+            if (command != -1)
+            {
+                wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
+                ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
+                break;
+            }
+            ancestor = ancestor->GetParent();
+        }
+    }
+
+    if (ret)
+    {
+        if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
+            gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+    }
+
+    return ret;
+}

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// button_press
+// "button_press_event"
+//-----------------------------------------------------------------------------
+
+static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
+{
+    if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;

 
 

-gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
-{ 
-  if (widget->window != gdk_event->window) return TRUE;
-  if (g_blockEventsOnDrag) return TRUE;
+    if (g_blockEventsOnDrag) return TRUE;
+    if (g_blockEventsOnScroll) return TRUE;

 
 

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

     {
     {

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

 /*
 /*

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

 */
 */

-      
-    };
-  };
-    
-  if (!win->HasVMT()) return TRUE;
-    
+
+        }
+    }
+
+    if (!win->HasVMT()) return TRUE;
+

 /*
 /*

-  printf( "OnButtonPress from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
+    printf( "OnButtonPress from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 */

-  
-  wxEventType event_type = wxEVT_LEFT_DOWN;
-  
-  if (gdk_event->button == 1)
-  {
-    switch (gdk_event->type)
+
+    wxEventType event_type = wxEVT_LEFT_DOWN;
+
+    if (gdk_event->button == 1)

     {
     {

-      case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
-      case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
-      default:  break;
-    };
-  }
-  else if (gdk_event->button == 2)
-  {
-    switch (gdk_event->type)
+        switch (gdk_event->type)
+        {
+            case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
+            case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
+            default:  break;
+        }
+    }
+    else if (gdk_event->button == 2)

     {
     {

-      case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
-      case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
-      default:  break;
-    };
-  }
-  else if (gdk_event->button == 3)
-  {
-    switch (gdk_event->type)
+        switch (gdk_event->type)
+        {
+            case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
+            case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
+            default:  break;
+        }
+    }
+    else if (gdk_event->button == 3)

     {
     {

-      case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
-      case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
-      default:  break;
-    };
-  };
-  
-  wxMouseEvent event( event_type );
-  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_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
-  event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
-  event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
-  
-  event.m_x = (long)gdk_event->x;
-  event.m_y = (long)gdk_event->y;
-  event.SetEventObject( win );
-  
-  win->ProcessEvent( event );
-  
-  return TRUE;
-};
+        switch (gdk_event->type)
+        {
+            case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
+            case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
+            default:  break;
+        }
+    }
+
+    wxMouseEvent event( event_type );
+    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_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
+    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
+    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+
+    event.m_x = (long)gdk_event->x;
+    event.m_y = (long)gdk_event->y;
+
+    // Some control don't have their own X window and thus cannot get
+    // any events.
+
+    if (!g_capturing)
+    {
+        wxNode *node = win->GetChildren().First();
+        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;
+            }
+            node = node->Next();
+        }
+    }
+
+    event.SetEventObject( win );
+
+    gs_timeLastClick = gdk_event->time;
+
+    if (win->GetEventHandler()->ProcessEvent( event ))
+        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
+
+    return TRUE;
+}

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// button_release
+// "button_release_event"
+//-----------------------------------------------------------------------------

 
 

-gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
-{ 
-  if (widget->window != gdk_event->window) return TRUE;
+static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
+{
+    if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
+
+    if (g_blockEventsOnDrag) return TRUE;
+    if (g_blockEventsOnScroll) return TRUE;

 
 

-  if (g_blockEventsOnDrag) return TRUE;
+    if (!win->HasVMT()) return TRUE;

 
 

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

 /*
 /*

-  printf( "OnButtonRelease from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
+    printf( "OnButtonRelease from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 */

-  
-  wxEventType event_type = wxEVT_NULL;
-  
-  switch (gdk_event->button)
-  {
-    case 1: event_type = wxEVT_LEFT_UP; break;
-    case 2: event_type = wxEVT_MIDDLE_UP; break;
-    case 3: event_type = wxEVT_RIGHT_UP; break;
-  };
-
-  wxMouseEvent event( event_type );
-  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_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
-  event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
-  event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
-  event.m_x = (long)gdk_event->x;
-  event.m_y = (long)gdk_event->y;
-  event.SetEventObject( win );
-  
-  win->ProcessEvent( event );
-  
-  return TRUE;
-};
+
+    wxEventType event_type = wxEVT_NULL;
+
+    switch (gdk_event->button)
+    {
+        case 1: event_type = wxEVT_LEFT_UP; break;
+        case 2: event_type = wxEVT_MIDDLE_UP; break;
+        case 3: event_type = wxEVT_RIGHT_UP; break;
+    }
+
+    wxMouseEvent event( event_type );
+    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_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
+    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
+    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+    event.m_x = (long)gdk_event->x;
+    event.m_y = (long)gdk_event->y;
+
+    // Some control don't have their own X window and thus cannot get
+    // any events.
+
+    if (!g_capturing)
+    {
+        wxNode *node = win->GetChildren().First();
+        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;
+            }
+            node = node->Next();
+        }
+    }
+
+    event.SetEventObject( win );
+
+    if (win->GetEventHandler()->ProcessEvent( event ))
+        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
+
+    return TRUE;
+}

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// motion_notify
+// "motion_notify_event"
+//-----------------------------------------------------------------------------
+
+static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
+{
+    if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;

 
 

-gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
-{ 
-  if (widget->window != gdk_event->window) return TRUE;
+    if (g_blockEventsOnDrag) return TRUE;
+    if (g_blockEventsOnScroll) return TRUE;

 
 

-  if (g_blockEventsOnDrag) return TRUE;
+    if (!win->HasVMT()) return TRUE;

 
 

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

 /*
 /*

-  printf( "OnMotion from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
+    printf( "OnMotion from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+      printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 */

-  
-  wxMouseEvent event( wxEVT_MOTION );
-  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_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
-  event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
-  event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
-  
-  event.m_x = (long)gdk_event->x;
-  event.m_y = (long)gdk_event->y;
-  event.SetEventObject( win );
-  
-  win->ProcessEvent( event );
-  
-  return TRUE;
-};

 
 

+    wxMouseEvent event( wxEVT_MOTION );
+    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_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
+    event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
+    event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+
+    event.m_x = (long)gdk_event->x;
+    event.m_y = (long)gdk_event->y;
+
+    // Some control don't have their own X window and thus cannot get
+    // any events.
+
+    if (!g_capturing)
+    {
+        wxNode *node = win->GetChildren().First();
+        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;
+            }
+            node = node->Next();
+        }
+    }
+
+    event.SetEventObject( win );
+
+    if (win->GetEventHandler()->ProcessEvent( event ))
+        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
+
+    return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// "focus_in_event"

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-// focus_in

 
 

-gint gtk_window_focus_in_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
+static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )

 {
 {

-  if (g_blockEventsOnDrag) return TRUE;
-  if (win->m_wxwindow)
-  {
-    if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
+    if (g_blockEventsOnDrag) return TRUE;
+    if (win->m_wxwindow)

     {
     {

-      GTK_WIDGET_SET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
-/*      
-      printf( "SetFocus flag from " );
-      if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-      printf( ".\n" );
+        if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
+        {
+            GTK_WIDGET_SET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
+/*
+            printf( "SetFocus flag from " );
+            if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+                printf( win->GetClassInfo()->GetClassName() );
+            printf( ".\n" );

 */
 */

-    };
-  };
-  
-  if (!win->HasVMT()) return TRUE;
-  
+        }
+    }
+
+    if (!win->HasVMT()) return TRUE;
+

 /*
 /*

-  printf( "OnSetFocus from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( "   " );
-  printf( WXSTRINGCAST win->GetLabel() );
-  printf( ".\n" );
+    printf( "OnSetFocus from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( "   " );
+    printf( WXSTRINGCAST win->GetLabel() );
+    printf( ".\n" );

 */
 */

-  
-  wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
-  event.SetEventObject( win );
-  win->ProcessEvent( event );
-  
-  return TRUE;
-};

 
 

+    wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
+    event.SetEventObject( win );
+
+    if (win->GetEventHandler()->ProcessEvent( event ))
+        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
+
+    return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// "focus_out_event"

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-// focus out

 
 

-gint gtk_window_focus_out_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
+static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )

 {
 {

-  if (g_blockEventsOnDrag) return TRUE;
-  if (win->m_wxwindow)
-  {
-    if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
-      GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
-  };
-  
-  if (!win->HasVMT()) return TRUE;
-  
+    if (g_blockEventsOnDrag) return TRUE;
+    if (win->m_wxwindow)
+    {
+      if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
+          GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
+    }
+
+    if (!win->HasVMT()) return TRUE;
+

 /*
 /*

-  printf( "OnKillFocus from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
+    printf( "OnKillFocus from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 */

-  
-  wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
-  event.SetEventObject( win );
-  win->ProcessEvent( event );
-  
-  return TRUE;
-};
+
+    wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
+    event.SetEventObject( win );
+
+    if (win->GetEventHandler()->ProcessEvent( event ))
+        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
+
+    return TRUE;
+}

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// vertical scroll
+// "enter_notify_event"
+//-----------------------------------------------------------------------------

 
 

-void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )

 {
 {

-  if (g_blockEventsOnDrag) return;
+    if (widget->window != gdk_event->window) return TRUE;
+
+    if (g_blockEventsOnDrag) return TRUE;
+
+    if (!win->HasVMT()) return TRUE;

 
 /*
 
 /*

-  printf( "OnVScroll from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
-*/
-  
-  if (!win->HasVMT()) return;
-  
-  float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
-  if (fabs(diff) < 0.2) return;
-  
-/*
-  int i = (int)(win->m_oldVerticalPos+0.5);
-  printf( "Old value: %d.\n", i );
-  i = (int)(win->m_vAdjust->value+0.5);
-  printf( "Sending new value: %d.\n", i );
+    printf( "OnEnter from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 
 */
 

-  wxEventType command = wxEVT_NULL;
-  
-  float line_step = win->m_vAdjust->step_increment;
-  float page_step = win->m_vAdjust->page_increment;
-  
-  if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
-  else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
-  else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
-  else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
-  else command = wxEVT_SCROLL_THUMBTRACK;
-      
-  int value = (int)(win->m_vAdjust->value+0.5);
-
-  wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
-  event.SetEventObject( win );
-  win->ProcessEvent( event );
-};
+    if ((widget->window) && (win->m_cursor))
+        gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );

 
 

+    wxMouseEvent event( wxEVT_ENTER_WINDOW );
+    event.SetEventObject( win );
+
+    if (win->GetEventHandler()->ProcessEvent( event ))
+       gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
+
+    return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// "leave_notify_event"

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-// horizontal scroll

 
 

-void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
-{ 
-  if (g_blockEventsOnDrag) return;
-  
+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 (!win->HasVMT()) return TRUE;
+

 /*
 /*

-  printf( "OnHScroll from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
+    printf( "OnLeave from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 */

-  
-  if (!win->HasVMT()) return;
-    
-  float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
-  if (fabs(diff) < 0.2) return;
-  
+
+    if ((widget->window) && (win->m_cursor))
+        gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
+
+    wxMouseEvent event( wxEVT_LEAVE_WINDOW );
+    event.SetEventObject( win );
+
+    if (win->GetEventHandler()->ProcessEvent( event ))
+        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
+
+    return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// "value_changed" from m_vAdjust
+//-----------------------------------------------------------------------------
+
+static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+{
+    if (g_blockEventsOnDrag) return;
+

 /*
 /*

-  int i = (int)(win->m_oldHorizontalPos+0.5);
-  printf( "Old value: %d.\n", i );
-  i = (int)(win->m_hAdjust->value+0.5);
-  printf( "Sending new value: %d.\n", i );
+    printf( "OnVScroll from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 */

-      
-  wxEventType command = wxEVT_NULL;
-  
-  float line_step = win->m_hAdjust->step_increment;
-  float page_step = win->m_hAdjust->page_increment;
-  
-  if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
-  else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
-  else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
-  else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
-  else command = wxEVT_SCROLL_THUMBTRACK;
-
-  int value = (int)(win->m_hAdjust->value+0.5);
-      
-  wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
-  event.SetEventObject( win );
-  win->ProcessEvent( event );
-};

 
 

+    if (!win->HasVMT()) return;
+
+    float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
+    if (fabs(diff) < 0.2) return;
+
+    wxEventType command = wxEVT_NULL;
+
+    float line_step = win->m_vAdjust->step_increment;
+    float page_step = win->m_vAdjust->page_increment;
+
+    if (win->m_isScrolling)
+    {
+        command = wxEVT_SCROLL_THUMBTRACK;
+    }
+    else
+    {
+        if (fabs(win->m_vAdjust->value-win->m_vAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM;
+        else if (fabs(win->m_vAdjust->value-win->m_vAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP;
+        else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
+        else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
+        else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
+        else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
+        else command = wxEVT_SCROLL_THUMBTRACK;
+    }
+
+    int value = (int)(win->m_vAdjust->value+0.5);
+
+    wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
+    event.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( event );
+}
+
+//-----------------------------------------------------------------------------
+// "value_changed" from m_hAdjust

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-// vertical scroll change

 
 

-void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )

 {
 {

-  if (g_blockEventsOnDrag) return;
+    if (g_blockEventsOnDrag) return;

 
 /*
 
 /*

-  printf( "OnVScroll change from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
+    printf( "OnHScroll from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 */

-  
-  if (!win->HasVMT()) return;
-  
-  wxEventType command = wxEVT_SCROLL_THUMBTRACK;
-  int value = (int)(win->m_vAdjust->value+0.5);

 
 

-  wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
-  event.SetEventObject( win );
-  win->ProcessEvent( event );
-};
+    if (!win->HasVMT()) return;
+
+    float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
+    if (fabs(diff) < 0.2) return;
+
+    wxEventType command = wxEVT_NULL;
+
+    float line_step = win->m_hAdjust->step_increment;
+    float page_step = win->m_hAdjust->page_increment;
+
+    if (win->m_isScrolling)
+    {
+        command = wxEVT_SCROLL_THUMBTRACK;
+    }
+    else
+    {
+        if (fabs(win->m_hAdjust->value-win->m_hAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM;
+        else if (fabs(win->m_hAdjust->value-win->m_hAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP;
+        else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
+        else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
+        else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
+        else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
+        else command = wxEVT_SCROLL_THUMBTRACK;
+    }
+
+    int value = (int)(win->m_hAdjust->value+0.5);
+
+    wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
+    event.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( event );
+}

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// horizontal scroll change
+// "changed" from m_vAdjust
+//-----------------------------------------------------------------------------
+
+static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
+{
+    if (g_blockEventsOnDrag) return;

 
 

-void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
-{ 
-  if (g_blockEventsOnDrag) return;
-  

 /*
 /*

-  printf( "OnHScroll change from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
+    printf( "OnVScroll change from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 */

-  
-  if (!win->HasVMT()) return;
-    
-  wxEventType command = wxEVT_SCROLL_THUMBTRACK;
-  int value = (int)(win->m_hAdjust->value+0.5);
-      
-  wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
-  event.SetEventObject( win );
-  win->ProcessEvent( event );
-};

 
 

+    if (!win->HasVMT()) return;
+
+    wxEventType command = wxEVT_SCROLL_THUMBTRACK;
+    int value = (int)(win->m_vAdjust->value+0.5);
+
+    wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
+    event.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( event );
+}
+
+//-----------------------------------------------------------------------------
+// "changed" from m_hAdjust

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-// drop

 
 

-void gtk_window_drop_callback( GtkWidget *widget, GdkEvent *event, wxWindow *win )
+static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )

 {
 {

-  if (!win->HasVMT()) return;
-  
-  if (win->GetDropTarget())
-  {
-    int x = 0;
-    int y = 0;
-    gdk_window_get_pointer( widget->window, &x, &y, NULL );
-    win->GetDropTarget()->Drop( event, x, y );
-  };
-  
+    if (g_blockEventsOnDrag) return;
+

 /*
 /*

-  g_free (event->dropdataavailable.data);
-  g_free (event->dropdataavailable.data_type);
+    printf( "OnHScroll change from " );
+    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+        printf( win->GetClassInfo()->GetClassName() );
+    printf( ".\n" );

 */
 */

+
+    if (!win->HasVMT()) return;
+
+    wxEventType command = wxEVT_SCROLL_THUMBTRACK;
+    int value = (int)(win->m_hAdjust->value+0.5);
+
+    wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
+    event.SetEventObject( win );
+    win->GetEventHandler()->ProcessEvent( event );

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

-// destroy
-
-bool gtk_window_destroy_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
-{ 
-  printf( "OnDestroy from " );
-  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-    printf( win->GetClassInfo()->GetClassName() );
-  printf( ".\n" );
-  printf( "Goodbye.\n" );
-  printf( "     Robert Roebling.\n" );
-  
-  return FALSE;
-};
+// "button_press_event" from scrollbar
+//-----------------------------------------------------------------------------
+
+static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
+                                                 GdkEventButton *WXUNUSED(gdk_event),
+                                                wxWindow *win )
+{
+//    if (gdk_event->window != widget->slider) return FALSE;
+
+    win->m_isScrolling = TRUE;
+    g_blockEventsOnScroll = TRUE;
+
+    return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// "button_release_event" from scrollbar
+//-----------------------------------------------------------------------------
+
+static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
+                                                   GdkEventButton *WXUNUSED(gdk_event),
+                                                  wxWindow *win )
+{
+
+//  don't test here as we can reelase the mouse while being over
+//  a different window then the slider
+//
+//    if (gdk_event->window != widget->slider) return FALSE;
+
+    GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(win->m_widget);
+
+    if (widget == GTK_RANGE(s_window->vscrollbar))
+        gtk_signal_emit_by_name( GTK_OBJECT(win->m_hAdjust), "value_changed" );
+    else
+        gtk_signal_emit_by_name( GTK_OBJECT(win->m_vAdjust), "value_changed" );
+
+    win->m_isScrolling = FALSE;
+    g_blockEventsOnScroll = FALSE;
+
+    return FALSE;
+}

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-// enter
-
-bool 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 (!win->HasVMT()) return TRUE;
-  
-  if (widget->window)
-    gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
-    
-  wxMouseEvent event( wxEVT_ENTER_WINDOW );
-  event.SetEventObject( win );
-  return win->ProcessEvent( event );
-};
-    
+// InsertChild for wxWindow.

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-// leave
-
-bool gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
-{
-  if (widget->window != gdk_event->window) return TRUE;
-  if (!win->HasVMT()) return TRUE;
-  if (g_blockEventsOnDrag) return TRUE;
-  
-  if (widget->window)
-    gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
-    
-  wxMouseEvent event( wxEVT_LEAVE_WINDOW );
-  event.SetEventObject( win );
-  return win->ProcessEvent( event );
-};
-    
+
+// Callback for wxWindow. This very strange beast has to be used because
+// 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...
+
+static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
+{
+    gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
+                     GTK_WIDGET(child->m_widget),
+                    child->m_x,
+                    child->m_y );
+
+    gtk_widget_set_usize( GTK_WIDGET(child->m_widget),
+                          child->m_width,
+                         child->m_height );
+}
+

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-// wxWindow implementation
+// wxWindow

 //-----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler)
 
 BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
 //-----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler)
 
 BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)

-  EVT_SIZE(wxWindow::OnSize)
-  EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
-  EVT_INIT_DIALOG(wxWindow::OnInitDialog)
-  EVT_IDLE(wxWindow::OnIdle)
+    EVT_SIZE(wxWindow::OnSize)
+    EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
+    EVT_INIT_DIALOG(wxWindow::OnInitDialog)
+    EVT_IDLE(wxWindow::OnIdle)

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

-  m_widget = NULL;
-  m_wxwindow = NULL;
-  m_parent = NULL;
-  m_children.DeleteContents( FALSE );
-  m_x = 0;
-  m_y = 0;
-  m_width = 0;
-  m_height = 0;
-  m_retCode = 0;
-  m_eventHandler = this;
-  m_windowValidator = NULL;
-  m_windowId = -1;
-  m_cursor = new wxCursor( wxCURSOR_ARROW );
-  m_font = *wxSWISS_FONT;
-  m_windowStyle = 0;
-  m_windowName = "noname";
-  m_constraints = NULL;
-  m_constraintsInvolvedIn = NULL;
-  m_windowSizer = NULL;
-  m_sizerParent = NULL;
-  m_autoLayout = FALSE;
-  m_sizeSet = FALSE;
-  m_hasVMT = FALSE;
-  m_needParent = TRUE;
-  m_hasScrolling = FALSE;
-  m_hAdjust = NULL;
-  m_vAdjust = NULL;
-  m_oldHorizontalPos = 0.0;
-  m_oldVerticalPos = 0.0;
-  m_isShown = FALSE;
-  m_isEnabled = TRUE;
-  m_drawingOffsetX = 0;
-  m_drawingOffsetY = 0;
-  m_pDropTarget = NULL;
-  m_resizing = FALSE;
-};
+    m_widget = (GtkWidget *) NULL;
+    m_wxwindow = (GtkWidget *) NULL;
+    m_parent = (wxWindow *) NULL;
+    m_children.DeleteContents( FALSE );
+
+    m_x = 0;
+    m_y = 0;
+    m_width = 0;
+    m_height = 0;
+    m_minWidth = -1;
+    m_minHeight = -1;
+    m_maxWidth = -1;
+    m_maxHeight = -1;
+
+    m_retCode = 0;
+
+    m_eventHandler = this;
+    m_windowValidator = (wxValidator *) NULL;
+
+    m_windowId = -1;
+
+    m_cursor = (wxCursor *) NULL;
+    m_font = *wxSWISS_FONT;
+    m_windowStyle = 0;
+    m_windowName = "noname";
+
+    m_constraints = (wxLayoutConstraints *) NULL;
+    m_constraintsInvolvedIn = (wxList *) NULL;
+    m_windowSizer = (wxSizer *) NULL;
+    m_sizerParent = (wxWindow *) NULL;
+    m_autoLayout = FALSE;
+
+    m_sizeSet = FALSE;
+    m_hasVMT = FALSE;
+    m_needParent = TRUE;
+
+    m_hasScrolling = FALSE;
+    m_isScrolling = FALSE;
+    m_hAdjust = (GtkAdjustment*) NULL;
+    m_vAdjust = (GtkAdjustment*) NULL;
+    m_oldHorizontalPos = 0.0;
+    m_oldVerticalPos = 0.0;
+
+    m_isShown = FALSE;
+    m_isEnabled = TRUE;
+
+    m_dropTarget = (wxDropTarget*) NULL;
+    m_resizing = FALSE;
+    m_scrollGC = (GdkGC*) NULL;
+    m_widgetStyle = (GtkStyle*) NULL;
+
+    m_insertCallback = wxInsertChildInWindow;
+
+    m_clientObject = (wxClientData*) NULL;
+    m_clientData = NULL;
+}

 
 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
 
 wxWindow::wxWindow( 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  )

 {
 {

-  m_cursor = NULL;
-  Create( parent, id, pos, size, style, name );
-};
+    m_insertCallback = wxInsertChildInWindow;
+    Create( parent, id, pos, size, style, name );
+}

 
 bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
 bool wxWindow::Create( 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  )

 {
 {

-  m_isShown = FALSE;
-  m_isEnabled = TRUE;
-  m_needParent = TRUE;
-  
-  PreCreation( parent, id, pos, size, style, name );
-  
-  m_widget = gtk_scrolled_window_new( NULL, NULL );
-  m_hasScrolling = TRUE;
-  
-  GtkScrolledWindow *s_window;
-  s_window = GTK_SCROLLED_WINDOW(m_widget);
-  
-  GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-  scroll_class->scrollbar_spacing = 0;
-  
-  gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
-    
-  m_oldHorizontalPos = 0.0;
-  m_oldVerticalPos = 0.0;
- 
-  m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) );
-  m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) );
-  
-  gtk_signal_connect (GTK_OBJECT (m_hAdjust), "value_changed",
+    m_isShown = FALSE;
+    m_isEnabled = TRUE;
+    m_needParent = TRUE;
+
+    PreCreation( parent, id, pos, size, style, name );
+
+    m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
+    GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
+
+    GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
+
+    GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+    scroll_class->scrollbar_spacing = 0;
+
+    gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
+
+    m_oldHorizontalPos = 0.0;
+    m_oldVerticalPos = 0.0;
+
+    m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) );
+    m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) );
+
+    m_wxwindow = gtk_myfixed_new();
+
+#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);
+#else
+    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
+    GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
+#endif
+
+    if (m_windowStyle & wxRAISED_BORDER)
+    {
+        gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
+    }
+    else if (m_windowStyle & wxSUNKEN_BORDER)
+    {
+        gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
+    }
+    else
+    {
+        gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
+    }
+
+    if (m_windowStyle & wxTAB_TRAVERSAL == wxTAB_TRAVERSAL)
+        GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
+    else
+        GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
+
+    // shut the viewport up
+    gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
+    gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
+
+    // I _really_ don't want scrollbars in the beginning
+    m_vAdjust->lower = 0.0;
+    m_vAdjust->upper = 1.0;
+    m_vAdjust->value = 0.0;
+    m_vAdjust->step_increment = 1.0;
+    m_vAdjust->page_increment = 1.0;
+    m_vAdjust->page_size = 5.0;
+    gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
+    m_hAdjust->lower = 0.0;
+    m_hAdjust->upper = 1.0;
+    m_hAdjust->value = 0.0;
+    m_hAdjust->step_increment = 1.0;
+    m_hAdjust->page_increment = 1.0;
+    m_hAdjust->page_size = 5.0;
+    gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
+
+    // these handlers block mouse events to any window during scrolling
+    // such as motion events and prevent GTK and wxWindows from fighting
+    // over where the slider should be
+
+    gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_press_event",
+          (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
+
+    gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_press_event",
+          (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
+
+    gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_release_event",
+          (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
+
+    gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event",
+          (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
+
+    // these handers het notified when screen updates are required either when
+    // scrolling or when the window size (and therefore scrollbar configuration)
+    // has changed
+
+    gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",

           (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
           (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );

-  gtk_signal_connect (GTK_OBJECT (m_vAdjust), "value_changed",
+    gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",

           (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
           (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );

-          
-  gtk_signal_connect (GTK_OBJECT (m_hAdjust), "changed",
+
+    gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed",

           (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
           (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );

-  gtk_signal_connect (GTK_OBJECT (m_vAdjust), "changed",
+    gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",

           (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
           (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );

-  
-  GtkViewport *viewport;
-  viewport = GTK_VIEWPORT(s_window->viewport);
-  
-  if (m_windowStyle & wxRAISED_BORDER)
-  {
-    gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
-  }
-  else if (m_windowStyle & wxSUNKEN_BORDER)
-  {
-    gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
-  }
-  else
-  {
-    gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
-  };
-    
-  m_wxwindow = gtk_myfixed_new();
-  
-  if (m_wxwindow) GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
-    
-  if (m_windowStyle & wxTAB_TRAVERSAL == wxTAB_TRAVERSAL)
-    GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
-  else
-    GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
-
-  gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
-
-  // shut the viewport up
-  gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
-  gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
-  
-  // I _really_ don't want scrollbars in the beginning    
-  m_vAdjust->lower = 0.0;
-  m_vAdjust->upper = 1.0;
-  m_vAdjust->value = 0.0;
-  m_vAdjust->step_increment = 1.0;
-  m_vAdjust->page_increment = 1.0;
-  m_vAdjust->page_size = 5.0;
-  gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
-  m_hAdjust->lower = 0.0;
-  m_hAdjust->upper = 1.0;
-  m_hAdjust->value = 0.0;
-  m_hAdjust->step_increment = 1.0;
-  m_hAdjust->page_increment = 1.0;
-  m_hAdjust->page_size = 5.0;
-  gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
-  
-  gtk_widget_show( m_wxwindow );
-  
-  PostCreation();
-  
-  Show( TRUE );
-
-  return TRUE;  
-};
-
-wxWindow::~wxWindow(void)
-{
-  m_hasVMT = FALSE;
-  
-  if (m_pDropTarget) delete m_pDropTarget;
-  
-  if (m_parent) m_parent->RemoveChild( this );
-  if (m_widget) Show( FALSE );
-
-  DestroyChildren();
-  
-  if (m_wxwindow) gtk_widget_destroy( m_wxwindow );
-    
-  if (m_widget) gtk_widget_destroy( m_widget );
-  
-  wxDELETE(m_cursor);
-
-  DeleteRelatedConstraints();
-  if (m_constraints)
-  {
-    // This removes any dangling pointers to this window
-    // in other windows' constraintsInvolvedIn lists.
-    UnsetConstraints(m_constraints);
-    delete m_constraints;
-    m_constraints = NULL;
-  }
-  if (m_windowSizer)
-  {
-    delete m_windowSizer;
-    m_windowSizer = NULL;
-  }
-  // If this is a child of a sizer, remove self from parent
-  if (m_sizerParent)
-    m_sizerParent->RemoveChild((wxWindow *)this);
-
-  // Just in case the window has been Closed, but
-  // we're then deleting immediately: don't leave
-  // dangling pointers.
-  wxPendingDelete.DeleteObject(this);
-
-  // Just in case we've loaded a top-level window via
-  // wxWindow::LoadNativeDialog but we weren't a dialog
-  // class
-  wxTopLevelWindows.DeleteObject(this);
-    
-};

 
 

-void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
-      const wxPoint &pos, const wxSize &size,
-      long style, const wxString &name )
+    gtk_widget_show( m_wxwindow );
+
+    if (m_parent) m_parent->AddChild( this );
+
+    (m_parent->m_insertCallback)( m_parent, this );
+
+    PostCreation();
+
+    Show( TRUE );
+
+    return TRUE;
+}
+
+wxWindow::~wxWindow()
+{
+    m_hasVMT = FALSE;
+
+    if (m_dropTarget) delete m_dropTarget;
+
+    if (m_parent) m_parent->RemoveChild( this );
+    if (m_widget) Show( FALSE );
+
+    DestroyChildren();
+
+    if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
+
+    if (m_scrollGC) gdk_gc_unref( m_scrollGC );
+
+    if (m_wxwindow) gtk_widget_destroy( m_wxwindow );
+
+    if (m_widget) gtk_widget_destroy( m_widget );
+
+    if (m_cursor) delete m_cursor;
+
+    DeleteRelatedConstraints();
+    if (m_constraints)
+    {
+        // This removes any dangling pointers to this window
+        // in other windows' constraintsInvolvedIn lists.
+        UnsetConstraints(m_constraints);
+        delete m_constraints;
+        m_constraints = (wxLayoutConstraints *) NULL;
+    }
+    if (m_windowSizer)
+    {
+        delete m_windowSizer;
+        m_windowSizer = (wxSizer *) NULL;
+    }
+    // If this is a child of a sizer, remove self from parent
+    if (m_sizerParent) m_sizerParent->RemoveChild((wxWindow *)this);
+
+    // Just in case the window has been Closed, but
+    // we're then deleting immediately: don't leave
+    // dangling pointers.
+    wxPendingDelete.DeleteObject(this);
+
+    // Just in case we've loaded a top-level window via
+    // wxWindow::LoadNativeDialog but we weren't a dialog
+    // class
+    wxTopLevelWindows.DeleteObject(this);
+
+    if (m_windowValidator) delete m_windowValidator;
+
+    if (m_clientObject) delete m_clientObject;
+}
+
+void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
+      const wxPoint &pos, const wxSize &size,
+      long style, const wxString &name )
+{
+    if (m_needParent && (parent == NULL))
+        wxFatalError( "Need complete parent.", name );
+
+    m_widget = (GtkWidget*) NULL;
+    m_wxwindow = (GtkWidget*) NULL;
+    m_hasVMT = FALSE;
+    m_parent = parent;
+    m_children.DeleteContents( FALSE );
+
+    m_width = size.x;
+    if (m_width == -1) m_width = 20;
+    m_height = size.y;
+    if (m_height == -1) m_height = 20;
+
+    m_x = (int)pos.x;
+    m_y = (int)pos.y;
+
+    if (!m_needParent)  // some reasonable defaults
+    {
+        if (m_x == -1)
+        {
+            m_x = (gdk_screen_width () - m_width) / 2;
+            if (m_x < 10) m_x = 10;
+        }
+        if (m_y == -1)
+        {
+            m_y = (gdk_screen_height () - m_height) / 2;
+            if (m_y < 10) m_y = 10;
+        }
+    }
+
+    m_minWidth = -1;
+    m_minHeight = -1;
+    m_maxWidth = -1;
+    m_maxHeight = -1;
+
+    m_retCode = 0;
+
+    m_eventHandler = this;
+
+    m_windowId = id == -1 ? wxNewId() : id;
+
+    m_sizeSet = FALSE;
+
+    m_cursor = new wxCursor( wxCURSOR_ARROW );
+    m_font = *wxSWISS_FONT;
+//  m_backgroundColour = wxWHITE;
+//  m_foregroundColour = wxBLACK;
+    m_windowStyle = style;
+    m_windowName = name;
+
+    m_constraints = (wxLayoutConstraints *) NULL;
+    m_constraintsInvolvedIn = (wxList *) NULL;
+    m_windowSizer = (wxSizer *) NULL;
+    m_sizerParent = (wxWindow *) NULL;
+    m_autoLayout = FALSE;
+
+    m_hasScrolling = FALSE;
+    m_isScrolling = FALSE;
+    m_hAdjust = (GtkAdjustment *) NULL;
+    m_vAdjust = (GtkAdjustment *) NULL;
+    m_oldHorizontalPos = 0.0;
+    m_oldVerticalPos = 0.0;
+
+    m_isShown = FALSE;
+    m_isEnabled = TRUE;
+
+    m_dropTarget = (wxDropTarget *) NULL;
+    m_resizing = FALSE;
+    m_windowValidator = (wxValidator *) NULL;
+    m_scrollGC = (GdkGC*) NULL;
+    m_widgetStyle = (GtkStyle*) NULL;
+
+    m_clientObject = (wxClientData*)NULL;
+    m_clientData = NULL;
+}
+
+void wxWindow::PostCreation()
+{
+    if (m_wxwindow)
+    {
+      gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
+        GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
+
+      gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
+        GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
+    }
+
+    ConnectWidget( GetConnectWidget() );
+
+    if (m_widget && m_parent) gtk_widget_realize( m_widget );
+
+    if (m_wxwindow) gtk_widget_realize( m_wxwindow );
+
+    SetCursor( *wxSTANDARD_CURSOR );
+
+    m_hasVMT = TRUE;
+}
+
+void wxWindow::ConnectWidget( GtkWidget *widget )

 {
 {

-  if (m_needParent && (parent == NULL))
-    wxFatalError( "Need complete parent.", name );
-
-  m_widget = NULL;
-  m_hasVMT = FALSE;
-  m_parent = parent;
-  m_children.DeleteContents( FALSE );
-  m_x = (int)pos.x;
-  m_y = (int)pos.y;
-  m_width = size.x;
-  if (m_width == -1) m_width = 20;
-  m_height = size.y;
-  if (m_height == -1) m_height = 20;
-  m_retCode = 0;
-  m_eventHandler = this;
-  m_windowValidator = NULL;
-  m_windowId = id;
-  m_sizeSet = FALSE;
-  if (m_cursor == NULL)
-    m_cursor = new wxCursor( wxCURSOR_ARROW );
-  m_font = *wxSWISS_FONT;
-  m_backgroundColour = wxWHITE;
-  m_foregroundColour = wxBLACK;
-  m_windowStyle = style;
-  m_windowName = name;
-  m_constraints = NULL;
-  m_constraintsInvolvedIn = NULL;
-  m_windowSizer = NULL;
-  m_sizerParent = NULL;
-  m_autoLayout = FALSE;
-  m_drawingOffsetX = 0;
-  m_drawingOffsetY = 0;
-  m_pDropTarget = NULL;
-  m_resizing = FALSE;
-}
-
-void wxWindow::PostCreation(void)
-{
-  if (m_parent) m_parent->AddChild( this );
-  
-//  GtkStyle *style = m_widget->style;
-//  style->font = m_font.GetInternalFont( 1.0 );          // destroy old font ?
-  
-  GtkWidget *connect_widget = m_widget;
-  if (m_wxwindow) connect_widget = m_wxwindow;
- 
-  gtk_object_set_data (GTK_OBJECT (connect_widget), "MyWxWindow", (gpointer)this );
-  
-  if (m_wxwindow)
-  {
-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event", 
-      GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
-      
-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw", 
-      GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
-  };
-  
-/*
-  gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate", 
-    GTK_SIGNAL_FUNC(gtk_window_size_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(connect_widget), "key_press_event",
-    GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
-
-  gtk_signal_connect( GTK_OBJECT(connect_widget), "button_press_event",
-    GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
-    
-  gtk_signal_connect( GTK_OBJECT(connect_widget), "button_release_event",
-    GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
-    
-  gtk_signal_connect( GTK_OBJECT(connect_widget), "motion_notify_event",
-    GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
-    
-  gtk_signal_connect( GTK_OBJECT(connect_widget), "focus_in_event", 
-    GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
-
-  gtk_signal_connect( GTK_OBJECT(connect_widget), "focus_out_event", 
-    GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
-
-  // Only for cursor handling
-    
-  gtk_signal_connect( GTK_OBJECT(m_widget), "enter_notify_event", 
-    GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
-    
-  gtk_signal_connect( GTK_OBJECT(m_widget), "leave_notify_event", 
-    GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
-    
-  if (m_wxwindow)
-  {
-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "enter_notify_event", 
+    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_release_event",
+      GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
+
+    gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
+      GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
+
+    gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
+      GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
+
+    gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",
+      GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
+
+    gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",

       GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
       GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );

-      
-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "leave_notify_event", 
-      GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
-  };
-  
-/*
-  // Does destroy ever get called ?

 
 

-  gtk_signal_connect( GTK_OBJECT(m_widget), "destroy_event", 
-    GTK_SIGNAL_FUNC(gtk_window_destroy_callback), (gpointer)this );
-    
-  if (m_wxwindow)
-  {
-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "destroy_event", 
-      GTK_SIGNAL_FUNC(gtk_window_destroy_callback), (gpointer)this );
-  };
-*/
-  
-  if (m_widget && m_parent) gtk_widget_realize( m_widget );
-  if (m_wxwindow) gtk_widget_realize( m_wxwindow );
-  
-  SetCursor( wxSTANDARD_CURSOR );
-  
-  m_hasVMT = TRUE;
-};
+    gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
+      GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
+}

 
 

-bool wxWindow::HasVMT(void)
+bool wxWindow::HasVMT()

 {
 {

-  return m_hasVMT;
-};
+    return m_hasVMT;
+}

 
 bool wxWindow::Close( bool force )
 {
 
 bool wxWindow::Close( bool force )
 {

-  wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
-  event.SetEventObject(this);
-  event.SetForce(force);
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+    wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
+    event.SetEventObject(this);
+    event.SetForce(force);

 
 

-  return GetEventHandler()->ProcessEvent(event);
-};
+    return GetEventHandler()->ProcessEvent(event);
+}

 
 

-bool wxWindow::Destroy(void)
+bool wxWindow::Destroy()

 {
 {

-  m_hasVMT = FALSE;
-  delete this;
-  return TRUE;
-};
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );

 
 

-bool wxWindow::DestroyChildren(void)
+    m_hasVMT = FALSE;
+    delete this;
+    return TRUE;
+}
+
+bool wxWindow::DestroyChildren()

 {
 {

-  if (GetChildren()) 
-  {

     wxNode *node;
     wxNode *node;

-    while ((node = GetChildren()->First()) != (wxNode *)NULL) 
+    while ((node = m_children.First()) != (wxNode *)NULL)

     {
     {

-      wxWindow *child;
-      if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) 
-      {
-        delete child;
-  if (GetChildren()->Member(child)) delete node;
-      };
-    };
-  };
-  return TRUE;
-};
+        wxWindow *child;
+        if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
+        {
+            delete child;
+            if (m_children.Member(child)) delete node;
+        }
+    }
+    return TRUE;
+}

 
 void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
 {
 
 void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
 {

-  // are we to set fonts here ?
-};
+    // are we to set fonts here ?
+}

 
 

-void wxWindow::ImplementSetSize(void)
-{ 
-  gtk_widget_set_usize( m_widget, m_width, m_height );
-};
+wxPoint wxWindow::GetClientAreaOrigin() const
+{
+    return wxPoint(0,0);
+}

 
 

-void wxWindow::ImplementSetPosition(void)
+void wxWindow::AdjustForParentClientOrigin( int& x, int& y, int sizeFlags )

 {
 {

-  if (IS_KIND_OF(this,wxFrame) || IS_KIND_OF(this,wxDialog))
-  {
-    if ((m_x != -1) || (m_y != -1))
-      gtk_widget_set_uposition( m_widget, m_x, m_y );
-    return;
-  }
-  
-  if (!m_parent)
-  {
-    printf( "wxWindow::SetSize error.\n" );
-    return;
-  }
-  
-  if ((m_parent) && (m_parent->m_wxwindow))
-    gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x, m_y );
-    
-  // Don't do anything for children of wxNotebook and wxMDIChildFrame   
-};
+    if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
+    {
+        wxPoint pt(GetParent()->GetClientAreaOrigin());
+        x += pt.x;
+        y += pt.y;
+    }
+}

 
 void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
 {
 
 void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
 {

-  if (m_resizing) return; // I don't like recursions
-  m_resizing = TRUE;
-  
-  int newX = x;
-  int newY = y;
-  int newW = width;
-  int newH = height;
-  
-  if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
-  {
-    if (newX == -1) newX = m_x;
-    if (newY == -1) newY = m_y;
-    if (newW == -1) newW = m_width;
-    if (newH == -1) newH = m_height;
-  };
-  
-  if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
-  {
-    if (newW == -1) newW = 80;
-  };
-  
-  if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
-  {
-    if (newH == -1) newH = 26;
-  };
-  
-  if ((m_x != newX) || (m_y != newY) || (!m_sizeSet))
-  {
-    m_x = newX;
-    m_y = newY;
-    ImplementSetPosition();
-  };
-  if ((m_width != newW) || (m_height != newH) || (!m_sizeSet))
-  {
-    m_width = newW;
-    m_height = newH;
-    ImplementSetSize();
-  };
-  m_sizeSet = TRUE;
-  
-  wxSizeEvent event( wxSize(m_width,m_height), GetId() );
-  event.SetEventObject( this );
-  ProcessEvent( event );
-  
-  m_resizing = FALSE;
-};
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+    wxASSERT_MSG( (m_parent != NULL), "wxWindow::SetSize requires parent.\n" );
+
+    if (m_resizing) return; // I don't like recursions
+    m_resizing = TRUE;
+
+    if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
+    {
+        // don't set the size for children of wxNotebook, just take the values.
+        m_x = x;
+        m_y = y;
+        m_width = width;
+        m_height = height;
+    }
+    else
+    {
+        int old_width = m_width;
+        int old_height = m_height;
+
+        if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
+        {
+            if (x != -1) m_x = x;
+            if (y != -1) m_y = y;
+            if (width != -1) m_width = width;
+            if (height != -1) m_height = height;
+        }
+        else
+        {
+            m_x = x;
+            m_y = y;
+            m_width = width;
+            m_height = height;
+        }
+
+        if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
+        {
+             if (width == -1) m_width = 80;
+        }
+
+        if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
+        {
+             if (height == -1) m_height = 26;
+        }
+
+        if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
+        if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
+        if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_minWidth;
+        if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_minHeight;
+
+        wxPoint pt( m_parent->GetClientAreaOrigin() );
+        gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y );
+
+        if ((old_width != m_width) || (old_height != m_height))
+             gtk_widget_set_usize( m_widget, m_width, m_height );
+    }
+
+    m_sizeSet = TRUE;
+
+    wxSizeEvent event( wxSize(m_width,m_height), GetId() );
+    event.SetEventObject( this );
+    GetEventHandler()->ProcessEvent( event );
+
+    m_resizing = FALSE;
+}

 
 void wxWindow::SetSize( int width, int height )
 {
 
 void wxWindow::SetSize( int width, int height )
 {

-  SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
-};
+    SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
+}

 
 void wxWindow::Move( int x, int y )
 {
 
 void wxWindow::Move( int x, int y )
 {

-  SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
-};
+    SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
+}

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

-  if (width) (*width) = m_width;
-  if (height) (*height) = m_height;
-};
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+    if (width) (*width) = m_width;
+    if (height) (*height) = m_height;
+}

 
 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 );
   if (!m_wxwindow)
   {
     SetSize( width, height );


@@ -1164,56 +1438,62 @@ void wxWindow::SetClientSize( int width, int height )
   {
     int dw = 0;
     int dh = 0;
   {
     int dw = 0;
     int dh = 0;

-    
+

     if (!m_hasScrolling)
     {
     if (!m_hasScrolling)
     {

-/*
-      do we have sunken dialogs ?
-      

       GtkStyleClass *window_class = m_wxwindow->style->klass;
       GtkStyleClass *window_class = m_wxwindow->style->klass;

-    
-      dw += 2 * window_class->xthickness;
-      dh += 2 * window_class->ythickness;
-*/
+
+      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 );
     }
     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
+      GtkWidget *viewport = scroll_window->child;
+#else

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

+#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) ||
       if ((m_windowStyle & wxRAISED_BORDER) ||

-          (m_windowStyle & wxSUNKEN_BORDER)
-   )
+          (m_windowStyle & wxSUNKEN_BORDER))

       {
         dw += 2 * viewport_class->xthickness;
         dh += 2 * viewport_class->ythickness;
       {
         dw += 2 * viewport_class->xthickness;
         dh += 2 * viewport_class->ythickness;

-      };
-    
-      if (GTK_WIDGET_VISIBLE(vscrollbar))
+      }
+
+      if (scroll_window->vscrollbar_visible)

       {
         dw += vscrollbar->allocation.width;
         dw += scroll_class->scrollbar_spacing;
       {
         dw += vscrollbar->allocation.width;
         dw += scroll_class->scrollbar_spacing;

-      };
-    
-      if (GTK_WIDGET_VISIBLE(hscrollbar))
+      }
+
+      if (scroll_window->hscrollbar_visible)

       {
         dh += hscrollbar->allocation.height;
         dw += scroll_class->scrollbar_spacing;
       {
         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 (!m_wxwindow)
   {
     if (width) (*width) = m_width;


@@ -1223,142 +1503,159 @@ void wxWindow::GetClientSize( int *width, int *height ) const
   {
     int dw = 0;
     int dh = 0;
   {
     int dw = 0;
     int dh = 0;

-    
+

     if (!m_hasScrolling)
     {
     if (!m_hasScrolling)
     {

-/*
-      do we have sunken dialogs ?
-      

       GtkStyleClass *window_class = m_wxwindow->style->klass;
       GtkStyleClass *window_class = m_wxwindow->style->klass;

-    
-      dw += 2 * window_class->xthickness;
-      dh += 2 * window_class->ythickness;
-*/
+
+      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 );
     }
     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
+      GtkWidget *viewport = scroll_window->child;
+#else

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

+#endif
+

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

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

       if ((m_windowStyle & wxRAISED_BORDER) ||
       if ((m_windowStyle & wxRAISED_BORDER) ||

-          (m_windowStyle & wxSUNKEN_BORDER)
-   )
+          (m_windowStyle & wxSUNKEN_BORDER))

       {
         dw += 2 * viewport_class->xthickness;
         dh += 2 * viewport_class->ythickness;
       {
         dw += 2 * viewport_class->xthickness;
         dh += 2 * viewport_class->ythickness;

-      };
-    
-      if (GTK_WIDGET_VISIBLE(vscrollbar))
+      }
+
+      if (scroll_window->vscrollbar_visible)

       {
 //        dw += vscrollbar->allocation.width;
         dw += 15;                               // range.slider_width = 11 + 2*2pts edge
         dw += scroll_class->scrollbar_spacing;
       {
 //        dw += vscrollbar->allocation.width;
         dw += 15;                               // range.slider_width = 11 + 2*2pts edge
         dw += scroll_class->scrollbar_spacing;

-      };
-    
-      if (GTK_WIDGET_VISIBLE(hscrollbar))
+      }
+
+      if (scroll_window->hscrollbar_visible)

       {
 //        dh += hscrollbar->allocation.height;
         dh += 15;
         dh += scroll_class->scrollbar_spacing;
       {
 //        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
 {

-  if (x) (*x) = m_x;
-  if (y) (*y) = m_y;
-};
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+    if (x) (*x) = m_x;
+    if (y) (*y) = m_y;
+}

 
 void wxWindow::ClientToScreen( int *x, int *y )
 {
 
 void wxWindow::ClientToScreen( int *x, int *y )
 {

-  // Does this look simple ?
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );

 
 

-  GdkWindow *source = 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 );
+    GdkWindow *source = (GdkWindow *) NULL;
+    if (m_wxwindow)
+        source = m_wxwindow->window;
+    else
+        source = m_widget->window;

 
 

-  if (!m_wxwindow)
-  {  
-    if (GTK_WIDGET_NO_WINDOW (m_widget))
+    int org_x = 0;
+    int org_y = 0;
+    gdk_window_get_origin( source, &org_x, &org_y );
+
+    if (!m_wxwindow)

     {
     {

-      org_x += m_widget->allocation.x;
-      org_y += m_widget->allocation.y;
-    };
-  };
-  
-  if (x) *x += org_x;  
-  if (y) *y += org_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;
+
+    if (x) *x += org_x;
+    if (y) *y += org_y;
+}

 
 void wxWindow::ScreenToClient( int *x, int *y )
 {
 
 void wxWindow::ScreenToClient( int *x, int *y )
 {

-  GdkWindow *source = NULL;
+  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+  GdkWindow *source = (GdkWindow *) NULL;

   if (m_wxwindow)
     source = m_wxwindow->window;
   else
     source = m_widget->window;
   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 );
 
   if (!m_wxwindow)
   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))
     {
       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;

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

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

-  if (IS_KIND_OF(this,wxDialog) || IS_KIND_OF(this,wxFrame))
-  {
-    if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (gdk_screen_width () - m_width) / 2;
-    if (direction & wxVERTICAL == wxVERTICAL) m_y = (gdk_screen_height () - m_height) / 2;
-    ImplementSetPosition();
-  }
-  else
+  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+  int x = m_x;
+  int y = m_y;
+
+  if (m_parent)

   {
   {

-    if (m_parent)
-    {

       int p_w = 0;
       int p_h = 0;
       m_parent->GetSize( &p_w, &p_h );
       int p_w = 0;
       int p_h = 0;
       m_parent->GetSize( &p_w, &p_h );

-      if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (p_w - m_width) / 2;
-      if (direction & wxVERTICAL == wxVERTICAL) m_y = (p_h - m_height) / 2;
-      ImplementSetPosition();
-    };
+      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;

   }
   }

-};

 
 

-void wxWindow::Fit(void)
+  Move( x, y );
+}
+
+void wxWindow::Fit()

 {
 {

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

   int maxX = 0;
   int maxY = 0;
   int maxX = 0;
   int maxY = 0;

-  wxNode *node = GetChildren()->First();
+  wxNode *node = m_children.First();

   while ( node )
   {
     wxWindow *win = (wxWindow *)node->Data();
   while ( node )
   {
     wxWindow *win = (wxWindow *)node->Data();


@@ -1373,29 +1670,93 @@ void wxWindow::Fit(void)
     node = node->Next();
   }
   SetClientSize(maxX + 5, maxY + 10);
     node = node->Next();
   }
   SetClientSize(maxX + 5, maxY + 10);

-};
+}
+
+void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
+{
+  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+  m_minWidth = minW;
+  m_minHeight = minH;
+  m_maxWidth = maxW;
+  m_maxHeight = maxH;
+}

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

-  //if (GetAutoLayout()) Layout();
-};
+//  if (GetAutoLayout()) Layout();
+}

 
 bool wxWindow::Show( bool show )
 {
 
 bool wxWindow::Show( bool show )
 {

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

   if (show)
     gtk_widget_show( m_widget );
   else
     gtk_widget_hide( m_widget );
   if (show)
     gtk_widget_show( m_widget );
   else
     gtk_widget_hide( m_widget );

-  m_isShown = show;  
+  m_isShown = show;

   return TRUE;
   return TRUE;

-};
+}

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

+  wxASSERT_MSG( (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
+{
+  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+  if (!m_font.Ok())
+  {
+    wxFAIL_MSG( "invalid font" );
+    return -1;
+  }
+
+  GdkFont *font = m_font.GetInternalFont( 1.0 );
+  return font->ascent + font->descent;
+}
+
+int wxWindow::GetCharWidth() const
+{
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+    if (!m_font.Ok())
+    {
+      wxFAIL_MSG( "invalid font" );
+      return -1;
+    }
+
+    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
+{
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+    wxFont fontToUse = m_font;
+    if (theFont) fontToUse = *theFont;
+
+    if (!fontToUse.Ok())
+    {
+      wxFAIL_MSG( "invalid font" );
+      return;
+    }
+    wxASSERT_MSG( (m_font.Ok()), "invalid font" );
+
+    GdkFont *font = fontToUse.GetInternalFont( 1.0 );
+    if (x) (*x) = gdk_string_width( font, string );
+    if (y) (*y) = font->ascent + font->descent;
+    if (descent) (*descent) = font->descent;
+    if (externalLeading) (*externalLeading) = 0;  // ??
+}

 
 void wxWindow::MakeModal( bool modal )
 {
 
 void wxWindow::MakeModal( bool modal )
 {


@@ -1415,200 +1776,222 @@ void wxWindow::MakeModal( bool modal )
   }
 }
 
   }
 }
 

-void wxWindow::SetFocus(void)
+void wxWindow::SetFocus()

 {
 {

-  GtkWidget *connect_widget = m_widget;
-  if (m_wxwindow) connect_widget = m_wxwindow;
-  if (connect_widget)
-  {
-    if (GTK_WIDGET_CAN_FOCUS(connect_widget) && !GTK_WIDGET_HAS_FOCUS (connect_widget) )
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+    GtkWidget *connect_widget = GetConnectWidget();
+    if (connect_widget)

     {
     {

-      gtk_widget_grab_focus (connect_widget);
-    };
-  };
-};
+        if (GTK_WIDGET_CAN_FOCUS(connect_widget) && !GTK_WIDGET_HAS_FOCUS (connect_widget) )
+        {
+            gtk_widget_grab_focus (connect_widget);
+        }
+    }
+}

 
 

-bool wxWindow::OnClose(void)
+bool wxWindow::OnClose()

 {
 {

-  return TRUE;
-};
+    return TRUE;
+}

 
 void wxWindow::AddChild( wxWindow *child )
 {
 
 void wxWindow::AddChild( wxWindow *child )
 {

-  // Addchild is (often) called before the program
-  // has left the parents constructor so that no
-  // virtual tables work yet. The approach below
-  // practically imitates virtual tables, i.e. it
-  // implements a different AddChild() behaviour
-  // for wxFrame, wxDialog, wxWindow and 
-  // wxMDIParentFrame.
-
-  // wxFrame and wxDialog as children aren't placed into the parents
-  
-  if (( IS_KIND_OF(child,wxFrame) || IS_KIND_OF(child,wxDialog) ) &&
-      (!IS_KIND_OF(child,wxMDIChildFrame)))
-  {
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+    wxASSERT_MSG( (child != NULL), "invalid child" );
+

     m_children.Append( child );
     m_children.Append( child );

-    
-    if ((child->m_x != -1) && (child->m_y != -1))
-      gtk_widget_set_uposition( child->m_widget, child->m_x, child->m_y );
-      
-    return;
-  }
-  
-  // In the case of an wxMDIChildFrame descendant, we use the 
-  // client windows's AddChild()
-  
-  if (IS_KIND_OF(this,wxMDIParentFrame))
-  {
-    if (IS_KIND_OF(child,wxMDIChildFrame))
-    {
-      wxMDIClientWindow *client = ((wxMDIParentFrame*)this)->GetClientWindow();
-      if (client)
-      { 
-        client->AddChild( child );
-        return;
-      }
-    }
-  }
-  
-  // wxNotebook is very special, so it has a private AddChild()
-  
-  if (IS_KIND_OF(this,wxNotebook))
-  {
-    wxNotebook *tab = (wxNotebook*)this;
-    tab->AddChild( child );
-    return;
-  }
-  
-  // wxFrame has a private AddChild
-  
-  if (IS_KIND_OF(this,wxFrame) && !IS_KIND_OF(this,wxMDIChildFrame))
+}
+
+wxWindow *wxWindow::ReParent( wxWindow *newParent )
+{
+  wxWindow *oldParent = GetParent();
+
+  if (oldParent) oldParent->RemoveChild( this );
+
+  gtk_widget_unparent( m_widget );
+
+  if (newParent)

   {
   {

-    wxFrame *frame = (wxFrame*)this;
-    frame->AddChild( child );
-    return;
+     newParent->AddChild( this );
+     (newParent->m_insertCallback)( newParent, this );

   }
   }

-  
-  // All the rest
-  
-  m_children.Append( child );
-  if (m_wxwindow) gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget, 
-    child->m_x, child->m_y );
-  
-  gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height );
-};

 
 

-wxList *wxWindow::GetChildren(void)
+  return oldParent;
+}
+
+void wxWindow::RemoveChild( wxWindow *child )
+{
+    m_children.DeleteObject( child );
+    child->m_parent = (wxWindow *) NULL;
+}
+
+void wxWindow::SetReturnCode( int retCode )
+{
+    m_retCode = retCode;
+}
+
+int wxWindow::GetReturnCode()

 {
 {

-  return (&m_children);
-};
+    return m_retCode;
+}

 
 

-void wxWindow::RemoveChild( wxWindow *child )
+void wxWindow::Raise()

 {
 {

-  if (GetChildren())
- GetChildren()->DeleteObject( child );
-  child->m_parent = NULL;
-};
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );

 
 

-void wxWindow::SetReturnCode( int retCode )
+    if (m_widget) gdk_window_raise( m_widget->window );
+}
+
+void wxWindow::Lower()
+{
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+    if (m_widget) gdk_window_lower( m_widget->window );
+}
+
+wxEvtHandler *wxWindow::GetEventHandler() const
+{
+    return m_eventHandler;
+}
+
+void wxWindow::SetEventHandler( wxEvtHandler *handler )
+{
+    m_eventHandler = handler;
+}
+
+void wxWindow::PushEventHandler(wxEvtHandler *handler)
+{
+    handler->SetNextHandler(GetEventHandler());
+    SetEventHandler(handler);
+}
+
+wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)

 {
 {

-  m_retCode = retCode;
-};
+    if (GetEventHandler())
+    {
+        wxEvtHandler *handlerA = GetEventHandler();
+        wxEvtHandler *handlerB = handlerA->GetNextHandler();
+        handlerA->SetNextHandler((wxEvtHandler *) NULL);
+        SetEventHandler(handlerB);
+        if (deleteHandler)
+        {
+            delete handlerA;
+            return (wxEvtHandler*) NULL;
+        }
+        else
+            return handlerA;
+     }
+     else
+        return (wxEvtHandler *) NULL;
+}

 
 

-int wxWindow::GetReturnCode(void)
+wxValidator *wxWindow::GetValidator()

 {
 {

-  return m_retCode;
-};
+    return m_windowValidator;
+}

 
 

-wxWindow *wxWindow::GetParent(void)
+void wxWindow::SetValidator( const wxValidator& validator )

 {
 {

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

 
 

-wxEvtHandler *wxWindow::GetEventHandler(void)
+void wxWindow::SetClientObject( wxClientData *data )

 {
 {

-  return m_eventHandler;
-};
+  if (m_clientObject) delete m_clientObject;
+  m_clientObject = data;
+}

 
 

-void wxWindow::SetEventhandler( wxEvtHandler *handler )
+wxClientData *wxWindow::GetClientObject()

 {
 {

-  m_eventHandler = handler;
-};
+  return m_clientObject;
+}

 
 

-wxValidator *wxWindow::GetValidator(void)
+void wxWindow::SetClientData( void *data )

 {
 {

-  return m_windowValidator;
-};
+  m_clientData = data;
+}

 
 

-void wxWindow::SetValidator( wxValidator *validator )
+void *wxWindow::GetClientData()

 {
 {

-  m_windowValidator = validator;
-};
+  return m_clientData;
+}

 
 

-bool wxWindow::IsBeingDeleted(void)
+bool wxWindow::IsBeingDeleted()

 {
   return FALSE;
 {
   return FALSE;

-};
+}

 
 void wxWindow::SetId( wxWindowID id )
 {
   m_windowId = id;
 
 void wxWindow::SetId( wxWindowID id )
 {
   m_windowId = id;

-};
+}

 
 

-wxWindowID wxWindow::GetId(void)
+wxWindowID wxWindow::GetId() const

 {
   return m_windowId;
 {
   return m_windowId;

-};
+}

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

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

 
 

-  if (m_cursor != NULL)
-    if (*m_cursor == cursor)
-      return;
-  (*m_cursor) = cursor;
-  if (m_widget->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 ((m_widget) && (m_widget->window))

     gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
     gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );

-  if (m_wxwindow && m_wxwindow->window)
+
+  if ((m_wxwindow) && (m_wxwindow->window))

     gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
     gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );

-};
+}

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

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

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

-      gdk_window_clear_area( m_wxwindow->window, 
-        rect->x, 
-        rect->y, 
-        rect->width, 
+      gdk_window_clear_area( m_wxwindow->window,
+        rect->x,
+        rect->y,
+        rect->width,

         rect->height );
     else
       Clear();
         rect->height );
     else
       Clear();

-  };
+  }

   if (!rect)
   {
     if (m_wxwindow)
     {
   if (!rect)
   {
     if (m_wxwindow)
     {

-      wxClientDC dc(this);
-      PrepareDC(dc);
-      long x = 0;
-      long y = 0;
-      dc.GetInternalDeviceOrigin( &x, &y );
-      

       int w = 0;
       int h = 0;
       GetClientSize( &w, &h );
       int w = 0;
       int h = 0;
       GetClientSize( &w, &h );

-      
+

       GdkRectangle gdk_rect;
       GdkRectangle gdk_rect;

-      gdk_rect.x = x;
-      gdk_rect.y = y;
+      gdk_rect.x = 0;
+      gdk_rect.y = 0;

       gdk_rect.width = w;
       gdk_rect.height = h;
       gtk_widget_draw( m_wxwindow, &gdk_rect );
       gdk_rect.width = w;
       gdk_rect.height = h;
       gtk_widget_draw( m_wxwindow, &gdk_rect );

-    };
+    }

   }
   else
   {
   }
   else
   {


@@ -1617,79 +2000,174 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
     gdk_rect.y = rect->y;
     gdk_rect.width = rect->width;
     gdk_rect.height = rect->height;
     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 );
     if (m_wxwindow)
       gtk_widget_draw( m_wxwindow, &gdk_rect );
     else
       gtk_widget_draw( m_widget, &gdk_rect );

-  };
-};
+  }
+}
+
+wxRegion wxWindow::GetUpdateRegion() const
+{
+  return m_updateRegion;
+}

 
 

-bool wxWindow::IsExposed( long x, long y )
+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
+{
+  return (m_updateRegion.Contains( x, y, w, h ) != wxOutRegion );
+}
+
+bool wxWindow::IsExposed( const wxPoint& pt ) const
+{
+  return (m_updateRegion.Contains( pt.x, pt.y ) != wxOutRegion );
+}

 
 

-bool wxWindow::IsExposed( long x, long y, long width, long height )
+bool wxWindow::IsExposed( const wxRect& rect ) const

 {
 {

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

 
 

-void wxWindow::Clear(void)
+void wxWindow::Clear()

 {
 {

-  if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
-};
+    wxCHECK_RET( m_widget != NULL, "invalid window" );
+
+    if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
+}

 
 

-wxColour wxWindow::GetBackgroundColour(void) const
+wxColour wxWindow::GetBackgroundColour() const

 {
 {

-  return m_backgroundColour;
-};
+    return m_backgroundColour;
+}

 
 void wxWindow::SetBackgroundColour( const wxColour &colour )
 {
 
 void wxWindow::SetBackgroundColour( const wxColour &colour )
 {

-  m_backgroundColour = colour;
-  if (m_wxwindow)
+    wxCHECK_RET( m_widget != NULL, "invalid window" );
+
+    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;
+
+    if (m_wxwindow)
+    {
+        GdkWindow *window = m_wxwindow->window;
+        m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
+        gdk_window_set_background( window, m_backgroundColour.GetColor() );
+        gdk_window_clear( window );
+    }
+
+    ApplyWidgetStyle();
+}
+
+wxColour wxWindow::GetForegroundColour() const
+{
+    return m_foregroundColour;
+}
+
+void wxWindow::SetForegroundColour( const wxColour &colour )
+{
+    wxCHECK_RET( m_widget != NULL, "invalid window" );
+
+    if (m_foregroundColour == colour) return;
+
+    m_foregroundColour = colour;
+    if (!m_foregroundColour.Ok()) return;
+
+    ApplyWidgetStyle();
+}
+
+GtkStyle *wxWindow::GetWidgetStyle()
+{
+  if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
+
+  m_widgetStyle =
+    gtk_style_copy(
+      gtk_widget_get_style( m_widget ) );
+
+  return m_widgetStyle;
+}
+
+void wxWindow::SetWidgetStyle()
+{
+  GtkStyle *style = GetWidgetStyle();
+
+  gdk_font_unref( style->font );
+  style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
+
+  if (m_foregroundColour.Ok())

   {
   {

-    m_backgroundColour.CalcPixel( m_wxwindow->style->colormap );
-    gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );
-    gdk_window_clear( m_wxwindow->window );
-  };
-  // do something ?
-};
+    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();
+  }
+}
+
+void wxWindow::ApplyWidgetStyle()
+{
+}

 
 

-bool wxWindow::Validate(void)
+bool wxWindow::Validate()

 {
 {

-  wxNode *node = GetChildren()->First();
+  wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+
+  wxNode *node = m_children.First();

   while (node)
   {
     wxWindow *child = (wxWindow *)node->Data();
   while (node)
   {
     wxWindow *child = (wxWindow *)node->Data();

-    if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this)) 
+    if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))

       { return FALSE; }
     node = node->Next();
       { return FALSE; }
     node = node->Next();

-  };
+  }

   return TRUE;
   return TRUE;

-};
+}

 
 

-bool wxWindow::TransferDataToWindow(void)
+bool wxWindow::TransferDataToWindow()

 {
 {

-  wxNode *node = GetChildren()->First();
+  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() )
     {
   while (node)
   {
     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 );
+      wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION );

       return FALSE;
       return FALSE;

-    };
+    }

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

-  };
+  }

   return TRUE;
   return TRUE;

-};
+}

 
 

-bool wxWindow::TransferDataFromWindow(void)
+bool wxWindow::TransferDataFromWindow()

 {
 {

-  wxNode *node = GetChildren()->First();
+  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+  wxNode *node = m_children.First();

   while (node)
   {
     wxWindow *child = (wxWindow *)node->Data();
   while (node)
   {
     wxWindow *child = (wxWindow *)node->Data();


@@ -1698,138 +2176,176 @@ bool wxWindow::TransferDataFromWindow(void)
    node = node->Next();
   }
   return TRUE;
    node = node->Next();
   }
   return TRUE;

-};
+}
+
+void wxWindow::SetAcceleratorTable( const wxAcceleratorTable& accel )
+{
+  m_acceleratorTable = accel;
+}

 
 void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
 {
   TransferDataToWindow();
 
 void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
 {
   TransferDataToWindow();

-};
+}

 
 

-void wxWindow::InitDialog(void)
+void wxWindow::InitDialog()

 {
 {

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

-};
+}

 
 

-void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
+static void SetInvokingWindow( wxMenu *menu, wxWindow *win )

 {
 {

-  GtkWidget *dnd_widget = GetDropTargetWidget();
-  
-  if (m_pDropTarget)
-  {
-    gtk_signal_disconnect_by_func( GTK_OBJECT(dnd_widget),
-      GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
-  
-    m_pDropTarget->UnregisterWidget( dnd_widget );
-    delete m_pDropTarget;
-  };
-  m_pDropTarget = dropTarget;
-  if (m_pDropTarget)
+  menu->SetInvokingWindow( win );
+  wxNode *node = menu->m_items.First();
+  while (node)

   {
   {

-    m_pDropTarget->RegisterWidget( dnd_widget );
-    
-    gtk_signal_connect( GTK_OBJECT(dnd_widget), "drop_data_available_event",
-      GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
-  };
-};
+    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) )
+{
+  wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+
+  wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" );
+
+  SetInvokingWindow( menu, this );
+  gtk_menu_popup(
+                  GTK_MENU(menu->m_menu),
+                  (GtkWidget *)NULL,          // parent menu shell
+                  (GtkWidget *)NULL,          // parent menu item
+                  (GtkMenuPositionFunc)NULL,
+                  NULL,                       // client data
+                  0,                          // button used to activate it
+                  0//gs_timeLastClick            // the time of activation
+                );
+  return TRUE;
+}
+
+void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
+{
+  wxCHECK_RET( m_widget != NULL, "invalid window" );
+
+  GtkWidget *dnd_widget = GetConnectWidget();
+
+  if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
+
+  if (m_dropTarget) delete m_dropTarget;
+  m_dropTarget = dropTarget;
+
+  if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
+}

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

-  return m_pDropTarget;
-};
+  return m_dropTarget;
+}

 
 

-GtkWidget* wxWindow::GetDropTargetWidget(void)
+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;
 }

-  
-void wxWindow::SetFont( const wxFont &font )
+
+bool wxWindow::IsOwnGtkWindow( GdkWindow *window )

 {
 {

-  m_font = font;
-/*
-  create new style
-  copy old style values to new one
-  set font in new style
-  -> takes to many resources
-  
-  GtkStyle *style = gtk_style_new();
-  ...
-*/
-};
+  if (m_wxwindow) return (window == m_wxwindow->window);
+  return (window == m_widget->window);
+}

 
 

-wxFont *wxWindow::GetFont(void)
+void wxWindow::SetFont( const wxFont &font )

 {
 {

-  return &m_font;
-};
+  wxCHECK_RET( m_widget != NULL, "invalid window" );
+
+  if (((wxFont*)&font)->Ok())
+    m_font = font;
+  else
+    m_font = *wxSWISS_FONT;
+
+  ApplyWidgetStyle();
+}

 
 void wxWindow::SetWindowStyleFlag( long flag )
 {
   m_windowStyle = flag;
 
 void wxWindow::SetWindowStyleFlag( long flag )
 {
   m_windowStyle = flag;

-};
+}

 
 

-long wxWindow::GetWindowStyleFlag(void) const
+long wxWindow::GetWindowStyleFlag() const

 {
   return m_windowStyle;
 {
   return m_windowStyle;

-};
+}

 
 

-void wxWindow::CaptureMouse(void)
+void wxWindow::CaptureMouse()

 {
 {

-  GtkWidget *connect_widget = m_widget;
-  if (m_wxwindow) connect_widget = m_wxwindow;
+  wxCHECK_RET( m_widget != NULL, "invalid window" );
+
+  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)
   gtk_grab_add( connect_widget );
   gdk_pointer_grab ( connect_widget->window, FALSE,
                     (GdkEventMask)

-        (GDK_BUTTON_PRESS_MASK | 
+        (GDK_BUTTON_PRESS_MASK |

         GDK_BUTTON_RELEASE_MASK |
         GDK_BUTTON_RELEASE_MASK |

-        GDK_POINTER_MOTION_MASK), 
-        NULL, NULL, GDK_CURRENT_TIME );
-};
+        GDK_POINTER_MOTION_MASK),
+        (GdkWindow *) NULL, (GdkCursor *) NULL, GDK_CURRENT_TIME );
+  g_capturing = TRUE;
+}

 
 

-void wxWindow::ReleaseMouse(void)
+void wxWindow::ReleaseMouse()

 {
 {

-  GtkWidget *connect_widget = m_widget;
-  if (m_wxwindow) connect_widget = m_wxwindow;
+  wxCHECK_RET( m_widget != NULL, "invalid window" );
+
+  wxCHECK_RET( g_capturing == TRUE, "ReleaseMouse called twice" );
+
+  GtkWidget *connect_widget = GetConnectWidget();

   gtk_grab_remove( connect_widget );
   gdk_pointer_ungrab ( GDK_CURRENT_TIME );
   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) )
 {

-};
+}

 
 

-wxString wxWindow::GetTitle(void) const
+wxString wxWindow::GetTitle() const

 {
   return (wxString&)m_windowName;
 {
   return (wxString&)m_windowName;

-};
+}

 
 

-wxString wxWindow::GetLabel(void) const
+wxString wxWindow::GetLabel() const

 {
   return GetTitle();
 {
   return GetTitle();

-};
+}

 
 void wxWindow::SetName( const wxString &name )
 {
   m_windowName = name;
 
 void wxWindow::SetName( const wxString &name )
 {
   m_windowName = name;

-};
+}

 
 

-wxString wxWindow::GetName(void) const
+wxString wxWindow::GetName() const

 {
   return (wxString&)m_windowName;
 {
   return (wxString&)m_windowName;

-};
+}

 
 

-bool wxWindow::IsShown(void) const
+bool wxWindow::IsShown() const

 {
   return m_isShown;
 {
   return m_isShown;

-};
+}

 
 

-bool wxWindow::IsRetained(void)
+bool wxWindow::IsRetained()

 {
   return FALSE;
 {
   return FALSE;

-};
+}

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


@@ -1841,9 +2357,9 @@ wxWindow *wxWindow::FindWindow( long id )
     wxWindow *res = child->FindWindow( id );
     if (res) return res;
     node = node->Next();
     wxWindow *res = child->FindWindow( id );
     if (res) return res;
     node = node->Next();

-  };
-  return NULL;
-};
+  }
+  return (wxWindow *) NULL;
+}

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


@@ -1855,83 +2371,85 @@ wxWindow *wxWindow::FindWindow( const wxString& name )
     wxWindow *res = child->FindWindow( name );
     if (res) return res;
     node = node->Next();
     wxWindow *res = child->FindWindow( name );
     if (res) return res;
     node = node->Next();

-  };
-  return NULL;
-};
+  }
+  return (wxWindow *) NULL;
+}

 
 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
 
 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,

-      int range, bool WXUNUSED(refresh) )
+      int range, bool refresh )

 {
 {

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

   if (!m_wxwindow) return;
 
   if (!m_wxwindow) return;
 

+  m_hasScrolling = TRUE;
+

   if (orient == wxHORIZONTAL)
   {
     float fpos = (float)pos;
   if (orient == wxHORIZONTAL)
   {
     float fpos = (float)pos;

-    m_oldHorizontalPos = fpos;

     float frange = (float)range;
     float fthumb = (float)thumbVisible;
     float frange = (float)range;
     float fthumb = (float)thumbVisible;

-    
-    if ((fabs(fpos-m_hAdjust->value) < 0.2) &&
-        (fabs(frange-m_hAdjust->upper) < 0.2) &&
-  (fabs(fthumb-m_hAdjust->page_size) < 0.2))
+
+    if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
+        (fabs(fthumb-m_hAdjust->page_size) < 0.2))
+    {
+      SetScrollPos( orient, pos, refresh );

       return;
       return;

-      
+    }
+
+    m_oldHorizontalPos = fpos;
+

     m_hAdjust->lower = 0.0;
     m_hAdjust->upper = frange;
     m_hAdjust->value = fpos;
     m_hAdjust->step_increment = 1.0;
     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-2,0));
+    m_hAdjust->page_increment = (float)(wxMax(fthumb,0));

     m_hAdjust->page_size = fthumb;
   }
   else
   {
     float fpos = (float)pos;
     m_hAdjust->page_size = fthumb;
   }
   else
   {
     float fpos = (float)pos;

-    m_oldVerticalPos = fpos;

     float frange = (float)range;
     float fthumb = (float)thumbVisible;
     float frange = (float)range;
     float fthumb = (float)thumbVisible;

-    
-    if ((fabs(fpos-m_vAdjust->value) < 0.2) &&
-        (fabs(frange-m_vAdjust->upper) < 0.2) &&
-  (fabs(fthumb-m_vAdjust->page_size) < 0.2))
+
+    if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
+        (fabs(fthumb-m_vAdjust->page_size) < 0.2))
+    {
+      SetScrollPos( orient, pos, refresh );

       return;
       return;

-      
+    }
+
+    m_oldVerticalPos = fpos;
+

     m_vAdjust->lower = 0.0;
     m_vAdjust->upper = frange;
     m_vAdjust->value = fpos;
     m_vAdjust->step_increment = 1.0;
     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-2,0));
+    m_vAdjust->page_increment = (float)(wxMax(fthumb,0));

     m_vAdjust->page_size = fthumb;
     m_vAdjust->page_size = fthumb;

-  };
-  
+  }
+

   if (m_wxwindow->window)
   {
     if (orient == wxHORIZONTAL)
   if (m_wxwindow->window)
   {
     if (orient == wxHORIZONTAL)

-    {
-/*
-      m_drawingOffsetX = -16000;
-  
-      gtk_myfixed_set_offset( GTK_MYFIXED(m_wxwindow), m_drawingOffsetX, m_drawingOffsetY );
-*/  

       gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
       gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );

-    }

     else
     else

-    { 
-/*
-      m_drawingOffsetY = -16000;
-  
-      gtk_myfixed_set_offset( GTK_MYFIXED(m_wxwindow), m_drawingOffsetX, m_drawingOffsetY );
-*/      

       gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
       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" );
+

   if (!m_wxwindow) return;
   if (!m_wxwindow) return;

-  
+

   if (orient == wxHORIZONTAL)
   {
     float fpos = (float)pos;
   if (orient == wxHORIZONTAL)
   {
     float fpos = (float)pos;


@@ -1946,86 +2464,81 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
     m_oldVerticalPos = fpos;
     if (fabs(fpos-m_vAdjust->value) < 0.2) return;
     m_vAdjust->value = fpos;
     m_oldVerticalPos = fpos;
     if (fabs(fpos-m_vAdjust->value) < 0.2) return;
     m_vAdjust->value = fpos;

-  };
-  
-  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" );
-  };
-};
+  }
+
+  if (!m_isScrolling)
+  {
+    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" );
+

   if (!m_wxwindow) return 0;
 
   if (orient == wxHORIZONTAL)
     return (int)(m_hAdjust->page_size+0.5);
   else
     return (int)(m_vAdjust->page_size+0.5);
   if (!m_wxwindow) return 0;
 
   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" );
+

   if (!m_wxwindow) return 0;
 
   if (orient == wxHORIZONTAL)
     return (int)(m_hAdjust->value+0.5);
   else
     return (int)(m_vAdjust->value+0.5);
   if (!m_wxwindow) return 0;
 
   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" );
+
+  wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+

   if (!m_wxwindow) return 0;
 
   if (orient == wxHORIZONTAL)
     return (int)(m_hAdjust->upper+0.5);
   else
     return (int)(m_vAdjust->upper+0.5);
   if (!m_wxwindow) return 0;
 
   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" );
+

   if (!m_wxwindow) return;
   if (!m_wxwindow) return;

-  
-  bool refresh = FALSE;
-    
-  if ((m_drawingOffsetX == 0) && (m_drawingOffsetY == 0))
-  {
-    m_drawingOffsetX = -16000;
-    m_drawingOffsetY = -16000;
-    refresh = TRUE;
-  }
-  else
-  {
-    m_drawingOffsetX += dx;
-    m_drawingOffsetY += dy;
-  }
-  
-//  printf( "X: %d  Y: %d  \n", (int)m_drawingOffsetX, (int)m_drawingOffsetY );
-  
-  gtk_myfixed_set_offset( GTK_MYFIXED(m_wxwindow), m_drawingOffsetX, m_drawingOffsetY );
-  
-  if (refresh) Refresh();
-  
-/*
-    The code here is very nifty, but it doesn't work with
-    overlapping windows...

 
     int cw = 0;
     int ch = 0;
     GetClientSize( &cw, &ch );
 
     int cw = 0;
     int ch = 0;
     GetClientSize( &cw, &ch );

-    
+

     int w = cw - abs(dx);
     int h = ch - abs(dy);
     if ((h < 0) || (w < 0))
     {
       Refresh();
       return;
     int w = cw - abs(dx);
     int h = ch - abs(dy);
     if ((h < 0) || (w < 0))
     {
       Refresh();
       return;

-    };
+    }

     int s_x = 0;
     int s_y = 0;
     if (dx < 0) s_x = -dx;
     int s_x = 0;
     int s_y = 0;
     if (dx < 0) s_x = -dx;


@@ -2034,33 +2547,33 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
     int d_y = 0;
     if (dx > 0) d_x = dx;
     if (dy > 0) d_y = dy;
     int d_y = 0;
     if (dx > 0) d_x = dx;
     if (dy > 0) d_y = dy;

-    gdk_window_copy_area( m_wxwindow->window, m_wxwindow->style->fg_gc[0], d_x, d_y,
+
+    if (!m_scrollGC)
+    {
+      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,

       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;
     if (dy < 0) rect.y = ch+dy; else rect.y = 0;
     if (dy != 0) rect.width = cw; else rect.width = abs(dx);
     if (dx != 0) rect.height = ch; else rect.height = abs(dy);
     wxRect rect;
     if (dx < 0) rect.x = cw+dx; else rect.x = 0;
     if (dy < 0) rect.y = ch+dy; else rect.y = 0;
     if (dy != 0) rect.width = cw; else rect.width = abs(dx);
     if (dx != 0) rect.height = ch; else rect.height = abs(dy);

-  
-    Refresh( TRUE, &rect );
-*/
-};

 
 

-void wxWindow::GetDrawingOffset( long *x, long *y )
-{
-  if (x) *x = m_drawingOffsetX;
-  if (y) *y = m_drawingOffsetY;
-};
+    Refresh( TRUE, &rect );
+}

 
 //-------------------------------------------------------------------------------------
 //          Layout
 //-------------------------------------------------------------------------------------
 
 
 //-------------------------------------------------------------------------------------
 //          Layout
 //-------------------------------------------------------------------------------------
 

-wxLayoutConstraints *wxWindow::GetConstraints(void) const
+wxLayoutConstraints *wxWindow::GetConstraints() const

 {
   return m_constraints;
 {
   return m_constraints;

-};
+}

 
 void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
 {
 
 void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
 {


@@ -2097,27 +2610,27 @@ void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
 void wxWindow::SetAutoLayout( bool autoLayout )
 {
   m_autoLayout = autoLayout;
 void wxWindow::SetAutoLayout( bool autoLayout )
 {
   m_autoLayout = autoLayout;

-};
+}

 
 

-bool wxWindow::GetAutoLayout(void) const
+bool wxWindow::GetAutoLayout() const

 {
   return m_autoLayout;
 {
   return m_autoLayout;

-};
+}

 
 

-wxSizer *wxWindow::GetSizer(void) const
+wxSizer *wxWindow::GetSizer() const

 {
   return m_windowSizer;
 {
   return m_windowSizer;

-};
+}

 
 void wxWindow::SetSizerParent( wxWindow *win )
 {
   m_sizerParent = win;
 
 void wxWindow::SetSizerParent( wxWindow *win )
 {
   m_sizerParent = win;

-};
+}

 
 

-wxWindow *wxWindow::GetSizerParent(void) const
+wxWindow *wxWindow::GetSizerParent() const

 {
   return m_sizerParent;
 {
   return m_sizerParent;

-};
+}

 
 // This removes any dangling pointers to this window
 // in other windows' constraintsInvolvedIn lists.
 
 // This removes any dangling pointers to this window
 // in other windows' constraintsInvolvedIn lists.


@@ -2162,7 +2675,7 @@ void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
 }
 
 // Reset any constraints that mention this window
 }
 
 // Reset any constraints that mention this window

-void wxWindow::DeleteRelatedConstraints(void)
+void wxWindow::DeleteRelatedConstraints()

 {
   if (m_constraintsInvolvedIn)
   {
 {
   if (m_constraintsInvolvedIn)
   {


@@ -2189,7 +2702,7 @@ void wxWindow::DeleteRelatedConstraints(void)
       node = next;
     }
     delete m_constraintsInvolvedIn;
       node = next;
     }
     delete m_constraintsInvolvedIn;

-    m_constraintsInvolvedIn = NULL;
+    m_constraintsInvolvedIn = (wxList *) NULL;

   }
 }
 
   }
 }
 


@@ -2204,7 +2717,7 @@ void wxWindow::SetSizer(wxSizer *sizer)
  * New version
  */
 
  * New version
  */
 

-bool wxWindow::Layout(void)
+bool wxWindow::Layout()

 {
   if (GetConstraints())
   {
 {
   if (GetConstraints())
   {


@@ -2213,7 +2726,7 @@ bool wxWindow::Layout(void)
     GetConstraints()->width.SetValue(w);
     GetConstraints()->height.SetValue(h);
   }
     GetConstraints()->width.SetValue(w);
     GetConstraints()->height.SetValue(h);
   }

-  
+

   // If top level (one sizer), evaluate the sizer's constraints.
   if (GetSizer())
   {
   // If top level (one sizer), evaluate the sizer's constraints.
   if (GetSizer())
   {


@@ -2254,7 +2767,7 @@ bool wxWindow::LayoutPhase1(int *noChanges)
 bool wxWindow::LayoutPhase2(int *noChanges)
 {
   *noChanges = 0;
 bool wxWindow::LayoutPhase2(int *noChanges)
 {
   *noChanges = 0;

-  
+

   // Layout children
   DoPhase(1);
   DoPhase(2);
   // Layout children
   DoPhase(1);
   DoPhase(2);


@@ -2273,7 +2786,7 @@ bool wxWindow::DoPhase(int phase)
   {
     noChanges = 0;
     noFailures = 0;
   {
     noChanges = 0;
     noFailures = 0;

-    wxNode *node = GetChildren()->First();
+    wxNode *node = m_children.First();

     while (node)
     {
       wxWindow *child = (wxWindow *)node->Data();
     while (node)
     {
       wxWindow *child = (wxWindow *)node->Data();


@@ -2304,7 +2817,7 @@ bool wxWindow::DoPhase(int phase)
   return TRUE;
 }
 
   return TRUE;
 }
 

-void wxWindow::ResetConstraints(void)
+void wxWindow::ResetConstraints()

 {
   wxLayoutConstraints *constr = GetConstraints();
   if (constr)
 {
   wxLayoutConstraints *constr = GetConstraints();
   if (constr)


@@ -2318,7 +2831,7 @@ void wxWindow::ResetConstraints(void)
     constr->centreX.SetDone(FALSE);
     constr->centreY.SetDone(FALSE);
   }
     constr->centreX.SetDone(FALSE);
     constr->centreY.SetDone(FALSE);
   }

-  wxNode *node = GetChildren()->First();
+  wxNode *node = m_children.First();

   while (node)
   {
     wxWindow *win = (wxWindow *)node->Data();
   while (node)
   {
     wxWindow *win = (wxWindow *)node->Data();


@@ -2360,24 +2873,24 @@ 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);
+    wxDebugMsg(_("Constraint(s) not satisfied for window of type %s, name %s:\n"), (const char *)windowClass, (const char *)winName);

     if (!constr->left.GetDone())
     if (!constr->left.GetDone())

-      wxDebugMsg("  unsatisfied 'left' constraint.\n");
+      wxDebugMsg(_("  unsatisfied 'left' constraint.\n"));

     if (!constr->right.GetDone())
     if (!constr->right.GetDone())

-      wxDebugMsg("  unsatisfied 'right' constraint.\n");
+      wxDebugMsg(_("  unsatisfied 'right' constraint.\n"));

     if (!constr->width.GetDone())
     if (!constr->width.GetDone())

-      wxDebugMsg("  unsatisfied 'width' constraint.\n");
+      wxDebugMsg(_("  unsatisfied 'width' constraint.\n"));

     if (!constr->height.GetDone())
     if (!constr->height.GetDone())

-      wxDebugMsg("  unsatisfied 'height' constraint.\n");
-    wxDebugMsg("Please check constraints: try adding AsIs() constraints.\n");
+      wxDebugMsg(_("  unsatisfied 'height' constraint.\n"));
+    wxDebugMsg(_("Please check constraints: try adding AsIs() constraints.\n"));

   }
 
   if (recurse)
   {
   }
 
   if (recurse)
   {

-    wxNode *node = GetChildren()->First();
+    wxNode *node = m_children.First();

     while (node)
     {
       wxWindow *win = (wxWindow *)node->Data();
     while (node)
     {
       wxWindow *win = (wxWindow *)node->Data();


@@ -2395,7 +2908,7 @@ void wxWindow::TransformSizerToActual(int *x, int *y) const
   if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
          m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
     return;
   if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
          m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
     return;

-    
+

   int xp, yp;
   m_sizerParent->GetPosition(&xp, &yp);
   m_sizerParent->TransformSizerToActual(&xp, &yp);
   int xp, yp;
   m_sizerParent->GetPosition(&xp, &yp);
   m_sizerParent->TransformSizerToActual(&xp, &yp);