Disable wxUSE_ENH_METAFILE for wxGTK builds.

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

diff --git a/src/msw/app.cpp b/src/msw/app.cpp
index f0d21977043fd7397654339340f46a7b601af2e5..633722e0167055e31feb9507d8f48ee6b6afdabb 100644 (file)
--- a/src/msw/app.cpp
+++ b/src/msw/app.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        app.cpp
+// Name:        src/msw/app.cpp

 // Purpose:     wxApp
 // Author:      Julian Smart
 // Modified by:
 // Purpose:     wxApp
 // Author:      Julian Smart
 // Modified by:


@@ -17,10 +17,6 @@
 // headers
 // ---------------------------------------------------------------------------
 
 // headers
 // ---------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "app.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -29,6 +25,8 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

+    #include "wx/msw/wrapcctl.h"
+    #include "wx/dynarray.h"

     #include "wx/frame.h"
     #include "wx/app.h"
     #include "wx/utils.h"
     #include "wx/frame.h"
     #include "wx/app.h"
     #include "wx/utils.h"


@@ -42,18 +40,23 @@
     #include "wx/dialog.h"
     #include "wx/msgdlg.h"
     #include "wx/intl.h"
     #include "wx/dialog.h"
     #include "wx/msgdlg.h"
     #include "wx/intl.h"

-    #include "wx/dynarray.h"
-    #include "wx/wxchar.h"
-    #include "wx/icon.h"
+    #include "wx/crt.h"

     #include "wx/log.h"
     #include "wx/log.h"

+    #include "wx/module.h"

 #endif
 
 #include "wx/apptrait.h"
 #include "wx/filename.h"
 #endif
 
 #include "wx/apptrait.h"
 #include "wx/filename.h"

-#include "wx/module.h"

 #include "wx/dynlib.h"
 #include "wx/dynlib.h"

+#include "wx/evtloop.h"
+#include "wx/thread.h"
+#include "wx/scopeguard.h"
+#include "wx/vector.h"

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

+#include "wx/msw/dc.h"
+#include "wx/msw/ole/oleutils.h"
+#include "wx/msw/private/timer.h"

 
 #if wxUSE_TOOLTIPS
     #include "wx/tooltip.h"
 
 #if wxUSE_TOOLTIPS
     #include "wx/tooltip.h"


@@ -61,12 +64,17 @@
 
 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
 // compilers don't support it (missing headers, libs, ...)
 
 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
 // compilers don't support it (missing headers, libs, ...)

-#if defined(__GNUWIN32_OLD__) || defined(__SYMANTEC__) || defined(__SALFORDC__)
+#if defined(__GNUWIN32_OLD__) || defined(__SYMANTEC__)

     #undef wxUSE_OLE
 
     #define  wxUSE_OLE 0
 #endif // broken compilers
 
     #undef wxUSE_OLE
 
     #define  wxUSE_OLE 0
 #endif // broken compilers
 

+#if defined(__POCKETPC__) || defined(__SMARTPHONE__)
+    #include <ole2.h>
+    #include <aygshell.h>
+#endif
+

 #if wxUSE_OLE
     #include <ole2.h>
 #endif
 #if wxUSE_OLE
     #include <ole2.h>
 #endif


@@ -74,44 +82,62 @@
 #include <string.h>
 #include <ctype.h>
 
 #include <string.h>
 #include <ctype.h>
 

-#include "wx/msw/wrapcctl.h"
-
-// For MB_TASKMODAL
-#ifdef __WXWINCE__
-#include "wx/msw/wince/missing.h"
-#endif
-
-#if (!defined(__MINGW32__) || wxCHECK_W32API_VERSION( 2, 0 )) && \
-    !defined(__CYGWIN__) && !defined(__DIGITALMARS__) && !defined(__WXWINCE__) && \
-    (!defined(_MSC_VER) || (_MSC_VER > 1100))
-    #include <shlwapi.h>
+#include "wx/msw/missing.h"
+
+// instead of including <shlwapi.h> which is not part of the core SDK and not
+// shipped at all with other compilers, we always define the parts of it we
+// need here ourselves
+//
+// NB: DLLVER_PLATFORM_WINDOWS will be defined if shlwapi.h had been somehow
+//     included already
+#ifndef DLLVER_PLATFORM_WINDOWS
+    // hopefully we don't need to change packing as DWORDs should be already
+    // correctly aligned
+    struct DLLVERSIONINFO
+    {
+        DWORD cbSize;
+        DWORD dwMajorVersion;                   // Major version
+        DWORD dwMinorVersion;                   // Minor version
+        DWORD dwBuildNumber;                    // Build number
+        DWORD dwPlatformID;                     // DLLVER_PLATFORM_*
+    };
+
+    typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
+#endif // defined(DLLVERSIONINFO)
+
+#ifndef ATTACH_PARENT_PROCESS
+    #define ATTACH_PARENT_PROCESS ((DWORD)-1)

 #endif
 
 // ---------------------------------------------------------------------------
 // global variables
 // ---------------------------------------------------------------------------
 
 #endif
 
 // ---------------------------------------------------------------------------
 // global variables
 // ---------------------------------------------------------------------------
 

-extern wxList WXDLLEXPORT wxPendingDelete;
-

 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 extern void wxSetKeyboardHook(bool doIt);
 #endif
 
 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 extern void wxSetKeyboardHook(bool doIt);
 #endif
 

-// NB: all "NoRedraw" classes must have the same names as the "normal" classes
-//     with NR suffix - wxWindow::MSWCreate() supposes this
-#ifdef __WXWINCE__
-      wxChar *wxCanvasClassName;
-      wxChar *wxCanvasClassNameNR;
-#else
-const wxChar *wxCanvasClassName        = wxT("wxWindowClass");
-const wxChar *wxCanvasClassNameNR      = wxT("wxWindowClassNR");
-#endif
-const wxChar *wxMDIFrameClassName      = wxT("wxMDIFrameClass");
-const wxChar *wxMDIFrameClassNameNoRedraw = wxT("wxMDIFrameClassNR");
-const wxChar *wxMDIChildFrameClassName = wxT("wxMDIChildFrameClass");
-const wxChar *wxMDIChildFrameClassNameNoRedraw = wxT("wxMDIChildFrameClassNR");
+// because of mingw32 4.3 bug this struct can't be inside the namespace below:
+// see http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/110282
+struct ClassRegInfo
+{
+    ClassRegInfo(const wxChar *name)
+        : regname(name),
+          regnameNR(regname + wxApp::GetNoRedrawClassSuffix())
+    {
+    }
+
+    // the name of the registered class with and without CS_[HV]REDRAW styles
+    wxString regname;
+    wxString regnameNR;
+};
+
+namespace
+{

 
 

-HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
+wxVector<ClassRegInfo> gs_regClassesInfo;
+
+} // anonymous namespace

 
 // ----------------------------------------------------------------------------
 // private functions
 
 // ----------------------------------------------------------------------------
 // private functions


