Added wxComboCtrl::SetHint(), GetHint()

[wxWidgets.git] / src / msw / toplevel.cpp

diff --git a/src/msw/toplevel.cpp b/src/msw/toplevel.cpp
index 214fbc7718e000b90a8bc37b88724dcdc1bbfd39..5fb5fd504feabaccb006a71bd0dba361ab2b869e 100644 (file)
--- a/src/msw/toplevel.cpp
+++ b/src/msw/toplevel.cpp
@@ -47,11 +47,10 @@
     #if _WIN32_WCE < 400 || !defined(__WINCE_STANDARDSDK__)
         #include <aygshell.h>
     #endif
     #if _WIN32_WCE < 400 || !defined(__WINCE_STANDARDSDK__)
         #include <aygshell.h>
     #endif

-    #include "wx/msw/wince/missing.h"

 #endif
 
 #endif
 

-#include "wx/msw/missing.h"

 #include "wx/msw/winundef.h"
 #include "wx/msw/winundef.h"

+#include "wx/msw/missing.h"

 
 #include "wx/display.h"
 
 
 #include "wx/display.h"
 


@@ -79,17 +78,6 @@ static inline bool IsZoomed(HWND WXUNUSED(hwnd)) { return false; }
 LONG APIENTRY _EXPORT
 wxDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
 
 LONG APIENTRY _EXPORT
 wxDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
 

-// ----------------------------------------------------------------------------
-// globals
-// ----------------------------------------------------------------------------
-
-// the name of the default wxWidgets class
-#ifdef __WXWINCE__
-extern       wxChar *wxCanvasClassName;
-#else
-extern const wxChar *wxCanvasClassName;
-#endif
-

 // ----------------------------------------------------------------------------
 // wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
 // module to ensure that the window is always deleted)
 // ----------------------------------------------------------------------------
 // wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
 // module to ensure that the window is always deleted)


@@ -140,7 +128,7 @@ void wxTopLevelWindowMSW::Init()
     m_fsIsMaximized = false;
     m_fsIsShowing = false;
 
     m_fsIsMaximized = false;
     m_fsIsShowing = false;
 

-    m_winLastFocused = (wxWindow *)NULL;
+    m_winLastFocused = NULL;

 
 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
     m_MenuBarHWND = 0;
 
 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
     m_MenuBarHWND = 0;


@@ -222,9 +210,11 @@ WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const
     }
 
 #ifndef __WXWINCE__
     }
 
 #ifndef __WXWINCE__

-    if ( style & wxSYSTEM_MENU )
+    // 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;
         msflags |= WS_SYSMENU;

-#endif
+#endif // !__WXWINCE__

 
     // NB: under CE these 2 styles are not supported currently, we should
     //     call Minimize()/Maximize() "manually" if we want to support them
 
     // NB: under CE these 2 styles are not supported currently, we should
     //     call Minimize()/Maximize() "manually" if we want to support them


@@ -298,7 +288,7 @@ WXHWND wxTopLevelWindowMSW::MSWGetParent() const
         if ( !parent )
         {
             // this flag doesn't make sense then and will be ignored
         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
         {
         }
         else
         {


@@ -383,29 +373,10 @@ bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
     // no dialogs support under MicroWin yet
     return CreateFrame(title, pos, size);
 #else // !__WXMICROWIN__
     // no dialogs support under MicroWin yet
     return CreateFrame(title, pos, size);
 #else // !__WXMICROWIN__

-    wxWindow *parent = GetParent();
-
-    // 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) )
-    {
-        parent = wxTheApp->GetTopWindow();
-
-        if ( parent )
-        {
-            // 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() )
-            {
-                parent = NULL;
-            }
-        }
-    }
+    // static cast is valid as we're only ever called for dialogs
+    wxWindow * const
+        parent = static_cast<wxDialog *>(this)->
+                    GetParentForModalDialog(GetParent());

 
     m_hWnd = (WXHWND)::CreateDialogIndirect
                        (
 
     m_hWnd = (WXHWND)::CreateDialogIndirect
                        (


@@ -424,25 +395,10 @@ bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
         return false;
     }
 
         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);
-    }
-

 #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 !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 )
     {
         wxFrame *winTop = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
         if ( winTop )


@@ -456,7 +412,7 @@ bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
             }
         }
     }
             }
         }
     }

