Chnaged text id for clipboard to "text/plain"

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

diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp
index 2d1683c26d5317e3ebee0b1369de39be136ed350..e3a3a49f5d3279ce3b0578802970e25f8b4415a3 100644 (file)
--- a/src/gtk1/window.cpp
+++ b/src/gtk1/window.cpp
@@ -9,7 +9,7 @@
 
 
 #ifdef __GNUG__
 
 
 #ifdef __GNUG__

-#pragma implementation "window.h"
+    #pragma implementation "window.h"

 #endif
 
 #include "wx/defs.h"
 #endif
 
 #include "wx/defs.h"


@@ -21,18 +21,29 @@
 #include "wx/utils.h"
 #include "wx/dialog.h"
 #include "wx/msgdlg.h"
 #include "wx/utils.h"
 #include "wx/dialog.h"
 #include "wx/msgdlg.h"

-#include "wx/dcclient.h"
-#include "wx/dnd.h"
+
+#if wxUSE_DRAG_AND_DROP
+    #include "wx/dnd.h"
+#endif
+
+#if wxUSE_TOOLTIPS
+    #include "wx/tooltip.h"
+#endif
+

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

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

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

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

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


@@ -114,11 +125,9 @@
 // conditional compilation
 //-------------------------------------------------------------------------
 
 // conditional compilation
 //-------------------------------------------------------------------------
 

-#if (GTK_MINOR_VERSION == 1)
-#if (GTK_MICRO_VERSION >= 5)
+#if (GTK_MINOR_VERSION > 0)

 #define NEW_GTK_SCROLL_CODE
 #endif
 #define NEW_GTK_SCROLL_CODE
 #endif

-#endif

 
 //-----------------------------------------------------------------------------
 // (debug)
 
 //-----------------------------------------------------------------------------
 // (debug)


@@ -126,14 +135,14 @@
 
 #ifdef __WXDEBUG__
 
 
 #ifdef __WXDEBUG__
 

-static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget), 
-                                         GdkEvent *WXUNUSED(event), 
-                                        const char *name )
+static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
+                                         GdkEvent *WXUNUSED(event),
+                                         const char *name )

 {
     printf( "FOCUS NOW AT: " );
     printf( name );
     printf( "\n" );
 {
     printf( "FOCUS NOW AT: " );
     printf( name );
     printf( "\n" );

-    
+

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -144,9 +153,9 @@ void debug_focus_in( GtkWidget* widget, const char* name, const char *window )
     wxString tmp = name;
     tmp += " FROM ";
     tmp += window;
     wxString tmp = name;
     tmp += " FROM ";
     tmp += window;

-    
+

     char *s = new char[tmp.Length()+1];
     char *s = new char[tmp.Length()+1];

-    
+

     strcpy( s, WXSTRINGCAST tmp );
 
     gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
     strcpy( s, WXSTRINGCAST tmp );
 
     gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",


@@ -160,7 +169,6 @@ void debug_focus_in( GtkWidget* widget, const char* name, const char *window )
 //-----------------------------------------------------------------------------
 
 extern wxList     wxPendingDelete;
 //-----------------------------------------------------------------------------
 
 extern wxList     wxPendingDelete;

-extern wxList     wxTopLevelWindows;

 extern bool       g_blockEventsOnDrag;
 extern bool       g_blockEventsOnScroll;
 static bool       g_capturing = FALSE;
 extern bool       g_blockEventsOnDrag;
 extern bool       g_blockEventsOnScroll;
 static bool       g_capturing = FALSE;


@@ -236,6 +244,8 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
     switch (gdk_event->keyval)
     {
         case GDK_BackSpace:     key_code = WXK_BACK;        break;
     switch (gdk_event->keyval)
     {
         case GDK_BackSpace:     key_code = WXK_BACK;        break;

+       case GDK_ISO_Left_Tab:
+        case GDK_KP_Tab:

         case GDK_Tab:           key_code = WXK_TAB;         break;
         case GDK_Linefeed:      key_code = WXK_RETURN;      break;
         case GDK_Clear:         key_code = WXK_CLEAR;       break;
         case GDK_Tab:           key_code = WXK_TAB;         break;
         case GDK_Linefeed:      key_code = WXK_RETURN;      break;
         case GDK_Clear:         key_code = WXK_CLEAR;       break;


@@ -260,7 +270,6 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
         case GDK_Execute:       key_code = WXK_EXECUTE;     break;
         case GDK_Insert:        key_code = WXK_INSERT;      break;
         case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;
         case GDK_Execute:       key_code = WXK_EXECUTE;     break;
         case GDK_Insert:        key_code = WXK_INSERT;      break;
         case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;

-        case GDK_KP_Tab:        key_code = WXK_TAB;         break;

         case GDK_KP_Enter:      key_code = WXK_RETURN;      break;
         case GDK_KP_Home:       key_code = WXK_HOME;        break;
         case GDK_KP_Left:       key_code = WXK_LEFT;        break;
         case GDK_KP_Enter:      key_code = WXK_RETURN;      break;
         case GDK_KP_Home:       key_code = WXK_HOME;        break;
         case GDK_KP_Left:       key_code = WXK_LEFT;        break;


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

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

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


@@ -339,38 +348,52 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
             ancestor = ancestor->GetParent();
         }
     }
             ancestor = ancestor->GetParent();
         }
     }