@@ -146,12 +172,12 @@ void *wxGUIAppTraits::BeforeChildWaitLoop()
        focus/activation entirely when the child process terminates which would
        happen if we simply disabled everything using wxWindowDisabler. Indeed,
        remember that Windows will never activate a disabled window and when the
        focus/activation entirely when the child process terminates which would
        happen if we simply disabled everything using wxWindowDisabler. Indeed,
        remember that Windows will never activate a disabled window and when the

-       last childs window is closed and Windows looks for a window to activate
+       last child's window is closed and Windows looks for a window to activate

        all our windows are still disabled. There is no way to enable them in
        all our windows are still disabled. There is no way to enable them in

-       time because we don't know when the childs windows are going to be
-       closed, so the solution we use here is to keep one special tiny frame
+       time because we don't know when the child's windows are going to be
+       closed, so the solution we use here is to keep one special tiny dialog

        enabled all the time. Then when the child terminates it will get
        enabled all the time. Then when the child terminates it will get

-       activated and when we close it below -- after reenabling all the other
+       activated and when we close it below -- after re-enabling all the other

        windows! -- the previously active window becomes activated again and
        everything is ok.
      */
        windows! -- the previously active window becomes activated again and
        everything is ok.
      */


@@ -160,383 +186,593 @@ void *wxGUIAppTraits::BeforeChildWaitLoop()
     // first disable all existing windows
     wxWindowDisabler *wd = new wxWindowDisabler;
 
     // first disable all existing windows
     wxWindowDisabler *wd = new wxWindowDisabler;
 

-    // then create an "invisible" frame: it has minimal size, is positioned
-    // (hopefully) outside the screen and doesn't appear on the taskbar
-    wxWindow *winActive = new wxFrame
+    // then create an "invisible" dialog: it has minimal size, is positioned
+    // (hopefully) outside the screen and doesn't appear in the Alt-TAB list
+    // (unlike the frames, which is why we use a dialog here)
+    wxWindow *winActive = new wxDialog

                     (
                         wxTheApp->GetTopWindow(),
                         wxID_ANY,
                         wxEmptyString,
                         wxPoint(32600, 32600),
                     (
                         wxTheApp->GetTopWindow(),
                         wxID_ANY,
                         wxEmptyString,
                         wxPoint(32600, 32600),

-                        wxSize(1, 1),
-                        wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR
+                        wxSize(1, 1)

                     );
     winActive->Show();
 
     return new ChildWaitLoopData(wd, winActive);
 }
 
                     );
     winActive->Show();
 
     return new ChildWaitLoopData(wd, winActive);
 }
 

-void wxGUIAppTraits::AlwaysYield()
-{
-    wxYield();
-}
-

 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
 {
     wxEndBusyCursor();
 
 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
 {
     wxEndBusyCursor();
 

-    const ChildWaitLoopData * const data = (ChildWaitLoopData *)dataOrig;
+    ChildWaitLoopData * const data = (ChildWaitLoopData *)dataOrig;

 
     delete data->wd;
 
 
     delete data->wd;
 

-    // finally delete the dummy frame and, as wd has been already destroyed and
-    // the other windows reenabled, the activation is going to return to the
-    // window which had had it before
+    // finally delete the dummy dialog and, as wd has been already destroyed
+    // and the other windows reenabled, the activation is going to return to
+    // the window which had had it before

     data->winActive->Destroy();
     data->winActive->Destroy();

+
+    // also delete the temporary data object itself
+    delete data;

 }
 
 }
 

+#if wxUSE_THREADS

 bool wxGUIAppTraits::DoMessageFromThreadWait()
 {
     // we should return false only if the app should exit, i.e. only if
     // Dispatch() determines that the main event loop should terminate
 bool wxGUIAppTraits::DoMessageFromThreadWait()
 {
     // we should return false only if the app should exit, i.e. only if
     // Dispatch() determines that the main event loop should terminate

-    return !wxTheApp || wxTheApp->Dispatch();
+    wxEventLoopBase * const evtLoop = wxEventLoop::GetActive();
+    if ( !evtLoop || !evtLoop->Pending() )
+    {
+        // no events means no quit event
+        return true;
+    }
+
+    return evtLoop->Dispatch();

 }
 
 }
 

-wxToolkitInfo& wxGUIAppTraits::GetToolkitInfo()
+DWORD wxGUIAppTraits::WaitForThread(WXHANDLE hThread, int flags)

 {
 {

-    static wxToolkitInfo info;
-    wxToolkitInfo& baseInfo = wxAppTraits::GetToolkitInfo();
-    info.versionMajor = baseInfo.versionMajor;
-    info.versionMinor = baseInfo.versionMinor;
-    info.os = baseInfo.os;
-    info.shortName = _T("msw");
-    info.name = _T("wxMSW");
-#ifdef __WXUNIVERSAL__
-    info.shortName << _T("univ");
-    info.name << _T("/wxUniversal");
+    // We only ever dispatch messages from the main thread and, additionally,
+    // even from the main thread we shouldn't wait for the message if we don't
+    // have a running event loop as we would never remove them from the message
+    // queue then and so we would enter an infinite loop as
+    // MsgWaitForMultipleObjects() keeps returning WAIT_OBJECT_0 + 1.
+    if ( flags == wxTHREAD_WAIT_BLOCK ||
+            !wxIsMainThread() ||
+                !wxEventLoop::GetActive() )
+    {
+        // Simple blocking wait.
+        return DoSimpleWaitForThread(hThread);
+    }
+
+    return ::MsgWaitForMultipleObjects
+             (
+               1,                   // number of objects to wait for
+               (HANDLE *)&hThread,  // the objects
+               false,               // wait for any objects, not all
+               INFINITE,            // no timeout
+               QS_ALLINPUT |        // return as soon as there are any events
+               QS_ALLPOSTMESSAGE
+             );
+}
+#endif // wxUSE_THREADS
+
+wxPortId wxGUIAppTraits::GetToolkitVersion(int *majVer, int *minVer) const
+{
+    OSVERSIONINFO info;
+    wxZeroMemory(info);
+
+    // on Windows, the toolkit version is the same of the OS version
+    // as Windows integrates the OS kernel with the GUI toolkit.
+    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    if ( ::GetVersionEx(&info) )
+    {
+        if ( majVer )
+            *majVer = info.dwMajorVersion;
+        if ( minVer )
+            *minVer = info.dwMinorVersion;
+    }
+
+#if defined(__WXHANDHELD__) || defined(__WXWINCE__)
+    return wxPORT_WINCE;
+#else
+    return wxPORT_MSW;

 #endif
 #endif

-    return info;

 }
 
 }
 