-#endif
+#endif // !__WXWINCE__

 
     // move the dialog to its initial position without forcing repainting
     int x, y, w, h;
 
     // move the dialog to its initial position without forcing repainting
     int x, y, w, h;


@@ -480,7 +436,7 @@ bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
 
     if ( !title.empty() )
     {
 
     if ( !title.empty() )
     {

-        ::SetWindowText(GetHwnd(), title);
+        ::SetWindowText(GetHwnd(), title.wx_str());

     }
 
     SubclassWin(m_hWnd);
     }
 
     SubclassWin(m_hWnd);


@@ -503,10 +459,13 @@ bool wxTopLevelWindowMSW::CreateFrame(const wxString& title,
 
     const wxSize sz = IsAlwaysMaximized() ? wxDefaultSize : size;
 
 
     const wxSize sz = IsAlwaysMaximized() ? wxDefaultSize : size;
 

+#ifndef __WXWINCE__

     if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
         exflags |= WS_EX_LAYOUTRTL;
     if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
         exflags |= WS_EX_LAYOUTRTL;

+#endif

 
 

-    return MSWCreate(wxCanvasClassName, title, pos, sz, flags, exflags);
+    return MSWCreate(MSWGetRegisteredClassName(),
+                     title.wx_str(), pos, sz, flags, exflags);

 }
 
 bool wxTopLevelWindowMSW::Create(wxWindow *parent,
 }
 
 bool wxTopLevelWindowMSW::Create(wxWindow *parent,


@@ -517,22 +476,15 @@ bool wxTopLevelWindowMSW::Create(wxWindow *parent,
                                  long style,
                                  const wxString& name)
 {
                                  long style,
                                  const wxString& name)
 {

-    bool ret wxDUMMY_INITIALIZE(false);
-
-    // init our fields
-    Init();
-

     wxSize sizeReal = size;
     if ( !sizeReal.IsFullySpecified() )
     {
         sizeReal.SetDefaults(GetDefaultSize());
     }
 
     wxSize sizeReal = size;
     if ( !sizeReal.IsFullySpecified() )
     {
         sizeReal.SetDefaults(GetDefaultSize());
     }
 

-    m_windowStyle = style;
-
-    SetName(name);
-
-    m_windowId = id == wxID_ANY ? NewControlId() : id;
+    bool ret = CreateBase(parent, id, pos, sizeReal, style, name);
+    if ( !ret )
+        return false;

 
     wxTopLevelWindows.Append(this);
 
 
     wxTopLevelWindows.Append(this);
 


@@ -560,17 +512,23 @@ bool wxTopLevelWindowMSW::Create(wxWindow *parent,
 
         // reuse the code in MSWGetStyle() but correct the results slightly for
         // the dialog
 
         // 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;
 
         // all dialogs are popups
         dlgTemplate->style |= WS_POPUP;

-        
+
+#ifndef __WXWINCE__

         if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
         {
             dlgTemplate->dwExtendedStyle |= WS_EX_LAYOUTRTL;
         }
 
         if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
         {
             dlgTemplate->dwExtendedStyle |= WS_EX_LAYOUTRTL;
         }
 

-#ifndef __WXWINCE__

         // force 3D-look if necessary, it looks impossibly ugly otherwise
         if ( style & (wxRESIZE_BORDER | wxCAPTION) )
             dlgTemplate->style |= DS_MODALFRAME;
         // force 3D-look if necessary, it looks impossibly ugly otherwise
         if ( style & (wxRESIZE_BORDER | wxCAPTION) )
             dlgTemplate->style |= DS_MODALFRAME;


@@ -618,6 +576,8 @@ bool wxTopLevelWindowMSW::Create(wxWindow *parent,
 
 wxTopLevelWindowMSW::~wxTopLevelWindowMSW()
 {
 
 wxTopLevelWindowMSW::~wxTopLevelWindowMSW()
 {

+    SendDestroyEvent();
+

 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
     SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo;
     delete info;
 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
     SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo;
     delete info;


@@ -649,6 +609,14 @@ void wxTopLevelWindowMSW::DoShowWindow(int nShowCmd)
     m_iconized = nShowCmd == SW_MINIMIZE;
 }
 
     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
 bool wxTopLevelWindowMSW::Show(bool show)
 {
     // don't use wxWindow version as we want to call DoShowWindow() ourselves


@@ -670,12 +638,21 @@ bool wxTopLevelWindowMSW::Show(bool show)
 
             m_maximizeOnShow = false;
         }
 
             m_maximizeOnShow = false;
         }

+        else if ( m_iconized )
+        {
+            // iconize and show
+            nShowCmd = SW_MINIMIZE;
+        }

         else // just show
         {
         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
         }
     }
     else // hide


@@ -740,7 +717,8 @@ void wxTopLevelWindowMSW::Maximize(bool maximize)
 bool wxTopLevelWindowMSW::IsMaximized() const
 {
     return IsAlwaysMaximized() ||
 bool wxTopLevelWindowMSW::IsMaximized() const
 {
     return IsAlwaysMaximized() ||

-#if !defined(__SMARTPHONE__) && !defined(__POCKETPC__)
+#if !defined(__SMARTPHONE__) && !defined(__POCKETPC__) && !defined(__WINCE_STANDARDSDK__)
+

            (::IsZoomed(GetHwnd()) != 0) ||
 #endif
            m_maximizeOnShow;
            (::IsZoomed(GetHwnd()) != 0) ||
 #endif
            m_maximizeOnShow;


@@ -748,7 +726,17 @@ bool wxTopLevelWindowMSW::IsMaximized() const
 
 void wxTopLevelWindowMSW::Iconize(bool iconize)
 {
 
 void wxTopLevelWindowMSW::Iconize(bool iconize)
 {

-    DoShowWindow(iconize ? SW_MINIMIZE : SW_RESTORE);
+    if ( IsShown() )
+    {
+        // change the window state immediately
+        DoShowWindow(iconize ? SW_MINIMIZE : SW_RESTORE);
+    }
+    else // hidden
+    {
+        // iconizing the window shouldn't show it so just remember that we need
+        // to become iconized when shown later
+        m_iconized = true;
+    }

 }
 
 bool wxTopLevelWindowMSW::IsIconized() const
 }
 
 bool wxTopLevelWindowMSW::IsIconized() const


@@ -756,6 +744,9 @@ bool wxTopLevelWindowMSW::IsIconized() const
 #ifdef __WXWINCE__
     return false;
 #else
 #ifdef __WXWINCE__
     return false;
 #else

+    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,
     // 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,


@@ -778,6 +769,79 @@ void wxTopLevelWindowMSW::SetLayoutDirection(wxLayoutDirection dir)
         wxTopLevelWindowBase::SetLayoutDirection(dir);
 }
 
         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__
+

 // ----------------------------------------------------------------------------
 // wxTopLevelWindowMSW fullscreen
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowMSW fullscreen
 // ----------------------------------------------------------------------------


@@ -873,7 +937,7 @@ bool wxTopLevelWindowMSW::ShowFullScreen(bool show, long style)
 
         // finally send an event allowing the window to relayout itself &c
         wxSizeEvent event(rect.GetSize(), GetId());
 
         // finally send an event allowing the window to relayout itself &c
         wxSizeEvent event(rect.GetSize(), GetId());

-        GetEventHandler()->ProcessEvent(event);
+        HandleWindowEvent(event);

     }
     else // stop showing full screen
     {
     }
     else // stop showing full screen
     {


@@ -903,30 +967,44 @@ wxString wxTopLevelWindowMSW::GetTitle() const
     return GetLabel();
 }
 
     return GetLabel();
 }
 

-void wxTopLevelWindowMSW::SetIcon(const wxIcon& icon)
+bool wxTopLevelWindowMSW::DoSelectAndSetIcon(const wxIconBundle& icons,
+                                             int smX,
+                                             int smY,
+                                             int i)

 {
 {

-    SetIcons( wxIconBundle( icon ) );
+    const wxSize size(::GetSystemMetrics(smX), ::GetSystemMetrics(smY));
+
+    const wxIcon icon = icons.GetIconOfExactSize(size);
+    if ( icon.Ok() )
+    {
+        ::SendMessage(GetHwnd(), WM_SETICON, i, (LPARAM)GetHiconOf(icon));
+        return true;
+    }
+
+    return false;

 }
 
 void wxTopLevelWindowMSW::SetIcons(const wxIconBundle& icons)
 {
     wxTopLevelWindowBase::SetIcons(icons);
 
 }
 
 void wxTopLevelWindowMSW::SetIcons(const wxIconBundle& icons)
 {
     wxTopLevelWindowBase::SetIcons(icons);
 

-#if !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 )
+    bool anySet =
+        DoSelectAndSetIcon(icons, SM_CXSMICON, SM_CYSMICON, ICON_SMALL);
+    if ( DoSelectAndSetIcon(icons, SM_CXICON, SM_CYICON, ICON_BIG) )
+        anySet = true;
+
+    if ( !anySet )

     {
     {

-        ::SendMessage( GetHwndOf( this ), WM_SETICON, ICON_BIG,
-                       (LPARAM)GetHiconOf(big) );
+        wxFAIL_MSG( "icon bundle doesn't contain any suitable icon" );

     }
     }

-#endif // !__WXMICROWIN__

 }
 
 bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
 }
 
 bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)


@@ -947,7 +1025,7 @@ bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
                           MF_BYCOMMAND |
                           (enable ? MF_ENABLED : MF_GRAYED)) == -1 )
     {
                           MF_BYCOMMAND |
                           (enable ? MF_ENABLED : MF_GRAYED)) == -1 )
     {

-        wxLogLastError(_T("EnableMenuItem(SC_CLOSE)"));
+        wxLogLastError(wxT("EnableMenuItem(SC_CLOSE)"));

 
         return false;
     }
 
         return false;
     }


