]> git.saurik.com Git - wxWidgets.git/blobdiff - src/gtk/window.cpp
crash in some very special case when arrows were used to move around fixed
[wxWidgets.git] / src / gtk / window.cpp
index 2d1683c26d5317e3ebee0b1369de39be136ed350..91c07fb36d1721d6d588fa823d71385bf8b4e6f5 100644 (file)
@@ -9,7 +9,7 @@
 
 
 #ifdef __GNUG__
-#pragma implementation "window.h"
+    #pragma implementation "window.h"
 #endif
 
 #include "wx/defs.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 "gdk/gdkprivate.h"
-#include "gdk/gdkkeysyms.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
 //-----------------------------------------------------------------------------
 
 #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" );
-    
+
     return FALSE;
 }
 
@@ -144,9 +155,9 @@ void debug_focus_in( GtkWidget* widget, const char* name, const char *window )
     wxString tmp = name;
     tmp += " FROM ";
     tmp += window;
-    
+
     char *s = new char[tmp.Length()+1];
-    
+
     strcpy( s, WXSTRINGCAST tmp );
 
     gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
@@ -236,6 +247,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;
+       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;
@@ -260,7 +273,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_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;
@@ -312,7 +324,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
 
     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);
@@ -339,38 +351,52 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
             ancestor = ancestor->GetParent();
         }
     }
-    
+
     // 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;
-        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 );
-       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();
-       ret = TRUE;
+        ret = TRUE;
     }
-    
+
     // win is a panel: left/right can be propagated to the panel
-    if ((!ret) && (win->m_wxwindow) && 
-        ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) || 
+    if ((!ret) && (win->m_wxwindow) &&
+        ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) ||
          (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
     {
         wxNavigationKeyEvent new_event;
         new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
         new_event.SetCurrentFocus( win );
-       ret = win->GetEventHandler()->ProcessEvent( new_event );
+        ret = win->GetEventHandler()->ProcessEvent( new_event );
     }
 */
-    
+
     if (ret)
     {
         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
@@ -379,6 +405,123 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
     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"
 //-----------------------------------------------------------------------------
@@ -466,37 +609,37 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
         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;
-               }
-                   
-           }
-           else
-           {
+                }
+
+            }
+            else
+            {
                 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))
@@ -505,12 +648,16 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
-               }
+                }
             }
             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;
@@ -570,37 +717,37 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
         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;
-               }
-                   
-           }
-           else
-           {
+                }
+
+            }
+            else
+            {
                 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))
@@ -609,12 +756,16 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
-               }
+                }
             }
             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 ))
@@ -629,6 +780,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 )
 {
+    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;
@@ -641,7 +803,7 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
     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);
@@ -664,37 +826,37 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
         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;
-               }
-                   
-           }
-           else
-           {
+                }
+
+            }
+            else
+            {
                 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))
@@ -703,12 +865,16 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
                     event.m_x -= child->m_x;
                     event.m_y -= child->m_y;
                     break;
-               }
+                }
             }
             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 ))
@@ -724,9 +890,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;
-    
+
     g_focusWindow = win;
-    
+
     if (win->m_wxwindow)
     {
         if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
@@ -816,13 +982,13 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     wxMouseEvent event( wxEVT_ENTER_WINDOW );
     event.SetEventObject( win );
-    
+
     int x = 0;
     int y = 0;
     GdkModifierType state = (GdkModifierType)0;
-    
+
     gdk_window_get_pointer( widget->window, &x, &y, &state );
-    
+
     event.m_shiftDown = (state & GDK_SHIFT_MASK);
     event.m_controlDown = (state & GDK_CONTROL_MASK);
     event.m_altDown = (state & GDK_MOD1_MASK);
@@ -833,7 +999,11 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     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" );
 
@@ -868,9 +1038,9 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
     int x = 0;
     int y = 0;
     GdkModifierType state = (GdkModifierType)0;
-    
+
     gdk_window_get_pointer( widget->window, &x, &y, &state );
-    
+
     event.m_shiftDown = (state & GDK_SHIFT_MASK);
     event.m_controlDown = (state & GDK_CONTROL_MASK);
     event.m_altDown = (state & GDK_MOD1_MASK);
@@ -881,7 +1051,11 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     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" );
 
@@ -1038,7 +1212,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),
-                                                wxWindow *win )
+                                                 wxWindow *win )
 {
 //  don't test here as we can release the mouse while being over
 //  a different window then the slider
@@ -1057,7 +1231,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
 
 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
@@ -1082,23 +1256,44 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
 // 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),
-                    child->m_x,
-                    child->m_y );
+                       child->m_x,
+                     child->m_y );
 
     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,7 +1306,7 @@ BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
     EVT_SIZE(wxWindow::OnSize)
     EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
     EVT_INIT_DIALOG(wxWindow::OnInitDialog)