-// ===========================================================================
-// wxApp implementation
-// ===========================================================================
+#if wxUSE_TIMER

 
 

-int wxApp::m_nCmdShow = SW_SHOWNORMAL;
+wxTimerImpl *wxGUIAppTraits::CreateTimerImpl(wxTimer *timer)
+{
+    return new wxMSWTimerImpl(timer);
+}
+
+#endif // wxUSE_TIMER
+
+wxEventLoopBase* wxGUIAppTraits::CreateEventLoop()
+{
+    return new wxEventLoop;
+}

 
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------

-// wxWin macros
+// Stuff for using console from the GUI applications

 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
+#ifndef __WXWINCE__

 
 

-BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
-    EVT_IDLE(wxApp::OnIdle)
-    EVT_END_SESSION(wxApp::OnEndSession)
-    EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
-END_EVENT_TABLE()
+#if wxUSE_DYNLIB_CLASS

 
 

-// class to ensure that wxAppBase::CleanUp() is called if our Initialize()
-// fails
-class wxCallBaseCleanup
+#include <wx/dynlib.h>
+
+namespace

 {
 {

-public:
-    wxCallBaseCleanup(wxApp *app) : m_app(app) { }
-    ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }

 
 

-    void Dismiss() { m_app = NULL; }
+/*
+    Helper class to manipulate console from a GUI app.

 
 

-private:
-    wxApp *m_app;
-};
+    Notice that console output is available in the GUI app only if:
+    - AttachConsole() returns TRUE (which means it never works under pre-XP)
+    - we have a valid STD_ERROR_HANDLE
+    - command history hasn't been changed since our startup

 
 

-//// Initialize
-bool wxApp::Initialize(int& argc, wxChar **argv)
+    To check if all these conditions are verified, you need to simple call
+    IsOkToUse(). It will check the first two conditions above the first time it
+    is called (and if this fails, the subsequent calls will return immediately)
+    and also recheck the last one every time it is called.
+ */
+class wxConsoleStderr

 {
 {

-    if ( !wxAppBase::Initialize(argc, argv) )
-        return false;
+public:
+    // default ctor does nothing, call Init() before using this class
+    wxConsoleStderr()
+    {
+        m_hStderr = INVALID_HANDLE_VALUE;
+        m_historyLen =
+        m_dataLen =
+        m_dataLine = 0;

 
 

-    // ensure that base cleanup is done if we return too early
-    wxCallBaseCleanup callBaseCleanup(this);
+        m_ok = -1;
+    }

 
 

-#ifdef __WXWINCE__
-    wxString tmp = GetAppName();
-    tmp += wxT("ClassName");
-    wxCanvasClassName = wxStrdup( tmp.c_str() );
-    tmp += wxT("NR");
-    wxCanvasClassNameNR = wxStrdup( tmp.c_str() );
-    HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
-    if (hWnd)
+    ~wxConsoleStderr()

     {
     {

-        SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
-        return false;
+        if ( m_hStderr != INVALID_HANDLE_VALUE )
+        {
+            if ( !::FreeConsole() )
+            {
+                wxLogLastError(wxT("FreeConsole"));
+            }
+        }

     }
     }

-#endif

 
 

-    // the first thing to do is to check if we're trying to run an Unicode
-    // program under Win9x w/o MSLU emulation layer - if so, abort right now
-    // as it has no chance to work
-#if wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
-    if ( wxGetOsVersion() != wxWINDOWS_NT && wxGetOsVersion() != wxWINDOWS_CE )
+    // return true if we were successfully initialized and there had been no
+    // console activity which would interfere with our output since then
+    bool IsOkToUse() const

     {
     {

-        // note that we can use MessageBoxW() as it's implemented even under
-        // Win9x - OTOH, we can't use wxGetTranslation() because the file APIs
-        // used by wxLocale are not
-        ::MessageBox
-        (
-         NULL,
-         _T("This program uses Unicode and requires Windows NT/2000/XP/CE.\nProgram aborted."),
-         _T("wxWidgets Fatal Error"),
-         MB_ICONERROR | MB_OK
-        );
+        if ( m_ok == -1 )
+        {
+            wxConsoleStderr * const self = const_cast<wxConsoleStderr *>(this);
+            self->m_ok = self->DoInit();

 
 

-        return false;
-    }
-#endif // wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
+            // no need to call IsHistoryUnchanged() as we just initialized
+            // m_history anyhow
+            return m_ok == 1;
+        }

 
 

-#if defined(__WIN95__) && !defined(__WXMICROWIN__)
-    InitCommonControls();
-#endif // __WIN95__
+        return m_ok && IsHistoryUnchanged();
+    }

 
 

-#if wxUSE_OLE || wxUSE_DRAG_AND_DROP

 
 

-#if wxUSE_OLE
-    // we need to initialize OLE library
-#ifdef __WXWINCE__
-    if ( FAILED(::CoInitializeEx(NULL, COINIT_MULTITHREADED)) )
-        wxLogError(_("Cannot initialize OLE"));
-#else
-    if ( FAILED(::OleInitialize(NULL)) )
-        wxLogError(_("Cannot initialize OLE"));
-#endif
-#endif
+    // output the provided text on the console, return true if ok
+    bool Write(const wxString& text);

 
 

-#endif // wxUSE_OLE
+private:
+    // called by Init() once only to do the real initialization
+    bool DoInit();

 
 

-#if wxUSE_CTL3D
-    if (!Ctl3dRegister(wxhInstance))
-        wxLogError(wxT("Cannot register CTL3D"));
+    // retrieve the command line history into the provided buffer and return
+    // its length
+    int GetCommandHistory(wxWxCharBuffer& buf) const;

 
 

-    Ctl3dAutoSubclass(wxhInstance);
-#endif // wxUSE_CTL3D
+    // check if the console history has changed
+    bool IsHistoryUnchanged() const;

 
 

-    RegisterWindowClasses();
+    int m_ok;                   // initially -1, set to true or false by Init()

 
 

-#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
-    // Create the brush for disabling bitmap buttons
-    LOGBRUSH lb;
-    lb.lbStyle = BS_PATTERN;
-    lb.lbColor = 0;
-    lb.lbHatch = (int)LoadBitmap( wxhInstance, wxT("wxDISABLE_BUTTON_BITMAP") );
-    if ( lb.lbHatch )
-    {
-        wxDisableButtonBrush = ::CreateBrushIndirect( &lb );
-        ::DeleteObject( (HGDIOBJ)lb.lbHatch );
-    }
-    //else: wxWidgets resources are probably not linked in
-#endif // !__WXMICROWIN__ && !__WXWINCE__
+    wxDynamicLibrary m_dllKernel32;

 
 

-#if wxUSE_PENWINDOWS
-    wxRegisterPenWin();
-#endif
+    HANDLE m_hStderr;           // console handle, if it's valid we must call
+                                // FreeConsole() (even if m_ok != 1)

 
 

-    wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
+    wxWxCharBuffer m_history;   // command history on startup
+    int m_historyLen;           // length command history buffer

 
 

-#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
-    wxSetKeyboardHook(true);
-#endif
+    wxCharBuffer m_data;        // data between empty line and cursor position
+    int m_dataLen;              // length data buffer
+    int m_dataLine;             // line offset

 
 

-    callBaseCleanup.Dismiss();
+    typedef DWORD (WINAPI *GetConsoleCommandHistory_t)(LPTSTR sCommands,
+                                                       DWORD nBufferLength,
+                                                       LPCTSTR sExeName);
+    typedef DWORD (WINAPI *GetConsoleCommandHistoryLength_t)(LPCTSTR sExeName);

 
 

-    return true;
-}
+    GetConsoleCommandHistory_t m_pfnGetConsoleCommandHistory;
+    GetConsoleCommandHistoryLength_t m_pfnGetConsoleCommandHistoryLength;

 
 

-// ---------------------------------------------------------------------------
-// RegisterWindowClasses
-// ---------------------------------------------------------------------------
+    wxDECLARE_NO_COPY_CLASS(wxConsoleStderr);
+};

 
 

-// TODO we should only register classes really used by the app. For this it
-//      would be enough to just delay the class registration until an attempt
-//      to create a window of this class is made.
-bool wxApp::RegisterWindowClasses()
+bool wxConsoleStderr::DoInit()

 {
 {

-    WNDCLASS wndclass;
-    wxZeroMemory(wndclass);
+    HANDLE hStderr = ::GetStdHandle(STD_ERROR_HANDLE);

 
 

-    // for each class we register one with CS_(V|H)REDRAW style and one
-    // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
-    static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
-    static const long styleNoRedraw = CS_DBLCLKS;
+    if ( hStderr == INVALID_HANDLE_VALUE || !hStderr )
+        return false;

 
 

-    // the fields which are common to all classes
-    wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
-    wndclass.hInstance     = wxhInstance;
-    wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
+    if ( !m_dllKernel32.Load(wxT("kernel32.dll")) )
+        return false;
+
+    typedef BOOL (WINAPI *AttachConsole_t)(DWORD dwProcessId);
+    AttachConsole_t wxDL_INIT_FUNC(pfn, AttachConsole, m_dllKernel32);
+
+    if ( !pfnAttachConsole || !pfnAttachConsole(ATTACH_PARENT_PROCESS) )
+        return false;

 
 

-    // Register the frame window class.
-    wndclass.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1);
-    wndclass.lpszClassName = wxCanvasClassName;
-    wndclass.style         = styleNormal;
+    // console attached, set m_hStderr now to ensure that we free it in the
+    // dtor
+    m_hStderr = hStderr;

 
 

-    if ( !RegisterClass(&wndclass) )
+    wxDL_INIT_FUNC_AW(m_pfn, GetConsoleCommandHistory, m_dllKernel32);
+    if ( !m_pfnGetConsoleCommandHistory )
+        return false;
+
+    wxDL_INIT_FUNC_AW(m_pfn, GetConsoleCommandHistoryLength, m_dllKernel32);
+    if ( !m_pfnGetConsoleCommandHistoryLength )
+        return false;
+
+    // remember the current command history to be able to compare with it later
+    // in IsHistoryUnchanged()
+    m_historyLen = GetCommandHistory(m_history);
+    if ( !m_history )
+        return false;
+
+
+    // now find the first blank line above the current position
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+
+    if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )

     {
     {

-        wxLogLastError(wxT("RegisterClass(frame)"));
+        wxLogLastError(wxT("GetConsoleScreenBufferInfo"));
+        return false;

     }
 
     }
 

-    // "no redraw" frame
-    wndclass.lpszClassName = wxCanvasClassNameNR;
-    wndclass.style         = styleNoRedraw;
+    COORD pos;
+    pos.X = 0;
+    pos.Y = csbi.dwCursorPosition.Y + 1;

 
 

-    if ( !RegisterClass(&wndclass) )
+    // we decide that a line is empty if first 4 characters are spaces
+    DWORD ret;
+    char buf[4];
+    do

     {
     {

-        wxLogLastError(wxT("RegisterClass(no redraw frame)"));
+        pos.Y--;
+        if ( !::ReadConsoleOutputCharacterA(m_hStderr, buf, WXSIZEOF(buf),
+                                            pos, &ret) )
+        {
+            wxLogLastError(wxT("ReadConsoleOutputCharacterA"));
+            return false;
+        }
+    } while ( wxStrncmp("    ", buf, WXSIZEOF(buf)) != 0 );
+
+    // calculate line offset and length of data
+    m_dataLine = csbi.dwCursorPosition.Y - pos.Y;
+    m_dataLen = m_dataLine*csbi.dwMaximumWindowSize.X + csbi.dwCursorPosition.X;
+
+    if ( m_dataLen > 0 )
+    {
+        m_data.extend(m_dataLen);
+        if ( !::ReadConsoleOutputCharacterA(m_hStderr, m_data.data(), m_dataLen,
+                                            pos, &ret) )
+        {
+            wxLogLastError(wxT("ReadConsoleOutputCharacterA"));
+            return false;
+        }

     }
 
     }
 

-    // Register the MDI frame window class.
-    wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
-    wndclass.lpszClassName = wxMDIFrameClassName;
-    wndclass.style         = styleNormal;
+    return true;
+}

 
 