@@ -955,7 +1033,7 @@ bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
     // update appearance immediately
     if ( !::DrawMenuBar(GetHwnd()) )
     {
     // update appearance immediately
     if ( !::DrawMenuBar(GetHwnd()) )
     {

-        wxLogLastError(_T("DrawMenuBar"));
+        wxLogLastError(wxT("DrawMenuBar"));

     }
 #endif
 #endif // !__WXMICROWIN__
     }
 #endif
 #endif // !__WXMICROWIN__


@@ -968,7 +1046,7 @@ bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
 bool wxTopLevelWindowMSW::SetShape(const wxRegion& region)
 {
     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
 bool wxTopLevelWindowMSW::SetShape(const wxRegion& region)
 {
     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,

-                 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
+                 wxT("Shaped windows must be created with the wxFRAME_SHAPED style."));

 
     // The empty region signifies that the shape should be removed from the
     // window.
 
     // The empty region signifies that the shape should be removed from the
     // window.


@@ -976,7 +1054,7 @@ bool wxTopLevelWindowMSW::SetShape(const wxRegion& region)
     {
         if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0)
         {
     {
         if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0)
         {

-            wxLogLastError(_T("SetWindowRgn"));
+            wxLogLastError(wxT("SetWindowRgn"));

             return false;
         }
         return true;
             return false;
         }
         return true;


@@ -997,13 +1075,13 @@ bool wxTopLevelWindowMSW::SetShape(const wxRegion& region)
     DWORD dwStyle =   ::GetWindowLong(GetHwnd(), GWL_STYLE);
     DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
     ::GetClientRect(GetHwnd(), &rect);
     DWORD dwStyle =   ::GetWindowLong(GetHwnd(), GWL_STYLE);
     DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
     ::GetClientRect(GetHwnd(), &rect);

-    ::AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle);
+    ::AdjustWindowRectEx(&rect, dwStyle, ::GetMenu(GetHwnd()) != NULL, dwExStyle);

     ::OffsetRgn(hrgn, -rect.left, -rect.top);
 
     // Now call the shape API with the new region.
     if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0)
     {
     ::OffsetRgn(hrgn, -rect.left, -rect.top);
 
     // Now call the shape API with the new region.
     if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0)
     {

-        wxLogLastError(_T("SetWindowRgn"));
+        wxLogLastError(wxT("SetWindowRgn"));

         return false;
     }
     return true;
         return false;
     }
     return true;