-    EVT_IDLE(wxWindow::OnIdle)
+    EVT_KEY_DOWN(wxWindow::OnKeyDown)
 END_EVENT_TABLE()
 
 wxWindow::wxWindow()
@@ -1162,7 +1357,9 @@ wxWindow::wxWindow()
     m_isShown = FALSE;
     m_isEnabled = TRUE;
 
+#if wxUSE_DRAG_AND_DROP
     m_dropTarget = (wxDropTarget*) NULL;
+#endif
     m_resizing = FALSE;
     m_scrollGC = (GdkGC*) NULL;
     m_widgetStyle = (GtkStyle*) NULL;
@@ -1171,9 +1368,13 @@ wxWindow::wxWindow()
 
     m_clientObject = (wxClientData*) NULL;
     m_clientData = NULL;
-    
+
     m_isStaticBox = FALSE;
     m_acceptsFocus = FALSE;
+
+#if wxUSE_TOOLTIPS
+    m_toolTip = (wxToolTip*) NULL;
+#endif // wxUSE_TOOLTIPS
 }
 
 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
@@ -1196,7 +1397,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
 
     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
-    
+
 #ifdef __WXDEBUG__
     debug_focus_in( m_widget, "wxWindow::m_widget", name );
 #endif
@@ -1250,9 +1451,11 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
         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
@@ -1328,13 +1531,28 @@ wxWindow::~wxWindow()
 {
     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_parent) m_parent->RemoveChild( this );
+    
     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
 
     if (m_scrollGC) gdk_gc_unref( m_scrollGC );
@@ -1348,28 +1566,29 @@ wxWindow::~wxWindow()
     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;
     }
+    
     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);
 
-    // 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);
 
-    // 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;
@@ -1397,7 +1616,7 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
     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)
         {
@@ -1447,7 +1666,9 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
     m_isShown = FALSE;
     m_isEnabled = TRUE;
 
+#if wxUSE_DRAG_AND_DROP
     m_dropTarget = (wxDropTarget *) NULL;
+#endif
     m_resizing = FALSE;
     m_windowValidator = (wxValidator *) NULL;
     m_scrollGC = (GdkGC*) NULL;
@@ -1455,24 +1676,31 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
 
     m_clientObject = (wxClientData*)NULL;
     m_clientData = NULL;
-    
+
     m_isStaticBox = FALSE;
+
+#if wxUSE_TOOLTIPS
+    m_toolTip = (wxToolTip*) NULL;
+#endif // wxUSE_TOOLTIPS
 }
 
 void wxWindow::PostCreation()
 {
+    wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+    
     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() );
 
-    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 );
 
@@ -1486,6 +1714,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_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 );
 
@@ -1519,9 +1750,11 @@ bool wxWindow::Close( bool force )
 
     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()
@@ -1568,17 +1801,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" );
 
-    if (m_resizing) return; // I don't like recursions
+    if (m_resizing) return; /* I don't like recursions */
     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;
@@ -1619,11 +1852,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;
 
-        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 );
 
-        if ((old_width != m_width) || (old_height != m_height))
-             gtk_widget_set_usize( m_widget, m_width, m_height );
+            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 );
+       }
     }
 
     m_sizeSet = TRUE;
@@ -1635,14 +1881,9 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
     m_resizing = FALSE;
 }
 
-void wxWindow::SetSize( int width, int height )
-{
-    SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
-}
-
-void wxWindow::Move( int x, int y )
+void wxWindow::OnInternalIdle()
 {
-    SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
+    UpdateWindowUI();
 }
 
 void wxWindow::GetSize( int *width, int *height ) const
@@ -1653,7 +1894,7 @@ void wxWindow::GetSize( int *width, int *height ) const
     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" );
 
@@ -1894,7 +2135,7 @@ void wxWindow::Fit()
 
         node = node->Next();
     }
-    
+
     SetClientSize(maxX + 7, maxY + 14);
 }
 
@@ -1917,13 +2158,15 @@ bool wxWindow::Show( bool show )
 {
     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 );
-       
+
     m_isShown = show;
-    
+
     return TRUE;
 }
 
@@ -1932,7 +2175,7 @@ void wxWindow::Enable( bool 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 );
 }
@@ -1944,7 +2187,7 @@ int wxWindow::GetCharHeight() const
     wxCHECK_MSG( m_font.Ok(), 12, "invalid font" );
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );
-    
+
     return font->ascent + font->descent;
 }
 
@@ -1955,7 +2198,7 @@ int wxWindow::GetCharWidth() const
     wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );
 
     GdkFont *font = m_font.GetInternalFont( 1.0 );