-    if ( !RegisterClass(&wndclass) )
+int wxConsoleStderr::GetCommandHistory(wxWxCharBuffer& buf) const
+{
+    // these functions are internal and may only be called by cmd.exe
+    static const wxChar *CMD_EXE = wxT("cmd.exe");
+
+    const int len = m_pfnGetConsoleCommandHistoryLength(CMD_EXE);
+    if ( len )

     {
     {

-        wxLogLastError(wxT("RegisterClass(MDI parent)"));
+        buf.extend(len);
+
+        int len2 = m_pfnGetConsoleCommandHistory(buf.data(), len, CMD_EXE);
+
+#if !wxUSE_UNICODE
+        // there seems to be a bug in the GetConsoleCommandHistoryA(), it
+        // returns the length of Unicode string and not ANSI one
+        len2 /= 2;
+#endif // !wxUSE_UNICODE
+
+        if ( len2 != len )
+        {
+            wxFAIL_MSG( wxT("failed getting history?") );
+        }

     }
 
     }
 

-    // "no redraw" MDI frame
-    wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
-    wndclass.style         = styleNoRedraw;
+    return len;
+}
+
+bool wxConsoleStderr::IsHistoryUnchanged() const
+{
+    wxASSERT_MSG( m_ok == 1, wxT("shouldn't be called if not initialized") );
+
+    // get (possibly changed) command history
+    wxWxCharBuffer history;
+    const int historyLen = GetCommandHistory(history);

 
 

-    if ( !RegisterClass(&wndclass) )
+    // and compare it with the original one
+    return historyLen == m_historyLen && history &&
+                memcmp(m_history, history, historyLen) == 0;
+}
+
+bool wxConsoleStderr::Write(const wxString& text)
+{
+    wxASSERT_MSG( m_hStderr != INVALID_HANDLE_VALUE,
+                    wxT("should only be called if Init() returned true") );
+
+    // get current position
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )

     {
     {

-        wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
+        wxLogLastError(wxT("GetConsoleScreenBufferInfo"));
+        return false;

     }
 
     }
 

