]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/toplevel.cpp
Bumped the reference manual date.
[wxWidgets.git] / src / msw / toplevel.cpp
index d73404fc54ac533931d6361e4d64e456de0691b5..0d1a0735cdde9113e08dff1284c3b12b08a22715 100644 (file)
@@ -1,12 +1,12 @@
 ///////////////////////////////////////////////////////////////////////////////
-// Name:        msw/toplevel.cpp
+// Name:        src/msw/toplevel.cpp
 // Purpose:     implements wxTopLevelWindow for MSW
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     24.09.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
-// License:     wxWindows licence
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 // headers
 // ----------------------------------------------------------------------------
 
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "toplevel.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
     #pragma hdrstop
 #endif
 
+#include "wx/toplevel.h"
+
 #ifndef WX_PRECOMP
     #include "wx/app.h"
-    #include "wx/toplevel.h"
+    #include "wx/dialog.h"
     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/frame.h"
+    #include "wx/menu.h"
     #include "wx/containr.h"        // wxSetFocusToChild()
+    #include "wx/module.h"
 #endif //WX_PRECOMP
 
-#include "wx/module.h"
+#include "wx/dynlib.h"
 
 #include "wx/msw/private.h"
-#include "wx/msw/winundef.h"
-
-// This can't be undefed in winundef.h or
-// there are further errors
-#if defined(__WXWINCE__) && defined(CreateDialog)
-#undef CreateDialog
+#if defined(__WXWINCE__) && !defined(__HANDHELDPC__)
+    #include <ole2.h>
+    #include <shellapi.h>
+    // Standard SDK doesn't have aygshell.dll: see include/wx/msw/wince/libraries.h
+    #if _WIN32_WCE < 400 || !defined(__WINCE_STANDARDSDK__)
+        #include <aygshell.h>
+    #endif
 #endif
 
+#include "wx/msw/winundef.h"
+#include "wx/msw/missing.h"
+
 #include "wx/display.h"
 
 #ifndef ICON_BIG
@@ -65,8 +69,8 @@
 
 #ifdef __WXMICROWIN__
 
-// static inline bool IsIconic(HWND WXUNUSED(hwnd)) { return FALSE; }
-static inline bool IsZoomed(HWND WXUNUSED(hwnd)) { return FALSE; }
+// static inline bool IsIconic(HWND WXUNUSED(hwnd)) { return false; }
+static inline bool IsZoomed(HWND WXUNUSED(hwnd)) { return false; }
 
 #endif // __WXMICROWIN__
 
@@ -75,16 +79,6 @@ static inline bool IsZoomed(HWND WXUNUSED(hwnd)) { return FALSE; }
 LONG APIENTRY _EXPORT
 wxDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
 
-// ----------------------------------------------------------------------------
-// globals
-// ----------------------------------------------------------------------------
-
-// list of all frames and modeless dialogs
-wxWindowList wxModelessWindows;
-
-// the name of the default wxWindows class
-extern const wxChar *wxCanvasClassName;
-
 // ----------------------------------------------------------------------------
 // wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
 // module to ensure that the window is always deleted)
@@ -127,18 +121,29 @@ END_EVENT_TABLE()
 void wxTopLevelWindowMSW::Init()
 {
     m_iconized =
-    m_maximizeOnShow = FALSE;
-
-    // unlike (almost?) all other windows, frames are created hidden
-    m_isShown = FALSE;
+    m_maximizeOnShow = false;
 
     // Data to save/restore when calling ShowFullScreen
     m_fsStyle = 0;
     m_fsOldWindowStyle = 0;
-    m_fsIsMaximized = FALSE;
-    m_fsIsShowing = FALSE;
+    m_fsIsMaximized = false;
+    m_fsIsShowing = false;
+
+    m_winLastFocused = NULL;
+
+#if defined(__SMARTPHONE__) && defined(__WXWINCE__)
+    m_MenuBarHWND = 0;
+#endif
+
+#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
+    SHACTIVATEINFO* info = new SHACTIVATEINFO;
+    wxZeroMemory(*info);
+    info->cbSize = sizeof(SHACTIVATEINFO);
 
-    m_winLastFocused = (wxWindow *)NULL;
+    m_activateInfo = (void*) info;
+#endif
+
+    m_menuSystem = NULL;
 }
 
 WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const
@@ -150,72 +155,86 @@ WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const
                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exflags
                       ) & ~WS_CHILD & ~WS_VISIBLE;
 
+    // For some reason, WS_VISIBLE needs to be defined on creation for
+    // SmartPhone 2003. The title can fail to be displayed otherwise.
+#if defined(__SMARTPHONE__) || (defined(__WXWINCE__) && _WIN32_WCE < 400)
+    msflags |= WS_VISIBLE;
+    ((wxTopLevelWindowMSW*)this)->wxWindowBase::Show(true);
+#endif
+
     // first select the kind of window being created
     //
     // note that if we don't set WS_POPUP, Windows assumes WS_OVERLAPPED and
-    // creates a window with both caption and border, hence we also test it
-    // below in some other cases
-    if ( style & wxFRAME_TOOL_WINDOW )
-        msflags |= WS_POPUP;
-    else
-    {
-#ifdef __WXWINCE__
-        if (msflags & WS_BORDER)
-#endif
-            msflags |= WS_OVERLAPPED;
-    }
+    // creates a window with both caption and border, hence we need to use
+    // WS_POPUP in a few cases just to avoid having caption/border which we
+    // don't want
 
     // border and caption styles
-    if ( style & wxRESIZE_BORDER )
-    {
-#ifndef __WXWINCE__
+    if ( ( style & wxRESIZE_BORDER ) && !IsAlwaysMaximized())
         msflags |= WS_THICKFRAME;
-#endif
-    }
     else if ( exflags && ((style & wxBORDER_DOUBLE) || (style & wxBORDER_RAISED)) )
         *exflags |= WS_EX_DLGMODALFRAME;
     else if ( !(style & wxBORDER_NONE) )
         msflags |= WS_BORDER;
-#ifndef __WXWINCE__
+#ifndef __POCKETPC__
     else
         msflags |= WS_POPUP;
 #endif
 
+    // normally we consider that all windows without a caption must be popups,
+    // but CE is an exception: there windows normally do not have the caption
+    // but shouldn't be made popups as popups can't have menus and don't look
+    // like normal windows anyhow
+
+    // TODO: Smartphone appears to like wxCAPTION, but we should check that
+    // we need it.
+#if defined(__SMARTPHONE__) || !defined(__WXWINCE__)
     if ( style & wxCAPTION )
         msflags |= WS_CAPTION;
 #ifndef __WXWINCE__
     else
         msflags |= WS_POPUP;
+#endif // !__WXWINCE__
 #endif
 
     // next translate the individual flags
-    if ( style & wxMINIMIZE_BOX )
-        msflags |= WS_MINIMIZEBOX;
-    if ( style & wxMAXIMIZE_BOX )
-        msflags |= WS_MAXIMIZEBOX;
-    if ( style & wxSYSTEM_MENU )
-        msflags |= WS_SYSMENU;
+
+    // WS_EX_CONTEXTHELP is incompatible with WS_MINIMIZEBOX and WS_MAXIMIZEBOX
+    // and is ignored if we specify both of them, but chances are that if we
+    // use wxWS_EX_CONTEXTHELP, we really do want to have the context help
+    // button while wxMINIMIZE/wxMAXIMIZE are included by default, so the help
+    // takes precedence
+    if ( !(GetExtraStyle() & wxWS_EX_CONTEXTHELP) )
+    {
+        if ( style & wxMINIMIZE_BOX )
+            msflags |= WS_MINIMIZEBOX;
+        if ( style & wxMAXIMIZE_BOX )
+            msflags |= WS_MAXIMIZEBOX;
+    }
+
 #ifndef __WXWINCE__