-    
+
     return gdk_string_width( font, "H" );
 }
 
@@ -1977,7 +2220,7 @@ void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
 void wxWindow::MakeModal( bool modal )
 {
     return;
-    
+
     // Disable all other windows
     if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
     {
@@ -1992,10 +2235,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" );
-    
+
     GtkWidget *connect_widget = GetConnectWidget();
     if (connect_widget)
     {
@@ -2003,13 +2256,13 @@ void wxWindow::SetFocus()
         {
             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 +2276,6 @@ bool wxWindow::AcceptsFocus() const
     return IsEnabled() && IsShown() && m_acceptsFocus;
 }
 
-bool wxWindow::OnClose()
-{
-    return TRUE;
-}
-
 void wxWindow::AddChild( wxWindow *child )
 {
     wxCHECK_RET( (m_widget != NULL), "invalid window" );
@@ -2039,7 +2287,7 @@ void wxWindow::AddChild( wxWindow *child )
 wxWindow *wxWindow::ReParent( wxWindow *newParent )
 {
     wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );
-    
+
     wxWindow *oldParent = GetParent();
 
     if (oldParent) oldParent->RemoveChild( this );
@@ -2205,20 +2453,19 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
         {
             gdk_window_clear_area( m_wxwindow->window,
                                    rect->x, rect->y,
-                                   rect->width,
-                                   rect->height );
+                                   rect->width, rect->height );
         }
         else
         {
-            Clear();
+            gdk_window_clear( m_wxwindow->window );
         }
     }
-    
+
     if (!rect)
     {
         if (m_wxwindow)
             gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
-       else
+        else
             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
     }
     else
@@ -2265,9 +2512,48 @@ void wxWindow::Clear()
 {
     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;
@@ -2282,23 +2568,26 @@ void wxWindow::SetBackgroundColour( const wxColour &colour )
     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 );
-    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();
-       m_backgroundColour = sysbg;
-    } 
+        m_backgroundColour = sysbg;
+    }
     else
     {
         ApplyWidgetStyle();
@@ -2320,14 +2609,14 @@ void wxWindow::SetForegroundColour( const wxColour &colour )
     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();
-       m_backgroundColour = sysbg;
-    } 
+        m_backgroundColour = sysbg;
+    }
     else
     {
         ApplyWidgetStyle();
@@ -2387,9 +2676,9 @@ bool wxWindow::Validate()
     {
         wxWindow *child = (wxWindow *)node->Data();
         if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
-        { 
-           return FALSE; 
-       }
+        {
+            return FALSE;
+        }
         node = node->Next();
     }
     return TRUE;
@@ -2423,9 +2712,9 @@ bool wxWindow::TransferDataFromWindow()
     {
         wxWindow *child = (wxWindow *)node->Data();
         if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
-        { 
-           return FALSE; 
-       }
+        {
+            return FALSE;
+        }
         node = node->Next();
     }
     return TRUE;
@@ -2459,31 +2748,49 @@ static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
         wxMenuItem *menuitem = (wxMenuItem*)node->Data();
         if (menuitem->IsSubMenu())
         {
-           SetInvokingWindow( menuitem->GetSubMenu(), win );
-       }
+            SetInvokingWindow( menuitem->GetSubMenu(), win );
+        }
         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 );
+
+    menu->UpdateUI();
+
+    gs_pop_x = x;
+    gs_pop_y = y;
+
     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;
 }
 
+#if wxUSE_DRAG_AND_DROP
+
 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
 {
     wxCHECK_RET( m_widget != NULL, "invalid window" );
@@ -2503,6 +2810,8 @@ wxDropTarget *wxWindow::GetDropTarget() const
     return m_dropTarget;
 }
 
+#endif
+
 GtkWidget* wxWindow::GetConnectWidget()
 {
     GtkWidget *connect_widget = m_widget;
@@ -2527,14 +2836,14 @@ void wxWindow::SetFont( const wxFont &font )
         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();
-       m_backgroundColour = sysbg;
-    } 
+        m_backgroundColour = sysbg;
+    }
     else
     {
         ApplyWidgetStyle();
@@ -2564,9 +2873,9 @@ void wxWindow::CaptureMouse()
                          (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;
 }
 
@@ -2735,7 +3044,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 (fabs(fpos-m_vAdjust->value) < 0.2) return;
         m_vAdjust->value = fpos;
     }
@@ -3142,9 +3451,9 @@ void wxWindow::SetConstraintSizes(bool recurse)
     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" );
@@ -3279,7 +3588,3 @@ void wxWindow::GetPositionConstraint(int *x, int *y) const
     GetPosition(x, y);
 }
 
-void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) )
-{
-    UpdateWindowUI();
-}