-    // Register the MDI child frame window class.
-    wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
-    wndclass.lpszClassName = wxMDIChildFrameClassName;
-    wndclass.style         = styleNormal;
+    // and calculate new position (where is empty line)
+    csbi.dwCursorPosition.X = 0;
+    csbi.dwCursorPosition.Y -= m_dataLine;

 
 

-    if ( !RegisterClass(&wndclass) )
+    if ( !::SetConsoleCursorPosition(m_hStderr, csbi.dwCursorPosition) )

     {
     {

-        wxLogLastError(wxT("RegisterClass(MDI child)"));
+        wxLogLastError(wxT("SetConsoleCursorPosition"));
+        return false;

     }
 
     }
 

-    // "no redraw" MDI child frame
-    wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
-    wndclass.style         = styleNoRedraw;
+    DWORD ret;
+    if ( !::FillConsoleOutputCharacter(m_hStderr, wxT(' '), m_dataLen,
+                                       csbi.dwCursorPosition, &ret) )
+    {
+        wxLogLastError(wxT("FillConsoleOutputCharacter"));
+        return false;
+    }

 
 

-    if ( !RegisterClass(&wndclass) )
+    if ( !::WriteConsole(m_hStderr, text.t_str(), text.length(), &ret, NULL) )

     {
     {

-        wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
+        wxLogLastError(wxT("WriteConsole"));
+        return false;

     }
 
     }
 

+    WriteConsoleA(m_hStderr, m_data, m_dataLen, &ret, 0);
+

     return true;
 }
 
     return true;
 }
 

+wxConsoleStderr s_consoleStderr;
+
+} // anonymous namespace
+
+bool wxGUIAppTraits::CanUseStderr()
+{
+    return s_consoleStderr.IsOkToUse();
+}
+
+bool wxGUIAppTraits::WriteToStderr(const wxString& text)
+{
+    return s_consoleStderr.IsOkToUse() && s_consoleStderr.Write(text);
+}
+
+#else // !wxUSE_DYNLIB_CLASS
+
+bool wxGUIAppTraits::CanUseStderr()
+{
+    return false;
+}
+
+bool wxGUIAppTraits::WriteToStderr(const wxString& WXUNUSED(text))
+{
+    return false;
+}
+
+#endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
+
+#endif // !__WXWINCE__
+
+// ===========================================================================
+// wxApp implementation
+// ===========================================================================
+
+int wxApp::m_nCmdShow = SW_SHOWNORMAL;
+

 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------

-// UnregisterWindowClasses
+// wxWin macros

 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 

-bool wxApp::UnregisterWindowClasses()
+IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
+
+BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
+    EVT_IDLE(wxApp::OnIdle)
+    EVT_END_SESSION(wxApp::OnEndSession)
+    EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
+END_EVENT_TABLE()
+
+// class to ensure that wxAppBase::CleanUp() is called if our Initialize()
+// fails
+class wxCallBaseCleanup

 {
 {

-    bool retval = true;
+public:
+    wxCallBaseCleanup(wxApp *app) : m_app(app) { }
+    ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }

 
 

-#ifndef __WXMICROWIN__
-    // MDI frame window class.
-    if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
-    {
-        wxLogLastError(wxT("UnregisterClass(MDI parent)"));
+    void Dismiss() { m_app = NULL; }

 
 

-        retval = false;
-    }
+private:
+    wxApp *m_app;
+};

 
 