+    // notice that if wxCLOSE_BOX is specified we need to use WS_SYSMENU too as
+    // otherwise the close box doesn't appear
+    if ( style & (wxSYSTEM_MENU | wxCLOSE_BOX) )
+        msflags |= WS_SYSMENU;
+#endif // !__WXWINCE__
+
+    // NB: under CE these 2 styles are not supported currently, we should
+    //     call Minimize()/Maximize() "manually" if we want to support them
     if ( style & wxMINIMIZE )
         msflags |= WS_MINIMIZE;
+
     if ( style & wxMAXIMIZE )
         msflags |= WS_MAXIMIZE;
-#endif
 
     // Keep this here because it saves recoding this function in wxTinyFrame
-#if wxUSE_ITSY_BITSY && !defined(__WIN32__)
-    if ( style & wxTINY_CAPTION_VERT )
-        msflags |= IBS_VERTCAPTION;
-    if ( style & wxTINY_CAPTION_HORIZ )
-        msflags |= IBS_HORZCAPTION;
-#else
-    if ( style & (wxTINY_CAPTION_VERT | wxTINY_CAPTION_HORIZ) )
+    if ( style & wxTINY_CAPTION )
         msflags |= WS_CAPTION;
-#endif
 
     if ( exflags )
     {
-#if !defined(__WIN16__)
+        // there is no taskbar under CE, so omit all this
+#if !defined(__WXWINCE__)
         if ( !(GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) )
         {
             if ( style & wxFRAME_TOOL_WINDOW )
@@ -239,24 +258,20 @@ WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const
             // The second one is solved here by using WS_EX_APPWINDOW flag, the
             // first one is dealt with in our MSWGetParent() method
             // implementation
-#ifndef __WXWINCE__
             if ( !(style & wxFRAME_NO_TASKBAR) && GetParent() )
             {
                 // need to force the frame to appear in the taskbar
                 *exflags |= WS_EX_APPWINDOW;
             }
-#endif
             //else: nothing to do [here]
         }
-#endif // !Win16
+
+        if ( GetExtraStyle() & wxWS_EX_CONTEXTHELP )
+            *exflags |= WS_EX_CONTEXTHELP;
+#endif // !__WXWINCE__
 
         if ( style & wxSTAY_ON_TOP )
             *exflags |= WS_EX_TOPMOST;
-
-#ifdef __WIN32__
-        if ( GetExtraStyle() & wxFRAME_EX_CONTEXTHELP )
-            *exflags |= WS_EX_CONTEXTHELP;
-#endif // __WIN32__
     }
 
     return msflags;
@@ -276,7 +291,7 @@ WXHWND wxTopLevelWindowMSW::MSWGetParent() const
         if ( !parent )
         {
             // this flag doesn't make sense then and will be ignored
-            wxFAIL_MSG( _T("wxFRAME_FLOAT_ON_PARENT but no parent?") );
+            wxFAIL_MSG( wxT("wxFRAME_FLOAT_ON_PARENT but no parent?") );
         }
         else
         {
@@ -296,39 +311,130 @@ WXHWND wxTopLevelWindowMSW::MSWGetParent() const
     return (WXHWND)hwndParent;
 }
 
-bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
-                                       const wxString& title,
-                                       const wxPoint& pos,
-                                       const wxSize& size)
+#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
+bool wxTopLevelWindowMSW::HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam)
 {
-#ifdef __WXMICROWIN__
-    // no dialogs support under MicroWin yet
-    return CreateFrame(title, pos, size);
-#else // !__WXMICROWIN__
-    wxWindow *parent = GetParent();
+    SHACTIVATEINFO *info = (SHACTIVATEINFO*) m_activateInfo;
+    if ( info )
+    {
+        SHHandleWMSettingChange(GetHwnd(), wParam, lParam, info);
+    }
+
+    return wxWindowMSW::HandleSettingChange(wParam, lParam);
+}
+#endif
 
-    // for the dialogs without wxDIALOG_NO_PARENT style, use the top level
-    // app window as parent - this avoids creating modal dialogs without
-    // parent
-    if ( !parent && !(GetWindowStyleFlag() & wxDIALOG_NO_PARENT) )
+WXLRESULT wxTopLevelWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+{
+    WXLRESULT rc = 0;
+    bool processed = false;
+
+    switch ( message )
     {
-        parent = wxTheApp->GetTopWindow();
+#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
+        case WM_ACTIVATE:
+        {
+            SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo;
+            if (info)
+            {
+                DWORD flags = 0;
+                if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) flags = SHA_INPUTDIALOG;
+                SHHandleWMActivate(GetHwnd(), wParam, lParam, info, flags);
+            }
 
-        if ( parent )
+            // This implicitly sends a wxEVT_ACTIVATE_APP event
+            if (wxTheApp)
+                wxTheApp->SetActive(wParam != 0, FindFocus());
+
+            break;
+        }
+        case WM_HIBERNATE:
         {
-            // don't use transient windows as parents, this is dangerous as it
-            // can lead to a crash if the parent is destroyed before the child
-            //
-            // also don't use the window which is currently hidden as then the
-            // dialog would be hidden as well
-            if ( (parent->GetExtraStyle() & wxWS_EX_TRANSIENT) ||
-                    !parent->IsShown() )
+            if (wxTheApp)
             {
-                parent = NULL;
+                wxActivateEvent event(wxEVT_HIBERNATE, true, wxID_ANY);
+                event.SetEventObject(wxTheApp);
+                processed = wxTheApp->ProcessEvent(event);
             }
+            break;
         }
+#endif // __SMARTPHONE__ || __POCKETPC__
+
+        case WM_SYSCOMMAND:
+            {
+                // From MSDN:
+                //
+                //      ... the four low-order bits of the wParam parameter are
+                //      used internally by the system. To obtain the correct
+                //      result when testing the value of wParam, an application
+                //      must combine the value 0xFFF0 with the wParam value by
+                //      using the bitwise AND operator.
+                unsigned id = wParam & 0xfff0;
+
+                // Preserve the focus when minimizing/restoring the window: we
+                // need to do it manually as DefWindowProc() doesn't appear to
+                // do this for us for some reason (perhaps because we don't use
+                // WM_NEXTDLGCTL for setting focus?). Moreover, our code in
+                // OnActivate() doesn't work in this case as we receive the
+                // deactivation event too late when the window is being
+                // minimized and the focus is already NULL by then. Similarly,
+                // we receive the activation event too early and restoring
+                // focus in it fails because the window is still minimized. So
+                // we need to do it here.
+                if ( id == SC_MINIMIZE )
+                {
+                    // For minimization, it's simple enough: just save the
+                    // focus as usual. The important thing is that we're not
+                    // minimized yet, so this works correctly.
+                    DoSaveLastFocus();
+                }
+                else if ( id == SC_RESTORE )
+                {
+                    // For restoring, it's trickier as DefWindowProc() sets
+                    // focus to the window itself. So run it first and restore
+                    // our saved focus only afterwards.
+                    processed = true;
+                    rc = wxTopLevelWindowBase::MSWWindowProc(message,
+                                                             wParam, lParam);
+
+                    DoRestoreLastFocus();
+                }
+
+#ifndef __WXUNIVERSAL__
+                // We need to generate events for the custom items added to the
+                // system menu if it had been created (and presumably modified).
+                // As SC_SIZE is the first of the system-defined commands, we
+                // only do this for the custom commands before it and leave
+                // SC_SIZE and everything after it to DefWindowProc().
+                if ( m_menuSystem && id < SC_SIZE )
+                {
+                    if ( m_menuSystem->MSWCommand(0 /* unused anyhow */, id) )
+                        processed = true;
+                }
+#endif // #ifndef __WXUNIVERSAL__
+            }
+            break;
     }
 
