added option to hide page controls

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

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index d62e1887230ed46d963e6235a73527ea80c775d7..9457a59a57cbf194b81e2d8ad35269a29d8f0b1f 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -25,7 +25,11 @@
 #include "wx/dcclient.h"
 #include "wx/dnd.h"
 #include "wx/mdi.h"
 #include "wx/dcclient.h"
 #include "wx/dnd.h"
 #include "wx/mdi.h"

+#include "wx/menu.h"

 #include "wx/notebook.h"
 #include "wx/notebook.h"

+#include "wx/statusbr.h"
+#include <wx/intl.h>
+//#include "wx/treectrl.h"

 #include "gdk/gdkkeysyms.h"
 #include <math.h>
 #include "wx/gtk/win_gtk.h"
 #include "gdk/gdkkeysyms.h"
 #include <math.h>
 #include "wx/gtk/win_gtk.h"


@@ -52,15 +56,18 @@ void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gd
   if (g_blockEventsOnDrag) return;
   
 /*
   if (g_blockEventsOnDrag) return;
   
 /*

-  printf( "OnExpose from " );
+ if (IS_KIND_OF(win,wxStatusBar))
+ {
+    printf( "OnExpose from " );

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

-  
+

   printf( "x: %d \n", gdk_event->area.x );
   printf( "y: %d \n", gdk_event->area.y );
   printf( "w: %d \n", gdk_event->area.width );
   printf( "h: %d \n", gdk_event->area.height );
   printf( "x: %d \n", gdk_event->area.x );
   printf( "y: %d \n", gdk_event->area.y );
   printf( "w: %d \n", gdk_event->area.width );
   printf( "h: %d \n", gdk_event->area.height );

+}

 */
 
   win->m_updateRegion.Union( gdk_event->area.x,
 */
 
   win->m_updateRegion.Union( gdk_event->area.x,


@@ -75,7 +82,7 @@ void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gd
   win->ProcessEvent( event );
   
   win->m_updateRegion.Clear();
   win->ProcessEvent( event );
   
   win->m_updateRegion.Clear();

-};
+}

 
 //-----------------------------------------------------------------------------
 // draw (of m_wxwindow, not of m_widget)
 
 //-----------------------------------------------------------------------------
 // draw (of m_wxwindow, not of m_widget)


@@ -86,6 +93,8 @@ void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect,
   if (g_blockEventsOnDrag) return;
   
 /*
   if (g_blockEventsOnDrag) return;
   
 /*

+ if (IS_KIND_OF(win,wxStatusBar))
+ {

   printf( "OnDraw from " );
   if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
     printf( win->GetClassInfo()->GetClassName() );
   printf( "OnDraw from " );
   if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
     printf( win->GetClassInfo()->GetClassName() );


@@ -95,6 +104,7 @@ void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect,
   printf( "y: %d \n", rect->y );
   printf( "w: %d \n", rect->width );
   printf( "h: %d \n", rect->height );
   printf( "y: %d \n", rect->y );
   printf( "w: %d \n", rect->width );
   printf( "h: %d \n", rect->height );

+}

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


@@ -104,7 +114,7 @@ void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect,
   win->ProcessEvent( event );
   
   win->m_updateRegion.Clear();
   win->ProcessEvent( event );
   
   win->m_updateRegion.Clear();

-};
+}

 
 //-----------------------------------------------------------------------------
 // size 
 
 //-----------------------------------------------------------------------------
 // size 


@@ -126,7 +136,7 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc
       (win->m_height == alloc->height))
   {
     return;
       (win->m_height == alloc->height))
   {
     return;

-  };
+  }

   
   printf( "OnResize from " );
   if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
   
   printf( "OnResize from " );
   if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())


@@ -144,7 +154,7 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc
   wxSizeEvent event( wxSize( alloc->width, alloc->height), win->GetId() );
   event.SetEventObject( win );
   win->ProcessEvent( event );
   wxSizeEvent event( wxSize( alloc->width, alloc->height), win->GetId() );
   event.SetEventObject( win );
   win->ProcessEvent( event );

-};
+}

 */
 
 //-----------------------------------------------------------------------------
 */
 
 //-----------------------------------------------------------------------------


@@ -237,8 +247,8 @@ gint gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), GdkEventKey *gd
     {
       if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF)) 
         key_code = gdk_event->keyval;
     {
       if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF)) 
         key_code = gdk_event->keyval;

-    };
-  };
+    }
+  }

 
   if (!key_code) return FALSE;
   
 
   if (!key_code) return FALSE;
   


@@ -251,16 +261,21 @@ gint gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), GdkEventKey *gd
   event.m_x = 0;
   event.m_y = 0;
   event.SetEventObject( win );
   event.m_x = 0;
   event.m_y = 0;
   event.SetEventObject( win );

-  return win->ProcessEvent( event );
-};
+  
+  bool ret = win->ProcessEvent( event );
+/*
+  if (ret) printf( "found.\n") ;
+*/
+  return ret;
+}

 
 //-----------------------------------------------------------------------------
 // button_press
 
 gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 { 
 
 //-----------------------------------------------------------------------------
 // button_press
 
 gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 { 

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

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


@@ -275,10 +290,10 @@ gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_ev
       printf( ".\n" );
 */
       
       printf( ".\n" );
 */
       

-    };
-  };
+    }
+  }

     
     

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

     
 /*
   printf( "OnButtonPress from " );
     
 /*
   printf( "OnButtonPress from " );


@@ -286,7 +301,7 @@ gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_ev
     printf( win->GetClassInfo()->GetClassName() );
   printf( ".\n" );
 */
     printf( win->GetClassInfo()->GetClassName() );
   printf( ".\n" );
 */

-  
+

   wxEventType event_type = wxEVT_LEFT_DOWN;
   
   if (gdk_event->button == 1)
   wxEventType event_type = wxEVT_LEFT_DOWN;
   
   if (gdk_event->button == 1)


@@ -296,7 +311,7 @@ gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_ev
       case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
       case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
       default:  break;
       case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
       case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
       default:  break;

-    };
+    }

   }
   else if (gdk_event->button == 2)
   {
   }
   else if (gdk_event->button == 2)
   {


@@ -305,7 +320,7 @@ gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_ev
       case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
       case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
       default:  break;
       case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
       case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
       default:  break;

-    };
+    }

   }
   else if (gdk_event->button == 3)
   {
   }
   else if (gdk_event->button == 3)
   {


@@ -314,8 +329,8 @@ gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_ev
       case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
       case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
       default:  break;
       case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
       case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
       default:  break;

-    };
-  };
+    }
+  }

   
   wxMouseEvent event( event_type );
   event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
   
   wxMouseEvent event( event_type );
   event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);


@@ -333,7 +348,7 @@ gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_ev
   win->ProcessEvent( event );
   
   return TRUE;
   win->ProcessEvent( event );
   
   return TRUE;

-};
+}

 
 //-----------------------------------------------------------------------------
 // button_release
 
 //-----------------------------------------------------------------------------
 // button_release


@@ -342,9 +357,9 @@ gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_
 { 
   if (widget->window != gdk_event->window) return TRUE;
 
 { 
   if (widget->window != gdk_event->window) return TRUE;
 

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

 
 

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

  
 /*
   printf( "OnButtonRelease from " );
  
 /*
   printf( "OnButtonRelease from " );


@@ -360,7 +375,7 @@ gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_
     case 1: event_type = wxEVT_LEFT_UP; break;
     case 2: event_type = wxEVT_MIDDLE_UP; break;
     case 3: event_type = wxEVT_RIGHT_UP; break;
     case 1: event_type = wxEVT_LEFT_UP; break;
     case 2: event_type = wxEVT_MIDDLE_UP; break;
     case 3: event_type = wxEVT_RIGHT_UP; break;

-  };
+  }

 
   wxMouseEvent event( event_type );
   event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
 
   wxMouseEvent event( event_type );
   event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);


@@ -374,8 +389,10 @@ gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_
   event.m_y = (long)gdk_event->y;
   event.SetEventObject( win );
   
   event.m_y = (long)gdk_event->y;
   event.SetEventObject( win );
   

-  return win->ProcessEvent( event );
-};
+  win->ProcessEvent( event );
+  
+  return TRUE;
+}

 
 //-----------------------------------------------------------------------------
 // motion_notify
 
 //-----------------------------------------------------------------------------
 // motion_notify


@@ -384,9 +401,9 @@ gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_e
 { 
   if (widget->window != gdk_event->window) return TRUE;
 
 { 
   if (widget->window != gdk_event->window) return TRUE;
 

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

 
 

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

   
 /*
   printf( "OnMotion from " );
   
 /*
   printf( "OnMotion from " );


@@ -410,15 +427,15 @@ gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_e
   
   win->ProcessEvent( event );
   
   
   win->ProcessEvent( event );
   

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

 
 //-----------------------------------------------------------------------------
 // focus_in
 
 gint gtk_window_focus_in_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
 {
 
 //-----------------------------------------------------------------------------
 // focus_in
 
 gint gtk_window_focus_in_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
 {

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

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


@@ -430,10 +447,10 @@ gint gtk_window_focus_in_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUS
         printf( win->GetClassInfo()->GetClassName() );
       printf( ".\n" );
 */
         printf( win->GetClassInfo()->GetClassName() );
       printf( ".\n" );
 */

-    };
-  };
+    }
+  }

   
   

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

   
 /*
   printf( "OnSetFocus from " );
   
 /*
   printf( "OnSetFocus from " );


@@ -446,22 +463,24 @@ gint gtk_window_focus_in_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUS
   
   wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
   event.SetEventObject( win );
   
   wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
   event.SetEventObject( win );

-  return win->ProcessEvent( event );
-};
+  win->ProcessEvent( event );
+  
+  return TRUE;
+}

 
 //-----------------------------------------------------------------------------
 // focus out
 
 gint gtk_window_focus_out_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
 {
 
 //-----------------------------------------------------------------------------
 // focus out
 
 gint gtk_window_focus_out_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
 {

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

   if (win->m_wxwindow)
   {
     if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
       GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
   if (win->m_wxwindow)
   {
     if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
       GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);

-  };
+  }

   
   

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

   
 /*
   printf( "OnKillFocus from " );
   
 /*
   printf( "OnKillFocus from " );


@@ -472,8 +491,10 @@ gint gtk_window_focus_out_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNU
   
   wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
   event.SetEventObject( win );
   
   wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
   event.SetEventObject( win );

-  return win->ProcessEvent( event );
-};
+  win->ProcessEvent( event );
+  
+  return TRUE;
+}

 
 //-----------------------------------------------------------------------------
 // vertical scroll
 
 //-----------------------------------------------------------------------------
 // vertical scroll


@@ -517,7 +538,7 @@ void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
   wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
   event.SetEventObject( win );
   win->ProcessEvent( event );
   wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
   event.SetEventObject( win );
   win->ProcessEvent( event );

-};
+}

 
 //-----------------------------------------------------------------------------
 // horizontal scroll
 
 //-----------------------------------------------------------------------------
 // horizontal scroll


@@ -561,7 +582,7 @@ void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
   wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
   event.SetEventObject( win );
   win->ProcessEvent( event );
   wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
   event.SetEventObject( win );
   win->ProcessEvent( event );

-};
+}

 
 //-----------------------------------------------------------------------------
 // vertical scroll change
 
 //-----------------------------------------------------------------------------
 // vertical scroll change


@@ -585,7 +606,7 @@ void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *
   wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
   event.SetEventObject( win );
   win->ProcessEvent( event );
   wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
   event.SetEventObject( win );
   win->ProcessEvent( event );

-};
+}

 
 //-----------------------------------------------------------------------------
 // horizontal scroll change
 
 //-----------------------------------------------------------------------------
 // horizontal scroll change


@@ -609,22 +630,22 @@ void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *
   wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
   event.SetEventObject( win );
   win->ProcessEvent( event );
   wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
   event.SetEventObject( win );
   win->ProcessEvent( event );

-};
+}

 
 //-----------------------------------------------------------------------------
 // drop
 
 void gtk_window_drop_callback( GtkWidget *widget, GdkEvent *event, wxWindow *win )
 {
 
 //-----------------------------------------------------------------------------
 // drop
 
 void gtk_window_drop_callback( GtkWidget *widget, GdkEvent *event, wxWindow *win )
 {

-  printf( "OnDrop.\n" );
-
+  if (!win->HasVMT()) return;
+  

   if (win->GetDropTarget())
   {
     int x = 0;
     int y = 0;
     gdk_window_get_pointer( widget->window, &x, &y, NULL );
     win->GetDropTarget()->Drop( event, x, y );
   if (win->GetDropTarget())
   {
     int x = 0;
     int y = 0;
     gdk_window_get_pointer( widget->window, &x, &y, NULL );
     win->GetDropTarget()->Drop( event, x, y );

-  };
+  }

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


@@ -645,7 +666,7 @@ bool gtk_window_destroy_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSE
   printf( "     Robert Roebling.\n" );
   
   return FALSE;
   printf( "     Robert Roebling.\n" );
   
   return FALSE;

-};
+}

 
 //-----------------------------------------------------------------------------
 // enter
 
 //-----------------------------------------------------------------------------
 // enter


@@ -653,8 +674,8 @@ bool gtk_window_destroy_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSE
 bool gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {
   if (widget->window != gdk_event->window) return TRUE;
 bool gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {
   if (widget->window != gdk_event->window) return TRUE;

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

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


@@ -662,7 +683,7 @@ bool gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event,
   wxMouseEvent event( wxEVT_ENTER_WINDOW );
   event.SetEventObject( win );
   return win->ProcessEvent( event );
   wxMouseEvent event( wxEVT_ENTER_WINDOW );
   event.SetEventObject( win );
   return win->ProcessEvent( event );

-};
+}

     
 //-----------------------------------------------------------------------------
 // leave
     
 //-----------------------------------------------------------------------------
 // leave


@@ -670,8 +691,8 @@ bool gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event,
 bool gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {
   if (widget->window != gdk_event->window) return TRUE;
 bool gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 {
   if (widget->window != gdk_event->window) return TRUE;

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

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


@@ -679,7 +700,7 @@ bool gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event,
   wxMouseEvent event( wxEVT_LEAVE_WINDOW );
   event.SetEventObject( win );
   return win->ProcessEvent( event );
   wxMouseEvent event( wxEVT_LEAVE_WINDOW );
   event.SetEventObject( win );
   return win->ProcessEvent( event );

-};
+}

     
 //-----------------------------------------------------------------------------
 // wxWindow implementation
     
 //-----------------------------------------------------------------------------
 // wxWindow implementation


@@ -731,23 +752,18 @@ wxWindow::wxWindow()
   m_drawingOffsetY = 0;
   m_pDropTarget = NULL;
   m_resizing = FALSE;
   m_drawingOffsetY = 0;
   m_pDropTarget = NULL;
   m_resizing = FALSE;

-};
-
-wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
-      const wxPoint &pos, const wxSize &size,
-      long style, const wxString &name )
-{
-  Create( parent, id, pos, size, style, name );
-};
+}

 
 bool wxWindow::Create( wxWindow *parent, wxWindowID id,
       const wxPoint &pos, const wxSize &size,
 
 bool wxWindow::Create( wxWindow *parent, wxWindowID id,
       const wxPoint &pos, const wxSize &size,

-      long style, const wxString &name )
+      long style, const wxString &name  )

 {
   m_isShown = FALSE;
   m_isEnabled = TRUE;
   m_needParent = TRUE;
   
 {
   m_isShown = FALSE;
   m_isEnabled = TRUE;
   m_needParent = TRUE;
   

+  m_cursor = NULL;
+  

   PreCreation( parent, id, pos, size, style, name );
   
   m_widget = gtk_scrolled_window_new( NULL, NULL );
   PreCreation( parent, id, pos, size, style, name );
   
   m_widget = gtk_scrolled_window_new( NULL, NULL );


@@ -791,10 +807,12 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
   else
   {
     gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
   else
   {
     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_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


@@ -829,7 +847,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
   Show( TRUE );
 
   return TRUE;  
   Show( TRUE );
 
   return TRUE;  

-};
+}

 
 wxWindow::~wxWindow(void)
 {
 
 wxWindow::~wxWindow(void)
 {


@@ -846,7 +864,7 @@ wxWindow::~wxWindow(void)
     
   if (m_widget) gtk_widget_destroy( m_widget );
   
     
   if (m_widget) gtk_widget_destroy( m_widget );
   

-//  delete m_cursor;
+  wxDELETE(m_cursor);

 
   DeleteRelatedConstraints();
   if (m_constraints)
 
   DeleteRelatedConstraints();
   if (m_constraints)


@@ -863,8 +881,7 @@ wxWindow::~wxWindow(void)
     m_windowSizer = NULL;
   }
   // If this is a child of a sizer, remove self from parent
     m_windowSizer = NULL;
   }
   // If this is a child of a sizer, remove self from parent

-  if (m_sizerParent)
-    m_sizerParent->RemoveChild((wxWindow *)this);
+  if (m_sizerParent) m_sizerParent->RemoveChild((wxWindow *)this);

 
   // Just in case the window has been Closed, but
   // we're then deleting immediately: don't leave
 
   // Just in case the window has been Closed, but
   // we're then deleting immediately: don't leave


@@ -876,14 +893,15 @@ wxWindow::~wxWindow(void)
   // class
   wxTopLevelWindows.DeleteObject(this);
     
   // class
   wxTopLevelWindows.DeleteObject(this);
     

-};
+  if (m_windowValidator) delete m_windowValidator;
+}

 
 void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
       const wxPoint &pos, const wxSize &size,
       long style, const wxString &name )
 {
   if (m_needParent && (parent == NULL))
 
 void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
       const wxPoint &pos, const wxSize &size,
       long style, const wxString &name )
 {
   if (m_needParent && (parent == NULL))

-    wxFatalError( "Need complete parent.", name );
+    wxFatalError( _("Need complete parent."), name );

 
   m_widget = NULL;
   m_hasVMT = FALSE;
 
   m_widget = NULL;
   m_hasVMT = FALSE;


@@ -897,10 +915,10 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
   if (m_height == -1) m_height = 20;
   m_retCode = 0;
   m_eventHandler = this;
   if (m_height == -1) m_height = 20;
   m_retCode = 0;
   m_eventHandler = this;

-  m_windowValidator = NULL;

   m_windowId = id;
   m_sizeSet = FALSE;
   m_windowId = id;
   m_sizeSet = FALSE;

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

   m_font = *wxSWISS_FONT;
   m_backgroundColour = wxWHITE;
   m_foregroundColour = wxBLACK;
   m_font = *wxSWISS_FONT;
   m_backgroundColour = wxWHITE;
   m_foregroundColour = wxBLACK;


@@ -915,6 +933,7 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
   m_drawingOffsetY = 0;
   m_pDropTarget = NULL;
   m_resizing = FALSE;
   m_drawingOffsetY = 0;
   m_pDropTarget = NULL;
   m_resizing = FALSE;

+  m_windowValidator = NULL;

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


@@ -924,8 +943,7 @@ void wxWindow::PostCreation(void)
 //  GtkStyle *style = m_widget->style;
 //  style->font = m_font.GetInternalFont( 1.0 );          // destroy old font ?
   
 //  GtkStyle *style = m_widget->style;
 //  style->font = m_font.GetInternalFont( 1.0 );          // destroy old font ?
   

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

  
   gtk_object_set_data (GTK_OBJECT (connect_widget), "MyWxWindow", (gpointer)this );
   
  
   gtk_object_set_data (GTK_OBJECT (connect_widget), "MyWxWindow", (gpointer)this );
   


@@ -936,7 +954,7 @@ void wxWindow::PostCreation(void)
       
     gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw", 
       GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
       
     gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw", 
       GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );

-  };
+  }

   
 /*
   gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate", 
   
 /*
   gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate", 


@@ -961,9 +979,6 @@ void wxWindow::PostCreation(void)
   gtk_signal_connect( GTK_OBJECT(connect_widget), "focus_out_event", 
     GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
 
   gtk_signal_connect( GTK_OBJECT(connect_widget), "focus_out_event", 
     GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
 

-  gtk_signal_connect( GTK_OBJECT(connect_widget), "drop_data_available_event",
-    GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
-      

   // Only for cursor handling
     
   gtk_signal_connect( GTK_OBJECT(m_widget), "enter_notify_event", 
   // Only for cursor handling
     
   gtk_signal_connect( GTK_OBJECT(m_widget), "enter_notify_event", 


@@ -979,7 +994,7 @@ void wxWindow::PostCreation(void)
       
     gtk_signal_connect( GTK_OBJECT(m_wxwindow), "leave_notify_event", 
       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
       
     gtk_signal_connect( GTK_OBJECT(m_wxwindow), "leave_notify_event", 
       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );

-  };
+  }

   
 /*
   // Does destroy ever get called ?
   
 /*
   // Does destroy ever get called ?


@@ -991,7 +1006,7 @@ void wxWindow::PostCreation(void)
   {
     gtk_signal_connect( GTK_OBJECT(m_wxwindow), "destroy_event", 
       GTK_SIGNAL_FUNC(gtk_window_destroy_callback), (gpointer)this );
   {
     gtk_signal_connect( GTK_OBJECT(m_wxwindow), "destroy_event", 
       GTK_SIGNAL_FUNC(gtk_window_destroy_callback), (gpointer)this );

-  };
+  }

 */
   
   if (m_widget && m_parent) gtk_widget_realize( m_widget );
 */
   
   if (m_widget && m_parent) gtk_widget_realize( m_widget );


@@ -1000,12 +1015,12 @@ void wxWindow::PostCreation(void)
   SetCursor( wxSTANDARD_CURSOR );
   
   m_hasVMT = TRUE;
   SetCursor( wxSTANDARD_CURSOR );
   
   m_hasVMT = TRUE;

-};
+}

 
 bool wxWindow::HasVMT(void)
 {
   return m_hasVMT;
 
 bool wxWindow::HasVMT(void)
 {
   return m_hasVMT;

-};
+}

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


@@ -1014,14 +1029,14 @@ bool wxWindow::Close( bool force )
   event.SetForce(force);
 
   return GetEventHandler()->ProcessEvent(event);
   event.SetForce(force);
 
   return GetEventHandler()->ProcessEvent(event);

-};
+}

 
 bool wxWindow::Destroy(void)
 {
   m_hasVMT = FALSE;
   delete this;
   return TRUE;
 
 bool wxWindow::Destroy(void)
 {
   m_hasVMT = FALSE;
   delete this;
   return TRUE;

-};
+}

 
 bool wxWindow::DestroyChildren(void)
 {
 
 bool wxWindow::DestroyChildren(void)
 {


@@ -1035,35 +1050,34 @@ bool wxWindow::DestroyChildren(void)
       {
         delete child;
   if (GetChildren()->Member(child)) delete node;
       {
         delete child;
   if (GetChildren()->Member(child)) delete node;

-      };
-    };
-  };
+      }
+    }
+  }

   return TRUE;
   return TRUE;

-};
+}

 
 void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
 {
   // are we to set fonts here ?
 
 void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
 {
   // are we to set fonts here ?

-};
+}

 
 void wxWindow::ImplementSetSize(void)
 { 
   gtk_widget_set_usize( m_widget, m_width, m_height );
 
 void wxWindow::ImplementSetSize(void)
 { 
   gtk_widget_set_usize( m_widget, m_width, m_height );

-};
+}

 
 void wxWindow::ImplementSetPosition(void)
 {
 
 void wxWindow::ImplementSetPosition(void)
 {

-  if (!m_parent)
+  if (IS_KIND_OF(this,wxFrame) || IS_KIND_OF(this,wxDialog))

   {
   {

-    if (IsKindOf(CLASSINFO(wxFrame)) ||
-        IsKindOf(CLASSINFO(wxDialog)))
-    {
+    if ((m_x != -1) || (m_y != -1))

       gtk_widget_set_uposition( m_widget, m_x, m_y );
       gtk_widget_set_uposition( m_widget, m_x, m_y );

-    }
-    else
-    {
-      printf( "wxWindow::SetSize error.\n" );
-    }
+    return;
+  }
+  
+  if (!m_parent)
+  {
+    printf( _("wxWindow::SetSize error.\n") );

     return;
   }
   
     return;
   }
   


@@ -1071,7 +1085,7 @@ void wxWindow::ImplementSetPosition(void)
     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   
     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   

-};
+}

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


@@ -1089,30 +1103,30 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
     if (newY == -1) newY = m_y;
     if (newW == -1) newW = m_width;
     if (newH == -1) newH = m_height;
     if (newY == -1) newY = m_y;
     if (newW == -1) newW = m_width;
     if (newH == -1) newH = m_height;

-  };
+  }

   
   if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
   {
     if (newW == -1) newW = 80;
   
   if ((sizeFlags & wxSIZE_AUTO_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;
     m_y = newY;
     ImplementSetPosition();
   
   if ((m_x != newX) || (m_y != newY) || (!m_sizeSet))
   {
     m_x = newX;
     m_y = newY;
     ImplementSetPosition();

-  };
+  }

   if ((m_width != newW) || (m_height != newH) || (!m_sizeSet))
   {
     m_width = newW;
     m_height = newH;
     ImplementSetSize();
   if ((m_width != newW) || (m_height != newH) || (!m_sizeSet))
   {
     m_width = newW;
     m_height = newH;
     ImplementSetSize();

-  };
+  }

   m_sizeSet = TRUE;
   
   wxSizeEvent event( wxSize(m_width,m_height), GetId() );
   m_sizeSet = TRUE;
   
   wxSizeEvent event( wxSize(m_width,m_height), GetId() );


@@ -1120,23 +1134,23 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
   ProcessEvent( event );
   
   m_resizing = FALSE;
   ProcessEvent( event );
   
   m_resizing = FALSE;

-};
+}

 
 void wxWindow::SetSize( int width, int height )
 {
   SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
 
 void wxWindow::SetSize( int width, int height )
 {
   SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );

-};
+}

 
 void wxWindow::Move( int x, int y )
 {
   SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
 
 void wxWindow::Move( int x, int y )
 {
   SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );

-};
+}

 
 void wxWindow::GetSize( int *width, int *height ) const
 {
   if (width) (*width) = m_width;
   if (height) (*height) = m_height;
 
 void wxWindow::GetSize( int *width, int *height ) const
 {
   if (width) (*width) = m_width;
   if (height) (*height) = m_height;

-};
+}

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


@@ -1177,24 +1191,24 @@ void wxWindow::SetClientSize( int width, int height )
       {
         dw += 2 * viewport_class->xthickness;
         dh += 2 * viewport_class->ythickness;
       {
         dw += 2 * viewport_class->xthickness;
         dh += 2 * viewport_class->ythickness;

-      };
+      }

     
       if (GTK_WIDGET_VISIBLE(vscrollbar))
       {
         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 );
     
     SetSize( width+dw, height+dh );

-  };
-};
+  }
+}

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


@@ -1236,33 +1250,33 @@ void wxWindow::GetClientSize( int *width, int *height ) const
       {
         dw += 2 * viewport_class->xthickness;
         dh += 2 * viewport_class->ythickness;
       {
         dw += 2 * viewport_class->xthickness;
         dh += 2 * viewport_class->ythickness;

-      };
+      }

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

-      };
-    };
+      }
+    }

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

-  };
-};
+  }
+}

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

-};
+}

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


@@ -1284,12 +1298,12 @@ void wxWindow::ClientToScreen( int *x, int *y )
     {
       org_x += m_widget->allocation.x;
       org_y += m_widget->allocation.y;
     {
       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 )
 {


@@ -1309,23 +1323,20 @@ void wxWindow::ScreenToClient( int *x, int *y )
     {
       org_x += m_widget->allocation.x;
       org_y += m_widget->allocation.y;
     {
       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 )
 {

-  int x = 0;
-  int y = 0;
-  GetPosition( &x, &y );
-  if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
+  if (IS_KIND_OF(this,wxDialog) || IS_KIND_OF(this,wxFrame))

   {
   {

-    if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
-    if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
-    gtk_widget_set_uposition( m_widget, x, y );
+    if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (gdk_screen_width () - m_width) / 2;
+    if (direction & wxVERTICAL == wxVERTICAL) m_y = (gdk_screen_height () - m_height) / 2;
+    ImplementSetPosition();

   }
   else
   {
   }
   else
   {


@@ -1334,12 +1345,12 @@ void wxWindow::Centre( int direction )
       int p_w = 0;
       int p_h = 0;
       m_parent->GetSize( &p_w, &p_h );
       int p_w = 0;
       int p_h = 0;
       m_parent->GetSize( &p_w, &p_h );

-      if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2;
-      if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2;
-      gtk_widget_set_uposition( m_widget, x, y );
-    };
+      if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (p_w - m_width) / 2;
+      if (direction & wxVERTICAL == wxVERTICAL) m_y = (p_h - m_height) / 2;
+      ImplementSetPosition();
+    }

   }
   }

-};
+}

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


@@ -1359,13 +1370,13 @@ void wxWindow::Fit(void)
 
     node = node->Next();
   }
 
     node = node->Next();
   }

-  SetClientSize(maxX + 5, maxY + 5);
-};
+  SetClientSize(maxX + 5, maxY + 10);
+}

 
 void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
 {
   //if (GetAutoLayout()) Layout();
 
 void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
 {
   //if (GetAutoLayout()) Layout();

-};
+}

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


@@ -1375,14 +1386,14 @@ bool wxWindow::Show( bool show )
     gtk_widget_hide( m_widget );
   m_isShown = show;  
   return TRUE;
     gtk_widget_hide( m_widget );
   m_isShown = show;  
   return TRUE;

-};
+}

 
 void wxWindow::Enable( bool enable )
 {
   m_isEnabled = enable;
   gtk_widget_set_sensitive( m_widget, enable );
   if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
 
 void wxWindow::Enable( bool enable )
 {
   m_isEnabled = enable;
   gtk_widget_set_sensitive( m_widget, enable );
   if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );

-};
+}

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


@@ -1404,22 +1415,20 @@ void wxWindow::MakeModal( bool modal )
 
 void wxWindow::SetFocus(void)
 {
 
 void wxWindow::SetFocus(void)
 {

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

   if (connect_widget)
   {
     if (GTK_WIDGET_CAN_FOCUS(connect_widget) && !GTK_WIDGET_HAS_FOCUS (connect_widget) )
     {
       gtk_widget_grab_focus (connect_widget);
   if (connect_widget)
   {
     if (GTK_WIDGET_CAN_FOCUS(connect_widget) && !GTK_WIDGET_HAS_FOCUS (connect_widget) )
     {
       gtk_widget_grab_focus (connect_widget);

-    };
-  };
-};
+    }
+  }
+}

 
 bool wxWindow::OnClose(void)
 {
 
 bool wxWindow::OnClose(void)
 {

-  printf( "OnClose event.\n" );

   return TRUE;
   return TRUE;

-};
+}

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


@@ -1431,113 +1440,175 @@ void wxWindow::AddChild( wxWindow *child )
   // for wxFrame, wxDialog, wxWindow and 
   // wxMDIParentFrame.
 
   // for wxFrame, wxDialog, wxWindow and 
   // wxMDIParentFrame.
 

-  if (IsKindOf(CLASSINFO(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 ((child->m_x != -1) && (child->m_y != -1))
+      gtk_widget_set_uposition( child->m_widget, child->m_x, child->m_y );
+      
+    return;
+  }
+  
+  // In the case of an wxMDIChildFrame descendant, we use the 
+  // client windows's AddChild()
+  
+  if (IS_KIND_OF(this,wxMDIParentFrame))

   {
   {

-    if (child->IsKindOf(CLASSINFO(wxMDIChildFrame)))
+    if (IS_KIND_OF(child,wxMDIChildFrame))

     {
       wxMDIClientWindow *client = ((wxMDIParentFrame*)this)->GetClientWindow();
       if (client)
       { 
         client->AddChild( child );
         return;
     {
       wxMDIClientWindow *client = ((wxMDIParentFrame*)this)->GetClientWindow();
       if (client)
       { 
         client->AddChild( child );
         return;

-      };
-    };
-  };
+      }
+    }
+  }

   
   

-  // wxNotebooks are very special, so they have their own AddChild
+  // wxNotebook is very special, so it has a private AddChild()

   
   

-  if (IsKindOf(CLASSINFO(wxNotebook)))
+  if (IS_KIND_OF(this,wxNotebook))

   {
     wxNotebook *tab = (wxNotebook*)this;
     tab->AddChild( child );
     return;
   {
     wxNotebook *tab = (wxNotebook*)this;
     tab->AddChild( child );
     return;

-  };
+  }

   
   

-  m_children.Append( child );
-  if (child->IsKindOf(CLASSINFO(wxFrame)) || child->IsKindOf(CLASSINFO(wxDialog)))
+  // wxFrame has a private AddChild
+  
+  if (IS_KIND_OF(this,wxFrame) && !IS_KIND_OF(this,wxMDIChildFrame))

   {
   {

-    if ((child->m_x != -1) && (child->m_y != -1))
-      gtk_widget_set_uposition( child->m_widget, child->m_x, child->m_y );
+    wxFrame *frame = (wxFrame*)this;
+    frame->AddChild( child );
+    return;

   }
   }

-  else
-  {
-    if (m_wxwindow)
-      gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget, child->m_x, child->m_y );
-  };
+  
+  // All the rest
+  
+  m_children.Append( child );
+  if (m_wxwindow) gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget, 
+    child->m_x, child->m_y );
+  

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

-};
+}

 
 wxList *wxWindow::GetChildren(void)
 {
   return (&m_children);
 
 wxList *wxWindow::GetChildren(void)
 {
   return (&m_children);

-};
+}

 
 void wxWindow::RemoveChild( wxWindow *child )
 {
   if (GetChildren())
  GetChildren()->DeleteObject( child );
   child->m_parent = NULL;
 
 void wxWindow::RemoveChild( wxWindow *child )
 {
   if (GetChildren())
  GetChildren()->DeleteObject( child );
   child->m_parent = NULL;

-};
+}

 
 void wxWindow::SetReturnCode( int retCode )
 {
   m_retCode = retCode;
 
 void wxWindow::SetReturnCode( int retCode )
 {
   m_retCode = retCode;

-};
+}

 
 int wxWindow::GetReturnCode(void)
 {
   return m_retCode;
 
 int wxWindow::GetReturnCode(void)
 {
   return m_retCode;

-};
+}

 
 wxWindow *wxWindow::GetParent(void)
 {
   return m_parent;
 
 wxWindow *wxWindow::GetParent(void)
 {
   return m_parent;

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

 
 wxEvtHandler *wxWindow::GetEventHandler(void)
 {
   return m_eventHandler;
 
 wxEvtHandler *wxWindow::GetEventHandler(void)
 {
   return m_eventHandler;

-};
+}

 
 

-void wxWindow::SetEventhandler( wxEvtHandler *handler )
+void wxWindow::SetEventHandler( wxEvtHandler *handler )

 {
   m_eventHandler = handler;
 {
   m_eventHandler = handler;

-};
+}
+
+void wxWindow::PushEventHandler(wxEvtHandler *handler)
+{
+       handler->SetNextHandler(GetEventHandler());
+       SetEventHandler(handler);
+}
+
+wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
+{
+       if ( GetEventHandler() )
+       {
+               wxEvtHandler *handlerA = GetEventHandler();
+               wxEvtHandler *handlerB = handlerA->GetNextHandler();
+               handlerA->SetNextHandler(NULL);
+               SetEventHandler(handlerB);
+               if ( deleteHandler )
+               {
+                       delete handlerA;
+                       return NULL;
+               }
+               else
+                       return handlerA;
+       }
+       else
+               return NULL;
+}

 
 wxValidator *wxWindow::GetValidator(void)
 {
   return m_windowValidator;
 
 wxValidator *wxWindow::GetValidator(void)
 {
   return m_windowValidator;

-};
+}

 
 

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

 {
 {

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

 
 bool wxWindow::IsBeingDeleted(void)
 {
   return FALSE;
 
 bool wxWindow::IsBeingDeleted(void)
 {
   return FALSE;

-};
+}

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

-};
+}

 
 wxWindowID wxWindow::GetId(void)
 {
   return m_windowId;
 
 wxWindowID wxWindow::GetId(void)
 {
   return m_windowId;

-};
+}

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

-  if (*m_cursor == cursor) return;
+  wxASSERT(m_cursor != NULL);
+
+  if (m_cursor != NULL)
+    if (*m_cursor == cursor)
+      return;

   (*m_cursor) = cursor;
   if (m_widget->window)
     gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
   if (m_wxwindow && m_wxwindow->window)
     gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
   (*m_cursor) = cursor;
   if (m_widget->window)
     gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
   if (m_wxwindow && m_wxwindow->window)
     gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );

-};
+}

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


@@ -1546,12 +1617,12 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
     if (rect)
       gdk_window_clear_area( m_wxwindow->window, 
         rect->x, 
     if (rect)
       gdk_window_clear_area( m_wxwindow->window, 
         rect->x, 

-  rect->y, 
-  rect->width, 
-  rect->height );
+        rect->y, 
+        rect->width, 
+        rect->height );

     else
     else

-      Clear();
-  };
+      Clear(); 
+  }

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


@@ -1572,7 +1643,7 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
       gdk_rect.width = w;
       gdk_rect.height = h;
       gtk_widget_draw( m_wxwindow, &gdk_rect );
       gdk_rect.width = w;
       gdk_rect.height = h;
       gtk_widget_draw( m_wxwindow, &gdk_rect );

-    };
+    }

   }
   else
   {
   }
   else
   {


@@ -1581,32 +1652,33 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
     gdk_rect.y = rect->y;
     gdk_rect.width = rect->width;
     gdk_rect.height = rect->height;
     gdk_rect.y = rect->y;
     gdk_rect.width = rect->width;
     gdk_rect.height = rect->height;

+    

     if (m_wxwindow)
       gtk_widget_draw( m_wxwindow, &gdk_rect );
     else
       gtk_widget_draw( m_widget, &gdk_rect );
     if (m_wxwindow)
       gtk_widget_draw( m_wxwindow, &gdk_rect );
     else
       gtk_widget_draw( m_widget, &gdk_rect );

-  };
-};
+  }
+}

 
 bool wxWindow::IsExposed( long x, long y )
 {
   return (m_updateRegion.Contains( x, y ) != wxOutRegion );
 
 bool wxWindow::IsExposed( long x, long y )
 {
   return (m_updateRegion.Contains( x, y ) != wxOutRegion );

-};
+}

 
 bool wxWindow::IsExposed( long x, long y, long width, long height )
 {
   return (m_updateRegion.Contains( x, y, width, height ) != wxOutRegion );
 
 bool wxWindow::IsExposed( long x, long y, long width, long height )
 {
   return (m_updateRegion.Contains( x, y, width, height ) != wxOutRegion );

-};
+}

 
 void wxWindow::Clear(void)
 {
   if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
 
 void wxWindow::Clear(void)
 {
   if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );

-};
+}

 
 wxColour wxWindow::GetBackgroundColour(void) const
 {
   return m_backgroundColour;
 
 wxColour wxWindow::GetBackgroundColour(void) const
 {
   return m_backgroundColour;

-};
+}

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


@@ -1616,9 +1688,19 @@ void wxWindow::SetBackgroundColour( const wxColour &colour )
     m_backgroundColour.CalcPixel( m_wxwindow->style->colormap );
     gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );
     gdk_window_clear( m_wxwindow->window );
     m_backgroundColour.CalcPixel( m_wxwindow->style->colormap );
     gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );
     gdk_window_clear( m_wxwindow->window );

-  };
+  }

   // do something ?
   // do something ?

-};
+}
+
+wxColour wxWindow::GetForegroundColour(void) const
+{
+  return m_foregroundColour;
+}
+
+void wxWindow::SetForegroundColour( const wxColour &colour )
+{
+  m_foregroundColour = colour;
+}

 
 bool wxWindow::Validate(void)
 {
 
 bool wxWindow::Validate(void)
 {


@@ -1629,9 +1711,9 @@ bool wxWindow::Validate(void)
     if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this)) 
       { return FALSE; }
     node = node->Next();
     if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this)) 
       { return FALSE; }
     node = node->Next();

-  };
+  }

   return TRUE;
   return TRUE;

-};
+}

 
 bool wxWindow::TransferDataToWindow(void)
 {
 
 bool wxWindow::TransferDataToWindow(void)
 {


@@ -1642,13 +1724,13 @@ bool wxWindow::TransferDataToWindow(void)
     if (child->GetValidator() && /* child->GetValidator()->Ok() && */
   !child->GetValidator()->TransferToWindow() )
     {
     if (child->GetValidator() && /* child->GetValidator()->Ok() && */
   !child->GetValidator()->TransferToWindow() )
     {

-      wxMessageBox( "Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION );
+      wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION );

       return FALSE;
       return FALSE;

-    };
+    }

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

-  };
+  }

   return TRUE;
   return TRUE;

-};
+}

 
 bool wxWindow::TransferDataFromWindow(void)
 {
 
 bool wxWindow::TransferDataFromWindow(void)
 {


@@ -1661,41 +1743,75 @@ bool wxWindow::TransferDataFromWindow(void)
    node = node->Next();
   }
   return TRUE;
    node = node->Next();
   }
   return TRUE;

-};
+}

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

-};
+}

 
 void wxWindow::InitDialog(void)
 {
   wxInitDialogEvent event(GetId());
   event.SetEventObject( this );
   GetEventHandler()->ProcessEvent(event);
 
 void wxWindow::InitDialog(void)
 {
   wxInitDialogEvent event(GetId());
   event.SetEventObject( this );
   GetEventHandler()->ProcessEvent(event);

-};
+}
+
+static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
+{
+  menu->SetInvokingWindow( win );
+  wxNode *node = menu->m_items.First();
+  while (node)
+  {
+    wxMenuItem *menuitem = (wxMenuItem*)node->Data();
+    if (menuitem->IsSubMenu())
+      SetInvokingWindow( menuitem->GetSubMenu(), win );
+    node = node->Next();
+  }
+}
+
+bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) )
+{
+  SetInvokingWindow( menu, this );
+  gtk_menu_popup( GTK_MENU(menu->m_menu), NULL, NULL, NULL, NULL, 0, 0 );
+  return TRUE;
+}

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

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

   if (m_pDropTarget)
   {
   if (m_pDropTarget)
   {

-    m_pDropTarget->UnregisterWidget( connect_widget );
+    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;
     delete m_pDropTarget;

-  };
+  }

   m_pDropTarget = dropTarget;
   if (m_pDropTarget)
   {
   m_pDropTarget = dropTarget;
   if (m_pDropTarget)
   {

-    m_pDropTarget->RegisterWidget( connect_widget );
-  };
-};
+    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 );
+  }
+}

 
 wxDropTarget *wxWindow::GetDropTarget() const
 {
   return m_pDropTarget;
 
 wxDropTarget *wxWindow::GetDropTarget() const
 {
   return m_pDropTarget;

-};
+}

 
 

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

 void wxWindow::SetFont( const wxFont &font )
 {
   m_font = font;
 void wxWindow::SetFont( const wxFont &font )
 {
   m_font = font;


@@ -1708,27 +1824,26 @@ void wxWindow::SetFont( const wxFont &font )
   GtkStyle *style = gtk_style_new();
   ...
 */
   GtkStyle *style = gtk_style_new();
   ...
 */

-};
+}

 
 wxFont *wxWindow::GetFont(void)
 {
   return &m_font;
 
 wxFont *wxWindow::GetFont(void)
 {
   return &m_font;

-};
+}

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

-};
+}

 
 long wxWindow::GetWindowStyleFlag(void) const
 {
   return m_windowStyle;
 
 long wxWindow::GetWindowStyleFlag(void) const
 {
   return m_windowStyle;

-};
+}

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

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

   gtk_grab_add( connect_widget );
   gdk_pointer_grab ( connect_widget->window, FALSE,
                     (GdkEventMask)
   gtk_grab_add( connect_widget );
   gdk_pointer_grab ( connect_widget->window, FALSE,
                     (GdkEventMask)


@@ -1736,49 +1851,48 @@ void wxWindow::CaptureMouse(void)
         GDK_BUTTON_RELEASE_MASK |
         GDK_POINTER_MOTION_MASK), 
         NULL, NULL, GDK_CURRENT_TIME );
         GDK_BUTTON_RELEASE_MASK |
         GDK_POINTER_MOTION_MASK), 
         NULL, NULL, GDK_CURRENT_TIME );

-};
+}

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

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

   gtk_grab_remove( connect_widget );
   gdk_pointer_ungrab ( GDK_CURRENT_TIME );
   gtk_grab_remove( connect_widget );
   gdk_pointer_ungrab ( GDK_CURRENT_TIME );

-};
+}

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

-};
+}

 
 wxString wxWindow::GetTitle(void) const
 {
   return (wxString&)m_windowName;
 
 wxString wxWindow::GetTitle(void) const
 {
   return (wxString&)m_windowName;

-};
+}

 
 wxString wxWindow::GetLabel(void) const
 {
   return GetTitle();
 
 wxString wxWindow::GetLabel(void) const
 {
   return GetTitle();

-};
+}

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

-};
+}

 
 wxString wxWindow::GetName(void) const
 {
   return (wxString&)m_windowName;
 
 wxString wxWindow::GetName(void) const
 {
   return (wxString&)m_windowName;

-};
+}

 
 bool wxWindow::IsShown(void) const
 {
   return m_isShown;
 
 bool wxWindow::IsShown(void) const
 {
   return m_isShown;

-};
+}

 
 bool wxWindow::IsRetained(void)
 {
   return FALSE;
 
 bool wxWindow::IsRetained(void)
 {
   return FALSE;

-};
+}

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


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

-  };
+  }

   return NULL;
   return NULL;

-};
+}

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


@@ -1804,9 +1918,9 @@ wxWindow *wxWindow::FindWindow( const wxString& name )
     wxWindow *res = child->FindWindow( name );
     if (res) return res;
     node = node->Next();
     wxWindow *res = child->FindWindow( name );
     if (res) return res;
     node = node->Next();

-  };
+  }

   return NULL;
   return NULL;

-};
+}

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


@@ -1850,18 +1964,32 @@ void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
     m_vAdjust->step_increment = 1.0;
     m_vAdjust->page_increment = (float)(wxMax(fthumb-2,0));
     m_vAdjust->page_size = fthumb;
     m_vAdjust->step_increment = 1.0;
     m_vAdjust->page_increment = (float)(wxMax(fthumb-2,0));
     m_vAdjust->page_size = fthumb;

-  };
+  }

   
   if (m_wxwindow->window)
   
   if (m_wxwindow->window)

-  {  
+  {

     if (orient == wxHORIZONTAL)
     if (orient == wxHORIZONTAL)

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

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

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

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

+    }

       
     gtk_widget_set_usize( m_widget, m_width, m_height );
       
     gtk_widget_set_usize( m_widget, m_width, m_height );

-  };
-};
+  }
+}

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


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

-  };
+  }

   
   if (m_wxwindow->window)
   {  
   
   if (m_wxwindow->window)
   {  


@@ -1889,8 +2017,8 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
       gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
     else  
       gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
       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
 {


@@ -1900,7 +2028,7 @@ int wxWindow::GetScrollThumb( int orient ) const
     return (int)(m_hAdjust->page_size+0.5);
   else
     return (int)(m_vAdjust->page_size+0.5);
     return (int)(m_hAdjust->page_size+0.5);
   else
     return (int)(m_vAdjust->page_size+0.5);

-};
+}

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


@@ -1910,7 +2038,7 @@ int wxWindow::GetScrollPos( int orient ) const
     return (int)(m_hAdjust->value+0.5);
   else
     return (int)(m_vAdjust->value+0.5);
     return (int)(m_hAdjust->value+0.5);
   else
     return (int)(m_vAdjust->value+0.5);

-};
+}

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


@@ -1920,19 +2048,32 @@ int wxWindow::GetScrollRange( int orient ) const
     return (int)(m_hAdjust->upper+0.5);
   else
     return (int)(m_vAdjust->upper+0.5);
     return (int)(m_hAdjust->upper+0.5);
   else
     return (int)(m_vAdjust->upper+0.5);

-};
+}

 
 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 {
   if (!m_wxwindow) return;
   
 
 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
 {
   if (!m_wxwindow) return;
   

-  m_drawingOffsetX += dx;
-  m_drawingOffsetY += dy;
+  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 );
   
   
 //  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...
 /*
     The code here is very nifty, but it doesn't work with
     overlapping windows...


@@ -1947,7 +2088,7 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
     {
       Refresh();
       return;
     {
       Refresh();
       return;

-    };
+    }

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


@@ -1967,13 +2108,13 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
   
     Refresh( TRUE, &rect );
 */
   
     Refresh( TRUE, &rect );
 */

-};
+}

 
 void wxWindow::GetDrawingOffset( long *x, long *y )
 {
   if (x) *x = m_drawingOffsetX;
   if (y) *y = m_drawingOffsetY;
 
 void wxWindow::GetDrawingOffset( long *x, long *y )
 {
   if (x) *x = m_drawingOffsetX;
   if (y) *y = m_drawingOffsetY;

-};
+}

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


@@ -1982,7 +2123,7 @@ void wxWindow::GetDrawingOffset( long *x, long *y )
 wxLayoutConstraints *wxWindow::GetConstraints(void) const
 {
   return m_constraints;
 wxLayoutConstraints *wxWindow::GetConstraints(void) const
 {
   return m_constraints;

-};
+}

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


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

-};
+}

 
 bool wxWindow::GetAutoLayout(void) const
 {
   return m_autoLayout;
 
 bool wxWindow::GetAutoLayout(void) const
 {
   return m_autoLayout;

-};
+}

 
 wxSizer *wxWindow::GetSizer(void) const
 {
   return m_windowSizer;
 
 wxSizer *wxWindow::GetSizer(void) const
 {
   return m_windowSizer;

-};
+}

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

-};
+}

 
 wxWindow *wxWindow::GetSizerParent(void) const
 {
   return m_sizerParent;
 
 wxWindow *wxWindow::GetSizerParent(void) const
 {
   return m_sizerParent;

-};
+}

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


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

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

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

-    wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
+    wxDebugMsg(_("Constraint(s) not satisfied for window of type %s, name %s:\n"), (const char *)windowClass, (const char *)winName);

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

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

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

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

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

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

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

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

   }
 
   if (recurse)
   }
 
   if (recurse)


@@ -2429,9 +2570,7 @@ bool wxWindow::AcceptsFocus() const
   return IsEnabled() && IsShown();
 }
 
   return IsEnabled() && IsShown();
 }
 

-void wxWindow::OnIdle(wxIdleEvent& event)
+void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) )

 {
   UpdateWindowUI();
 }
 {
   UpdateWindowUI();
 }

-
-#include "../common/wincmn.cpp"