-    // "no redraw" MDI frame
-    if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
-    {
-        wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
+//// Initialize
+bool wxApp::Initialize(int& argc, wxChar **argv)
+{
+    if ( !wxAppBase::Initialize(argc, argv) )
+        return false;

 
 

-        retval = false;
-    }
+    // ensure that base cleanup is done if we return too early
+    wxCallBaseCleanup callBaseCleanup(this);

 
 

-    // MDI child frame window class.
-    if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
-    {
-        wxLogLastError(wxT("UnregisterClass(MDI child)"));
+#if !defined(__WXMICROWIN__)
+    InitCommonControls();
+#endif // !defined(__WXMICROWIN__)

 
 

-        retval = false;
-    }
+#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
+    SHInitExtraControls();
+#endif
+
+#ifndef __WXWINCE__
+    // Don't show a message box if a function such as SHGetFileInfo
+    // fails to find a device.
+    SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
+#endif
+
+    wxOleInitialize();
+
+#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
+    wxSetKeyboardHook(true);
+#endif

 
 

-    // "no redraw" MDI child frame
-    if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
+    callBaseCleanup.Dismiss();
+
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// Win32 window class registration
+// ---------------------------------------------------------------------------
+
+/* static */
+const wxChar *wxApp::GetRegisteredClassName(const wxChar *name,
+                                            int bgBrushCol,
+                                            int extraStyles)
+{
+    const size_t count = gs_regClassesInfo.size();
+    for ( size_t n = 0; n < count; n++ )

     {
     {

-        wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
+        if ( gs_regClassesInfo[n].regname == name )
+            return gs_regClassesInfo[n].regname.c_str();
+    }
+
+    // we need to register this class
+    WNDCLASS wndclass;
+    wxZeroMemory(wndclass);
+
+    wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
+    wndclass.hInstance     = wxGetInstance();
+    wndclass.hCursor       = ::LoadCursor(NULL, IDC_ARROW);
+    wndclass.hbrBackground = (HBRUSH)wxUIntToPtr(bgBrushCol + 1);
+    wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | extraStyles;

 
 

-        retval = false;
+
+    ClassRegInfo regClass(name);
+    wndclass.lpszClassName = regClass.regname.t_str();
+    if ( !::RegisterClass(&wndclass) )
+    {
+        wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"),
+                       regClass.regname));
+        return NULL;

     }
 
     }
 

-    // canvas class name
-    if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
+    wndclass.style &= ~(CS_HREDRAW | CS_VREDRAW);
+    wndclass.lpszClassName = regClass.regnameNR.t_str();
+    if ( !::RegisterClass(&wndclass) )

     {
     {

-        wxLogLastError(wxT("UnregisterClass(canvas)"));
+        wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"),
+                       regClass.regname));
+        ::UnregisterClass(regClass.regname.c_str(), wxGetInstance());
+        return NULL;
+    }

 
 

-        retval = false;
+    gs_regClassesInfo.push_back(regClass);
+
+    // take care to return the pointer which will remain valid after the
+    // function returns (it could be invalidated later if new elements are
+    // added to the vector and it's reallocated but this shouldn't matter as
+    // this pointer should be used right now, not stored)
+    return gs_regClassesInfo.back().regname.t_str();
+}
+
+bool wxApp::IsRegisteredClassName(const wxString& name)
+{
+    const size_t count = gs_regClassesInfo.size();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        if ( gs_regClassesInfo[n].regname == name ||
+                gs_regClassesInfo[n].regnameNR == name )
+            return true;

     }
 
     }
 

-    if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
+    return false;
+}
+
+void wxApp::UnregisterWindowClasses()
+{
+    const size_t count = gs_regClassesInfo.size();
+    for ( size_t n = 0; n < count; n++ )

     {
     {

-        wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
+        const ClassRegInfo& regClass = gs_regClassesInfo[n];
+        if ( !::UnregisterClass(regClass.regname.c_str(), wxGetInstance()) )
+        {
+            wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
+                           regClass.regname));
+        }

 
 

-        retval = false;
+        if ( !::UnregisterClass(regClass.regnameNR.c_str(), wxGetInstance()) )
+        {
+            wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
+                           regClass.regnameNR));
+        }

     }
     }

-#endif // __WXMICROWIN__

 
 

-    return retval;
+    gs_regClassesInfo.clear();

 }
 
 void wxApp::CleanUp()
 {
 }
 
 void wxApp::CleanUp()
 {

-    // all objects pending for deletion must be deleted first, otherwise we
-    // would crash when they use wxWinHandleHash (and UnregisterWindowClasses()
-    // call wouldn't succeed as long as any windows still exist), so call the
-    // base class method first and only then do our clean up
+    // all objects pending for deletion must be deleted first, otherwise
+    // UnregisterWindowClasses() call wouldn't succeed (because windows
+    // using the classes being unregistered still exist), so call the base
+    // class method first and only then do our clean up

     wxAppBase::CleanUp();
 
 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     wxSetKeyboardHook(false);
 #endif
 
     wxAppBase::CleanUp();
 
 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     wxSetKeyboardHook(false);
 #endif
 

-#if wxUSE_PENWINDOWS
-    wxCleanUpPenWin();
-#endif
-
-    if ( wxDisableButtonBrush )
-        ::DeleteObject( wxDisableButtonBrush );
-
-#if wxUSE_OLE
-#ifdef __WXWINCE__
-    ::CoUninitialize();
-#else
-    ::OleUninitialize();
-#endif
-#endif
+    wxOleUninitialize();

 
     // for an EXE the classes are unregistered when it terminates but DLL may
     // be loaded several times (load/unload/load) into the same process in
     // which case the registration will fail after the first time if we don't
     // unregister the classes now
     UnregisterWindowClasses();
 
     // for an EXE the classes are unregistered when it terminates but DLL may
     // be loaded several times (load/unload/load) into the same process in
     // which case the registration will fail after the first time if we don't
     // unregister the classes now
     UnregisterWindowClasses();

-
-#if wxUSE_CTL3D
-    Ctl3dUnregister(wxhInstance);
-#endif
-
-    delete wxWinHandleHash;
-    wxWinHandleHash = NULL;
-    
-#ifdef __WXWINCE__
-    free( wxCanvasClassName );
-    free( wxCanvasClassNameNR );
-#endif

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


@@ -550,33 +786,20 @@ wxApp::wxApp()
 
 wxApp::~wxApp()
 {
 
 wxApp::~wxApp()
 {

-    // our cmd line arguments are allocated inside wxEntry(HINSTANCE), they
-    // don't come from main(), so we have to free them
-
-    while ( argc )
-    {
-        // m_argv elements were allocated by wxStrdup()
-        free(argv[--argc]);
-    }
-
-    // but m_argv itself -- using new[]
-    delete [] argv;

 }
 
 // ----------------------------------------------------------------------------
 // wxApp idle handling
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxApp idle handling
 // ----------------------------------------------------------------------------
 

-void wxApp::OnIdle(wxIdleEvent& event)
+void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))

 {
 {

-    wxAppBase::OnIdle(event);
-

 #if wxUSE_DC_CACHEING
     // automated DC cache management: clear the cached DCs and bitmap
     // if it's likely that the app has finished with them, that is, we
     // get an idle event and we're not dragging anything.
     if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
 #if wxUSE_DC_CACHEING
     // automated DC cache management: clear the cached DCs and bitmap
     // if it's likely that the app has finished with them, that is, we
     // get an idle event and we're not dragging anything.
     if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))