+    if ( !processed )
+        rc = wxTopLevelWindowBase::MSWWindowProc(message, wParam, lParam);
+
+    return rc;
+}
+
+bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
+                                       const wxString& title,
+                                       const wxPoint& pos,
+                                       const wxSize& size)
+{
+#ifdef __WXMICROWIN__
+    // no dialogs support under MicroWin yet
+    return CreateFrame(title, pos, size);
+#else // !__WXMICROWIN__
+    // static cast is valid as we're only ever called for dialogs
+    wxWindow * const
+        parent = static_cast<wxDialog *>(this)->GetParentForModalDialog();
+
     m_hWnd = (WXHWND)::CreateDialogIndirect
                        (
                         wxGetInstance(),
@@ -343,34 +449,19 @@ bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
 
         wxLogSysError(wxT("Can't create dialog using memory template"));
 
-        return FALSE;
-    }
-
-    WXDWORD exflags;
-    (void)MSWGetCreateWindowFlags(&exflags);
-
-    if ( exflags )
-    {
-        ::SetWindowLong(GetHwnd(), GWL_EXSTYLE, exflags);
-        ::SetWindowPos(GetHwnd(),
-                       exflags & WS_EX_TOPMOST ? HWND_TOPMOST : 0,
-                       0, 0, 0, 0,
-                       SWP_NOSIZE |
-                       SWP_NOMOVE |
-                       (exflags & WS_EX_TOPMOST ? 0 : SWP_NOZORDER) |
-                       SWP_NOACTIVATE);
+        return false;
     }
 
-#if defined(__WIN95__)
+#if !defined(__WXWINCE__)
     // For some reason, the system menu is activated when we use the
     // WS_EX_CONTEXTHELP style, so let's set a reasonable icon
-    if ( exflags & WS_EX_CONTEXTHELP )
+    if ( HasExtraStyle(wxWS_EX_CONTEXTHELP) )
     {
         wxFrame *winTop = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
         if ( winTop )
         {
             wxIcon icon = winTop->GetIcon();
-            if ( icon.Ok() )
+            if ( icon.IsOk() )
             {
                 ::SendMessage(GetHwnd(), WM_SETICON,
                               (WPARAM)TRUE,
@@ -378,52 +469,42 @@ bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
             }
         }
     }
-#endif // __WIN95__
+#endif // !__WXWINCE__
 
-    // move the dialog to its initial position without forcing repainting
-    int x, y, w, h;
-    if ( !MSWGetCreateWindowCoords(pos, size, x, y, w, h) )
+    if ( !title.empty() )
     {
-        x =
-        w = (int)CW_USEDEFAULT;
+        ::SetWindowText(GetHwnd(), title.t_str());
     }
 
-    // we can't use CW_USEDEFAULT here as we're not calling CreateWindow()
-    // and passing CW_USEDEFAULT to MoveWindow() results in resizing the
-    // window to (0, 0) size which breaks quite a lot of things, e.g. the
-    // sizer calculation in wxSizer::Fit()
-    if ( w == (int)CW_USEDEFAULT )
-    {
-        // the exact number doesn't matter, the dialog will be resized
-        // again soon anyhow but it should be big enough to allow
-        // calculation relying on "totalSize - clientSize > 0" work, i.e.
-        // at least greater than the title bar height
-        w =
-        h = 100;
-    }
-
-    if ( x == (int)CW_USEDEFAULT )
-    {
-        // centre it on the screen - what else can we do?
-        wxSize sizeDpy = wxGetDisplaySize();
+    SubclassWin(m_hWnd);
 
-        x = (sizeDpy.x - w) / 2;
-        y = (sizeDpy.y - h) / 2;
-    }
+#if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__)
+    // move the dialog to its initial position without forcing repainting
+    int x, y, w, h;
+    (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
 
-    if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) )
+    if ( x == (int)CW_USEDEFAULT )
     {
-        wxLogLastError(wxT("MoveWindow"));
+        // Let the system position the window, just set its size.
+        ::SetWindowPos(GetHwnd(), 0,
+                       0, 0, w, h,
+                       SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
     }
-
-    if ( !title.empty() )
+    else // Move the window to the desired location and set its size too.
     {
-        ::SetWindowText(GetHwnd(), title);
+        if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) )
+        {
+            wxLogLastError(wxT("MoveWindow"));
+        }
     }
+#endif // !__WXWINCE__
 
-    SubclassWin(m_hWnd);
+#ifdef __SMARTPHONE__
+    // Work around title non-display glitch
+    Show(false);
+#endif
 
-    return TRUE;
+    return true;
 #endif // __WXMICROWIN__/!__WXMICROWIN__
 }
 
