no message

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

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index 70c53851a70b840e5a97ff5b5cce88b4d1ac560b..a76a068ebde04772b779e9b28080b4106a050225 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -28,11 +28,12 @@
 #include "wx/menu.h"
 #include "wx/notebook.h"
 #include "wx/statusbr.h"
 #include "wx/menu.h"
 #include "wx/notebook.h"
 #include "wx/statusbr.h"

-#include <wx/intl.h>
-#include "gdk/gdkkeysyms.h"
-#include <math.h>
+#include "wx/intl.h"

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

+#include "gdk/gdkkeysyms.h"
+
+#include <math.h>

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


@@ -42,12 +43,12 @@
    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
    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 
+   some more information about what the wxWindow, which is the base class

    for all other window classes, does seems required as well.
    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 descentants:
    What does wxWindow do? It contains the common interface for the following
    jobs of its descentants:

-   
+

    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.
    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.


@@ -56,20 +57,20 @@
    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-
    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 
+   work classes are a special case and are handled a bit differently from

    the rest.
    the rest.

-   
+

    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.
    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 actaul inter-
    face for this is usually in wxScrolledWidget, but the GTK implementation
    is in this class.
    4) Provide the entire mechanism for scrolling widgets. This actaul inter-
    face for this is usually in wxScrolledWidget, 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.
    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 class would always contain
    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
    Normally one might expect, that one wxWindows class would always contain
    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


@@ -80,7 +81,7 @@
    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.
    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 widget. 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
    All windows must have a widget, with which they interact with other under-
    lying GTK widget. 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


@@ -94,14 +95,14 @@
    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.
    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.
    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.
    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.


@@ -115,27 +116,39 @@
 extern wxList wxPendingDelete;
 extern wxList wxTopLevelWindows;
 extern bool   g_blockEventsOnDrag;
 extern wxList wxPendingDelete;
 extern wxList wxTopLevelWindows;
 extern bool   g_blockEventsOnDrag;

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

 
 //-----------------------------------------------------------------------------
 // "expose_event" (of m_wxwindow, not of m_widget)
 //-----------------------------------------------------------------------------
 
 static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
 
 //-----------------------------------------------------------------------------
 // "expose_event" (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;
   if (g_blockEventsOnDrag) return;
   if (!win->HasVMT()) return;
   if (g_blockEventsOnDrag) return;

-  
+

   win->m_updateRegion.Union( gdk_event->area.x,
                              gdk_event->area.y,
   win->m_updateRegion.Union( gdk_event->area.x,
                              gdk_event->area.y,

-                            gdk_event->area.width,
+                             gdk_event->area.width,

                              gdk_event->area.height );
                              gdk_event->area.height );

-           
+

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

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

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

-  
+

   win->m_updateRegion.Clear();
 }
 
   win->m_updateRegion.Clear();
 }
 


@@ -144,16 +157,16 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp
 //-----------------------------------------------------------------------------
 
 static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
 //-----------------------------------------------------------------------------
 
 static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )

-{ 
+{

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

-  
+

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

-           
+

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

-  
+

   win->m_updateRegion.Clear();
 }
 
   win->m_updateRegion.Clear();
 }
 


@@ -162,7 +175,7 @@ static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle
 //-----------------------------------------------------------------------------
 
 static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
 //-----------------------------------------------------------------------------
 
 static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )

-{ 
+{

   if (!win->HasVMT()) return FALSE;
   if (g_blockEventsOnDrag) return FALSE;
 
   if (!win->HasVMT()) return FALSE;
   if (g_blockEventsOnDrag) return FALSE;
 


@@ -246,13 +259,13 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
     case GDK_F12:           key_code = WXK_F12;         break;
     default:
     {
     case GDK_F12:           key_code = WXK_F12;         break;
     default:
     {

-      if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF)) 
+      if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))

         key_code = gdk_event->keyval;
     }
   }
 
   if (!key_code) return FALSE;
         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);
   wxKeyEvent event( wxEVT_CHAR );
   event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
   event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);


@@ -262,31 +275,31 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
   event.m_x = 0;
   event.m_y = 0;
   event.SetEventObject( win );
   event.m_x = 0;
   event.m_y = 0;
   event.SetEventObject( win );

-  
+

   bool ret = win->GetEventHandler()->ProcessEvent( event );
   bool ret = win->GetEventHandler()->ProcessEvent( event );

-  
+

   if (!ret)
   {
     wxWindow *ancestor = win;
     while (ancestor)
   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 );
       int command = ancestor->GetAcceleratorTable()->GetCommand( event );
       if (command != -1)
       {
         wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
         ret = ancestor->GetEventHandler()->ProcessEvent( command_event );

-       break;
+    break;

       }
       ancestor = ancestor->GetParent();
     }
   }
       }
       ancestor = ancestor->GetParent();
     }
   }

-  
+

   if (ret)
   {
   if (ret)
   {

-    if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF)) 
+    if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))

       gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
   }
       gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
   }

-  
+

   return ret;
 }
 
   return ret;
 }
 


@@ -297,7 +310,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
 static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 {
   if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
 static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 {
   if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;

-  
+

   if (g_blockEventsOnDrag) return TRUE;
 
   if (win->m_wxwindow)
   if (g_blockEventsOnDrag) return TRUE;
 
   if (win->m_wxwindow)


@@ -305,17 +318,17 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
     if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow) && !GTK_WIDGET_HAS_FOCUS (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;
 
 /*


@@ -326,7 +339,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
 */
 
   wxEventType event_type = wxEVT_LEFT_DOWN;
 */
 
   wxEventType event_type = wxEVT_LEFT_DOWN;

-  
+

   if (gdk_event->button == 1)
   {
     switch (gdk_event->type)
   if (gdk_event->button == 1)
   {
     switch (gdk_event->type)


@@ -354,7 +367,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
       default:  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);
   wxMouseEvent event( event_type );
   event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
   event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);


@@ -363,35 +376,40 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
   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_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.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
   // Some control don't have their own X window and thus cannot get

-  // any events. 
-  
-  wxNode *node = win->GetChildren()->First();
-  while (node)
+  // any events.
+
+  if (!g_capturing)

   {
   {

-    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))
+    wxNode *node = win->GetChildren()->First();
+    while (node)

     {
     {

-      win = child;
-      event.m_x -= child->m_x;
-      event.m_y -= child->m_y;
-      break;
+      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();

     }
     }

-    node = node->Next();

   }
   }

-  
+

   event.SetEventObject( win );
   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" );
   if (win->GetEventHandler()->ProcessEvent( event ))
     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );

-  
+

   return TRUE;
 }
 
   return TRUE;
 }
 


@@ -400,21 +418,22 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
 //-----------------------------------------------------------------------------
 
 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 //-----------------------------------------------------------------------------
 
 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )

-{ 
+{

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

+

   if (g_blockEventsOnDrag) return TRUE;
 
   if (!win->HasVMT()) return TRUE;
   if (g_blockEventsOnDrag) 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;
   wxEventType event_type = wxEVT_NULL;

-  
+

   switch (gdk_event->button)
   {
     case 1: event_type = wxEVT_LEFT_UP; break;
   switch (gdk_event->button)
   {
     case 1: event_type = wxEVT_LEFT_UP; break;


@@ -432,32 +451,35 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
   event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
   event.m_x = (long)gdk_event->x;
   event.m_y = (long)gdk_event->y;
   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
   // Some control don't have their own X window and thus cannot get

-  // any events. 
-  
-  wxNode *node = win->GetChildren()->First();
-  while (node)
+  // any events.
+
+  if (!g_capturing)

   {
   {

-    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))
+    wxNode *node = win->GetChildren()->First();
+    while (node)

     {
     {

-      win = child;
-      event.m_x -= child->m_x;
-      event.m_y -= child->m_y;
-      break;
+      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();

     }
     }

-    node = node->Next();

   }
   }

-  
+

   event.SetEventObject( win );
   event.SetEventObject( win );

-  
+

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

-  
+

   return TRUE;
 }
 
   return TRUE;
 }
 


@@ -466,19 +488,20 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
 //-----------------------------------------------------------------------------
 
 static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
 //-----------------------------------------------------------------------------
 
 static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )

-{ 
+{

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

+

   if (g_blockEventsOnDrag) return TRUE;
 
   if (!win->HasVMT()) return TRUE;
   if (g_blockEventsOnDrag) 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);
   wxMouseEvent event( wxEVT_MOTION );
   event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
   event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);


@@ -487,35 +510,38 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
   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_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.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
   // Some control don't have their own X window and thus cannot get

-  // any events. 
-  
-  wxNode *node = win->GetChildren()->First();
-  while (node)
+  // any events.
+
+  if (!g_capturing)

   {
   {

-    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))
+    wxNode *node = win->GetChildren()->First();
+    while (node)

     {
     {

-      win = child;
-      event.m_x -= child->m_x;
-      event.m_y -= child->m_y;
-      break;
+      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();

     }
     }

-    node = node->Next();

   }
   }

-  
+

   event.SetEventObject( win );
   event.SetEventObject( win );

-  
+

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

-  
+

   return TRUE;
 }
 
   return TRUE;
 }
 


@@ -531,7 +557,7 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
     if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
     {
       GTK_WIDGET_SET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
     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( "SetFocus flag from " );
       if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
         printf( win->GetClassInfo()->GetClassName() );


@@ -539,9 +565,9 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
 */
     }
   }
 */
     }
   }

-  
+

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

-  
+

 /*
   printf( "OnSetFocus from " );
   if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 /*
   printf( "OnSetFocus from " );
   if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())


@@ -550,13 +576,13 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
   printf( WXSTRINGCAST win->GetLabel() );
   printf( ".\n" );
 */
   printf( WXSTRINGCAST win->GetLabel() );
   printf( ".\n" );
 */

-  
+

   wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
   event.SetEventObject( win );
   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" );
   if (win->GetEventHandler()->ProcessEvent( event ))
     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );

-  
+

   return TRUE;
 }
 
   return TRUE;
 }
 


@@ -572,25 +598,87 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
     if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
       GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
   }
     if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
       GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
   }

-  
+

   if (!win->HasVMT()) return TRUE;
   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 );
   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;
 }
 
   if (win->GetEventHandler()->ProcessEvent( event ))
     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
 
   return TRUE;
 }
 

+//-----------------------------------------------------------------------------
+// "enter_notify_event"
+//-----------------------------------------------------------------------------
+
+static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
+{
+  if (widget->window != gdk_event->window) return TRUE;
+
+  if (g_blockEventsOnDrag) return TRUE;
+
+  if (!win->HasVMT()) return TRUE;
+
+/*
+  printf( "OnEnter from " );
+  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+    printf( win->GetClassInfo()->GetClassName() );
+  printf( ".\n" );
+*/
+
+  if ((widget->window) && (win->m_cursor))
+    gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
+
+  wxMouseEvent event( wxEVT_ENTER_WINDOW );
+  event.SetEventObject( win );
+
+  if (win->GetEventHandler()->ProcessEvent( event ))
+    gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
+
+  return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// "leave_notify_event"
+//-----------------------------------------------------------------------------
+
+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( "OnLeave from " );
+  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+    printf( win->GetClassInfo()->GetClassName() );
+  printf( ".\n" );
+*/
+
+  if ((widget->window) && (win->m_cursor))
+    gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
+
+  wxMouseEvent event( wxEVT_LEAVE_WINDOW );
+  event.SetEventObject( win );
+
+  if (win->GetEventHandler()->ProcessEvent( event ))
+    gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
+
+  return TRUE;
+}
+

 //-----------------------------------------------------------------------------
 // "value_changed" from m_vAdjust
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // "value_changed" from m_vAdjust
 //-----------------------------------------------------------------------------


@@ -605,23 +693,23 @@ static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
     printf( win->GetClassInfo()->GetClassName() );
   printf( ".\n" );
 */
     printf( win->GetClassInfo()->GetClassName() );
   printf( ".\n" );
 */

-  
+

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

-  
+

   float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
   if (fabs(diff) < 0.2) return;
   float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
   if (fabs(diff) < 0.2) return;

-  
+

   wxEventType command = wxEVT_NULL;
   wxEventType command = wxEVT_NULL;

-  
+

   float line_step = win->m_vAdjust->step_increment;
   float page_step = win->m_vAdjust->page_increment;
   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;
   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 );
   int value = (int)(win->m_vAdjust->value+0.5);
 
   wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );


@@ -634,26 +722,26 @@ static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
 //-----------------------------------------------------------------------------
 
 static void gtk_window_hscroll_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( "OnHScroll 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;
   if (!win->HasVMT()) return;

-    
+

   float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
   if (fabs(diff) < 0.2) return;
   float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
   if (fabs(diff) < 0.2) return;

-  
+

   wxEventType command = wxEVT_NULL;
   wxEventType command = wxEVT_NULL;

-  
+

   float line_step = win->m_hAdjust->step_increment;
   float page_step = win->m_hAdjust->page_increment;
   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;
   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;


@@ -661,7 +749,7 @@ static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
   else command = wxEVT_SCROLL_THUMBTRACK;
 
   int value = (int)(win->m_hAdjust->value+0.5);
   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 );
   wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
   event.SetEventObject( win );
   win->GetEventHandler()->ProcessEvent( event );


@@ -681,9 +769,9 @@ static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxW
     printf( win->GetClassInfo()->GetClassName() );
   printf( ".\n" );
 */
     printf( win->GetClassInfo()->GetClassName() );
   printf( ".\n" );
 */

-  
+

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

-  
+

   wxEventType command = wxEVT_SCROLL_THUMBTRACK;
   int value = (int)(win->m_vAdjust->value+0.5);
 
   wxEventType command = wxEVT_SCROLL_THUMBTRACK;
   int value = (int)(win->m_vAdjust->value+0.5);
 


@@ -697,26 +785,59 @@ static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxW
 //-----------------------------------------------------------------------------
 
 static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
 //-----------------------------------------------------------------------------
 
 static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )

-{ 
+{

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

-  
+

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

-  
+

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

-    
+

   wxEventType command = wxEVT_SCROLL_THUMBTRACK;
   int value = (int)(win->m_hAdjust->value+0.5);
   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 );
 }
 
   wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
   event.SetEventObject( win );
   win->GetEventHandler()->ProcessEvent( event );
 }
 

+//-----------------------------------------------------------------------------
+// "button_press_event" from scrollbar
+//-----------------------------------------------------------------------------
+
+static gint gtk_scrollbar_button_press_callback( GtkRange *widget, GdkEventButton *gdk_event, wxWindow *win )
+{
+  if (gdk_event->window != widget->slider) return FALSE;
+
+  win->m_isScrolling = TRUE;
+
+  return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// "button_release_event" from scrollbar
+//-----------------------------------------------------------------------------
+
+static gint gtk_scrollbar_button_release_callback( GtkRange *widget, GdkEventButton *gdk_event, wxWindow *win )
+{
+  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;
+
+  return FALSE;
+}
+

 //-----------------------------------------------------------------------------
 // "drop_data_available_event"
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // "drop_data_available_event"
 //-----------------------------------------------------------------------------


@@ -724,7 +845,7 @@ static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxW
 static void gtk_window_drop_callback( GtkWidget *widget, GdkEvent *event, wxWindow *win )
 {
   if (!win->HasVMT()) return;
 static void gtk_window_drop_callback( GtkWidget *widget, GdkEvent *event, wxWindow *win )
 {
   if (!win->HasVMT()) return;

-  
+

   if (win->GetDropTarget())
   {
     int x = 0;
   if (win->GetDropTarget())
   {
     int x = 0;


@@ -732,49 +853,13 @@ static void gtk_window_drop_callback( GtkWidget *widget, GdkEvent *event, wxWind
     gdk_window_get_pointer( widget->window, &x, &y, (GdkModifierType *) NULL );
     win->GetDropTarget()->Drop( event, x, y );
   }
     gdk_window_get_pointer( widget->window, &x, &y, (GdkModifierType *) NULL );
     win->GetDropTarget()->Drop( event, x, y );
   }

-  
+

 /*
   g_free (event->dropdataavailable.data);
   g_free (event->dropdataavailable.data_type);
 */
 }
 
 /*
   g_free (event->dropdataavailable.data);
   g_free (event->dropdataavailable.data_type);
 */
 }
 

-//-----------------------------------------------------------------------------
-// "enter_notify_event"
-//-----------------------------------------------------------------------------
-
-static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
-{
-  if (widget->window != gdk_event->window) return TRUE;
-  if (g_blockEventsOnDrag) return TRUE;
-  if (!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->GetEventHandler()->ProcessEvent( event );
-}
-    
-//-----------------------------------------------------------------------------
-// "leave_notify_event"
-//-----------------------------------------------------------------------------
-
-static gint 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->GetEventHandler()->ProcessEvent( event );
-}
-    

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


@@ -806,7 +891,7 @@ wxWindow::wxWindow()
   m_eventHandler = this;
   m_windowValidator = (wxValidator *) NULL;
   m_windowId = -1;
   m_eventHandler = this;
   m_windowValidator = (wxValidator *) NULL;
   m_windowId = -1;

-  m_cursor = new wxCursor( wxCURSOR_ARROW );
+  m_cursor = (wxCursor *) NULL;

   m_font = *wxSWISS_FONT;
   m_windowStyle = 0;
   m_windowName = "noname";
   m_font = *wxSWISS_FONT;
   m_windowStyle = 0;
   m_windowName = "noname";


@@ -819,6 +904,7 @@ wxWindow::wxWindow()
   m_hasVMT = FALSE;
   m_needParent = TRUE;
   m_hasScrolling = 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_hAdjust = (GtkAdjustment *) NULL;
   m_vAdjust = (GtkAdjustment *) NULL;
   m_oldHorizontalPos = 0.0;


@@ -837,41 +923,51 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
   m_isShown = FALSE;
   m_isEnabled = TRUE;
   m_needParent = TRUE;
   m_isShown = FALSE;
   m_isEnabled = TRUE;
   m_needParent = TRUE;

-  
+

   m_cursor = (wxCursor *) NULL;
   m_cursor = (wxCursor *) NULL;

-  
+

   PreCreation( parent, id, pos, size, style, name );
   PreCreation( parent, id, pos, size, style, name );

-  
+

   m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
   m_hasScrolling = TRUE;
   m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
   m_hasScrolling = TRUE;

-  
-  GtkScrolledWindow *s_window;
-  s_window = GTK_SCROLLED_WINDOW(m_widget);
-  
+
+  GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
+
+  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 );
+

   GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
   scroll_class->scrollbar_spacing = 0;
   GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
   scroll_class->scrollbar_spacing = 0;

-  
+

   gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
   gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );

-    
+

   m_oldHorizontalPos = 0.0;
   m_oldVerticalPos = 0.0;
   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_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",
+
+  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);
-  
+
+  GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
+

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


@@ -884,11 +980,11 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
   {
     gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
   }
   {
     gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
   }

-    
+

   m_wxwindow = gtk_myfixed_new();
   m_wxwindow = gtk_myfixed_new();

-  
+

   if (m_wxwindow) GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
   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
   if (m_windowStyle & wxTAB_TRAVERSAL == wxTAB_TRAVERSAL)
     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
   else


@@ -899,8 +995,8 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
   // 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) );
   // 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    
+
+  // 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->lower = 0.0;
   m_vAdjust->upper = 1.0;
   m_vAdjust->value = 0.0;


@@ -915,31 +1011,31 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
   m_hAdjust->page_increment = 1.0;
   m_hAdjust->page_size = 5.0;
   gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
   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 );
   gtk_widget_show( m_wxwindow );

-  
+

   PostCreation();
   PostCreation();

-  
+

   Show( TRUE );
 
   Show( TRUE );
 

-  return TRUE;  
+  return TRUE;

 }
 
 wxWindow::~wxWindow(void)
 {
   m_hasVMT = FALSE;
 }
 
 wxWindow::~wxWindow(void)
 {
   m_hasVMT = FALSE;

-  
+

   if (m_pDropTarget) delete m_pDropTarget;
   if (m_pDropTarget) delete m_pDropTarget;

-  
+

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

-  
+

   if (m_wxwindow) gtk_widget_destroy( m_wxwindow );
   if (m_wxwindow) gtk_widget_destroy( m_wxwindow );

-    
+

   if (m_widget) gtk_widget_destroy( m_widget );
   if (m_widget) gtk_widget_destroy( m_widget );

-  
+

   wxDELETE(m_cursor);
 
   DeleteRelatedConstraints();
   wxDELETE(m_cursor);
 
   DeleteRelatedConstraints();


@@ -968,7 +1064,7 @@ wxWindow::~wxWindow(void)
   // wxWindow::LoadNativeDialog but we weren't a dialog
   // class
   wxTopLevelWindows.DeleteObject(this);
   // wxWindow::LoadNativeDialog but we weren't a dialog
   // class
   wxTopLevelWindows.DeleteObject(this);

-    
+

   if (m_windowValidator) delete m_windowValidator;
 }
 
   if (m_windowValidator) delete m_windowValidator;
 }
 


@@ -1009,6 +1105,8 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
   m_windowSizer = (wxSizer *) NULL;
   m_sizerParent = (wxWindow *) NULL;
   m_autoLayout = FALSE;
   m_windowSizer = (wxSizer *) NULL;
   m_sizerParent = (wxWindow *) NULL;
   m_autoLayout = FALSE;

+  m_hasScrolling = FALSE;
+  m_isScrolling = FALSE;

   m_pDropTarget = (wxDropTarget *) NULL;
   m_resizing = FALSE;
   m_windowValidator = (wxValidator *) NULL;
   m_pDropTarget = (wxDropTarget *) NULL;
   m_resizing = FALSE;
   m_windowValidator = (wxValidator *) NULL;


@@ -1018,67 +1116,56 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
 void wxWindow::PostCreation(void)
 {
   if (m_parent) m_parent->AddChild( this );
 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 = GetConnectWidget();
- 
+

   if (m_wxwindow)
   {
   if (m_wxwindow)
   {

-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event", 
+    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",

       GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
       GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );

-      
-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw", 
+
+    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",

       GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
   }
       GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
   }

-  
-  gtk_signal_connect( GTK_OBJECT(connect_widget), "key_press_event",
+
+  ConnectWidget( GetConnectWidget() );
+
+  if (m_widget && m_parent) gtk_widget_realize( m_widget );
+
+  if (m_wxwindow)
+  {
+    gtk_widget_realize( m_wxwindow );
+    gdk_gc_set_exposures( m_wxwindow->style->fg_gc[0], TRUE );
+  }
+
+  SetCursor( *wxSTANDARD_CURSOR );
+
+  m_hasVMT = TRUE;
+}
+
+void wxWindow::ConnectWidget( GtkWidget *widget )
+{
+  gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",

     GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
 
     GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
 

-  gtk_signal_connect( GTK_OBJECT(connect_widget), "button_press_event",
+  gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",

     GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
     GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );

-    
-  gtk_signal_connect( GTK_OBJECT(connect_widget), "button_release_event",
+
+  gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",

     GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
     GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );

-    
-  gtk_signal_connect( GTK_OBJECT(connect_widget), "motion_notify_event",
+
+  gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",

     GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
     GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );

-    
-  gtk_signal_connect( GTK_OBJECT(connect_widget), "focus_in_event", 
+
+  gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",

     GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
 
     GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
 

-  gtk_signal_connect( GTK_OBJECT(connect_widget), "focus_out_event", 
+  gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",

     GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
 
     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_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_widget), "leave_notify_event", 
+
+  gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",

     GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
     GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );

-    
-  if (m_wxwindow)
-  {
-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "enter_notify_event", 
-      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 );
-  }
-  
-  if (m_widget && m_parent) gtk_widget_realize( m_widget );
-  
-  if (m_wxwindow)
-  {
-    gtk_widget_realize( m_wxwindow );
-    gdk_gc_set_exposures( m_wxwindow->style->fg_gc[0], TRUE );
-  }
-  
-  SetCursor( wxSTANDARD_CURSOR );
-  
-  m_hasVMT = TRUE;

 }
 
 bool wxWindow::HasVMT(void)
 }
 
 bool wxWindow::HasVMT(void)