-    
+

     // win is a control: tab can be propagated up
     // win is a control: tab can be propagated up

-    if ((!ret) && (gdk_event->keyval == GDK_Tab))
+    if ( (!ret) && 
+         ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
+         ((win->m_windowStyle & wxTE_PROCESS_TAB) == 0))

     {
         wxNavigationKeyEvent new_event;
     {
         wxNavigationKeyEvent new_event;

-        new_event.SetDirection( !(gdk_event->state & GDK_SHIFT_MASK) );
-       new_event.SetWindowChange( FALSE );
+       /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
+        new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
+       /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */ 
+        new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );

         new_event.SetCurrentFocus( win );
         new_event.SetCurrentFocus( win );

-       ret = win->GetEventHandler()->ProcessEvent( new_event );
+        ret = win->GetEventHandler()->ProcessEvent( new_event );
+    }
+
+    if ( (!ret) && 
+         (gdk_event->keyval == GDK_Escape) )
+    {
+        wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
+        new_event.SetEventObject( win );
+        ret = win->GetEventHandler()->ProcessEvent( new_event );

     }
     
 /*
     }
     
 /*

+    Damn, I forgot why this didn't work, but it didn't work.
+

     // win is a panel: up can be propagated to the panel
     if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
         (gdk_event->keyval == GDK_Up))
     {
         win->m_parent->SetFocus();
     // win is a panel: up can be propagated to the panel
     if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
         (gdk_event->keyval == GDK_Up))
     {
         win->m_parent->SetFocus();

-       ret = TRUE;
+        ret = TRUE;

     }
     }

-    
+

     // win is a panel: left/right can be propagated to the panel
     // win is a panel: left/right can be propagated to the panel

-    if ((!ret) && (win->m_wxwindow) && 
-        ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) || 
+    if ((!ret) && (win->m_wxwindow) &&
+        ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) ||

          (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
     {
         wxNavigationKeyEvent new_event;
         new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
         new_event.SetCurrentFocus( win );
          (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
     {
         wxNavigationKeyEvent new_event;
         new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
         new_event.SetCurrentFocus( win );

-       ret = win->GetEventHandler()->ProcessEvent( new_event );
+        ret = win->GetEventHandler()->ProcessEvent( new_event );

     }
 */
     }
 */

-    
+

     if (ret)
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
     if (ret)
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );


@@ -379,6 +402,123 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
     return ret;
 }
 
     return ret;
 }
 

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

 //-----------------------------------------------------------------------------
 // "button_press_event"
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // "button_press_event"
 //-----------------------------------------------------------------------------


@@ -466,37 +606,37 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();

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

                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
-                   
-           }
-           else
-           {
+                }
+
+            }
+            else
+            {

                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&

-                   (child->m_x <= event.m_x) &&
+                    (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))
                     (child->m_y <= event.m_y) &&
                     (child->m_x+child->m_width  >= event.m_x) &&
                     (child->m_y+child->m_height >= event.m_y))


@@ -505,12 +645,16 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
+                }

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

+    wxPoint pt(win->GetClientAreaOrigin());
+    event.m_x -= pt.x;
+    event.m_y -= pt.y;
+

     event.SetEventObject( win );
 
     gs_timeLastClick = gdk_event->time;
     event.SetEventObject( win );
 
     gs_timeLastClick = gdk_event->time;


@@ -570,37 +714,37 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();

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

                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
-                   
-           }
-           else
-           {
+                }
+
+            }
+            else
+            {

                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&

-                   (child->m_x <= event.m_x) &&
+                    (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))
                     (child->m_y <= event.m_y) &&
                     (child->m_x+child->m_width  >= event.m_x) &&
                     (child->m_y+child->m_height >= event.m_y))


@@ -609,12 +753,16 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
+                }

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

+    wxPoint pt(win->GetClientAreaOrigin());
+    event.m_x -= pt.x;
+    event.m_y -= pt.y;
+

     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))


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

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

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


@@ -641,7 +800,7 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
       printf( win->GetClassInfo()->GetClassName() );
     printf( ".\n" );
     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);
 
     wxMouseEvent event( wxEVT_MOTION );
     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);


@@ -664,37 +823,37 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();
         while (node)
         {
             wxWindow *child = (wxWindow*)node->Data();

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

                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     win = child;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
-                   
-           }
-           else
-           {
+                }
+
+            }
+            else
+            {

                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&

-                   (child->m_x <= event.m_x) &&
+                    (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))
                     (child->m_y <= event.m_y) &&
                     (child->m_x+child->m_width  >= event.m_x) &&
                     (child->m_y+child->m_height >= event.m_y))


@@ -703,12 +862,16 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;

-               }
+                }

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

+    wxPoint pt(win->GetClientAreaOrigin());
+    event.m_x -= pt.x;
+    event.m_y -= pt.y;
+

     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     event.SetEventObject( win );
 
     if (win->GetEventHandler()->ProcessEvent( event ))


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

-    
+

     g_focusWindow = win;
     g_focusWindow = win;

-    
+

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


@@ -816,13 +979,13 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     event.SetEventObject( win );
 
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     event.SetEventObject( win );

-    
+

     int x = 0;
     int y = 0;
     GdkModifierType state = (GdkModifierType)0;
     int x = 0;
     int y = 0;
     GdkModifierType state = (GdkModifierType)0;

-    
+

     gdk_window_get_pointer( widget->window, &x, &y, &state );
     gdk_window_get_pointer( widget->window, &x, &y, &state );

-    
+

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


@@ -833,7 +996,11 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     event.m_x = (long)x;
     event.m_y = (long)y;
 
     event.m_x = (long)x;
     event.m_y = (long)y;

-    
+
+    wxPoint pt(win->GetClientAreaOrigin());
+    event.m_x -= pt.x;
+    event.m_y -= pt.y;
+

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


@@ -868,9 +1035,9 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
     int x = 0;
     int y = 0;
     GdkModifierType state = (GdkModifierType)0;
     int x = 0;
     int y = 0;
     GdkModifierType state = (GdkModifierType)0;

-    
+

     gdk_window_get_pointer( widget->window, &x, &y, &state );
     gdk_window_get_pointer( widget->window, &x, &y, &state );

-    
+

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


@@ -881,7 +1048,11 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     event.m_x = (long)x;
     event.m_y = (long)y;
 
     event.m_x = (long)x;
     event.m_y = (long)y;

-    
+
+    wxPoint pt(win->GetClientAreaOrigin());
+    event.m_x -= pt.x;
+    event.m_y -= pt.y;
+

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


@@ -907,6 +1078,7 @@ static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
 
     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;

+    win->m_oldVerticalPos = win->m_vAdjust->value;

 
     wxEventType command = wxEVT_NULL;
 
 
     wxEventType command = wxEVT_NULL;
 


@@ -954,6 +1126,7 @@ static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *
 
     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;

+    win->m_oldHorizontalPos = win->m_hAdjust->value;

 
     wxEventType command = wxEVT_NULL;
 
 
     wxEventType command = wxEVT_NULL;
 


@@ -1038,7 +1211,7 @@ static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxW
 
 static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
                                                  GdkEventButton *WXUNUSED(gdk_event),
 
 static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
                                                  GdkEventButton *WXUNUSED(gdk_event),

-                                                wxWindow *win )
+                                                 wxWindow *win )

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


@@ -1057,7 +1230,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
 
 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
                                                    GdkEventButton *WXUNUSED(gdk_event),
 
 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
                                                    GdkEventButton *WXUNUSED(gdk_event),

-                                                  wxWindow *win )
+                                                   wxWindow *win )

 {
 
 //  don't test here as we can release the mouse while being over
 {
 
 //  don't test here as we can release the mouse while being over


@@ -1082,23 +1255,44 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
 // InsertChild for wxWindow.
 //-----------------------------------------------------------------------------
 
 // InsertChild for wxWindow.
 //-----------------------------------------------------------------------------
 

-// Callback for wxWindow. This very strange beast has to be used because
-// C++ has no virtual methods in a constructor. We have to emulate a
-// virtual function here as wxNotebook requires a different way to insert
-// a child in it. I had opted for creating a wxNotebookPage window class
-// which would have made this superfluous (such in the MDI window system),
-// but no-one was listening to me...
+/* Callback for wxWindow. This very strange beast has to be used because
+ * C++ has no virtual methods in a constructor. We have to emulate a
+ * virtual function here as wxNotebook requires a different way to insert
+ * a child in it. I had opted for creating a wxNotebookPage window class
+ * which would have made this superfluous (such in the MDI window system),
+ * but no-one was listening to me... */

 
 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 {
     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
                      GTK_WIDGET(child->m_widget),
 
 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
 {
     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
                      GTK_WIDGET(child->m_widget),

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

 
     gtk_widget_set_usize( GTK_WIDGET(child->m_widget),
                           child->m_width,
 
     gtk_widget_set_usize( GTK_WIDGET(child->m_widget),
                           child->m_width,

-                         child->m_height );
+                          child->m_height );
+
+    if (wxIS_KIND_OF(parent,wxFrame))
+    {
+        parent->m_sizeSet = FALSE;
+    }
+
+    if (parent->m_windowStyle & wxTAB_TRAVERSAL)
+    {
+        /* we now allow a window to get the focus as long as it
+           doesn't have any children. */
+        GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );
+    }
+}
+
+//-----------------------------------------------------------------------------
+// global functions
+//-----------------------------------------------------------------------------
+
+wxWindow* wxGetActiveWindow()
+{
+  return g_focusWindow;

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


@@ -1111,11 +1305,13 @@ BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
     EVT_SIZE(wxWindow::OnSize)
     EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
     EVT_INIT_DIALOG(wxWindow::OnInitDialog)
     EVT_SIZE(wxWindow::OnSize)
     EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
     EVT_INIT_DIALOG(wxWindow::OnInitDialog)

-    EVT_IDLE(wxWindow::OnIdle)
+    EVT_KEY_DOWN(wxWindow::OnKeyDown)

 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 

-wxWindow::wxWindow()
+void wxWindow::Init()

 {
 {

+    m_isWindow = TRUE;
+

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


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

+#if wxUSE_DRAG_AND_DROP

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

+#endif

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


@@ -1171,16 +1369,26 @@ wxWindow::wxWindow()
 
     m_clientObject = (wxClientData*) NULL;
     m_clientData = NULL;
 
     m_clientObject = (wxClientData*) NULL;
     m_clientData = NULL;

-    
+

     m_isStaticBox = FALSE;
     m_acceptsFocus = FALSE;
     m_isStaticBox = FALSE;
     m_acceptsFocus = FALSE;

+
+#if wxUSE_TOOLTIPS
+    m_toolTip = (wxToolTip*) NULL;
+#endif // wxUSE_TOOLTIPS
+}
+
+wxWindow::wxWindow()
+{
+    Init();

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

-    m_insertCallback = wxInsertChildInWindow;
+    Init();
+

     Create( parent, id, pos, size, style, name );
 }
 
     Create( parent, id, pos, size, style, name );
 }
 


@@ -1188,15 +1396,13 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
                        const wxPoint &pos, const wxSize &size,
                        long style, const wxString &name  )
 {
                        const wxPoint &pos, const wxSize &size,
                        long style, const wxString &name  )
 {

-    m_isShown = FALSE;
-    m_isEnabled = TRUE;
-    m_needParent = TRUE;
+    wxASSERT_MSG( m_isWindow, "Init() must have been called before!" );

 
     PreCreation( parent, id, pos, size, style, name );
 
     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
     PreCreation( parent, id, pos, size, style, name );
 
     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );

-    
+

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


@@ -1227,7 +1433,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
 #ifdef NEW_GTK_SCROLL_CODE
     gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), m_wxwindow );
 
 #ifdef NEW_GTK_SCROLL_CODE
     gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), m_wxwindow );