@@ -434,7 +515,15 @@ bool wxTopLevelWindowMSW::CreateFrame(const wxString& title,
     WXDWORD exflags;
     WXDWORD flags = MSWGetCreateWindowFlags(&exflags);
 
-    return MSWCreate(wxCanvasClassName, title, pos, size, flags, exflags);
+    const wxSize sz = IsAlwaysMaximized() ? wxDefaultSize : size;
+
+#ifndef __WXWINCE__
+    if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
+        exflags |= WS_EX_LAYOUTRTL;
+#endif
+
+    return MSWCreate(MSWGetRegisteredClassName(),
+                     title.t_str(), pos, sz, flags, exflags);
 }
 
 bool wxTopLevelWindowMSW::Create(wxWindow *parent,
@@ -445,27 +534,29 @@ bool wxTopLevelWindowMSW::Create(wxWindow *parent,
                                  long style,
                                  const wxString& name)
 {
-    bool ret wxDUMMY_INITIALIZE(false);
-
-    // init our fields
-    Init();
-
-    m_windowStyle = style;
-
-    SetName(name);
-
-    m_windowId = id == -1 ? NewControlId() : id;
+    wxSize sizeReal = size;
+    if ( !sizeReal.IsFullySpecified() )
+    {
+        sizeReal.SetDefaults(GetDefaultSize());
+    }
 
+    // notice that we should append this window to wxTopLevelWindows list
+    // before calling CreateBase() as it behaves differently for TLW and
+    // non-TLW windows
     wxTopLevelWindows.Append(this);
 
+    bool ret = CreateBase(parent, id, pos, sizeReal, style, name);
+    if ( !ret )
+        return false;
+
     if ( parent )
         parent->AddChild(this);
 
     if ( GetExtraStyle() & wxTOPLEVEL_EX_DIALOG )
     {
         // we have different dialog templates to allows creation of dialogs
-        // with & without captions under MSWindows, resizeable or not (but a
-        // resizeable dialog always has caption - otherwise it would look too
+        // with & without captions under MSWindows, resizable or not (but a
+        // resizable dialog always has caption - otherwise it would look too
         // strange)
 
         // we need 3 additional WORDs for dialog menu, class and title (as we
@@ -482,35 +573,79 @@ bool wxTopLevelWindowMSW::Create(wxWindow *parent,
 
         // reuse the code in MSWGetStyle() but correct the results slightly for
         // the dialog
-        dlgTemplate->style = MSWGetStyle(style, NULL);
+        //
+        // NB: we need a temporary variable as we can't pass pointer to
+        //     dwExtendedStyle directly, it's not aligned correctly for 64 bit
+        //     architectures
+        WXDWORD dwExtendedStyle;
+        dlgTemplate->style = MSWGetStyle(style, &dwExtendedStyle);
+        dlgTemplate->dwExtendedStyle = dwExtendedStyle;
 
         // all dialogs are popups
         dlgTemplate->style |= WS_POPUP;
 
+#ifndef __WXWINCE__
+        if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
+        {
+            dlgTemplate->dwExtendedStyle |= WS_EX_LAYOUTRTL;
+        }
+
         // force 3D-look if necessary, it looks impossibly ugly otherwise
         if ( style & (wxRESIZE_BORDER | wxCAPTION) )
             dlgTemplate->style |= DS_MODALFRAME;
+#endif
 
-        ret = CreateDialog(dlgTemplate, title, pos, size);
+        ret = CreateDialog(dlgTemplate, title, pos, sizeReal);
         free(dlgTemplate);
     }
     else // !dialog
     {
-        ret = CreateFrame(title, pos, size);
+        ret = CreateFrame(title, pos, sizeReal);
     }
 
+#ifndef __WXWINCE__
     if ( ret && !(GetWindowStyleFlag() & wxCLOSE_BOX) )
     {
         EnableCloseButton(false);
     }
+#endif
+
+    // for standard dialogs the dialog manager generates WM_CHANGEUISTATE
+    // itself but for custom windows we have to do it ourselves in order to
+    // make the keyboard indicators (such as underlines for accelerators and
+    // focus rectangles) work under Win2k+
+    if ( ret )
+    {
+        MSWUpdateUIState(UIS_INITIALIZE);
+    }
+
+    // Note: if we include PocketPC in this test, dialogs can fail to show up,
+    // for example the text entry dialog in the dialogs sample. Problem with Maximise()?
+#if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__WINCE_STANDARDSDK__))
+    if ( ( style & wxMAXIMIZE ) || IsAlwaysMaximized() )
+    {
+        this->Maximize();
+    }
+#endif
+
+#if defined(__SMARTPHONE__) && defined(__WXWINCE__)
+    SetRightMenu(); // to nothing for initialization
+#endif
 
     return ret;
 }
 
 wxTopLevelWindowMSW::~wxTopLevelWindowMSW()
 {
-    if ( wxModelessWindows.Find(this) )
-        wxModelessWindows.DeleteObject(this);
+    delete m_menuSystem;
+
+    SendDestroyEvent();
+
+#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
+    SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo;
+    delete info;
+    m_activateInfo = NULL;
+#endif
 
     // after destroying an owned window, Windows activates the next top level
     // window in Z order but it may be different from our owner (to reproduce
@@ -534,14 +669,28 @@ void wxTopLevelWindowMSW::DoShowWindow(int nShowCmd)
 {
     ::ShowWindow(GetHwnd(), nShowCmd);
 
-    m_iconized = nShowCmd == SW_MINIMIZE;
+    // Hiding the window doesn't change its iconized state.
+    if ( nShowCmd != SW_HIDE )
+    {
+        // Otherwise restoring, maximizing or showing the window normally also
+        // makes it not iconized and only minimizing it does make it iconized.
+        m_iconized = nShowCmd == SW_MINIMIZE;
+    }
+}
+
+void wxTopLevelWindowMSW::ShowWithoutActivating()
+{
+    if ( !wxWindowBase::Show(true) )
+        return;
+
+    DoShowWindow(SW_SHOWNA);
 }
 
 bool wxTopLevelWindowMSW::Show(bool show)
 {
     // don't use wxWindow version as we want to call DoShowWindow() ourselves
     if ( !wxWindowBase::Show(show) )
-        return FALSE;
+        return false;
 
     int nShowCmd;
     if ( show )
@@ -551,14 +700,40 @@ bool wxTopLevelWindowMSW::Show(bool show)
             // show and maximize
             nShowCmd = SW_MAXIMIZE;
 
-            m_maximizeOnShow = FALSE;
+            // This is necessary, or no window appears
+#if defined( __WINCE_STANDARDSDK__) || defined(__SMARTPHONE__)
+            DoShowWindow(SW_SHOW);
+#endif
+
+            m_maximizeOnShow = false;
+        }
+        else if ( m_iconized )
+        {
+            // We were iconized while we were hidden, so now we need to show
+            // the window in iconized state.
+            nShowCmd = SW_MINIMIZE;
+        }
+        else if ( ::IsIconic(GetHwnd()) )
+        {
+            // We were restored while we were hidden, so now we need to show
+            // the window in its normal state.
+            //
+            // As below, don't activate some kinds of windows.
+            if ( HasFlag(wxFRAME_TOOL_WINDOW) || !IsEnabled() )
+                nShowCmd = SW_SHOWNOACTIVATE;
+            else
+                nShowCmd = SW_RESTORE;
         }
         else // just show
         {
-           if ( GetWindowStyle() & wxFRAME_TOOL_WINDOW )
-               nShowCmd = SW_SHOWNA;
-           else
-               nShowCmd = SW_SHOW;
+            // we shouldn't use SW_SHOW which also activates the window for
+            // tool frames (as they shouldn't steal focus from the main window)
+            // nor for the currently disabled windows as they would be enabled
+            // as a side effect
+            if ( HasFlag(wxFRAME_TOOL_WINDOW) || !IsEnabled() )
+                nShowCmd = SW_SHOWNA;
+            else
+                nShowCmd = SW_SHOW;
         }
     }
     else // hide
@@ -566,28 +741,33 @@ bool wxTopLevelWindowMSW::Show(bool show)
         nShowCmd = SW_HIDE;
     }
 
+#if wxUSE_DEFERRED_SIZING
+    // we only set pending size if we're maximized before being shown, now that
+    // we're shown we don't need it any more (it is reset in size event handler
+    // for child windows but we have to do it ourselves for this parent window)
+    //
+    // make sure to reset it before actually showing the window as this will
+    // generate WM_SIZE events and we want to use the correct client size from
+    // them, not the size returned by WM_NCCALCSIZE in DoGetClientSize() which
+    // turns out to be wrong for maximized windows (see #11762)
+    m_pendingSize = wxDefaultSize;
+#endif // wxUSE_DEFERRED_SIZING
+
     DoShowWindow(nShowCmd);
 
-    if ( show )
-    {
-        ::BringWindowToTop(GetHwnd());
+#if defined(__WXWINCE__) && (_WIN32_WCE >= 400 && !defined(__POCKETPC__) && !defined(__SMARTPHONE__))
+    // Addornments have to be added when the frame is the correct size
+    wxFrame* frame = wxDynamicCast(this, wxFrame);
+    if (frame && frame->GetMenuBar())
+        frame->GetMenuBar()->AddAdornments(GetWindowStyleFlag());
+#endif
 
-        wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_windowId);
-        event.SetEventObject( this );
-        GetEventHandler()->ProcessEvent(event);
-    }
-    else // hide
-    {
-        // Try to highlight the correct window (the parent)
-        if ( GetParent() )
-        {
-            HWND hWndParent = GetHwndOf(GetParent());
-            if (hWndParent)
-                ::BringWindowToTop(hWndParent);
-        }
-    }
+    return true;
+}
 