@@ -1018,15 +1096,15 @@ void wxTopLevelWindowMSW::RequestUserAttention(int flags)
     // 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
     // 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)
+#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);
     // available in the headers, check if it is supported by the system
     typedef BOOL (WINAPI *FlashWindowEx_t)(FLASHWINFO *pfwi);

-    FlashWindowEx_t s_pfnFlashWindowEx = NULL;
+    static FlashWindowEx_t s_pfnFlashWindowEx = NULL;

     if ( !s_pfnFlashWindowEx )
     {
     if ( !s_pfnFlashWindowEx )
     {

-        wxDynamicLibrary dllUser32(_T("user32.dll"));
+        wxDynamicLibrary dllUser32(wxT("user32.dll"));

         s_pfnFlashWindowEx = (FlashWindowEx_t)
         s_pfnFlashWindowEx = (FlashWindowEx_t)

-                                dllUser32.GetSymbol(_T("FlashWindowEx"));
+                                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
 
         // we can safely unload user32.dll here, it's going to remain loaded as
         // long as the program is running anyhow


@@ -1064,17 +1142,27 @@ void wxTopLevelWindowMSW::RequestUserAttention(int flags)
 
 bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha)
 {
 
 bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha)
 {

+#if wxUSE_DYNLIB_CLASS

     typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);
     typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);

-    static PSETLAYEREDWINDOWATTR pSetLayeredWindowAttributes = NULL;
+    static PSETLAYEREDWINDOWATTR
+        pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)-1;

 
 

-    if ( pSetLayeredWindowAttributes == NULL )
+    if ( pSetLayeredWindowAttributes == (PSETLAYEREDWINDOWATTR)-1 )

     {
     {

-        wxDynamicLibrary dllUser32(_T("user32.dll"));
+        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)
         pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)

-            dllUser32.GetSymbol(wxT("SetLayeredWindowAttributes"));
+            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 == NULL )
+
+    if ( !pSetLayeredWindowAttributes )

         return false;
         return false;

+#endif // wxUSE_DYNLIB_CLASS

 
     LONG exstyle = GetWindowLong(GetHwnd(), GWL_EXSTYLE);
 
 
     LONG exstyle = GetWindowLong(GetHwnd(), GWL_EXSTYLE);
 


@@ -1086,11 +1174,16 @@ bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha)
         return true;
     }
 
         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);
 
     // 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);
 

-    return pSetLayeredWindowAttributes(GetHwnd(), 0, (BYTE)alpha, LWA_ALPHA) != 0;
+    if ( pSetLayeredWindowAttributes(GetHwnd(), 0, (BYTE)alpha, LWA_ALPHA) )
+        return true;
+#endif // wxUSE_DYNLIB_CLASS
+
+    return false;

 }
 
 bool wxTopLevelWindowMSW::CanSetTransparent()
 }
 
 bool wxTopLevelWindowMSW::CanSetTransparent()


