]> git.saurik.com Git - wxWidgets.git/blobdiff - src/univ/topluniv.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
use WX_DEFINE_ARRAY_INT for an array of ints (bug 1536482)
[wxWidgets.git] / src / univ / topluniv.cpp
diff --git a/src/univ/topluniv.cpp b/src/univ/topluniv.cpp
index 869a53a14abbe63cc38907b363edb1a7ec47f47a..89c2cfb0c7d8279f3945a1d54f45c32a6db3212b 100644 (file)
--- a/src/univ/topluniv.cpp
+++ b/src/univ/topluniv.cpp
@@ -1,8 +1,8 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        topluniv.cpp
+// Name:        src/univ/topluniv.cpp
 // Author:      Vaclav Slavik
 // Id:          $Id$
 // Author:      Vaclav Slavik
 // Id:          $Id$
-// Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
+// Copyright:   (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -14,31 +14,50 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 
-#ifdef __GNUG__
-    #pragma implementation "univtoplevel.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #endif
 
-#include "wx/defs.h"
+#include "wx/toplevel.h"
 
 #ifndef WX_PRECOMP
     #include "wx/dcclient.h"
     #include "wx/settings.h"
 
 #ifndef WX_PRECOMP
     #include "wx/dcclient.h"
     #include "wx/settings.h"
+    #include "wx/bitmap.h"
+    #include "wx/image.h"
+    #include "wx/frame.h"
 #endif
 
 #endif
 
-#include "wx/toplevel.h"
 #include "wx/univ/renderer.h"
 #include "wx/univ/renderer.h"
-#include "wx/bitmap.h"
-#include "wx/image.h"
 #include "wx/cshelp.h"
 #include "wx/evtloop.h"
 
 #include "wx/cshelp.h"
 #include "wx/evtloop.h"
 
+// ----------------------------------------------------------------------------
+// wxStdTLWInputHandler: handles focus, resizing and titlebar buttons clicks
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStdTLWInputHandler : public wxStdInputHandler
+{
+public:
+    wxStdTLWInputHandler(wxInputHandler *inphand);
+
+    virtual bool HandleMouse(wxInputConsumer *consumer,
+                             const wxMouseEvent& event);
+    virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event);
+    virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
+
+private:
+    // the window (button) which has capture or NULL and the last hittest result
+    wxTopLevelWindow *m_winCapture;
+    long              m_winHitTest;
+    long              m_winPressed;
+    bool              m_borderCursorOn;
+    wxCursor          m_origCursor;
+};
+
 
 // ----------------------------------------------------------------------------
 // event tables
 
 // ----------------------------------------------------------------------------
 // event tables
@@ -47,6 +66,7 @@
 BEGIN_EVENT_TABLE(wxTopLevelWindow, wxTopLevelWindowNative)
     WX_EVENT_TABLE_INPUT_CONSUMER(wxTopLevelWindow)
     EVT_NC_PAINT(wxTopLevelWindow::OnNcPaint)
 BEGIN_EVENT_TABLE(wxTopLevelWindow, wxTopLevelWindowNative)
     WX_EVENT_TABLE_INPUT_CONSUMER(wxTopLevelWindow)
     EVT_NC_PAINT(wxTopLevelWindow::OnNcPaint)
+    EVT_MENU_RANGE(wxID_CLOSE_FRAME, wxID_RESTORE_FRAME, wxTopLevelWindow::OnSystemMenu)
 END_EVENT_TABLE()
 
 WX_FORWARD_TO_INPUT_CONSUMER(wxTopLevelWindow)
 END_EVENT_TABLE()
 
 WX_FORWARD_TO_INPUT_CONSUMER(wxTopLevelWindow)
@@ -60,7 +80,16 @@ int wxTopLevelWindow::ms_canIconize = -1;
 
 void wxTopLevelWindow::Init()
 {
 
 void wxTopLevelWindow::Init()
 {
-    m_isActive = FALSE;
+    // once-only ms_drawDecorations initialization
+    if ( ms_drawDecorations == -1 )
+    {
+        ms_drawDecorations =
+            !wxSystemSettings::HasFeature(wxSYS_CAN_DRAW_FRAME_DECORATIONS) ||
+            wxGetEnv(wxT("WXDECOR"), NULL);
+    }
+
+    m_usingNativeDecorations = ms_drawDecorations == 0;
+    m_isActive = false;
     m_windowStyle = 0;
     m_pressedButton = 0;
 }
     m_windowStyle = 0;
     m_pressedButton = 0;
 }