-    return TRUE;
+void wxTopLevelWindowMSW::Raise()
+{
+    ::SetForegroundWindow(GetHwnd());
 }
 
 // ----------------------------------------------------------------------------
@@ -603,35 +783,77 @@ void wxTopLevelWindowMSW::Maximize(bool maximize)
     }
     else // hidden
     {
-        // we can't maximize the hidden frame because it shows it as well, so
-        // just remember that we should do it later in this case
+        // we can't maximize the hidden frame because it shows it as well,
+        // so just remember that we should do it later in this case
         m_maximizeOnShow = maximize;
+
+#if wxUSE_DEFERRED_SIZING
+        // after calling Maximize() the client code expects to get the frame
+        // "real" size and doesn't want to know that, because of implementation
+        // details, the frame isn't really maximized yet but will be only once
+        // it's shown, so return our size as it will be then in this case
+        if ( maximize )
+        {
+            // we must only change pending size here, and not call SetSize()
+            // because otherwise Windows would think that this (full screen)
+            // size is the natural size for the frame and so would use it when
+            // the user clicks on "restore" title bar button instead of the
+            // correct initial frame size
+            //
+            // NB: unfortunately we don't know which display we're on yet so we
+            //     have to use the default one
+            m_pendingSize = wxGetClientDisplayRect().GetSize();
+        }
+        //else: can't do anything in this case, we don't have the old size
+#endif // wxUSE_DEFERRED_SIZING
     }
 }
 
 bool wxTopLevelWindowMSW::IsMaximized() const
 {
-#ifdef __WXWINCE__
-    return FALSE;
-#else
-    return ::IsZoomed(GetHwnd()) != 0;
+    return IsAlwaysMaximized() ||
+#if !defined(__SMARTPHONE__) && !defined(__POCKETPC__) && !defined(__WINCE_STANDARDSDK__)
+
+           (::IsZoomed(GetHwnd()) != 0) ||
 #endif
+           m_maximizeOnShow;
 }
 
 void wxTopLevelWindowMSW::Iconize(bool iconize)
 {
-    DoShowWindow(iconize ? SW_MINIMIZE : SW_RESTORE);
+    if ( iconize == m_iconized )
+    {
+        // Do nothing, in particular don't restore non-iconized windows when
+        // Iconize(false) is called as this would wrongly un-maximize them.
+        return;
+    }
+
+    if ( IsShown() )
+    {
+        // change the window state immediately
+        DoShowWindow(iconize ? SW_MINIMIZE : SW_RESTORE);
+    }
+    else // hidden
+    {
+        // iconizing the window shouldn't show it so just update the internal
+        // state (otherwise it's done by DoShowWindow() itself)
+        m_iconized = iconize;
+    }
 }
 
 bool wxTopLevelWindowMSW::IsIconized() const
 {
 #ifdef __WXWINCE__
-    return FALSE;
+    return false;
 #else
-    // also update the current state
-    ((wxTopLevelWindowMSW *)this)->m_iconized = ::IsIconic(GetHwnd()) != 0;
-
-    return m_iconized;
+    if ( !IsShown() )
+        return m_iconized;
+
+    // don't use m_iconized, it may be briefly out of sync with the real state
+    // as it's only modified when we receive a WM_SIZE and we could be called
+    // from an event handler from one of the messages we receive before it,
+    // such as WM_MOVE
+    return ::IsIconic(GetHwnd()) != 0;
 #endif
 }
 
@@ -640,6 +862,154 @@ void wxTopLevelWindowMSW::Restore()
     DoShowWindow(SW_RESTORE);
 }
 
+void wxTopLevelWindowMSW::SetLayoutDirection(wxLayoutDirection dir)
+{
+    if ( dir == wxLayout_Default )
+        dir = wxTheApp->GetLayoutDirection();
+
+    if ( dir != wxLayout_Default )
+        wxTopLevelWindowBase::SetLayoutDirection(dir);
+}
+
+// ----------------------------------------------------------------------------
+// wxTopLevelWindowMSW geometry
+// ----------------------------------------------------------------------------
+
+#ifndef __WXWINCE__
+
+void wxTopLevelWindowMSW::DoGetPosition(int *x, int *y) const
+{
+    if ( IsIconized() )
+    {
+        WINDOWPLACEMENT wp;
+        wp.length = sizeof(WINDOWPLACEMENT);
+        if ( ::GetWindowPlacement(GetHwnd(), &wp) )
+        {
+            RECT& rc = wp.rcNormalPosition;
+
+            // the position returned by GetWindowPlacement() is in workspace
+            // coordinates except for windows with WS_EX_TOOLWINDOW style
+            if ( !HasFlag(wxFRAME_TOOL_WINDOW) )
+            {
+                // we must use the correct display for the translation as the
+                // task bar might be shown on one display but not the other one
+                int n = wxDisplay::GetFromWindow(this);
+                wxDisplay dpy(n == wxNOT_FOUND ? 0 : n);
+                const wxPoint ptOfs = dpy.GetClientArea().GetPosition() -
+                                      dpy.GetGeometry().GetPosition();
+
+                rc.left += ptOfs.x;
+                rc.top += ptOfs.y;
+            }
+
+            if ( x )
+                *x = rc.left;
+            if ( y )
+                *y = rc.top;
+
+            return;
+        }
+
+        wxLogLastError(wxT("GetWindowPlacement"));
+    }
+    //else: normal case
+
+    wxTopLevelWindowBase::DoGetPosition(x, y);
+}
+
+void wxTopLevelWindowMSW::DoGetSize(int *width, int *height) const
+{
+    if ( IsIconized() )
+    {
+        WINDOWPLACEMENT wp;
+        wp.length = sizeof(WINDOWPLACEMENT);
+        if ( ::GetWindowPlacement(GetHwnd(), &wp) )
+        {
+            const RECT& rc = wp.rcNormalPosition;
+
+            if ( width )
+                *width = rc.right - rc.left;
+            if ( height )
+                *height = rc.bottom - rc.top;
+
+            return;
+        }
+
+        wxLogLastError(wxT("GetWindowPlacement"));
+    }
+    //else: normal case
+
+    wxTopLevelWindowBase::DoGetSize(width, height);
+}
+
+#endif // __WXWINCE__
+
+void
+wxTopLevelWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
+                                              const wxSize& size,
+                                              int& x, int& y,
+                                              int& w, int& h) const
+{
+    // let the system position the window if no explicit position was specified
+    if ( pos.x == wxDefaultCoord )
+    {
+        // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
+        // can just as well set it to CW_USEDEFAULT as well
+        x =
+        y = CW_USEDEFAULT;
+    }
+    else
+    {
+        // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
+        // neither because it is not handled as a special value by Windows then
+        // and so we have to choose some default value for it, even if a
+        // completely arbitrary one
+        static const int DEFAULT_Y = 200;
+
+        x = pos.x;
+        y = pos.y == wxDefaultCoord ? DEFAULT_Y : pos.y;
+    }
+
+    if ( size.x == wxDefaultCoord || size.y == wxDefaultCoord )
+    {
+        // We don't use CW_USEDEFAULT here for several reasons:
+        //
+        //  1. It results in huge frames on modern screens (1000*800 is not
+        //     uncommon on my 1280*1024 screen) which is way too big for a half
+        //     empty frame of most of wxWidgets samples for example)
+        //
+        //  2. It is buggy for frames with wxFRAME_TOOL_WINDOW style for which
+        //     the default is for whatever reason 8*8 which breaks client <->
+        //     window size calculations (it would be nice if it didn't, but it
+        //     does and the simplest way to fix it seemed to change the broken
+        //     default size anyhow)
+        //
+        //  3. There is just no advantage in doing it: with x and y it is
+        //     possible that [future versions of] Windows position the new top
+        //     level window in some smart way which we can't do, but we can
+        //     guess a reasonably good size for a new window just as well
+        //     ourselves
+        //
+        // The only exception is for the Windows CE platform where the system
+        // does know better than we how should the windows be sized
+#ifdef _WIN32_WCE
+        w =
+        h = CW_USEDEFAULT;
+#else // !_WIN32_WCE
+        wxSize sizeReal = size;
+        sizeReal.SetDefaults(GetDefaultSize());
+
+        w = sizeReal.x;
+        h = sizeReal.y;
+#endif // _WIN32_WCE/!_WIN32_WCE
+    }
+    else
+    {
+        w = size.x;
+        h = size.y;
+    }
+}
+
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowMSW fullscreen
 // ----------------------------------------------------------------------------