@@ -1106,6 +1199,20 @@ bool wxTopLevelWindowMSW::CanSetTransparent()
     return (os_type == wxOS_WINDOWS_NT && ver_major >= 5);
 }
 
     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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxTopLevelWindow event handling
 // ----------------------------------------------------------------------------


@@ -1118,7 +1225,7 @@ void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
     {
         // restore focus to the child which was last focused unless we already
         // have it
     {
         // 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 *winFocus = FindFocus();
         if ( !winFocus || wxGetTopLevelParent(winFocus) != this )


@@ -1141,7 +1248,9 @@ void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
         if ( m_winLastFocused )
         {
             // let it know that it doesn't have focus any more
         if ( m_winLastFocused )
         {
             // let it know that it doesn't have focus any more

-            m_winLastFocused->HandleKillFocus((WXHWND)NULL);
+            // But this will already be done via WM_KILLFOCUS, so we'll get two kill
+            // focus events if we call it explicitly.
+            // m_winLastFocused->HandleKillFocus((WXHWND)NULL);

 
             // and don't remember it if it's a child from some other frame
             if ( wxGetTopLevelParent(m_winLastFocused) != this )
 
             // and don't remember it if it's a child from some other frame
             if ( wxGetTopLevelParent(m_winLastFocused) != this )


@@ -1150,11 +1259,10 @@ void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
             }
         }
 
             }
         }
 

-        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();
     }
 
         event.Skip();
     }


@@ -1226,7 +1334,7 @@ void wxTLWHiddenParentModule::OnExit()
     {
         if ( !::DestroyWindow(ms_hwnd) )
         {
     {
         if ( !::DestroyWindow(ms_hwnd) )
         {

-            wxLogLastError(_T("DestroyWindow(hidden TLW parent)"));
+            wxLogLastError(wxT("DestroyWindow(hidden TLW parent)"));

         }
 
         ms_hwnd = NULL;
         }
 
         ms_hwnd = NULL;


@@ -1236,7 +1344,7 @@ void wxTLWHiddenParentModule::OnExit()
     {
         if ( !::UnregisterClass(ms_className, wxGetInstance()) )
         {
     {
         if ( !::UnregisterClass(ms_className, wxGetInstance()) )
         {

-            wxLogLastError(_T("UnregisterClass(\"wxTLWHiddenParent\")"));
+            wxLogLastError(wxT("UnregisterClass(\"wxTLWHiddenParent\")"));

         }
 
         ms_className = NULL;
         }
 
         ms_className = NULL;


@@ -1250,7 +1358,7 @@ HWND wxTLWHiddenParentModule::GetHWND()
     {
         if ( !ms_className )
         {
     {
         if ( !ms_className )
         {

-            static const wxChar *HIDDEN_PARENT_CLASS = _T("wxTLWHiddenParent");
+            static const wxChar *HIDDEN_PARENT_CLASS = wxT("wxTLWHiddenParent");

 
             WNDCLASS wndclass;
             wxZeroMemory(wndclass);
 
             WNDCLASS wndclass;
             wxZeroMemory(wndclass);


@@ -1261,7 +1369,7 @@ HWND wxTLWHiddenParentModule::GetHWND()
 
             if ( !::RegisterClass(&wndclass) )
             {
 
             if ( !::RegisterClass(&wndclass) )
             {

-                wxLogLastError(_T("RegisterClass(\"wxTLWHiddenParent\")"));
+                wxLogLastError(wxT("RegisterClass(\"wxTLWHiddenParent\")"));

             }
             else
             {
             }
             else
             {


@@ -1273,7 +1381,7 @@ HWND wxTLWHiddenParentModule::GetHWND()
                                  (HMENU)NULL, wxGetInstance(), NULL);
         if ( !ms_hwnd )
         {
                                  (HMENU)NULL, wxGetInstance(), NULL);
         if ( !ms_hwnd )
         {

-            wxLogLastError(_T("CreateWindow(hidden TLW parent)"));
+            wxLogLastError(wxT("CreateWindow(hidden TLW parent)"));

         }
     }
 
         }
     }