-        wxDC::ClearCache();
+        wxMSWDCImpl::ClearCache();

 #endif // wxUSE_DC_CACHEING
 }
 
 #endif // wxUSE_DC_CACHEING
 }
 


@@ -586,15 +809,34 @@ void wxApp::WakeUpIdle()
     // start up again.  Doing it this way ensures that the idle handler
     // wakes up in the right thread (see also wxWakeUpMainThread() which does
     // the same for the main app thread only)
     // start up again.  Doing it this way ensures that the idle handler
     // wakes up in the right thread (see also wxWakeUpMainThread() which does
     // the same for the main app thread only)

-    wxWindow *topWindow = wxTheApp->GetTopWindow();
+    wxWindow * const topWindow = wxTheApp->GetTopWindow();

     if ( topWindow )
     {
     if ( topWindow )
     {

-        if ( !::PostMessage(GetHwndOf(topWindow), WM_NULL, 0, 0) )
+        HWND hwndTop = GetHwndOf(topWindow);
+
+        // Do not post WM_NULL if there's already a pending WM_NULL to avoid
+        // overflowing the message queue.
+        //
+        // Notice that due to a limitation of PeekMessage() API (which handles
+        // 0,0 range specially), we have to check the range from 0-1 instead.
+        // This still makes it possible to overflow the queue with WM_NULLs by
+        // interspersing the calles to WakeUpIdle() with windows creation but
+        // it should be rather hard to do it accidentally.
+        MSG msg;
+        if ( !::PeekMessage(&msg, hwndTop, 0, 1, PM_NOREMOVE) ||
+              ::PeekMessage(&msg, hwndTop, 1, 1, PM_NOREMOVE) )

         {
         {

-            // should never happen
-            wxLogLastError(wxT("PostMessage(WM_NULL)"));
+            if ( !::PostMessage(hwndTop, WM_NULL, 0, 0) )
+            {
+                // should never happen
+                wxLogLastError(wxT("PostMessage(WM_NULL)"));
+            }

         }
     }
         }
     }

+#if wxUSE_THREADS
+    else
+        wxWakeUpMainThread();
+#endif // wxUSE_THREADS

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


@@ -603,8 +845,24 @@ void wxApp::WakeUpIdle()
 
 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
 {
 
 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
 {

-    if (GetTopWindow())
-        GetTopWindow()->Close(true);
+    // Windows will terminate the process soon after we return from
+    // WM_ENDSESSION handler or when we delete our last window, so make sure we
+    // at least execute our cleanup code before
+
+    // prevent the window from being destroyed when the corresponding wxTLW is
+    // destroyed: this will result in a leak of a HWND, of course, but who
+    // cares when the process is being killed anyhow
+    if ( !wxTopLevelWindows.empty() )
+        wxTopLevelWindows[0]->SetHWND(0);
+
+    const int rc = OnExit();
+
+    wxEntryCleanup();
+
+    // calling exit() instead of ExitProcess() or not doing anything at all and
+    // being killed by Windows has the advantage of executing the dtors of
+    // global objects
+    exit(rc);

 }
 
 // Default behaviour: close the application with prompts. The
 }
 
 // Default behaviour: close the application with prompts. The


@@ -619,15 +877,45 @@ void wxApp::OnQueryEndSession(wxCloseEvent& event)
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// miscellaneous
+// system DLL versions

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