@@ -649,7 +1019,7 @@ bool wxTopLevelWindowMSW::ShowFullScreen(bool show, long style)
     if ( show == IsFullScreen() )
     {
         // nothing to do
-        return TRUE;
+        return true;
     }
 
     m_fsIsShowing = show;
@@ -695,15 +1065,17 @@ bool wxTopLevelWindowMSW::ShowFullScreen(bool show, long style)
             rect = wxDisplay(dpy).GetGeometry();
         }
         else // fall back to the main desktop
-#else // wxUSE_DISPLAY
+#endif // wxUSE_DISPLAY
         {
-            // FIXME: implement for WinCE
-#ifndef __WXWINCE__
             // resize to the size of the desktop
             wxCopyRECTToRect(wxGetWindowRect(::GetDesktopWindow()), rect);
+#ifdef __WXWINCE__
+            // FIXME: size of the bottom menu (toolbar)
+            // should be taken in account
+            rect.height += rect.y;
+            rect.y       = 0;
 #endif
         }
-#endif // wxUSE_DISPLAY
 
         SetSize(rect);
 
@@ -727,49 +1099,73 @@ bool wxTopLevelWindowMSW::ShowFullScreen(bool show, long style)
                      rect.x, rect.y, rect.width, rect.height,
                      flags);
 
+#if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
+        ::SHFullScreen(GetHwnd(), SHFS_HIDETASKBAR | SHFS_HIDESIPBUTTON);
+#endif
+
         // finally send an event allowing the window to relayout itself &c
         wxSizeEvent event(rect.GetSize(), GetId());
-        GetEventHandler()->ProcessEvent(event);
+        event.SetEventObject(this);
+        HandleWindowEvent(event);
     }
     else // stop showing full screen
     {
+#if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
+        ::SHFullScreen(GetHwnd(), SHFS_SHOWTASKBAR | SHFS_SHOWSIPBUTTON);
+#endif
         Maximize(m_fsIsMaximized);
         SetWindowLong(GetHwnd(),GWL_STYLE, m_fsOldWindowStyle);
         SetWindowPos(GetHwnd(),HWND_TOP,m_fsOldSize.x, m_fsOldSize.y,
             m_fsOldSize.width, m_fsOldSize.height, SWP_FRAMECHANGED);
     }
 
-    return TRUE;
+    return true;
 }
 
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowMSW misc
 // ----------------------------------------------------------------------------
 
-void wxTopLevelWindowMSW::SetIcon(const wxIcon& icon)
+void wxTopLevelWindowMSW::SetTitle( const wxString& title)
+{
+    SetLabel(title);
+}
+
+wxString wxTopLevelWindowMSW::GetTitle() const
 {
-    SetIcons( wxIconBundle( icon ) );
+    return GetLabel();
+}
+
+bool wxTopLevelWindowMSW::DoSelectAndSetIcon(const wxIconBundle& icons,
+                                             int smX,
+                                             int smY,
+                                             int i)
+{
+    const wxSize size(::GetSystemMetrics(smX), ::GetSystemMetrics(smY));
+
+    wxIcon icon = icons.GetIcon(size, wxIconBundle::FALLBACK_NEAREST_LARGER);
+
+    if ( !icon.IsOk() )
+        return false;
+
+    ::SendMessage(GetHwnd(), WM_SETICON, i, (LPARAM)GetHiconOf(icon));
+    return true;
 }
 
 void wxTopLevelWindowMSW::SetIcons(const wxIconBundle& icons)
 {
     wxTopLevelWindowBase::SetIcons(icons);
 
-#if defined(__WIN95__) && !defined(__WXMICROWIN__)
-    const wxIcon& sml = icons.GetIcon( wxSize( 16, 16 ) );
-    if( sml.Ok() && sml.GetWidth() == 16 && sml.GetHeight() == 16 )
+    if ( icons.IsEmpty() )
     {
-        ::SendMessage( GetHwndOf( this ), WM_SETICON, ICON_SMALL,
-                       (LPARAM)GetHiconOf(sml) );
+        // FIXME: SetIcons(wxNullIconBundle) should unset existing icons,
+        //        but we currently don't do that
+        wxASSERT_MSG( m_icons.IsEmpty(), "unsetting icons doesn't work" );
+        return;
     }
 
-    const wxIcon& big = icons.GetIcon( wxSize( 32, 32 ) );
-    if( big.Ok() && big.GetWidth() == 32 && big.GetHeight() == 32 )
-    {
-        ::SendMessage( GetHwndOf( this ), WM_SETICON, ICON_BIG,
-                       (LPARAM)GetHiconOf(big) );
-    }
-#endif // __WIN95__
+    DoSelectAndSetIcon(icons, SM_CXSMICON, SM_CYSMICON, ICON_SMALL);
+    DoSelectAndSetIcon(icons, SM_CXICON, SM_CYICON, ICON_BIG);
 }
 
 bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
@@ -790,126 +1186,251 @@ bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
                           MF_BYCOMMAND |
                           (enable ? MF_ENABLED : MF_GRAYED)) == -1 )
     {
-        wxLogLastError(_T("EnableMenuItem(SC_CLOSE)"));
+        wxLogLastError(wxT("EnableMenuItem(SC_CLOSE)"));
 
-        return FALSE;
+        return false;
     }
-
+#ifndef __WXWINCE__
     // update appearance immediately
     if ( !::DrawMenuBar(GetHwnd()) )
     {
-        wxLogLastError(_T("DrawMenuBar"));
+        wxLogLastError(wxT("DrawMenuBar"));
     }
+#endif
 #endif // !__WXMICROWIN__
 
-    return TRUE;
+    return true;
 }
 