@@ -77,21 +106,7 @@ bool wxTopLevelWindow::Create(wxWindow *parent,
     long styleOrig = 0,
          exstyleOrig = 0;
 
     long styleOrig = 0,
          exstyleOrig = 0;
 
-    if ( ms_drawDecorations == -1 )
-    {
-        ms_drawDecorations = 
-            !wxSystemSettings::HasFeature(wxSYS_CAN_DRAW_FRAME_DECORATIONS) 
-            || wxGetEnv(wxT("WXDECOR"), NULL);
-        // FIXME -- wxUniv should provide a way to force non-native decorations!
-        //          $WXDECOR is just a hack in absence of better wxUniv solution
-    }
-
-    if ( ms_canIconize == -1 )
-    {
-        ms_canIconize = wxSystemSettings::HasFeature(wxSYS_CAN_ICONIZE_FRAME);
-    }
-
-    if ( ms_drawDecorations )
+    if ( !m_usingNativeDecorations )
     {
         CreateInputHandler(wxINP_HANDLER_TOPLEVEL);
 
     {
         CreateInputHandler(wxINP_HANDLER_TOPLEVEL);
 
@@ -99,30 +114,29 @@ bool wxTopLevelWindow::Create(wxWindow *parent,
         exstyleOrig = GetExtraStyle();
         style &= ~(wxCAPTION | wxMINIMIZE_BOX | wxMAXIMIZE_BOX |
                    wxSYSTEM_MENU | wxRESIZE_BORDER | wxFRAME_TOOL_WINDOW |
         exstyleOrig = GetExtraStyle();
         style &= ~(wxCAPTION | wxMINIMIZE_BOX | wxMAXIMIZE_BOX |
                    wxSYSTEM_MENU | wxRESIZE_BORDER | wxFRAME_TOOL_WINDOW |
-                   wxTHICK_FRAME);
-        style = wxSIMPLE_BORDER;
-        SetExtraStyle(exstyleOrig &
-                      ~(wxFRAME_EX_CONTEXTHELP | wxDIALOG_EX_CONTEXTHELP));
+                   wxRESIZE_BORDER);
+        style |= wxBORDER_NONE;
+        SetExtraStyle(exstyleOrig & ~wxWS_EX_CONTEXTHELP);
     }
 
     if ( !wxTopLevelWindowNative::Create(parent, id, title, pos,
                                          size, style, name) )
     }
 
     if ( !wxTopLevelWindowNative::Create(parent, id, title, pos,
                                          size, style, name) )
-        return FALSE;
+        return false;
 
 
-    if ( ms_drawDecorations )
+    if ( !m_usingNativeDecorations )
     {
         m_windowStyle = styleOrig;
         m_exStyle = exstyleOrig;
     }
 
     {
         m_windowStyle = styleOrig;
         m_exStyle = exstyleOrig;
     }
 
-    return TRUE;
+    return true;
 }
 
 bool wxTopLevelWindow::ShowFullScreen(bool show, long style)
 {
 }
 
 bool wxTopLevelWindow::ShowFullScreen(bool show, long style)
 {
-    if ( show == IsFullScreen() ) return FALSE;
+    if ( show == IsFullScreen() ) return false;
 
 
-    if ( ms_drawDecorations )
+    if ( !m_usingNativeDecorations )
     {
         if ( show )
         {
     {
         if ( show )
         {
@@ -141,12 +155,35 @@ bool wxTopLevelWindow::ShowFullScreen(bool show, long style)
     return wxTopLevelWindowNative::ShowFullScreen(show, style);
 }
 
     return wxTopLevelWindowNative::ShowFullScreen(show, style);
 }
 
+/* static */
+void wxTopLevelWindow::UseNativeDecorationsByDefault(bool native)
+{
+    ms_drawDecorations = !native;
+}
+
+void wxTopLevelWindow::UseNativeDecorations(bool native)
+{
+    wxASSERT_MSG( !m_windowStyle, _T("must be called before Create()") );
+
+    m_usingNativeDecorations = native;
+}
+
+bool wxTopLevelWindow::IsUsingNativeDecorations() const
+{
+    return m_usingNativeDecorations;
+}
+
 long wxTopLevelWindow::GetDecorationsStyle() const
 {
     long style = 0;
 
     if ( m_windowStyle & wxCAPTION )
     {
 long wxTopLevelWindow::GetDecorationsStyle() const
 {
     long style = 0;
 
     if ( m_windowStyle & wxCAPTION )
     {
+        if ( ms_canIconize == -1 )
+        {
+            ms_canIconize = wxSystemSettings::HasFeature(wxSYS_CAN_ICONIZE_FRAME);
+        }
+
         style |= wxTOPLEVEL_TITLEBAR | wxTOPLEVEL_BUTTON_CLOSE;
         if ( (m_windowStyle & wxMINIMIZE_BOX) && ms_canIconize )
             style |= wxTOPLEVEL_BUTTON_ICONIZE;
         style |= wxTOPLEVEL_TITLEBAR | wxTOPLEVEL_BUTTON_CLOSE;
         if ( (m_windowStyle & wxMINIMIZE_BOX) && ms_canIconize )
             style |= wxTOPLEVEL_BUTTON_ICONIZE;
@@ -158,13 +195,13 @@ long wxTopLevelWindow::GetDecorationsStyle() const
                 style |= wxTOPLEVEL_BUTTON_MAXIMIZE;
         }
 #if wxUSE_HELP
                 style |= wxTOPLEVEL_BUTTON_MAXIMIZE;
         }
 #if wxUSE_HELP
-        if ( m_exStyle & (wxFRAME_EX_CONTEXTHELP | wxDIALOG_EX_CONTEXTHELP))
+        if ( m_exStyle & wxWS_EX_CONTEXTHELP)
             style |= wxTOPLEVEL_BUTTON_HELP;
 #endif
     }
     if ( (m_windowStyle & (wxSIMPLE_BORDER | wxNO_BORDER)) == 0 )
         style |= wxTOPLEVEL_BORDER;
             style |= wxTOPLEVEL_BUTTON_HELP;
 #endif
     }
     if ( (m_windowStyle & (wxSIMPLE_BORDER | wxNO_BORDER)) == 0 )
         style |= wxTOPLEVEL_BORDER;
-    if ( m_windowStyle & (wxRESIZE_BORDER | wxTHICK_FRAME) )
+    if ( m_windowStyle & (wxRESIZE_BORDER | wxRESIZE_BORDER) )
         style |= wxTOPLEVEL_RESIZEABLE;
 
     if ( IsMaximized() )
         style |= wxTOPLEVEL_RESIZEABLE;
 
     if ( IsMaximized() )
@@ -190,7 +227,7 @@ void wxTopLevelWindow::RefreshTitleBar()
 
 wxPoint wxTopLevelWindow::GetClientAreaOrigin() const
 {
 
 wxPoint wxTopLevelWindow::GetClientAreaOrigin() const
 {
-    if ( ms_drawDecorations )
+    if ( !m_usingNativeDecorations )
     {
         int w, h;
         wxTopLevelWindowNative::DoGetClientSize(&w, &h);
     {
         int w, h;
         wxTopLevelWindowNative::DoGetClientSize(&w, &h);
@@ -208,7 +245,7 @@ wxPoint wxTopLevelWindow::GetClientAreaOrigin() const
 
 void wxTopLevelWindow::DoGetClientSize(int *width, int *height) const
 {
 
 void wxTopLevelWindow::DoGetClientSize(int *width, int *height) const
 {
-    if ( ms_drawDecorations )
+    if ( !m_usingNativeDecorations )
     {
         int w, h;
         wxTopLevelWindowNative::DoGetClientSize(&w, &h);
     {
         int w, h;
         wxTopLevelWindowNative::DoGetClientSize(&w, &h);
@@ -227,7 +264,7 @@ void wxTopLevelWindow::DoGetClientSize(int *width, int *height) const
 
 void wxTopLevelWindow::DoSetClientSize(int width, int height)
 {
 
 void wxTopLevelWindow::DoSetClientSize(int width, int height)
 {
-    if ( ms_drawDecorations )
+    if ( !m_usingNativeDecorations )
     {
         wxSize size = m_renderer->GetFrameTotalSize(wxSize(width, height),
                                                GetDecorationsStyle());
     {
         wxSize size = m_renderer->GetFrameTotalSize(wxSize(width, height),
                                                GetDecorationsStyle());
@@ -237,19 +274,16 @@ void wxTopLevelWindow::DoSetClientSize(int width, int height)
         wxTopLevelWindowNative::DoSetClientSize(width, height);
 }
 
         wxTopLevelWindowNative::DoSetClientSize(width, height);
 }
 
-void wxTopLevelWindow::OnNcPaint(wxPaintEvent& event)
+void wxTopLevelWindow::OnNcPaint(wxNcPaintEvent& event)
 {
 {
-    if ( !ms_drawDecorations || !m_renderer )
+    if ( m_usingNativeDecorations || !m_renderer )
+    {
         event.Skip();
         event.Skip();
-    else
+    }
+    else // we're drawing the decorations ourselves
     {
         // get the window rect
     {
         // get the window rect
-        wxRect rect;
-        wxSize size = GetSize();
-        rect.x =
-        rect.y = 0;
-        rect.width = size.x;
-        rect.height = size.y;
+        wxRect rect(GetSize());
 
         wxWindowDC dc(this);
         m_renderer->DrawFrameTitleBar(dc, rect,
 
         wxWindowDC dc(this);
         m_renderer->DrawFrameTitleBar(dc, rect,
@@ -271,7 +305,7 @@ long wxTopLevelWindow::HitTest(const wxPoint& pt) const
 
 int wxTopLevelWindow::GetMinWidth() const
 {
 
 int wxTopLevelWindow::GetMinWidth() const
 {
-    if ( ms_drawDecorations )
+    if ( !m_usingNativeDecorations )
     {
         return wxMax(wxTopLevelWindowNative::GetMinWidth(),
                      m_renderer->GetFrameMinSize(GetDecorationsStyle()).x);
     {
         return wxMax(wxTopLevelWindowNative::GetMinWidth(),
                      m_renderer->GetFrameMinSize(GetDecorationsStyle()).x);
@@ -282,7 +316,7 @@ int wxTopLevelWindow::GetMinWidth() const
 
 int wxTopLevelWindow::GetMinHeight() const
 {
 
 int wxTopLevelWindow::GetMinHeight() const
 {
-    if ( ms_drawDecorations )
+    if ( !m_usingNativeDecorations )
     {
         return wxMax(wxTopLevelWindowNative::GetMinHeight(),
                      m_renderer->GetFrameMinSize(GetDecorationsStyle()).y);
     {
         return wxMax(wxTopLevelWindowNative::GetMinHeight(),
                      m_renderer->GetFrameMinSize(GetDecorationsStyle()).y);
@@ -295,15 +329,16 @@ int wxTopLevelWindow::GetMinHeight() const
 // icons
 // ----------------------------------------------------------------------------
 
 // icons
 // ----------------------------------------------------------------------------
 
-void wxTopLevelWindow::SetIcon(const wxIcon& icon)
+void wxTopLevelWindow::SetIcons(const wxIconBundle& icons)
 {
 {
-    wxTopLevelWindowNative::SetIcon(icon);
+    wxTopLevelWindowNative::SetIcons(icons);
 
 
-    if ( ms_drawDecorations && m_renderer )
+    if ( !m_usingNativeDecorations && m_renderer )
     {
         wxSize size = m_renderer->GetFrameIconSize();
     {
         wxSize size = m_renderer->GetFrameIconSize();
+        const wxIcon& icon = icons.GetIcon( size );
 
 
-        if ( !icon.Ok() || size.x == -1  )
+        if ( !icon.Ok() || size.x == wxDefaultCoord  )
             m_titlebarIcon = icon;
         else
         {
             m_titlebarIcon = icon;
         else
         {
@@ -313,12 +348,14 @@ void wxTopLevelWindow::SetIcon(const wxIcon& icon)
                 m_titlebarIcon = wxNullIcon;
             else if ( bmp1.GetWidth() == size.x && bmp1.GetHeight() == size.y )
                 m_titlebarIcon = icon;
                 m_titlebarIcon = wxNullIcon;
             else if ( bmp1.GetWidth() == size.x && bmp1.GetHeight() == size.y )
                 m_titlebarIcon = icon;
+#if wxUSE_IMAGE
             else
             {
                 wxImage img = bmp1.ConvertToImage();
                 img.Rescale(size.x, size.y);
                 m_titlebarIcon.CopyFromBitmap(wxBitmap(img));
             }
             else
             {
                 wxImage img = bmp1.ConvertToImage();
                 img.Rescale(size.x, size.y);
                 m_titlebarIcon.CopyFromBitmap(wxBitmap(img));
             }
+#endif // wxUSE_IMAGE
         }
     }
 }
         }
     }
 }
@@ -327,26 +364,59 @@ void wxTopLevelWindow::SetIcon(const wxIcon& icon)
 // interactive manipulation
 // ----------------------------------------------------------------------------
 
 // interactive manipulation
 // ----------------------------------------------------------------------------
 
+
+static bool wxGetResizingCursor(long hitTestResult, wxCursor& cursor)
+{
+    if ( hitTestResult & wxHT_TOPLEVEL_ANY_BORDER )
+    {
+        switch (hitTestResult)
+        {
+            case wxHT_TOPLEVEL_BORDER_N:
+            case wxHT_TOPLEVEL_BORDER_S:
+                cursor = wxCursor(wxCURSOR_SIZENS);
+                break;
+            case wxHT_TOPLEVEL_BORDER_W:
+            case wxHT_TOPLEVEL_BORDER_E:
+                cursor = wxCursor(wxCURSOR_SIZEWE);
+                break;
+            case wxHT_TOPLEVEL_BORDER_NE:
+            case wxHT_TOPLEVEL_BORDER_SW:
+                cursor = wxCursor(wxCURSOR_SIZENESW);
+                break;
+            case wxHT_TOPLEVEL_BORDER_NW:
+            case wxHT_TOPLEVEL_BORDER_SE:
+                cursor = wxCursor(wxCURSOR_SIZENWSE);
+                break;
+            default:
+                return false;
+        }
+        return true;
+    }
+
+    return false;
+}
+
 #define wxINTERACTIVE_RESIZE_DIR \
           (wxINTERACTIVE_RESIZE_W | wxINTERACTIVE_RESIZE_E | \
            wxINTERACTIVE_RESIZE_S | wxINTERACTIVE_RESIZE_N)
 
 struct wxInteractiveMoveData
 {
 #define wxINTERACTIVE_RESIZE_DIR \
           (wxINTERACTIVE_RESIZE_W | wxINTERACTIVE_RESIZE_E | \
            wxINTERACTIVE_RESIZE_S | wxINTERACTIVE_RESIZE_N)
 
 struct wxInteractiveMoveData
 {
-    wxTopLevelWindowBase *m_window;
+    wxTopLevelWindow     *m_window;
     wxEventLoop          *m_evtLoop;
     int                   m_flags;
     wxRect                m_rect;
     wxRect                m_rectOrig;
     wxPoint               m_pos;
     wxSize                m_minSize, m_maxSize;
     wxEventLoop          *m_evtLoop;
     int                   m_flags;
     wxRect                m_rect;
     wxRect                m_rectOrig;
     wxPoint               m_pos;
     wxSize                m_minSize, m_maxSize;
+    bool                  m_sizingCursor;
 };
 
 class wxInteractiveMoveHandler : public wxEvtHandler
 {
 public:
     wxInteractiveMoveHandler(wxInteractiveMoveData& data) : m_data(data) {}
 };
 
 class wxInteractiveMoveHandler : public wxEvtHandler
 {
 public:
     wxInteractiveMoveHandler(wxInteractiveMoveData& data) : m_data(data) {}
-    
+
 private:
     DECLARE_EVENT_TABLE()
     void OnMouseMove(wxMouseEvent& event);
 private:
     DECLARE_EVENT_TABLE()
     void OnMouseMove(wxMouseEvent& event);
@@ -365,7 +435,7 @@ BEGIN_EVENT_TABLE(wxInteractiveMoveHandler, wxEvtHandler)
 END_EVENT_TABLE()
 
 
 END_EVENT_TABLE()
 
 
-static inline LINKAGEMODE 
+static inline LINKAGEMODE
 void wxApplyResize(wxInteractiveMoveData& data, const wxPoint& diff)
 {
     if ( data.m_flags & wxINTERACTIVE_RESIZE_W )
 void wxApplyResize(wxInteractiveMoveData& data, const wxPoint& diff)
 {
     if ( data.m_flags & wxINTERACTIVE_RESIZE_W )
@@ -386,26 +456,26 @@ void wxApplyResize(wxInteractiveMoveData& data, const wxPoint& diff)
     {
         data.m_rect.height += diff.y;
     }
     {
         data.m_rect.height += diff.y;
     }
-    
-    if ( data.m_minSize.x != -1 && data.m_rect.width < data.m_minSize.x )
+
+    if ( data.m_minSize.x != wxDefaultCoord && data.m_rect.width < data.m_minSize.x )
     {
         if ( data.m_flags & wxINTERACTIVE_RESIZE_W )
             data.m_rect.x -= data.m_minSize.x - data.m_rect.width;
         data.m_rect.width = data.m_minSize.x;
     }
     {
         if ( data.m_flags & wxINTERACTIVE_RESIZE_W )
             data.m_rect.x -= data.m_minSize.x - data.m_rect.width;
         data.m_rect.width = data.m_minSize.x;
     }
-    if ( data.m_maxSize.x != -1 && data.m_rect.width > data.m_maxSize.x )
+    if ( data.m_maxSize.x != wxDefaultCoord && data.m_rect.width > data.m_maxSize.x )
     {
         if ( data.m_flags & wxINTERACTIVE_RESIZE_W )
             data.m_rect.x -= data.m_minSize.x - data.m_rect.width;
         data.m_rect.width = data.m_maxSize.x;
     }
     {
         if ( data.m_flags & wxINTERACTIVE_RESIZE_W )
             data.m_rect.x -= data.m_minSize.x - data.m_rect.width;
         data.m_rect.width = data.m_maxSize.x;
     }
-    if ( data.m_minSize.y != -1 && data.m_rect.height < data.m_minSize.y )
+    if ( data.m_minSize.y != wxDefaultCoord && data.m_rect.height < data.m_minSize.y )
     {
         if ( data.m_flags & wxINTERACTIVE_RESIZE_N )
             data.m_rect.y -= data.m_minSize.y - data.m_rect.height;
         data.m_rect.height = data.m_minSize.y;
     }
     {
         if ( data.m_flags & wxINTERACTIVE_RESIZE_N )
             data.m_rect.y -= data.m_minSize.y - data.m_rect.height;
         data.m_rect.height = data.m_minSize.y;
     }
-    if ( data.m_maxSize.y != -1 && data.m_rect.height > data.m_maxSize.y )
+    if ( data.m_maxSize.y != wxDefaultCoord && data.m_rect.height > data.m_maxSize.y )
     {
         if ( data.m_flags & wxINTERACTIVE_RESIZE_N )
             data.m_rect.y -= data.m_minSize.y - data.m_rect.height;
     {
         if ( data.m_flags & wxINTERACTIVE_RESIZE_N )
             data.m_rect.y -= data.m_minSize.y - data.m_rect.height;
@@ -435,25 +505,18 @@ void wxInteractiveMoveHandler::OnMouseMove(wxMouseEvent& event)
     }
 }
 
     }
 }
 
-void wxInteractiveMoveHandler::OnMouseDown(wxMouseEvent& event)
+void wxInteractiveMoveHandler::OnMouseDown(wxMouseEvent& WXUNUSED(event))
 {
     if ( m_data.m_flags & wxINTERACTIVE_WAIT_FOR_INPUT )
     {
 {
     if ( m_data.m_flags & wxINTERACTIVE_WAIT_FOR_INPUT )
     {
-        m_data.m_flags &= ~wxINTERACTIVE_WAIT_FOR_INPUT;
-        m_data.m_pos = wxGetMousePosition();
+        m_data.m_evtLoop->Exit();
     }
 }
 
 void wxInteractiveMoveHandler::OnKeyDown(wxKeyEvent& event)
 {
     }
 }
 
 void wxInteractiveMoveHandler::OnKeyDown(wxKeyEvent& event)
 {
-    if ( m_data.m_flags & wxINTERACTIVE_WAIT_FOR_INPUT )
-    {
-        m_data.m_flags &= ~wxINTERACTIVE_WAIT_FOR_INPUT;
-        m_data.m_pos = wxGetMousePosition();
-    }
-    
-    wxPoint diff(-1,-1);
-    
+    wxPoint diff(wxDefaultCoord,wxDefaultCoord);
+
     switch ( event.GetKeyCode() )
     {
         case WXK_UP:    diff = wxPoint(0, -16); break;
     switch ( event.GetKeyCode() )
     {
         case WXK_UP:    diff = wxPoint(0, -16); break;
@@ -468,35 +531,108 @@ void wxInteractiveMoveHandler::OnKeyDown(wxKeyEvent& event)
             m_data.m_evtLoop->Exit();
             return;
     }
             m_data.m_evtLoop->Exit();
             return;
     }
-    
-    if ( diff.x != -1 )
+
+    if ( diff.x != wxDefaultCoord )
     {
     {
+        if ( m_data.m_flags & wxINTERACTIVE_WAIT_FOR_INPUT )
+        {
+            m_data.m_flags &= ~wxINTERACTIVE_WAIT_FOR_INPUT;
+            if ( m_data.m_sizingCursor )
+            {
+                wxEndBusyCursor();
+                m_data.m_sizingCursor = false;
+            }
+
+            if ( m_data.m_flags & wxINTERACTIVE_MOVE )
+            {
+                m_data.m_pos = m_data.m_window->GetPosition() +
+                               wxPoint(m_data.m_window->GetSize().x/2, 8);
+            }
+        }
+
+        wxPoint warp;
+        bool changeCur = false;
+
         if ( m_data.m_flags & wxINTERACTIVE_MOVE )
         {
             m_data.m_rect.Offset(diff);
             m_data.m_window->Move(m_data.m_rect.GetPosition());
         if ( m_data.m_flags & wxINTERACTIVE_MOVE )
         {
             m_data.m_rect.Offset(diff);
             m_data.m_window->Move(m_data.m_rect.GetPosition());
+            warp = wxPoint(m_data.m_window->GetSize().x/2, 8);
         }
         else /* wxINTERACTIVE_RESIZE */
         {
         }
         else /* wxINTERACTIVE_RESIZE */
         {
-            if ( !(m_data.m_flags & wxINTERACTIVE_RESIZE_DIR) )
+            if ( !(m_data.m_flags &
+                  (wxINTERACTIVE_RESIZE_N | wxINTERACTIVE_RESIZE_S)) )
             {
                 if ( diff.y < 0 )
             {
                 if ( diff.y < 0 )
+                {
                     m_data.m_flags |= wxINTERACTIVE_RESIZE_N;
                     m_data.m_flags |= wxINTERACTIVE_RESIZE_N;
+                    m_data.m_pos.y = m_data.m_window->GetPosition().y;
+                    changeCur = true;
+                }
                 else if ( diff.y > 0 )
                 else if ( diff.y > 0 )
+                {
                     m_data.m_flags |= wxINTERACTIVE_RESIZE_S;
                     m_data.m_flags |= wxINTERACTIVE_RESIZE_S;
+                    m_data.m_pos.y = m_data.m_window->GetPosition().y +
+                                     m_data.m_window->GetSize().y;
+                    changeCur = true;
+                }
+            }
+            if ( !(m_data.m_flags &
+                  (wxINTERACTIVE_RESIZE_W | wxINTERACTIVE_RESIZE_E)) )
+            {
                 if ( diff.x < 0 )
                 if ( diff.x < 0 )
+                {
                     m_data.m_flags |= wxINTERACTIVE_RESIZE_W;
                     m_data.m_flags |= wxINTERACTIVE_RESIZE_W;
+                    m_data.m_pos.x = m_data.m_window->GetPosition().x;
+                    changeCur = true;
+                }
                 else if ( diff.x > 0 )
                 else if ( diff.x > 0 )
+                {
                     m_data.m_flags |= wxINTERACTIVE_RESIZE_E;
                     m_data.m_flags |= wxINTERACTIVE_RESIZE_E;
+                    m_data.m_pos.x = m_data.m_window->GetPosition().x +
+                                     m_data.m_window->GetSize().x;
+                    changeCur = true;
+                }
             }
 
             wxApplyResize(m_data, diff);
             m_data.m_window->SetSize(m_data.m_rect);
             }
 
             wxApplyResize(m_data, diff);
             m_data.m_window->SetSize(m_data.m_rect);
+
+            if ( m_data.m_flags & wxINTERACTIVE_RESIZE_W )
+                warp.x = 0;
+            else if ( m_data.m_flags & wxINTERACTIVE_RESIZE_E )
+                warp.x = m_data.m_window->GetSize().x-1;
+            else
+                warp.x = wxGetMousePosition().x - m_data.m_window->GetPosition().x;
+
+            if ( m_data.m_flags & wxINTERACTIVE_RESIZE_N )
+                warp.y = 0;
+            else if ( m_data.m_flags & wxINTERACTIVE_RESIZE_S )
+                warp.y = m_data.m_window->GetSize().y-1;
+            else
+                warp.y = wxGetMousePosition().y - m_data.m_window->GetPosition().y;
+        }
+
+        warp -= m_data.m_window->GetClientAreaOrigin();
+        m_data.m_window->WarpPointer(warp.x, warp.y);
+
+        if ( changeCur )
+        {
+            long hit = m_data.m_window->HitTest(warp);
+            wxCursor cur;
+            if ( wxGetResizingCursor(hit, cur) )
+            {
+                if ( m_data.m_sizingCursor )
+                    wxEndBusyCursor();
+                wxBeginBusyCursor(&cur);
+                m_data.m_sizingCursor = true;
+            }
         }
     }
 }
 
         }
     }
 }
 
-void wxInteractiveMoveHandler::OnMouseUp(wxMouseEvent& event)
+void wxInteractiveMoveHandler::OnMouseUp(wxMouseEvent& WXUNUSED(event))
 {
     m_data.m_evtLoop->Exit();
 }
 {
     m_data.m_evtLoop->Exit();
 }
@@ -507,16 +643,26 @@ void wxTopLevelWindow::InteractiveMove(int flags)
     wxASSERT_MSG( !((flags & wxINTERACTIVE_MOVE) && (flags & wxINTERACTIVE_RESIZE)),
                   wxT("can't move and resize window at the same time") );
 
     wxASSERT_MSG( !((flags & wxINTERACTIVE_MOVE) && (flags & wxINTERACTIVE_RESIZE)),
                   wxT("can't move and resize window at the same time") );
 
-    wxASSERT_MSG( !(flags & wxINTERACTIVE_RESIZE) || 
-                  (flags & wxINTERACTIVE_WAIT_FOR_INPUT) || 
+    wxASSERT_MSG( !(flags & wxINTERACTIVE_RESIZE) ||
+                  (flags & wxINTERACTIVE_WAIT_FOR_INPUT) ||
                   (flags & wxINTERACTIVE_RESIZE_DIR),
                   wxT("direction of resizing not specified") );
 
     wxInteractiveMoveData data;
     wxEventLoop loop;
                   (flags & wxINTERACTIVE_RESIZE_DIR),
                   wxT("direction of resizing not specified") );
 
     wxInteractiveMoveData data;
     wxEventLoop loop;
-    wxWindow *focus = FindFocus();
-    
-    // FIXME - display resize cursor if waiting for initial input
+
+    SetFocus();
+
+#ifndef __WXGTK__
+    if ( flags & wxINTERACTIVE_WAIT_FOR_INPUT )
+    {
+        wxCursor sizingCursor(wxCURSOR_SIZING);
+        wxBeginBusyCursor(&sizingCursor);
+        data.m_sizingCursor = true;
+    }
+    else
+#endif
+        data.m_sizingCursor = false;
 
     data.m_window = this;
     data.m_evtLoop = &loop;
 
     data.m_window = this;
     data.m_evtLoop = &loop;
@@ -526,17 +672,18 @@ void wxTopLevelWindow::InteractiveMove(int flags)
     data.m_minSize = wxSize(GetMinWidth(), GetMinHeight());
     data.m_maxSize = wxSize(GetMaxWidth(), GetMaxHeight());
 
     data.m_minSize = wxSize(GetMinWidth(), GetMinHeight());
     data.m_maxSize = wxSize(GetMaxWidth(), GetMaxHeight());
 
-    this->PushEventHandler(new wxInteractiveMoveHandler(data));
-    if ( focus )
-        focus->PushEventHandler(new wxInteractiveMoveHandler(data));
+    wxEvtHandler *handler = new wxInteractiveMoveHandler(data);
+    this->PushEventHandler(handler);
 
     CaptureMouse();
     loop.Run();
     ReleaseMouse();
 
 
     CaptureMouse();
     loop.Run();
     ReleaseMouse();
 
-    this->PopEventHandler(TRUE/*delete*/);
-    if ( focus )
-        focus->PopEventHandler(TRUE/*delete*/);
+    this->RemoveEventHandler(handler);
+    delete handler;
+
+    if ( data.m_sizingCursor )
+        wxEndBusyCursor();
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -578,7 +725,7 @@ void wxTopLevelWindow::ClickTitleBarButton(long button)
 
 bool wxTopLevelWindow::PerformAction(const wxControlAction& action,
                                      long numArg,
 
 bool wxTopLevelWindow::PerformAction(const wxControlAction& action,
                                      long numArg,
-                                     const wxString& strArg)
+                                     const wxString& WXUNUSED(strArg))
 {
     bool isActive = numArg != 0;
 
 {
     bool isActive = numArg != 0;
 
@@ -589,21 +736,21 @@ bool wxTopLevelWindow::PerformAction(const wxControlAction& action,
             m_isActive = isActive;
             RefreshTitleBar();
         }
             m_isActive = isActive;
             RefreshTitleBar();
         }
-        return TRUE;
+        return true;
     }
 
     else if ( action == wxACTION_TOPLEVEL_BUTTON_PRESS )
     {
         m_pressedButton = numArg;
         RefreshTitleBar();
     }
 
     else if ( action == wxACTION_TOPLEVEL_BUTTON_PRESS )
     {
         m_pressedButton = numArg;
         RefreshTitleBar();
-        return TRUE;
+        return true;
     }
 
     else if ( action == wxACTION_TOPLEVEL_BUTTON_RELEASE )
     {
         m_pressedButton = 0;
         RefreshTitleBar();
     }
 
     else if ( action == wxACTION_TOPLEVEL_BUTTON_RELEASE )
     {
         m_pressedButton = 0;
         RefreshTitleBar();
-        return TRUE;
+        return true;
     }
 
     else if ( action == wxACTION_TOPLEVEL_BUTTON_CLICK )
     }
 
     else if ( action == wxACTION_TOPLEVEL_BUTTON_CLICK )
@@ -611,13 +758,13 @@ bool wxTopLevelWindow::PerformAction(const wxControlAction& action,
         m_pressedButton = 0;
         RefreshTitleBar();
         ClickTitleBarButton(numArg);
         m_pressedButton = 0;
         RefreshTitleBar();
         ClickTitleBarButton(numArg);
-        return TRUE;
+        return true;
     }
 
     else if ( action == wxACTION_TOPLEVEL_MOVE )
     {
         InteractiveMove(wxINTERACTIVE_MOVE);
     }
 
     else if ( action == wxACTION_TOPLEVEL_MOVE )
     {
         InteractiveMove(wxINTERACTIVE_MOVE);
-        return TRUE;
+        return true;
     }
 
     else if ( action == wxACTION_TOPLEVEL_RESIZE )
     }
 
     else if ( action == wxACTION_TOPLEVEL_RESIZE )
@@ -632,29 +779,74 @@ bool wxTopLevelWindow::PerformAction(const wxControlAction& action,
         if ( numArg & wxHT_TOPLEVEL_BORDER_E )
             flags |= wxINTERACTIVE_RESIZE_E;
         InteractiveMove(flags);
         if ( numArg & wxHT_TOPLEVEL_BORDER_E )
             flags |= wxINTERACTIVE_RESIZE_E;
         InteractiveMove(flags);
-        return TRUE;
+        return true;
     }
 
     else
     }
 
     else
-        return FALSE;
+        return false;
+}
+
+void wxTopLevelWindow::OnSystemMenu(wxCommandEvent& event)
+{
+    bool ret = true;
+
+    switch (event.GetId())
+    {
+        case wxID_CLOSE_FRAME:
+            ret = PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
+                                wxTOPLEVEL_BUTTON_CLOSE);
+            break;
+        case wxID_MOVE_FRAME:
+            InteractiveMove(wxINTERACTIVE_MOVE | wxINTERACTIVE_WAIT_FOR_INPUT);
+            break;
+        case wxID_RESIZE_FRAME:
+            InteractiveMove(wxINTERACTIVE_RESIZE | wxINTERACTIVE_WAIT_FOR_INPUT);
+            break;
+        case wxID_MAXIMIZE_FRAME:
+            ret = PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
+                                wxTOPLEVEL_BUTTON_MAXIMIZE);
+            break;
+        case wxID_ICONIZE_FRAME:
+            ret = PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
+                                wxTOPLEVEL_BUTTON_ICONIZE);
+            break;
+        case wxID_RESTORE_FRAME:
+            ret = PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
+                                wxTOPLEVEL_BUTTON_RESTORE);
+            break;
+
+        default:
+            ret = false;
+    }
+
+    if ( !ret )
+        event.Skip();
 }
 
 }
 
+/* static */
+wxInputHandler *
+wxTopLevelWindow::GetStdInputHandler(wxInputHandler *handlerDef)
+{
+    static wxStdTLWInputHandler s_handler(handlerDef);
+
+    return &s_handler;
+}
 
 // ============================================================================
 
 // ============================================================================
-// wxStdFrameInputHandler: handles focus, resizing and titlebar buttons clicks
+// wxStdTLWInputHandler: handles focus, resizing and titlebar buttons clicks
 // ============================================================================
 
 // ============================================================================
 
-wxStdFrameInputHandler::wxStdFrameInputHandler(wxInputHandler *inphand)
-            : wxStdInputHandler(inphand)
+wxStdTLWInputHandler::wxStdTLWInputHandler(wxInputHandler *inphand)
+                    : wxStdInputHandler(inphand)
 {
     m_winCapture = NULL;
     m_winHitTest = 0;
     m_winPressed = 0;
 {
     m_winCapture = NULL;
     m_winHitTest = 0;
     m_winPressed = 0;
-    m_borderCursorOn = FALSE;
+    m_borderCursorOn = false;
 }
 
 }
 
-bool wxStdFrameInputHandler::HandleMouse(wxInputConsumer *consumer,
-                                         const wxMouseEvent& event)
+bool wxStdTLWInputHandler::HandleMouse(wxInputConsumer *consumer,
+                                       const wxMouseEvent& event)
 {
     // the button has 2 states: pressed and normal with the following
     // transitions between them:
 {
     // the button has 2 states: pressed and normal with the following
     // transitions between them:
@@ -678,18 +870,18 @@ bool wxStdFrameInputHandler::HandleMouse(wxInputConsumer *consumer,
                 m_winHitTest = hit;
                 m_winPressed = hit;
                 consumer->PerformAction(wxACTION_TOPLEVEL_BUTTON_PRESS, m_winPressed);
                 m_winHitTest = hit;
                 m_winPressed = hit;
                 consumer->PerformAction(wxACTION_TOPLEVEL_BUTTON_PRESS, m_winPressed);
-                return TRUE;
+                return true;
             }
             }
-            else if ( hit & wxHT_TOPLEVEL_TITLEBAR )
+            else if ( (hit & wxHT_TOPLEVEL_TITLEBAR) && !w->IsMaximized() )
             {
                 consumer->PerformAction(wxACTION_TOPLEVEL_MOVE);
             {
                 consumer->PerformAction(wxACTION_TOPLEVEL_MOVE);
-                return TRUE;
+                return true;
             }
             else if ( (consumer->GetInputWindow()->GetWindowStyle() & wxRESIZE_BORDER)
                       && (hit & wxHT_TOPLEVEL_ANY_BORDER) )
             {
                 consumer->PerformAction(wxACTION_TOPLEVEL_RESIZE, hit);
             }
             else if ( (consumer->GetInputWindow()->GetWindowStyle() & wxRESIZE_BORDER)
                       && (hit & wxHT_TOPLEVEL_ANY_BORDER) )
             {
                 consumer->PerformAction(wxACTION_TOPLEVEL_RESIZE, hit);
-                return TRUE;
+                return true;
             }
         }
 
             }
         }
 
@@ -703,7 +895,7 @@ bool wxStdFrameInputHandler::HandleMouse(wxInputConsumer *consumer,
                 if ( m_winHitTest == m_winPressed )
                 {
                     consumer->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK, m_winPressed);
                 if ( m_winHitTest == m_winPressed )
                 {
                     consumer->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK, m_winPressed);
-                    return TRUE;
+                    return true;
                 }
             }
             //else: the mouse was released outside the window, this doesn't
                 }
             }
             //else: the mouse was released outside the window, this doesn't
@@ -714,8 +906,8 @@ bool wxStdFrameInputHandler::HandleMouse(wxInputConsumer *consumer,
     return wxStdInputHandler::HandleMouse(consumer, event);
 }
 
     return wxStdInputHandler::HandleMouse(consumer, event);
 }
 
-bool wxStdFrameInputHandler::HandleMouseMove(wxInputConsumer *consumer,
-                                             const wxMouseEvent& event)
+bool wxStdTLWInputHandler::HandleMouseMove(wxInputConsumer *consumer,
+                                           const wxMouseEvent& event)
 {
     if ( event.GetEventObject() == m_winCapture )
     {
 {
     if ( event.GetEventObject() == m_winCapture )
     {
@@ -729,7 +921,7 @@ bool wxStdFrameInputHandler::HandleMouseMove(wxInputConsumer *consumer,
                 consumer->PerformAction(wxACTION_TOPLEVEL_BUTTON_PRESS, m_winPressed);
 
             m_winHitTest = hit;
                 consumer->PerformAction(wxACTION_TOPLEVEL_BUTTON_PRESS, m_winPressed);
 
             m_winHitTest = hit;
-            return TRUE;
+            return true;
         }
     }
     else if ( consumer->GetInputWindow()->GetWindowStyle() & wxRESIZE_BORDER )
         }
     }
     else if ( consumer->GetInputWindow()->GetWindowStyle() & wxRESIZE_BORDER )
@@ -744,37 +936,15 @@ bool wxStdFrameInputHandler::HandleMouseMove(wxInputConsumer *consumer,
 
             if ( m_borderCursorOn )
             {
 
             if ( m_borderCursorOn )
             {
-                m_borderCursorOn = FALSE;
+                m_borderCursorOn = false;
                 win->SetCursor(m_origCursor);
             }
 
             if ( hit & wxHT_TOPLEVEL_ANY_BORDER )
             {
                 win->SetCursor(m_origCursor);
             }
 
             if ( hit & wxHT_TOPLEVEL_ANY_BORDER )
             {
-                m_borderCursorOn = TRUE;
                 wxCursor cur;
 
                 wxCursor cur;
 
-                switch (hit)
-                {
-                    case wxHT_TOPLEVEL_BORDER_N:
-                    case wxHT_TOPLEVEL_BORDER_S:
-                        cur = wxCursor(wxCURSOR_SIZENS);
-                        break;
-                    case wxHT_TOPLEVEL_BORDER_W:
-                    case wxHT_TOPLEVEL_BORDER_E:
-                        cur = wxCursor(wxCURSOR_SIZEWE);
-                        break;
-                    case wxHT_TOPLEVEL_BORDER_NE:
-                    case wxHT_TOPLEVEL_BORDER_SW:
-                        cur = wxCursor(wxCURSOR_SIZENESW);
-                        break;
-                    case wxHT_TOPLEVEL_BORDER_NW:
-                    case wxHT_TOPLEVEL_BORDER_SE:
-                        cur = wxCursor(wxCURSOR_SIZENWSE);
-                        break;
-                    default:
-                        m_borderCursorOn = FALSE;
-                        break;
-                }
+                m_borderCursorOn = wxGetResizingCursor(hit, cur);
                 if ( m_borderCursorOn )
                 {
                     m_origCursor = win->GetCursor();
                 if ( m_borderCursorOn )
                 {
                     m_origCursor = win->GetCursor();
@@ -787,14 +957,14 @@ bool wxStdFrameInputHandler::HandleMouseMove(wxInputConsumer *consumer,
     return wxStdInputHandler::HandleMouseMove(consumer, event);
 }
 
     return wxStdInputHandler::HandleMouseMove(consumer, event);
 }
 
-bool wxStdFrameInputHandler::HandleActivation(wxInputConsumer *consumer,
-                                              bool activated)
+bool wxStdTLWInputHandler::HandleActivation(wxInputConsumer *consumer,
+                                            bool activated)
 {
     if ( m_borderCursorOn )
     {
         consumer->GetInputWindow()->SetCursor(m_origCursor);
 {
     if ( m_borderCursorOn )
     {
         consumer->GetInputWindow()->SetCursor(m_origCursor);
-        m_borderCursorOn = FALSE;
+        m_borderCursorOn = false;
     }
     consumer->PerformAction(wxACTION_TOPLEVEL_ACTIVATE, activated);
     }
     consumer->PerformAction(wxACTION_TOPLEVEL_ACTIVATE, activated);
-    return FALSE;
+    return false;
 }
 }
wxWidgets (Impactor)