-    GtkViewport *viewport = GTK_VIEWPORT(s_window->child);
+    GtkViewport *viewport = GTK_VIEWPORT( GTK_BIN(s_window)->child );

 #else
     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
     GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
 #else
     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
     GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);


@@ -1250,9 +1456,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 );
     }
 

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

     {
     {

-        GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
+        /* we now allow a window to get the focus as long as it
+           doesn't have any children. */
+        GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );

         m_acceptsFocus = FALSE;
     }
     else
         m_acceptsFocus = FALSE;
     }
     else


@@ -1328,13 +1536,28 @@ wxWindow::~wxWindow()
 {
     m_hasVMT = FALSE;
 
 {
     m_hasVMT = FALSE;
 

-    if (m_dropTarget) delete m_dropTarget;
+#if wxUSE_DRAG_AND_DROP
+    if (m_dropTarget)
+    {
+        delete m_dropTarget;
+       m_dropTarget = (wxDropTarget*) NULL;
+    }
+#endif
+
+#if wxUSE_TOOLTIPS
+    if (m_toolTip)
+    {
+        delete m_toolTip;
+       m_toolTip = (wxToolTip*) NULL;
+    }
+#endif // wxUSE_TOOLTIPS

 
 

-    if (m_parent) m_parent->RemoveChild( this );

     if (m_widget) Show( FALSE );
 
     DestroyChildren();
 
     if (m_widget) Show( FALSE );
 
     DestroyChildren();
 

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

     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
 
     if (m_scrollGC) gdk_gc_unref( m_scrollGC );
     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
 
     if (m_scrollGC) gdk_gc_unref( m_scrollGC );


@@ -1348,28 +1571,29 @@ wxWindow::~wxWindow()
     DeleteRelatedConstraints();
     if (m_constraints)
     {
     DeleteRelatedConstraints();
     if (m_constraints)
     {

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

         UnsetConstraints(m_constraints);
         delete m_constraints;
         m_constraints = (wxLayoutConstraints *) NULL;
     }
         UnsetConstraints(m_constraints);
         delete m_constraints;
         m_constraints = (wxLayoutConstraints *) NULL;
     }

+    

     if (m_windowSizer)
     {
         delete m_windowSizer;
         m_windowSizer = (wxSizer *) NULL;
     }
     if (m_windowSizer)
     {
         delete m_windowSizer;
         m_windowSizer = (wxSizer *) NULL;
     }

-    // If this is a child of a sizer, remove self from parent
+    /* 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
-    // dangling pointers.
+    /* Just in case the window has been Closed, but
+     * we're then deleting immediately: don't leave
+     * dangling pointers. */

     wxPendingDelete.DeleteObject(this);
 
     wxPendingDelete.DeleteObject(this);
 

-    // Just in case we've loaded a top-level window via
-    // wxWindow::LoadNativeDialog but we weren't a dialog
-    // class
+    /* Just in case we've loaded a top-level window via
+     * wxWindow::LoadNativeDialog but we weren't a dialog
+     * class */

     wxTopLevelWindows.DeleteObject(this);
 
     if (m_windowValidator) delete m_windowValidator;
     wxTopLevelWindows.DeleteObject(this);
 
     if (m_windowValidator) delete m_windowValidator;


@@ -1397,7 +1621,7 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
     m_x = (int)pos.x;
     m_y = (int)pos.y;
 
     m_x = (int)pos.x;
     m_y = (int)pos.y;
 

-    if (!m_needParent)  // some reasonable defaults
+    if (!m_needParent)  /* some reasonable defaults */

     {
         if (m_x == -1)
         {
     {
         if (m_x == -1)
         {


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

+#if wxUSE_DRAG_AND_DROP

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

+#endif

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


@@ -1455,24 +1681,31 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
 
     m_clientObject = (wxClientData*)NULL;
     m_clientData = NULL;
 
     m_clientObject = (wxClientData*)NULL;
     m_clientData = NULL;

-    
+

     m_isStaticBox = FALSE;
     m_isStaticBox = FALSE;

+
+#if wxUSE_TOOLTIPS
+    m_toolTip = (wxToolTip*) NULL;
+#endif // wxUSE_TOOLTIPS

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

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

     if (m_wxwindow)
     {
     if (m_wxwindow)
     {

-      gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
-        GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
+        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
+          GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );

 
 

-      gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
-        GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
+        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
+          GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );

     }
 
     ConnectWidget( GetConnectWidget() );
 
     }
 
     ConnectWidget( GetConnectWidget() );
 

-    if (m_widget && m_parent) gtk_widget_realize( m_widget );
+    /* we force the creation of wxFrame and wxDialog in the respective code */
+    if (m_parent) gtk_widget_realize( m_widget );

 
     if (m_wxwindow) gtk_widget_realize( m_wxwindow );
 
 
     if (m_wxwindow) gtk_widget_realize( m_wxwindow );
 


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

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

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


@@ -1519,9 +1755,11 @@ bool wxWindow::Close( bool force )
 
     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
     event.SetEventObject(this);
 
     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
     event.SetEventObject(this);

-    event.SetForce(force);
+    event.SetCanVeto(!force);

 
 

-    return GetEventHandler()->ProcessEvent(event);
+    /* return FALSE if window wasn't closed because the application vetoed the
+     * close event */
+    return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();

 }
 
 bool wxWindow::Destroy()
 }
 
 bool wxWindow::Destroy()


@@ -1568,17 +1806,17 @@ void wxWindow::AdjustForParentClientOrigin( int& x, int& y, int sizeFlags )
     }
 }
 
     }
 }
 

-void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
+void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )

 {
     wxASSERT_MSG( (m_widget != NULL), "invalid window" );
     wxASSERT_MSG( (m_parent != NULL), "wxWindow::SetSize requires parent.\n" );
 
 {
     wxASSERT_MSG( (m_widget != NULL), "invalid window" );
     wxASSERT_MSG( (m_parent != NULL), "wxWindow::SetSize requires parent.\n" );
 

-    if (m_resizing) return; // I don't like recursions
+    if (m_resizing) return; /* I don't like recursions */

     m_resizing = TRUE;
 
     m_resizing = TRUE;
 

-    if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
+    if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */

     {
     {

-        // don't set the size for children of wxNotebook, just take the values.
+        /* don't set the size for children of wxNotebook, just take the values. */

         m_x = x;
         m_y = y;
         m_width = width;
         m_x = x;
         m_y = y;
         m_width = width;


@@ -1619,11 +1857,24 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
         if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 
         if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 

-        wxPoint pt( m_parent->GetClientAreaOrigin() );
-        gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y );
+        if (GTK_WIDGET_HAS_DEFAULT(m_widget))
+       {
+           /* the default button has a border around it */
+           int border = 5;
+       
+            wxPoint pt( m_parent->GetClientAreaOrigin() );
+            gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x-border, m_y+pt.y-border );
+
+            gtk_widget_set_usize( m_widget, m_width+2*border, m_height+2*border );
+       }
+       else
+       {
+            wxPoint pt( m_parent->GetClientAreaOrigin() );
+            gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y );

 
 

-        if ((old_width != m_width) || (old_height != m_height))
-             gtk_widget_set_usize( m_widget, m_width, m_height );
+            if ((old_width != m_width) || (old_height != m_height))
+              gtk_widget_set_usize( m_widget, m_width, m_height );
+       }

     }
 
     m_sizeSet = TRUE;
     }
 
     m_sizeSet = TRUE;


@@ -1635,14 +1886,9 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
     m_resizing = FALSE;
 }
 
     m_resizing = FALSE;
 }
 

-void wxWindow::SetSize( int width, int height )
+void wxWindow::OnInternalIdle()

 {
 {

-    SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
-}
-
-void wxWindow::Move( int x, int y )
-{
-    SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
+    UpdateWindowUI();

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


@@ -1653,7 +1899,7 @@ void wxWindow::GetSize( int *width, int *height ) const
     if (height) (*height) = m_height;
 }
 
     if (height) (*height) = m_height;
 }
 

-void wxWindow::SetClientSize( int width, int height )
+void wxWindow::DoSetClientSize( int width, int height )

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


@@ -1683,7 +1929,7 @@ void wxWindow::SetClientSize( int width, int height )
             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 
 #ifdef NEW_GTK_SCROLL_CODE
             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 
 #ifdef NEW_GTK_SCROLL_CODE

-            GtkWidget *viewport = scroll_window->child;
+            GtkWidget *viewport = GTK_BIN(scroll_window)->child;

 #else
             GtkWidget *viewport = scroll_window->viewport;
 #endif
 #else
             GtkWidget *viewport = scroll_window->viewport;
 #endif


@@ -1748,7 +1994,7 @@ void wxWindow::GetClientSize( int *width, int *height ) const
             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 
 #ifdef NEW_GTK_SCROLL_CODE
             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
 
 #ifdef NEW_GTK_SCROLL_CODE

-            GtkWidget *viewport = scroll_window->child;
+            GtkWidget *viewport = GTK_BIN(scroll_window)->child;

 #else
             GtkWidget *viewport = scroll_window->viewport;
 #endif
 #else
             GtkWidget *viewport = scroll_window->viewport;
 #endif


@@ -1894,7 +2140,7 @@ void wxWindow::Fit()
 
         node = node->Next();
     }
 
         node = node->Next();
     }

-    
+

     SetClientSize(maxX + 7, maxY + 14);
 }
 
     SetClientSize(maxX + 7, maxY + 14);
 }
 


@@ -1917,13 +2163,15 @@ bool wxWindow::Show( bool show )
 {
     wxCHECK_MSG( (m_widget != NULL), FALSE, "invalid window" );
 
 {
     wxCHECK_MSG( (m_widget != NULL), FALSE, "invalid window" );
 

+    if (show == m_isShown) return TRUE;
+

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

-       
+

     m_isShown = show;
     m_isShown = show;

-    
+

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -1932,7 +2180,7 @@ void wxWindow::Enable( bool enable )
     wxCHECK_RET( (m_widget != NULL), "invalid window" );
 
     m_isEnabled = enable;
     wxCHECK_RET( (m_widget != NULL), "invalid window" );
 
     m_isEnabled = enable;

-    
+

     gtk_widget_set_sensitive( m_widget, enable );
     if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
 }
     gtk_widget_set_sensitive( m_widget, enable );
     if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
 }


@@ -1944,7 +2192,7 @@ int wxWindow::GetCharHeight() const
     wxCHECK_MSG( m_font.Ok(), 12, "invalid font" );
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );
     wxCHECK_MSG( m_font.Ok(), 12, "invalid font" );
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );

-    
+

     return font->ascent + font->descent;
 }
 
     return font->ascent + font->descent;
 }
 


@@ -1955,7 +2203,7 @@ int wxWindow::GetCharWidth() const
     wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );
     wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );

-    
+

     return gdk_string_width( font, "H" );
 }
 
     return gdk_string_width( font, "H" );
 }
 


@@ -1977,7 +2225,7 @@ void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
 void wxWindow::MakeModal( bool modal )
 {
     return;
 void wxWindow::MakeModal( bool modal )
 {
     return;

-    
+

     // Disable all other windows
     if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
     {
     // Disable all other windows
     if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
     {


@@ -1992,10 +2240,20 @@ void wxWindow::MakeModal( bool modal )
     }
 }
 
     }
 }
 

+void wxWindow::OnKeyDown( wxKeyEvent &event )
+{
+    event.SetEventType( wxEVT_CHAR );
+
+    if (!GetEventHandler()->ProcessEvent( event ))
+    {
+        event.Skip();
+    }
+}
+

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

-    
+

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


@@ -2003,13 +2261,13 @@ void wxWindow::SetFocus()
         {
             gtk_widget_grab_focus (connect_widget);
         }
         {
             gtk_widget_grab_focus (connect_widget);
         }

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

     }
 }
 
     }
 }
 


@@ -2023,11 +2281,6 @@ bool wxWindow::AcceptsFocus() const
     return IsEnabled() && IsShown() && m_acceptsFocus;
 }
 
     return IsEnabled() && IsShown() && m_acceptsFocus;
 }
 

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

 void wxWindow::AddChild( wxWindow *child )
 {
     wxCHECK_RET( (m_widget != NULL), "invalid window" );
 void wxWindow::AddChild( wxWindow *child )
 {
     wxCHECK_RET( (m_widget != NULL), "invalid window" );


@@ -2039,7 +2292,7 @@ void wxWindow::AddChild( wxWindow *child )
 wxWindow *wxWindow::ReParent( wxWindow *newParent )
 {
     wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );
 wxWindow *wxWindow::ReParent( wxWindow *newParent )
 {
     wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );

-    
+

     wxWindow *oldParent = GetParent();
 
     if (oldParent) oldParent->RemoveChild( this );
     wxWindow *oldParent = GetParent();
 
     if (oldParent) oldParent->RemoveChild( this );


@@ -2205,20 +2458,19 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
         {
             gdk_window_clear_area( m_wxwindow->window,
                                    rect->x, rect->y,
         {
             gdk_window_clear_area( m_wxwindow->window,
                                    rect->x, rect->y,

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

         }
         else
         {
         }
         else
         {

-            Clear();
+            gdk_window_clear( m_wxwindow->window );

         }
     }
         }
     }

-    
+

     if (!rect)
     {
         if (m_wxwindow)
             gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
     if (!rect)
     {
         if (m_wxwindow)
             gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );

-       else
+        else

             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
     }
     else
             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
     }
     else


@@ -2265,9 +2517,48 @@ void wxWindow::Clear()
 {
     wxCHECK_RET( m_widget != NULL, "invalid window" );
 
 {
     wxCHECK_RET( 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 );
+    }

 }
 
 }
 

+#if wxUSE_TOOLTIPS
+void wxWindow::SetToolTip( const wxString &tip )
+{
+    if (m_toolTip)
+    {
+        m_toolTip->SetTip( tip );
+    }
+    else
+    {
+        SetToolTip( new wxToolTip( tip ) );
+    }
+
+    // setting empty tooltip text does not remove the tooltip any more for
+    // wxMSW compatibility - use SetToolTip((wxToolTip *)NULL) for this
+}
+
+void wxWindow::SetToolTip( wxToolTip *tip )
+{
+    if (m_toolTip)
+    {
+        m_toolTip->SetTip( (char*) NULL );
+        delete m_toolTip;
+    }
+
+    m_toolTip = tip;
+
+    if (m_toolTip)
+        m_toolTip->Apply( this );
+}
+
+void wxWindow::ApplyToolTip( GtkTooltips *tips, const char *tip )
+{
+    gtk_tooltips_set_tip( tips, GetConnectWidget(), tip, (gchar*) NULL );
+}
+#endif // wxUSE_TOOLTIPS
+

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


@@ -2282,23 +2573,26 @@ void wxWindow::SetBackgroundColour( const wxColour &colour )
     m_backgroundColour = colour;
     if (!m_backgroundColour.Ok()) return;
 
     m_backgroundColour = colour;
     if (!m_backgroundColour.Ok()) return;
 

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

     {
     {

-        GdkWindow *window = m_wxwindow->window;
-        m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
-        gdk_window_set_background( window, m_backgroundColour.GetColor() );
-        gdk_window_clear( window );
+       /* wxMSW doesn't clear the window here. I don't do that
+          either to provide compatibility. call Clear() to do 
+          the job. */
+          
+        m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_wxwindow->window ) );
+        gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );

     }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
     }
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );

-    if (sysbg.Red() == colour.Red() && 
-        sysbg.Green() == colour.Green() && 
+    
+    if (sysbg.Red() == colour.Red() &&
+        sysbg.Green() == colour.Green() &&

         sysbg.Blue() == colour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
         sysbg.Blue() == colour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();

-       m_backgroundColour = sysbg;
-    } 
+        m_backgroundColour = sysbg;
+    }

     else
     {
         ApplyWidgetStyle();
     else
     {
         ApplyWidgetStyle();


@@ -2320,14 +2614,14 @@ void wxWindow::SetForegroundColour( const wxColour &colour )
     if (!m_foregroundColour.Ok()) return;
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
     if (!m_foregroundColour.Ok()) return;
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );

-    if (sysbg.Red() == colour.Red() && 
-        sysbg.Green() == colour.Green() && 
+    if (sysbg.Red() == colour.Red() &&
+        sysbg.Green() == colour.Green() &&

         sysbg.Blue() == colour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
         sysbg.Blue() == colour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();

-       m_backgroundColour = sysbg;
-    } 
+        m_backgroundColour = sysbg;
+    }

     else
     {
         ApplyWidgetStyle();
     else
     {
         ApplyWidgetStyle();


@@ -2387,9 +2681,9 @@ bool wxWindow::Validate()
     {
         wxWindow *child = (wxWindow *)node->Data();
         if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
     {
         wxWindow *child = (wxWindow *)node->Data();
         if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))

-        { 
-           return FALSE; 
-       }
+        {
+            return FALSE;
+        }

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


@@ -2423,9 +2717,9 @@ bool wxWindow::TransferDataFromWindow()
     {
         wxWindow *child = (wxWindow *)node->Data();
         if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
     {
         wxWindow *child = (wxWindow *)node->Data();
         if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )

-        { 
-           return FALSE; 
-       }
+        {
+            return FALSE;
+        }

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


@@ -2453,37 +2747,55 @@ void wxWindow::InitDialog()
 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 {
     menu->SetInvokingWindow( win );
 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 {
     menu->SetInvokingWindow( win );

-    wxNode *node = menu->m_items.First();
+    wxNode *node = menu->GetItems().First();

     while (node)
     {
         wxMenuItem *menuitem = (wxMenuItem*)node->Data();
         if (menuitem->IsSubMenu())
         {
     while (node)
     {
         wxMenuItem *menuitem = (wxMenuItem*)node->Data();
         if (menuitem->IsSubMenu())
         {

-           SetInvokingWindow( menuitem->GetSubMenu(), win );
-       }
+            SetInvokingWindow( menuitem->GetSubMenu(), win );
+        }

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

-bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) )
+static gint gs_pop_x = 0;
+static gint gs_pop_y = 0;
+
+static void pop_pos_callback( GtkMenu *menu, gint *x, gint *y, wxWindow *win )
+{
+    win->ClientToScreen( &gs_pop_x, &gs_pop_y );
+    *x = gs_pop_x;
+    *y = gs_pop_y;
+}
+
+bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )

 {
     wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
 
     wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" );
 
     SetInvokingWindow( menu, this );
 {
     wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
 
     wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" );
 
     SetInvokingWindow( menu, this );

+
+    menu->UpdateUI();
+
+    gs_pop_x = x;
+    gs_pop_y = y;
+

     gtk_menu_popup(
                   GTK_MENU(menu->m_menu),
     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
+                  (GtkWidget *) NULL,          // parent menu shell
+                  (GtkWidget *) NULL,          // parent menu item
+                  (GtkMenuPositionFunc) pop_pos_callback,
+                  (gpointer) this,             // client data
+                  0,                           // button used to activate it
+                  0 //gs_timeLastClick         // the time of activation

                 );
     return TRUE;
 }
 
                 );
     return TRUE;
 }
 

+#if wxUSE_DRAG_AND_DROP
+

 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 {
     wxCHECK_RET( m_widget != NULL, "invalid window" );
 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 {
     wxCHECK_RET( m_widget != NULL, "invalid window" );


@@ -2503,6 +2815,8 @@ wxDropTarget *wxWindow::GetDropTarget() const
     return m_dropTarget;
 }
 
     return m_dropTarget;
 }
 

+#endif
+

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


@@ -2520,21 +2834,23 @@ bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
 void wxWindow::SetFont( const wxFont &font )
 {
     wxCHECK_RET( m_widget != NULL, "invalid window" );
 void wxWindow::SetFont( const wxFont &font )
 {
     wxCHECK_RET( m_widget != NULL, "invalid window" );

-
+    
+    if (m_font == font) return;
+    

     if (((wxFont*)&font)->Ok())
         m_font = font;
     else
         m_font = *wxSWISS_FONT;
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
     if (((wxFont*)&font)->Ok())
         m_font = font;
     else
         m_font = *wxSWISS_FONT;
 
     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );

-    if (sysbg.Red() == m_backgroundColour.Red() && 
-        sysbg.Green() == m_backgroundColour.Green() && 
+    if (sysbg.Red() == m_backgroundColour.Red() &&
+        sysbg.Green() == m_backgroundColour.Green() &&

         sysbg.Blue() == m_backgroundColour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();
         sysbg.Blue() == m_backgroundColour.Blue())
     {
         m_backgroundColour = wxNullColour;
         ApplyWidgetStyle();

-       m_backgroundColour = sysbg;
-    } 
+        m_backgroundColour = sysbg;
+    }

     else
     {
         ApplyWidgetStyle();
     else
     {
         ApplyWidgetStyle();


@@ -2564,9 +2880,9 @@ void wxWindow::CaptureMouse()
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
                           GDK_POINTER_MOTION_MASK),
                          (GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
                           GDK_POINTER_MOTION_MASK),

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

     g_capturing = TRUE;
 }
 
     g_capturing = TRUE;
 }
 


@@ -2735,7 +3051,7 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
         if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
         if (fpos < 0.0) fpos = 0.0;
         m_oldVerticalPos = fpos;
         if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
         if (fpos < 0.0) fpos = 0.0;
         m_oldVerticalPos = fpos;

-    
+

         if (fabs(fpos-m_vAdjust->value) < 0.2) return;
         m_vAdjust->value = fpos;
     }
         if (fabs(fpos-m_vAdjust->value) < 0.2) return;
         m_vAdjust->value = fpos;
     }


@@ -3142,9 +3458,9 @@ void wxWindow::SetConstraintSizes(bool recurse)
     winName = "unnamed";
   else
     winName = GetName();
     winName = "unnamed";
   else
     winName = GetName();

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

     if (!constr->left.GetDone()) wxLogDebug( "  unsatisfied 'left' constraint.\n" );
     if (!constr->right.GetDone()) wxLogDebug( "  unsatisfied 'right' constraint.\n" );
     if (!constr->width.GetDone()) wxLogDebug( "  unsatisfied 'width' constraint.\n" );
     if (!constr->left.GetDone()) wxLogDebug( "  unsatisfied 'left' constraint.\n" );
     if (!constr->right.GetDone()) wxLogDebug( "  unsatisfied 'right' constraint.\n" );
     if (!constr->width.GetDone()) wxLogDebug( "  unsatisfied 'width' constraint.\n" );


@@ -3279,7 +3595,3 @@ void wxWindow::GetPositionConstraint(int *x, int *y) const
     GetPosition(x, y);
 }
 
     GetPosition(x, y);
 }
 

-void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) )
-{
-    UpdateWindowUI();
-}