-bool wxTopLevelWindowMSW::SetShape(const wxRegion& region)
+void wxTopLevelWindowMSW::RequestUserAttention(int flags)
 {
-#ifdef __WXWINCE__
-    return FALSE;
-#else
-    wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
-                 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
+    // check if we can use FlashWindowEx(): unfortunately a simple test for
+    // FLASHW_STOP doesn't work because MSVC6 headers do #define it but don't
+    // provide FlashWindowEx() declaration, so try to detect whether we have
+    // real headers for WINVER 0x0500 by checking for existence of a symbol not
+    // declated in MSVC6 header
+#if defined(FLASHW_STOP) && defined(VK_XBUTTON1) && wxUSE_DYNLIB_CLASS
+    // available in the headers, check if it is supported by the system
+    typedef BOOL (WINAPI *FlashWindowEx_t)(FLASHWINFO *pfwi);
+    static FlashWindowEx_t s_pfnFlashWindowEx = NULL;
+    if ( !s_pfnFlashWindowEx )
+    {
+        wxDynamicLibrary dllUser32(wxT("user32.dll"));
+        s_pfnFlashWindowEx = (FlashWindowEx_t)
+                                dllUser32.GetSymbol(wxT("FlashWindowEx"));
+
+        // we can safely unload user32.dll here, it's going to remain loaded as
+        // long as the program is running anyhow
+    }
 
-    // The empty region signifies that the shape should be removed from the
-    // window.
-    if ( region.IsEmpty() )
+    if ( s_pfnFlashWindowEx )
     {
-        if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0)
+        WinStruct<FLASHWINFO> fwi;
+        fwi.hwnd = GetHwnd();
+        fwi.dwFlags = FLASHW_ALL;
+        if ( flags & wxUSER_ATTENTION_INFO )
         {
-            wxLogLastError(_T("SetWindowRgn"));
-            return FALSE;
+            // just flash a few times
+            fwi.uCount = 3;
         }
-        return TRUE;
-    }
-
-    // Windows takes ownership of the region, so
-    // we'll have to make a copy of the region to give to it.
-    DWORD noBytes = ::GetRegionData(GetHrgnOf(region), 0, NULL);
-    RGNDATA *rgnData = (RGNDATA*) new char[noBytes];
-    ::GetRegionData(GetHrgnOf(region), noBytes, rgnData);
-    HRGN hrgn = ::ExtCreateRegion(NULL, noBytes, rgnData);
-    delete[] (char*) rgnData;
-
-    // SetWindowRgn expects the region to be in coordinants
-    // relative to the window, not the client area.  Figure
-    // out the offset, if any.
-    RECT rect;
-    DWORD dwStyle =   ::GetWindowLong(GetHwnd(), GWL_STYLE);
-    DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
-    ::GetClientRect(GetHwnd(), &rect);
-    ::AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle);
-    ::OffsetRgn(hrgn, -rect.left, -rect.top);
-
-    // Now call the shape API with the new region.
-    if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0)
-    {
-        wxLogLastError(_T("SetWindowRgn"));
-        return FALSE;
-    }
-    return TRUE;
-#endif
+        else // wxUSER_ATTENTION_ERROR
+        {
+            // flash until the user notices it
+            fwi.dwFlags |= FLASHW_TIMERNOFG;
+        }
+
+        s_pfnFlashWindowEx(&fwi);
+    }
+    else // FlashWindowEx() not available
+#endif // FlashWindowEx() defined
+    {
+        wxUnusedVar(flags);
+#ifndef __WXWINCE__
+        ::FlashWindow(GetHwnd(), TRUE);
+#endif // __WXWINCE__
+    }
+}
+
+wxMenu *wxTopLevelWindowMSW::MSWGetSystemMenu() const
+{
+#ifndef __WXUNIVERSAL__
+    if ( !m_menuSystem )
+    {
+        HMENU hmenu = ::GetSystemMenu(GetHwnd(), FALSE);
+        if ( !hmenu )
+        {
+            wxLogLastError(wxT("GetSystemMenu()"));
+            return NULL;
+        }
+
+        wxTopLevelWindowMSW * const
+            self = const_cast<wxTopLevelWindowMSW *>(this);
+
+        self->m_menuSystem = wxMenu::MSWNewFromHMENU(hmenu);
+
+        // We need to somehow associate this menu with this window to ensure
+        // that we get events from it. A natural idea would be to pretend that
+        // it's attached to our menu bar but this wouldn't work if we don't
+        // have any menu bar which is a common case for applications using
+        // custom items in the system menu (they mostly do it exactly because
+        // they don't have any other menus).
+        //
+        // So reuse the invoking window pointer instead, this is not exactly
+        // correct but doesn't seem to have any serious drawbacks.
+        m_menuSystem->SetInvokingWindow(self);
+    }
+#endif // #ifndef __WXUNIVERSAL__
+
+    return m_menuSystem;
+}
+
+// ----------------------------------------------------------------------------
+// Transparency support
+// ---------------------------------------------------------------------------
+
+bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha)
+{
+#if wxUSE_DYNLIB_CLASS
+    typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);
+    static PSETLAYEREDWINDOWATTR
+        pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)-1;
+
+    if ( pSetLayeredWindowAttributes == (PSETLAYEREDWINDOWATTR)-1 )
+    {
+        wxDynamicLibrary dllUser32(wxT("user32.dll"));
+
+        // use RawGetSymbol() and not GetSymbol() to avoid error messages under
+        // Windows 95: there is nothing the user can do about this anyhow
+        pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)
+            dllUser32.RawGetSymbol(wxT("SetLayeredWindowAttributes"));
+
+        // it's ok to destroy dllUser32 here, we link statically to user32.dll
+        // anyhow so it won't be unloaded
+    }
+
+    if ( !pSetLayeredWindowAttributes )
+        return false;
+#endif // wxUSE_DYNLIB_CLASS
+
+    LONG exstyle = GetWindowLong(GetHwnd(), GWL_EXSTYLE);
+
+    // if setting alpha to fully opaque then turn off the layered style
+    if (alpha == 255)
+    {
+        SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle & ~WS_EX_LAYERED);
+        Refresh();
+        return true;
+    }
+
+#if wxUSE_DYNLIB_CLASS
+    // Otherwise, set the layered style if needed and set the alpha value
+    if ((exstyle & WS_EX_LAYERED) == 0 )
+        SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle | WS_EX_LAYERED);
+
+    if ( pSetLayeredWindowAttributes(GetHwnd(), 0, (BYTE)alpha, LWA_ALPHA) )
+        return true;
+#endif // wxUSE_DYNLIB_CLASS
+
+    return false;
+}
+
+bool wxTopLevelWindowMSW::CanSetTransparent()
+{
+    // The API is available on win2k and above
+
+    static int os_type = -1;
+    static int ver_major = -1;
+
+    if (os_type == -1)
+        os_type = ::wxGetOsVersion(&ver_major);
+
+    return (os_type == wxOS_WINDOWS_NT && ver_major >= 5);
+}
+
+void wxTopLevelWindowMSW::DoFreeze()
+{
+    // do nothing: freezing toplevel window causes paint and mouse events
+    // to go through it any TLWs under it, so the best we can do is to freeze
+    // all children -- and wxWindowBase::Freeze() does that
+}
+
+void wxTopLevelWindowMSW::DoThaw()
+{
+    // intentionally empty -- see DoFreeze()
 }
 
+
 // ----------------------------------------------------------------------------
 // wxTopLevelWindow event handling
 // ----------------------------------------------------------------------------
 
-// Default activation behaviour - set the focus for the first child
-// subwindow found.
+void wxTopLevelWindowMSW::DoSaveLastFocus()
+{
+    if ( m_iconized )
+        return;
+
+    // remember the last focused child if it is our child
+    m_winLastFocused = FindFocus();
+
+    if ( m_winLastFocused )
+    {
+        // and don't remember it if it's a child from some other frame
+        if ( wxGetTopLevelParent(m_winLastFocused) != this )
+        {
+            m_winLastFocused = NULL;
+        }
+    }
+}
+
+void wxTopLevelWindowMSW::DoRestoreLastFocus()
+{
+    wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
+                                        : NULL;
+    if ( !parent )
+    {
+        parent = this;
+    }
+
+    wxSetFocusToChild(parent, &m_winLastFocused);
+}
+
 void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
 {
     if ( event.GetActive() )
     {
+        // We get WM_ACTIVATE before being restored from iconized state, so we
+        // can be still iconized here. In this case, avoid restoring the focus
+        // as it doesn't work anyhow and we will do when we're really restored.
+        if ( m_iconized )
+        {
+            event.Skip();
+            return;
+        }
+
         // restore focus to the child which was last focused unless we already
         // have it
-        wxLogTrace(_T("focus"), _T("wxTLW %08x activated."), (int) m_hWnd);
+        wxLogTrace(wxT("focus"), wxT("wxTLW %p activated."), m_hWnd);
 
         wxWindow *winFocus = FindFocus();
         if ( !winFocus || wxGetTopLevelParent(winFocus) != this )
-        {
-            wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
-                                                : NULL;
-            if ( !parent )
-            {
-                parent = this;
-            }
-
-            wxSetFocusToChild(parent, &m_winLastFocused);
-        }
+            DoRestoreLastFocus();
     }
     else // deactivating
     {
-        // remember the last focused child if it is our child
-        m_winLastFocused = FindFocus();
-
-        if ( m_winLastFocused )
-        {
-            // let it know that it doesn't have focus any more
-            m_winLastFocused->HandleKillFocus((WXHWND)NULL);
-
-            // and don't remember it if it's a child from some other frame
-            if ( wxGetTopLevelParent(m_winLastFocused) != this )
-            {
-                m_winLastFocused = NULL;
-            }
-        }
+        DoSaveLastFocus();
 
-        wxLogTrace(_T("focus"),
-                   _T("wxTLW %08x deactivated, last focused: %08x."),
-                   (int) m_hWnd,
-                   (int) (m_winLastFocused ? GetHwndOf(m_winLastFocused)
-                                           : NULL));
+        wxLogTrace(wxT("focus"),
+                   wxT("wxTLW %p deactivated, last focused: %p."),
+                   m_hWnd,
+                   m_winLastFocused ? GetHwndOf(m_winLastFocused) : NULL);
 
         event.Skip();
     }
 }
 
-// the DialogProc for all wxWindows dialogs
+// the DialogProc for all wxWidgets dialogs
 LONG APIENTRY _EXPORT
-wxDlgProc(HWND WXUNUSED(hDlg),
+wxDlgProc(HWND hDlg,
           UINT message,
           WPARAM WXUNUSED(wParam),
           LPARAM WXUNUSED(lParam))
@@ -917,15 +1438,38 @@ wxDlgProc(HWND WXUNUSED(hDlg),
     switch ( message )
     {
         case WM_INITDIALOG:
-            // for this message, returning TRUE tells system to set focus to
+        {
+            // under CE, add a "Ok" button in the dialog title bar and make it full
+            // screen
+            //
+            // TODO: find the window for this HWND, and take into account
+            // wxMAXIMIZE and wxCLOSE_BOX. For now, assume both are present.
+            //
+            // Standard SDK doesn't have aygshell.dll: see
+            // include/wx/msw/wince/libraries.h
+#if defined(__WXWINCE__) && !defined(__WINCE_STANDARDSDK__) && !defined(__HANDHELDPC__)
+            SHINITDLGINFO shidi;
+            shidi.dwMask = SHIDIM_FLAGS;
+            shidi.dwFlags = SHIDIF_SIZEDLG // take account of the SIP or menubar
+#ifndef __SMARTPHONE__
+                            | SHIDIF_DONEBUTTON
+#endif
+                        ;
+            shidi.hDlg = hDlg;
+            SHInitDialog( &shidi );
+#else // no SHInitDialog()
+            wxUnusedVar(hDlg);
+#endif
+            // for WM_INITDIALOG, returning TRUE tells system to set focus to
             // the first control in the dialog box, but as we set the focus
-            // ourselves, we return FALSE from here as well, so fall through
-
-        default:
-            // for all the other ones, FALSE means that we didn't process the
-            // message
+            // ourselves, we return FALSE for it as well
             return FALSE;
+        }
     }
+
+    // for almost all messages, returning FALSE means that we didn't process
+    // the message
+    return FALSE;
 }
 
 // ============================================================================
@@ -941,7 +1485,7 @@ bool wxTLWHiddenParentModule::OnInit()
     ms_hwnd = NULL;
     ms_className = NULL;
 
-    return TRUE;
+    return true;
 }
 
 void wxTLWHiddenParentModule::OnExit()
@@ -950,7 +1494,7 @@ void wxTLWHiddenParentModule::OnExit()
     {
         if ( !::DestroyWindow(ms_hwnd) )
         {
-            wxLogLastError(_T("DestroyWindow(hidden TLW parent)"));
+            wxLogLastError(wxT("DestroyWindow(hidden TLW parent)"));
         }
 
         ms_hwnd = NULL;
@@ -960,7 +1504,7 @@ void wxTLWHiddenParentModule::OnExit()
     {
         if ( !::UnregisterClass(ms_className, wxGetInstance()) )
         {
-            wxLogLastError(_T("UnregisterClass(\"wxTLWHiddenParent\")"));
+            wxLogLastError(wxT("UnregisterClass(\"wxTLWHiddenParent\")"));
         }
 
         ms_className = NULL;
@@ -974,7 +1518,7 @@ HWND wxTLWHiddenParentModule::GetHWND()
     {
         if ( !ms_className )
         {
-            static const wxChar *HIDDEN_PARENT_CLASS = _T("wxTLWHiddenParent");
+            static const wxChar *HIDDEN_PARENT_CLASS = wxT("wxTLWHiddenParent");
 
             WNDCLASS wndclass;
             wxZeroMemory(wndclass);
@@ -985,7 +1529,7 @@ HWND wxTLWHiddenParentModule::GetHWND()
 
             if ( !::RegisterClass(&wndclass) )
             {
-                wxLogLastError(_T("RegisterClass(\"wxTLWHiddenParent\")"));
+                wxLogLastError(wxT("RegisterClass(\"wxTLWHiddenParent\")"));
             }
             else
             {
@@ -997,11 +1541,9 @@ HWND wxTLWHiddenParentModule::GetHWND()
                                  (HMENU)NULL, wxGetInstance(), NULL);
         if ( !ms_hwnd )
         {
-            wxLogLastError(_T("CreateWindow(hidden TLW parent)"));
+            wxLogLastError(wxT("CreateWindow(hidden TLW parent)"));
         }
     }
 
     return ms_hwnd;
 }
-
-