@@ -1088,6 +1175,8 @@ bool wxWindow::HasVMT(void)
 
 bool wxWindow::Close( bool force )
 {
 
 bool wxWindow::Close( bool force )
 {

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

   wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
   event.SetEventObject(this);
   event.SetForce(force);
   wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
   event.SetEventObject(this);
   event.SetForce(force);


@@ -1097,6 +1186,8 @@ bool wxWindow::Close( bool force )
 
 bool wxWindow::Destroy(void)
 {
 
 bool wxWindow::Destroy(void)
 {

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

   m_hasVMT = FALSE;
   delete this;
   return TRUE;
   m_hasVMT = FALSE;
   delete this;
   return TRUE;


@@ -1104,13 +1195,13 @@ bool wxWindow::Destroy(void)
 
 bool wxWindow::DestroyChildren(void)
 {
 
 bool wxWindow::DestroyChildren(void)
 {

-  if (GetChildren()) 
+  if (GetChildren())

   {
     wxNode *node;
   {
     wxNode *node;

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

     {
       wxWindow *child;
     {
       wxWindow *child;

-      if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) 
+      if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)

       {
         delete child;
         if (GetChildren()->Member(child)) delete node;
       {
         delete child;
         if (GetChildren()->Member(child)) delete node;


@@ -1126,7 +1217,7 @@ void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
 }
 
 void wxWindow::ImplementSetSize(void)
 }
 
 void wxWindow::ImplementSetSize(void)

-{ 
+{

   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_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;


@@ -1142,29 +1233,31 @@ void wxWindow::ImplementSetPosition(void)
       gtk_widget_set_uposition( m_widget, m_x, m_y );
     return;
   }
       gtk_widget_set_uposition( m_widget, m_x, m_y );
     return;
   }

-  
+

   if (!m_parent)
   {
     wxFAIL_MSG( "wxWindow::SetSize error.\n" );
     return;
   }
   if (!m_parent)
   {
     wxFAIL_MSG( "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 );
   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   
+
+  // Don't do anything for children of wxNotebook and wxMDIChildFrame

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

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

   if (m_resizing) return; // I don't like recursions
   m_resizing = TRUE;
   if (m_resizing) return; // I don't like recursions
   m_resizing = TRUE;

-  
+

   int newX = x;
   int newY = y;
   int newW = width;
   int newH = height;
   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 ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
   {
     if (newX == -1) newX = m_x;


@@ -1172,17 +1265,17 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
     if (newW == -1) newW = m_width;
     if (newH == -1) newH = m_height;
   }
     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_WIDTH) == wxSIZE_AUTO_WIDTH)
   {
     if (newW == -1) newW = 80;
   }

-  
+

   if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
   {
     if (newH == -1) newH = 26;
   }
   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;
   if ((m_x != newX) || (m_y != newY) || (!m_sizeSet))
   {
     m_x = newX;


@@ -1196,11 +1289,11 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
     ImplementSetSize();
   }
   m_sizeSet = TRUE;
     ImplementSetSize();
   }
   m_sizeSet = TRUE;

-  
+

   wxSizeEvent event( wxSize(m_width,m_height), GetId() );
   event.SetEventObject( this );
   ProcessEvent( event );
   wxSizeEvent event( wxSize(m_width,m_height), GetId() );
   event.SetEventObject( this );
   ProcessEvent( event );

-  
+

   m_resizing = FALSE;
 }
 
   m_resizing = FALSE;
 }
 


@@ -1216,12 +1309,16 @@ void wxWindow::Move( int x, int y )
 
 void wxWindow::GetSize( int *width, int *height ) const
 {
 
 void wxWindow::GetSize( int *width, int *height ) const
 {

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

   if (width) (*width) = m_width;
   if (height) (*height) = m_height;
 }
 
 void wxWindow::SetClientSize( int width, int height )
 {
   if (width) (*width) = m_width;
   if (height) (*height) = m_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 );


@@ -1230,14 +1327,14 @@ void wxWindow::SetClientSize( int width, int height )
   {
     int dw = 0;
     int dh = 0;
   {
     int dw = 0;
     int dh = 0;

-    
+

     if (!m_hasScrolling)
     {
 /*
       do we have sunken dialogs ?
     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;
 */
       dw += 2 * window_class->xthickness;
       dh += 2 * window_class->ythickness;
 */


@@ -1246,39 +1343,41 @@ void wxWindow::SetClientSize( int width, int height )
     {
       GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
       GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
     {
       GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
       GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );

-    
+

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

-    
+

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

-    
+

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

-    
+

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

-    
+

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

-    
+

     SetSize( width+dw, height+dh );
   }
 }
 
 void wxWindow::GetClientSize( int *width, int *height ) const
 {
     SetSize( width+dw, height+dh );
   }
 }
 
 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;


@@ -1288,14 +1387,14 @@ void wxWindow::GetClientSize( int *width, int *height ) const
   {
     int dw = 0;
     int dh = 0;
   {
     int dw = 0;
     int dh = 0;

-    
+

     if (!m_hasScrolling)
     {
 /*
       do we have sunken dialogs ?
     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;
 */
       dw += 2 * window_class->xthickness;
       dh += 2 * window_class->ythickness;
 */


@@ -1304,27 +1403,27 @@ void wxWindow::GetClientSize( int *width, int *height ) const
     {
       GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
       GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
     {
       GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
       GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );

-    
+

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

-    
+

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

-    
+

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

-    
+

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

-    
+

       if (GTK_WIDGET_VISIBLE(hscrollbar))
       {
 //        dh += hscrollbar->allocation.height;
       if (GTK_WIDGET_VISIBLE(hscrollbar))
       {
 //        dh += hscrollbar->allocation.height;


@@ -1332,7 +1431,7 @@ void wxWindow::GetClientSize( int *width, int *height ) const
         dh += scroll_class->scrollbar_spacing;
       }
     }
         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;
   }


@@ -1340,62 +1439,70 @@ void wxWindow::GetClientSize( int *width, int *height ) const
 
 void wxWindow::GetPosition( int *x, int *y ) const
 {
 
 void wxWindow::GetPosition( int *x, int *y ) const
 {

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

   if (x) (*x) = m_x;
   if (y) (*y) = m_y;
 }
 
 void wxWindow::ClientToScreen( int *x, int *y )
 {
   if (x) (*x) = m_x;
   if (y) (*y) = m_y;
 }
 
 void wxWindow::ClientToScreen( int *x, int *y )
 {

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

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

-    
+

   int org_x = 0;
   int org_y = 0;
   gdk_window_get_origin( source, &org_x, &org_y );
 
   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;  
+
+  if (x) *x += org_x;
+  if (y) *y += org_y;

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

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

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

-    
+

   int org_x = 0;
   int org_y = 0;
   gdk_window_get_origin( source, &org_x, &org_y );
 
   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;  
+
+  if (x) *x -= org_x;
+  if (y) *y -= org_y;

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

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

   if (IS_KIND_OF(this,wxDialog) || IS_KIND_OF(this,wxFrame))
   {
     if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (gdk_screen_width () - m_width) / 2;
   if (IS_KIND_OF(this,wxDialog) || IS_KIND_OF(this,wxFrame))
   {
     if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (gdk_screen_width () - m_width) / 2;


@@ -1418,6 +1525,8 @@ void wxWindow::Centre( int direction )
 
 void wxWindow::Fit(void)
 {
 
 void wxWindow::Fit(void)
 {

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

   int maxX = 0;
   int maxY = 0;
   wxNode *node = GetChildren()->First();
   int maxX = 0;
   int maxY = 0;
   wxNode *node = GetChildren()->First();


@@ -1439,6 +1548,8 @@ void wxWindow::Fit(void)
 
 void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
 {
 
 void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
 {

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

   m_minWidth = minW;
   m_minHeight = minH;
   m_maxWidth = maxW;
   m_minWidth = minW;
   m_minHeight = minH;
   m_maxWidth = maxW;


@@ -1452,16 +1563,20 @@ void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
 
 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;
 }
 
 void wxWindow::Enable( bool enable )
 {
   return TRUE;
 }
 
 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 );


@@ -1469,12 +1584,28 @@ void wxWindow::Enable( bool enable )
 
 int wxWindow::GetCharHeight(void) const
 {
 
 int wxWindow::GetCharHeight(void) 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(void) const
 {
   GdkFont *font = m_font.GetInternalFont( 1.0 );
   return font->ascent + font->descent;
 }
 
 int wxWindow::GetCharWidth(void) 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" );
 }
   GdkFont *font = m_font.GetInternalFont( 1.0 );
   return gdk_string_width( font, "H" );
 }


@@ -1482,9 +1613,18 @@ int wxWindow::GetCharWidth(void) const
 void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
   int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const
 {
 void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
   int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const
 {

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

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

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

   GdkFont *font = fontToUse.GetInternalFont( 1.0 );
   if (x) (*x) = gdk_string_width( font, string );
   if (y) (*y) = font->ascent + font->descent;
   GdkFont *font = fontToUse.GetInternalFont( 1.0 );
   if (x) (*x) = gdk_string_width( font, string );
   if (y) (*y) = font->ascent + font->descent;


@@ -1512,6 +1652,8 @@ void wxWindow::MakeModal( bool modal )
 
 void wxWindow::SetFocus(void)
 {
 
 void wxWindow::SetFocus(void)
 {

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

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


@@ -1529,67 +1671,72 @@ bool wxWindow::OnClose(void)
 
 void wxWindow::AddChild( wxWindow *child )
 {
 
 void wxWindow::AddChild( wxWindow *child )
 {

+  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+  wxASSERT_MSG( (m_wxwindow != NULL), "window need client area" );
+  wxASSERT_MSG( (child != NULL), "invalid child" );
+  wxASSERT_MSG( (child->m_widget != NULL), "invalid 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
   // 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 
+  // for wxFrame, wxDialog, wxWindow and

   // wxMDIParentFrame.
 
   // wxFrame and wxDialog as children aren't placed into the parents
   // 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)))
   {
     m_children.Append( child );
   if (( IS_KIND_OF(child,wxFrame) || IS_KIND_OF(child,wxDialog) ) &&
       (!IS_KIND_OF(child,wxMDIChildFrame)))
   {
     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 );
     if ((child->m_x != -1) && (child->m_y != -1))
       gtk_widget_set_uposition( child->m_widget, child->m_x, child->m_y );

-      
+

     return;
   }
     return;
   }

-  
-  // In the case of an wxMDIChildFrame descendant, we use the 
+
+  // In the case of an wxMDIChildFrame descendant, we use the

   // client windows's AddChild()
   // client windows's AddChild()

-  
+

   if (IS_KIND_OF(this,wxMDIParentFrame))
   {
     if (IS_KIND_OF(child,wxMDIChildFrame))
     {
       wxMDIClientWindow *client = ((wxMDIParentFrame*)this)->GetClientWindow();
       if (client)
   if (IS_KIND_OF(this,wxMDIParentFrame))
   {
     if (IS_KIND_OF(child,wxMDIChildFrame))
     {
       wxMDIClientWindow *client = ((wxMDIParentFrame*)this)->GetClientWindow();
       if (client)

-      { 
+      {

         client->AddChild( child );
         return;
       }
     }
   }
         client->AddChild( child );
         return;
       }
     }
   }

-  
+

   // wxNotebook is very special, so it has a private AddChild()
   // wxNotebook is very special, so it has a private AddChild()

-  
+

   if (IS_KIND_OF(this,wxNotebook))
   {
     wxNotebook *tab = (wxNotebook*)this;
     tab->AddChild( child );
     return;
   }
   if (IS_KIND_OF(this,wxNotebook))
   {
     wxNotebook *tab = (wxNotebook*)this;
     tab->AddChild( child );
     return;
   }

-  
+

   // wxFrame has a private AddChild
   // wxFrame has a private AddChild

-  
+

   if (IS_KIND_OF(this,wxFrame) && !IS_KIND_OF(this,wxMDIChildFrame))
   {
     wxFrame *frame = (wxFrame*)this;
     frame->AddChild( child );
     return;
   }
   if (IS_KIND_OF(this,wxFrame) && !IS_KIND_OF(this,wxMDIChildFrame))
   {
     wxFrame *frame = (wxFrame*)this;
     frame->AddChild( child );
     return;
   }

-  
+

   // All the rest
   // All the rest

-  
+

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

-  if (m_wxwindow) gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget, 
+  if (m_wxwindow) gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget,

     child->m_x, child->m_y );
     child->m_x, child->m_y );

-  
+

   gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height );
 }
 
   gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height );
 }
 


@@ -1601,7 +1748,7 @@ wxList *wxWindow::GetChildren(void)
 void wxWindow::RemoveChild( wxWindow *child )
 {
   if (GetChildren())
 void wxWindow::RemoveChild( wxWindow *child )
 {
   if (GetChildren())

- GetChildren()->DeleteObject( child );
+  GetChildren()->DeleteObject( child );

   child->m_parent = (wxWindow *) NULL;
 }
 
   child->m_parent = (wxWindow *) NULL;
 }
 


@@ -1617,11 +1764,15 @@ int wxWindow::GetReturnCode(void)
 
 void wxWindow::Raise(void)
 {
 
 void wxWindow::Raise(void)
 {

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

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

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

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


@@ -1637,28 +1788,28 @@ void wxWindow::SetEventHandler( wxEvtHandler *handler )
 
 void wxWindow::PushEventHandler(wxEvtHandler *handler)
 {
 
 void wxWindow::PushEventHandler(wxEvtHandler *handler)
 {

-       handler->SetNextHandler(GetEventHandler());
-       SetEventHandler(handler);
+  handler->SetNextHandler(GetEventHandler());
+  SetEventHandler(handler);

 }
 
 wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
 {
 }
 
 wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
 {

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

 }
 
 wxValidator *wxWindow::GetValidator(void)
 }
 
 wxValidator *wxWindow::GetValidator(void)


@@ -1690,30 +1841,45 @@ wxWindowID wxWindow::GetId(void)
 
 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 (*((wxCursor*)&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() );
 }
 
 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
 {
     gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
 }
 
 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
         rect->height );
     else

-      Clear(); 
+      Clear();

   }
   if (!rect)
   {
   }
   if (!rect)
   {


@@ -1722,7 +1888,7 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
       int w = 0;
       int h = 0;
       GetClientSize( &w, &h );
       int w = 0;
       int h = 0;
       GetClientSize( &w, &h );

-      
+

       GdkRectangle gdk_rect;
       gdk_rect.x = 0;
       gdk_rect.y = 0;
       GdkRectangle gdk_rect;
       gdk_rect.x = 0;
       gdk_rect.y = 0;


@@ -1738,7 +1904,7 @@ 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
     if (m_wxwindow)
       gtk_widget_draw( m_wxwindow, &gdk_rect );
     else


@@ -1773,6 +1939,8 @@ bool wxWindow::IsExposed( const wxRect& rect ) const
 
 void wxWindow::Clear(void)
 {
 
 void wxWindow::Clear(void)
 {

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

   if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
 }
 
   if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
 }
 


@@ -1783,6 +1951,8 @@ wxColour wxWindow::GetBackgroundColour(void) const
 
 void wxWindow::SetBackgroundColour( const wxColour &colour )
 {
 
 void wxWindow::SetBackgroundColour( const wxColour &colour )
 {

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

   m_backgroundColour = colour;
   if (m_wxwindow)
   {
   m_backgroundColour = colour;
   if (m_wxwindow)
   {


@@ -1805,11 +1975,13 @@ void wxWindow::SetForegroundColour( const wxColour &colour )
 
 bool wxWindow::Validate(void)
 {
 
 bool wxWindow::Validate(void)
 {

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

   wxNode *node = GetChildren()->First();
   while (node)
   {
     wxWindow *child = (wxWindow *)node->Data();
   wxNode *node = GetChildren()->First();
   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();
   }


@@ -1818,6 +1990,8 @@ bool wxWindow::Validate(void)
 
 bool wxWindow::TransferDataToWindow(void)
 {
 
 bool wxWindow::TransferDataToWindow(void)
 {

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

   wxNode *node = GetChildren()->First();
   while (node)
   {
   wxNode *node = GetChildren()->First();
   while (node)
   {


@@ -1835,6 +2009,8 @@ bool wxWindow::TransferDataToWindow(void)
 
 bool wxWindow::TransferDataFromWindow(void)
 {
 
 bool wxWindow::TransferDataFromWindow(void)
 {

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

   wxNode *node = GetChildren()->First();
   while (node)
   {
   wxNode *node = GetChildren()->First();
   while (node)
   {


@@ -1858,6 +2034,8 @@ void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
 
 void wxWindow::InitDialog(void)
 {
 
 void wxWindow::InitDialog(void)
 {

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

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


@@ -1878,31 +2056,33 @@ static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 
 bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) )
 {
 
 bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) )
 {

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

   SetInvokingWindow( menu, this );
   SetInvokingWindow( menu, this );

-  gtk_menu_popup( GTK_MENU(menu->m_menu), (GtkWidget *) NULL, (GtkWidget *) NULL, (GtkMenuPositionFunc) NULL, NULL, 0, 0 );
+  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 )
 {
   return TRUE;
 }
 
 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 {

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

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

-  
-  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;
-  }
+
+  DisconnectDnDWidget( dnd_widget );
+
+  if (m_pDropTarget) delete m_pDropTarget;

   m_pDropTarget = dropTarget;
   m_pDropTarget = dropTarget;

-  if (m_pDropTarget)
-  {
-    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 );
-  }
+
+  ConnectDnDWidget( dnd_widget );

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


@@ -1910,14 +2090,34 @@ wxDropTarget *wxWindow::GetDropTarget() const
   return m_pDropTarget;
 }
 
   return m_pDropTarget;
 }
 

+void wxWindow::ConnectDnDWidget( GtkWidget *widget )
+{
+  if (!m_pDropTarget) return;
+
+  m_pDropTarget->RegisterWidget( widget );
+
+  gtk_signal_connect( GTK_OBJECT(widget), "drop_data_available_event",
+    GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
+}
+
+void wxWindow::DisconnectDnDWidget( GtkWidget *widget )
+{
+  if (!m_pDropTarget) return;
+
+  gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
+    GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
+
+  m_pDropTarget->UnregisterWidget( widget );
+}
+

 GtkWidget* wxWindow::GetConnectWidget(void)
 {
   GtkWidget *connect_widget = m_widget;
   if (m_wxwindow) connect_widget = m_wxwindow;
 GtkWidget* wxWindow::GetConnectWidget(void)
 {
   GtkWidget *connect_widget = m_widget;
   if (m_wxwindow) connect_widget = m_wxwindow;

-  
+

   return connect_widget;
 }
   return connect_widget;
 }

-  
+

 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 {
   if (m_wxwindow) return (window == m_wxwindow->window);
 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 {
   if (m_wxwindow) return (window == m_wxwindow->window);


@@ -1926,6 +2126,8 @@ bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 
 void wxWindow::SetFont( const wxFont &font )
 {
 
 void wxWindow::SetFont( const wxFont &font )
 {

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

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


@@ -1941,10 +2143,10 @@ void wxWindow::SetFont( const wxFont &font )
   {
     style = gtk_widget_get_style( m_widget );
   }
   {
     style = gtk_widget_get_style( m_widget );
   }

-  
+

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

-  
+

   gtk_widget_set_style( m_widget, style );
 }
 
   gtk_widget_set_style( m_widget, style );
 }
 


@@ -1965,21 +2167,31 @@ long wxWindow::GetWindowStyleFlag(void) const
 
 void wxWindow::CaptureMouse(void)
 {
 
 void wxWindow::CaptureMouse(void)
 {

+  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+  wxASSERT_MSG( (g_capturing == FALSE), "CaptureMouse called twice" );
+

   GtkWidget *connect_widget = GetConnectWidget();
   gtk_grab_add( connect_widget );
   gdk_pointer_grab ( connect_widget->window, FALSE,
                     (GdkEventMask)
   GtkWidget *connect_widget = GetConnectWidget();
   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), 
+        GDK_POINTER_MOTION_MASK),

         (GdkWindow *) NULL, (GdkCursor *) NULL, GDK_CURRENT_TIME );
         (GdkWindow *) NULL, (GdkCursor *) NULL, GDK_CURRENT_TIME );

+  g_capturing = TRUE;

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

+  wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+  wxASSERT_MSG( (g_capturing == TRUE), "ReleaseMouse called twice" );
+

   GtkWidget *connect_widget = GetConnectWidget();
   gtk_grab_remove( connect_widget );
   gdk_pointer_ungrab ( GDK_CURRENT_TIME );
   GtkWidget *connect_widget = GetConnectWidget();
   gtk_grab_remove( connect_widget );
   gdk_pointer_ungrab ( GDK_CURRENT_TIME );

+  g_capturing = FALSE;

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


@@ -2045,64 +2257,78 @@ wxWindow *wxWindow::FindWindow( const wxString& name )
 }
 
 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 (orient == wxHORIZONTAL)
   {
     float fpos = (float)pos;
   if (!m_wxwindow) return;
 
   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)
       gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
     else
       gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
   if (m_wxwindow->window)
   {
     if (orient == wxHORIZONTAL)
       gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
     else
       gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );

-      
+

     gtk_widget_set_usize( m_widget, m_width, m_height );
   }
 }
 
 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
 {
     gtk_widget_set_usize( m_widget, m_width, m_height );
   }
 }
 
 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;


@@ -2118,18 +2344,25 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
     if (fabs(fpos-m_vAdjust->value) < 0.2) return;
     m_vAdjust->value = 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)
   if (!m_wxwindow) return 0;
 
   if (orient == wxHORIZONTAL)


@@ -2140,6 +2373,10 @@ int wxWindow::GetScrollThumb( int orient ) const
 
 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)
   if (!m_wxwindow) return 0;
 
   if (orient == wxHORIZONTAL)


@@ -2150,6 +2387,10 @@ int wxWindow::GetScrollPos( int orient ) const
 
 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)
   if (!m_wxwindow) return 0;
 
   if (orient == wxHORIZONTAL)


@@ -2160,37 +2401,16 @@ int wxWindow::GetScrollRange( int orient ) const
 
 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))
     int w = cw - abs(dx);
     int h = ch - abs(dy);
     if ((h < 0) || (w < 0))


@@ -2208,13 +2428,13 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
     if (dy > 0) d_y = dy;
     gdk_window_copy_area( m_wxwindow->window, m_wxwindow->style->fg_gc[0], d_x, d_y,
       m_wxwindow->window, s_x, s_y, w, h );
     if (dy > 0) d_y = dy;
     gdk_window_copy_area( m_wxwindow->window, m_wxwindow->style->fg_gc[0], d_x, d_y,
       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 );
 }
 
     Refresh( TRUE, &rect );
 }
 


@@ -2378,7 +2598,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())
   {


@@ -2419,7 +2639,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);


@@ -2560,7 +2780,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);