+// these functions have trivial inline implementations for CE
+#ifndef __WXWINCE__
+
+#if wxUSE_DYNLIB_CLASS
+
+namespace
+{
+
+// helper function: retrieve the DLL version by using DllGetVersion(), returns
+// 0 if the DLL doesn't export such function
+int CallDllGetVersion(wxDynamicLibrary& dll)
+{
+    // now check if the function is available during run-time
+    wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dll );
+    if ( !pfnDllGetVersion )
+        return 0;
+
+    DLLVERSIONINFO dvi;
+    dvi.cbSize = sizeof(dvi);
+
+    HRESULT hr = (*pfnDllGetVersion)(&dvi);
+    if ( FAILED(hr) )
+    {
+        wxLogApiError(wxT("DllGetVersion"), hr);
+
+        return 0;
+    }
+
+    return 100*dvi.dwMajorVersion + dvi.dwMinorVersion;
+}
+
+} // anonymous namespace
+

 /* static */
 int wxApp::GetComCtl32Version()
 {
 /* static */
 int wxApp::GetComCtl32Version()
 {

-#if defined(__WXMICROWIN__) || defined(__WXWINCE__)
-    return 0;
-#else

     // cache the result
     //
     // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
     // cache the result
     //
     // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,


@@ -636,128 +924,104 @@ int wxApp::GetComCtl32Version()
 
     if ( s_verComCtl32 == -1 )
     {
 
     if ( s_verComCtl32 == -1 )
     {

-        // initally assume no comctl32.dll at all
-        s_verComCtl32 = 0;
-

         // we're prepared to handle the errors
         wxLogNull noLog;
 
         // we're prepared to handle the errors
         wxLogNull noLog;
 

-        // do we have it?
-        wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
+        // we don't want to load comctl32.dll, it should be already loaded but,
+        // depending on the OS version and the presence of the manifest, it can
+        // be either v5 or v6 and instead of trying to guess it just get the
+        // handle of the already loaded version
+        wxLoadedDLL dllComCtl32(wxT("comctl32.dll"));
+        if ( !dllComCtl32.IsLoaded() )
+        {
+            s_verComCtl32 = 0;
+            return 0;
+        }
+
+        // try DllGetVersion() for recent DLLs
+        s_verComCtl32 = CallDllGetVersion(dllComCtl32);

 
 

-        // if so, then we can check for the version
-        if ( dllComCtl32.IsLoaded() )
+        // if DllGetVersion() is unavailable either during compile or
+        // run-time, try to guess the version otherwise
+        if ( !s_verComCtl32 )

         {
         {

-#ifdef DLLVER_PLATFORM_WINDOWS
-            // try to use DllGetVersion() if available in _headers_
-            wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dllComCtl32 );
-            if ( pfnDllGetVersion )
+            // InitCommonControlsEx is unique to 4.70 and later
+            void *pfn = dllComCtl32.GetSymbol(wxT("InitCommonControlsEx"));
+            if ( !pfn )

             {
             {

-                DLLVERSIONINFO dvi;
-                dvi.cbSize = sizeof(dvi);
-
-                HRESULT hr = (*pfnDllGetVersion)(&dvi);
-                if ( FAILED(hr) )
-                {
-                    wxLogApiError(_T("DllGetVersion"), hr);
-                }
-                else
-                {
-                    // this is incompatible with _WIN32_IE values, but
-                    // compatible with the other values returned by
-                    // GetComCtl32Version()
-                    s_verComCtl32 = 100*dvi.dwMajorVersion +
-                                        dvi.dwMinorVersion;
-                }
+                // not found, must be 4.00
+                s_verComCtl32 = 400;

             }
             }

-#endif
-
-            // if DllGetVersion() is unavailable either during compile or
-            // run-time, try to guess the version otherwise
-            if ( !s_verComCtl32 )
+            else // 4.70+

             {
             {

-                // InitCommonControlsEx is unique to 4.70 and later
-                void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
+                // many symbols appeared in comctl32 4.71, could use any of
+                // them except may be DllInstall()
+                pfn = dllComCtl32.GetSymbol(wxT("InitializeFlatSB"));

                 if ( !pfn )
                 {
                 if ( !pfn )
                 {

-                    // not found, must be 4.00
-                    s_verComCtl32 = 400;
+                    // not found, must be 4.70
+                    s_verComCtl32 = 470;

                 }
                 }

-                else // 4.70+
+                else

                 {
                 {

-                    // many symbols appeared in comctl32 4.71, could use any of
-                    // them except may be DllInstall()
-                    pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
-                    if ( !pfn )
-                    {
-                        // not found, must be 4.70
-                        s_verComCtl32 = 470;
-                    }
-                    else
-                    {
-                        // found, must be 4.71 or later
-                        s_verComCtl32 = 471;
-                    }
+                    // found, must be 4.71 or later
+                    s_verComCtl32 = 471;

                 }
             }
         }
     }
 
     return s_verComCtl32;
                 }
             }
         }
     }
 
     return s_verComCtl32;

-#endif // Microwin/!Microwin

 }
 
 }
 

-// Yield to incoming messages
-
-bool wxApp::Yield(bool onlyIfNeeded)
+/* static */
+int wxApp::GetShell32Version()

 {
 {

-    // MT-FIXME
-    static bool s_inYield = false;
+    static int s_verShell32 = -1;
+    if ( s_verShell32 == -1 )
+    {
+        // we're prepared to handle the errors
+        wxLogNull noLog;

 
 

-#if wxUSE_LOG
-    // disable log flushing from here because a call to wxYield() shouldn't
-    // normally result in message boxes popping up &c
-    wxLog::Suspend();
-#endif // wxUSE_LOG
+        wxDynamicLibrary dllShell32(wxT("shell32.dll"), wxDL_VERBATIM);
+        if ( dllShell32.IsLoaded() )
+        {
+            s_verShell32 = CallDllGetVersion(dllShell32);

 
 

-    if ( s_inYield )
-    {
-        if ( !onlyIfNeeded )
+            if ( !s_verShell32 )
+            {
+                // there doesn't seem to be any way to distinguish between 4.00
+                // and 4.70 (starting from 4.71 we have DllGetVersion()) so
+                // just assume it is 4.0
+                s_verShell32 = 400;
+            }
+        }
+        else // failed load the DLL?

         {
         {

-            wxFAIL_MSG( wxT("wxYield called recursively" ) );
+            s_verShell32 = 0;

         }
         }

-
-        return false;

     }
 
     }
 

-    s_inYield = true;
-
-    // we don't want to process WM_QUIT from here - it should be processed in
-    // the main event loop in order to stop it
-    MSG msg;
-    while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
-            msg.message != WM_QUIT )
-    {
-#if wxUSE_THREADS
-        wxMutexGuiLeaveOrEnter();
-#endif // wxUSE_THREADS
+    return s_verShell32;
+}

 
 

-        if ( !wxTheApp->Dispatch() )
-            break;
-    }
+#else // !wxUSE_DYNLIB_CLASS

 
 

-    // if there are pending events, we must process them.
-    ProcessPendingEvents();
+/* static */
+int wxApp::GetComCtl32Version()
+{
+    return 0;
+}

 
 

-#if wxUSE_LOG
-    // let the logs be flashed again
-    wxLog::Resume();
-#endif // wxUSE_LOG
+/* static */
+int wxApp::GetShell32Version()
+{
+    return 0;
+}

 
 

-    s_inYield = false;
+#endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS

 
 

-    return true;
-}
+#endif // !__WXWINCE__

 
 #if wxUSE_EXCEPTIONS
 
 
 #if wxUSE_EXCEPTIONS
 


@@ -773,12 +1037,12 @@ bool wxApp::OnExceptionInMainLoop()
             ::MessageBox
               (
                 NULL,
             ::MessageBox
               (
                 NULL,

-                _T("An unhandled exception occurred. Press \"Abort\" to \
+                wxT("An unhandled exception occurred. Press \"Abort\" to \

 terminate the program,\r\n\
 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
 terminate the program,\r\n\
 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),

-                _T("Unhandled exception"),
+                wxT("Unhandled exception"),

                 MB_ABORTRETRYIGNORE |
                 MB_ABORTRETRYIGNORE |

-                MB_ICONERROR| 
+                MB_ICONERROR|

                 MB_TASKMODAL
               )
            )
                 MB_TASKMODAL
               )
            )


@@ -787,7 +1051,7 @@ terminate the program,\r\n\
             throw;
 
         default:
             throw;
 
         default:

-            wxFAIL_MSG( _T("unexpected MessageBox() return code") );
+            wxFAIL_MSG( wxT("unexpected MessageBox() return code") );

             // fall through
 
         case IDRETRY:
             // fall through
 
         case IDRETRY: