Applied #10639 (Not all previewed fonts are displayed with the correct nameface)

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

diff --git a/src/msw/app.cpp b/src/msw/app.cpp
index 2a65e8139e0d5e3382d11a44f709807e3bd5a46d..e8718ccdd916280b890dc94987242aebf5200370 100644 (file)
--- a/src/msw/app.cpp
+++ b/src/msw/app.cpp
@@ -51,6 +51,7 @@
 #include "wx/evtloop.h"
 #include "wx/thread.h"
 #include "wx/scopeguard.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/dc.h"
 
 #include "wx/msw/private.h"
 #include "wx/msw/dc.h"


@@ -116,12 +117,25 @@
 extern void wxSetKeyboardHook(bool doIt);
 #endif
 
 extern void wxSetKeyboardHook(bool doIt);
 #endif
 

-WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName = NULL;
-WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR = NULL;
-WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassName = NULL;
-WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassNameNoRedraw = NULL;
-WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassName = NULL;
-WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassNameNoRedraw = NULL;
+// 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
+{
+    // the base name of the class: this is used to construct the unique name in
+    // wxApp::GetRegisteredClassName()
+    wxString basename;
+
+    // the name of the registered class with and without CS_[HV]REDRAW styles
+    wxString regname,
+             regnameNR;
+};
+
+namespace
+{
+
+wxVector<ClassRegInfo> gs_regClassesInfo;
+
+} // anonymous namespace

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


@@ -186,11 +200,6 @@ void *wxGUIAppTraits::BeforeChildWaitLoop()
     return new ChildWaitLoopData(wd, winActive);
 }
 
     return new ChildWaitLoopData(wd, winActive);
 }
 

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

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


@@ -323,7 +332,7 @@ public:
         {
             if ( !::FreeConsole() )
             {
         {
             if ( !::FreeConsole() )
             {

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

             }
         }
     }
             }
         }
     }


@@ -382,7 +391,7 @@ private:
     GetConsoleCommandHistory_t m_pfnGetConsoleCommandHistory;
     GetConsoleCommandHistoryLength_t m_pfnGetConsoleCommandHistoryLength;
 
     GetConsoleCommandHistory_t m_pfnGetConsoleCommandHistory;
     GetConsoleCommandHistoryLength_t m_pfnGetConsoleCommandHistoryLength;
 

-    DECLARE_NO_COPY_CLASS(wxConsoleStderr)
+    wxDECLARE_NO_COPY_CLASS(wxConsoleStderr);

 };
 
 bool wxConsoleStderr::DoInit()
 };
 
 bool wxConsoleStderr::DoInit()


@@ -392,7 +401,7 @@ bool wxConsoleStderr::DoInit()
     if ( hStderr == INVALID_HANDLE_VALUE || !hStderr )
         return false;
 
     if ( hStderr == INVALID_HANDLE_VALUE || !hStderr )
         return false;
 

-    if ( !m_dllKernel32.Load(_T("kernel32.dll")) )
+    if ( !m_dllKernel32.Load(wxT("kernel32.dll")) )

         return false;
 
     typedef BOOL (WINAPI *AttachConsole_t)(DWORD dwProcessId);
         return false;
 
     typedef BOOL (WINAPI *AttachConsole_t)(DWORD dwProcessId);


@@ -425,7 +434,7 @@ bool wxConsoleStderr::DoInit()
 
     if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )
     {
 
     if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )
     {

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

         return false;
     }
 
         return false;
     }
 


@@ -442,7 +451,7 @@ bool wxConsoleStderr::DoInit()
         if ( !::ReadConsoleOutputCharacterA(m_hStderr, buf, WXSIZEOF(buf),
                                             pos, &ret) )
         {
         if ( !::ReadConsoleOutputCharacterA(m_hStderr, buf, WXSIZEOF(buf),
                                             pos, &ret) )
         {

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

             return false;
         }
     } while ( wxStrncmp("    ", buf, WXSIZEOF(buf)) != 0 );
             return false;
         }
     } while ( wxStrncmp("    ", buf, WXSIZEOF(buf)) != 0 );


@@ -457,7 +466,7 @@ bool wxConsoleStderr::DoInit()
         if ( !::ReadConsoleOutputCharacterA(m_hStderr, m_data.data(), m_dataLen,
                                             pos, &ret) )
         {
         if ( !::ReadConsoleOutputCharacterA(m_hStderr, m_data.data(), m_dataLen,
                                             pos, &ret) )
         {

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

             return false;
         }
     }
             return false;
         }
     }


@@ -468,7 +477,7 @@ bool wxConsoleStderr::DoInit()
 int wxConsoleStderr::GetCommandHistory(wxWxCharBuffer& buf) const
 {
     // these functions are internal and may only be called by cmd.exe
 int wxConsoleStderr::GetCommandHistory(wxWxCharBuffer& buf) const
 {
     // these functions are internal and may only be called by cmd.exe

-    static const wxChar *CMD_EXE = _T("cmd.exe");
+    static const wxChar *CMD_EXE = wxT("cmd.exe");

 
     const int len = m_pfnGetConsoleCommandHistoryLength(CMD_EXE);
     if ( len )
 
     const int len = m_pfnGetConsoleCommandHistoryLength(CMD_EXE);
     if ( len )


@@ -485,7 +494,7 @@ int wxConsoleStderr::GetCommandHistory(wxWxCharBuffer& buf) const
 
         if ( len2 != len )
         {
 
         if ( len2 != len )
         {

-            wxFAIL_MSG( _T("failed getting history?") );
+            wxFAIL_MSG( wxT("failed getting history?") );

         }
     }
 
         }
     }
 


@@ -494,7 +503,7 @@ int wxConsoleStderr::GetCommandHistory(wxWxCharBuffer& buf) const
 
 bool wxConsoleStderr::IsHistoryUnchanged() const
 {
 
 bool wxConsoleStderr::IsHistoryUnchanged() const
 {

-    wxASSERT_MSG( m_ok == 1, _T("shouldn't be called if not initialized") );
+    wxASSERT_MSG( m_ok == 1, wxT("shouldn't be called if not initialized") );

 
     // get (possibly changed) command history
     wxWxCharBuffer history;
 
     // get (possibly changed) command history
     wxWxCharBuffer history;


@@ -508,13 +517,13 @@ bool wxConsoleStderr::IsHistoryUnchanged() const
 bool wxConsoleStderr::Write(const wxString& text)
 {
     wxASSERT_MSG( m_hStderr != INVALID_HANDLE_VALUE,
 bool wxConsoleStderr::Write(const wxString& text)
 {
     wxASSERT_MSG( m_hStderr != INVALID_HANDLE_VALUE,

-                    _T("should only be called if Init() returned true") );
+                    wxT("should only be called if Init() returned true") );

 
     // get current position
     CONSOLE_SCREEN_BUFFER_INFO csbi;
     if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )
     {
 
     // get current position
     CONSOLE_SCREEN_BUFFER_INFO csbi;
     if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )
     {

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

         return false;
     }
 
         return false;
     }
 


@@ -524,21 +533,21 @@ bool wxConsoleStderr::Write(const wxString& text)
 
     if ( !::SetConsoleCursorPosition(m_hStderr, csbi.dwCursorPosition) )
     {
 
     if ( !::SetConsoleCursorPosition(m_hStderr, csbi.dwCursorPosition) )
     {

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

         return false;
     }
 
     DWORD ret;
         return false;
     }
 
     DWORD ret;

-    if ( !::FillConsoleOutputCharacter(m_hStderr, _T(' '), m_dataLen,
+    if ( !::FillConsoleOutputCharacter(m_hStderr, wxT(' '), m_dataLen,

                                        csbi.dwCursorPosition, &ret) )
     {
                                        csbi.dwCursorPosition, &ret) )
     {

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

         return false;
     }
 
     if ( !::WriteConsole(m_hStderr, text.wx_str(), text.length(), &ret, NULL) )
     {
         return false;
     }
 
     if ( !::WriteConsole(m_hStderr, text.wx_str(), text.length(), &ret, NULL) )
     {

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

         return false;
     }
 
         return false;
     }
 


@@ -620,8 +629,6 @@ bool wxApp::Initialize(int& argc, wxChar **argv)
 
     wxOleInitialize();
 
 
     wxOleInitialize();
 

-    RegisterWindowClasses();
-

 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     wxSetKeyboardHook(true);
 #endif
 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     wxSetKeyboardHook(true);
 #endif


@@ -632,143 +639,106 @@ bool wxApp::Initialize(int& argc, wxChar **argv)
 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------

-// RegisterWindowClasses
+// Win32 window class registration

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

-// This function registers the given class name and stores a pointer to a
-// heap-allocated copy of it at the specified location, it must be deleted
-// later.
-static void RegisterAndStoreClassName(const wxString& uniqueClassName,
-                                      const wxChar **className,
-                                      WNDCLASS *lpWndClass)
+/* static */
+const wxChar *wxApp::GetRegisteredClassName(const wxChar *name,
+                                            int bgBrushCol,
+                                            int extraStyles)

 {
 {

-    const size_t length = uniqueClassName.length() + 1; // for trailing NUL
-    wxChar * const newChars = new wxChar[length];
-    wxStrlcpy(newChars, uniqueClassName, length);
-    *className = newChars;
-    lpWndClass->lpszClassName = *className;
-
-    if ( !::RegisterClass(lpWndClass) )
+    const size_t count = gs_regClassesInfo.size();
+    for ( size_t n = 0; n < count; n++ )

     {
     {

-        wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"), newChars));
+        if ( gs_regClassesInfo[n].basename == name )
+            return gs_regClassesInfo[n].regname.c_str();

     }
     }

-}
-
-// This function registers the class defined by the provided WNDCLASS struct
-// contents using a unique name constructed from the specified base name and
-// and a suffix unique to this library instance. It also stores the generated
-// unique names for normal and "no redraw" versions of the class in the
-// provided variables, caller must delete their contents later.
-static void RegisterClassWithUniqueNames(const wxString& baseName,
-                                         const wxChar **className,
-                                         const wxChar **classNameNR,
-                                         WNDCLASS *lpWndClass)
-{
-    // 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;
-
-    const wxString uniqueSuffix(wxString::Format(wxT("@%p"), className));
-
-    wxString uniqueClassName(baseName + uniqueSuffix);
-    lpWndClass->style = styleNormal;
-    RegisterAndStoreClassName(uniqueClassName, className, lpWndClass);

 
 

-    // NB: remember that code elsewhere supposes that no redraw class names
-    //     use the same names as normal classes with "NR" suffix so we must put
-    //     "NR" at the end instead of using more natural baseName+"NR"+suffix
-    wxString uniqueClassNameNR(uniqueClassName + wxT("NR"));
-    lpWndClass->style = styleNoRedraw;
-    RegisterAndStoreClassName(uniqueClassNameNR, classNameNR, lpWndClass);
-}
-
-// 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()
-{
+    // we need to register this class

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

-    // the fields which are common to all classes

     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
     wndclass.hInstance     = wxhInstance;
     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
     wndclass.hInstance     = wxhInstance;

-    wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
-
-    // register the class for all normal windows and "no redraw" frames
-    wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
-    RegisterClassWithUniqueNames(wxT("wxWindowClass"),
-                                 &wxCanvasClassName,
-                                 &wxCanvasClassNameNR,
-                                 &wndclass);
-
-    // Register the MDI frame window class and "no redraw" MDI frame
-    wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
-    RegisterClassWithUniqueNames(wxT("wxMDIFrameClass"),
-                                 &wxMDIFrameClassName,
-                                 &wxMDIFrameClassNameNoRedraw,
-                                 &wndclass);
-
-    // Register the MDI child frame window class and "no redraw" MDI child frame
-    wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
-    RegisterClassWithUniqueNames(wxT("wxMDIChildFrameClass"),
-                                 &wxMDIChildFrameClassName,
-                                 &wxMDIChildFrameClassNameNoRedraw,
-                                 &wndclass);
-
-    return true;
-}
-
-// ---------------------------------------------------------------------------
-// UnregisterWindowClasses
-// ---------------------------------------------------------------------------
-
-// This function unregisters the class with the given name and frees memory
-// allocated for it by RegisterAndStoreClassName().
-static bool UnregisterAndFreeClassName(const wxChar **ppClassName)
-{
-    bool retval = true;
-
-    if ( !::UnregisterClass(*ppClassName, wxhInstance) )
+    wndclass.hCursor       = ::LoadCursor(NULL, IDC_ARROW);
+    wndclass.hbrBackground = (HBRUSH)wxUIntToPtr(bgBrushCol + 1);
+    wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | extraStyles;
+
+
+    ClassRegInfo regClass;
+    regClass.basename = name;
+
+    // constuct a unique suffix to allow registering the class with the same
+    // base name in a main application using wxWidgets and a DLL using
+    // wxWidgets loaded into its address space: as gs_regClassesInfo variable
+    // is different in them, we're going to obtain a unique prefix by using its
+    // address here
+    regClass.regname = regClass.basename +
+                            wxString::Format(wxT("@%p"), &gs_regClassesInfo);
+    wndclass.lpszClassName = regClass.regname.wx_str();
+    if ( !::RegisterClass(&wndclass) )

     {
     {

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

 
 

-        retval = false;
+    // NB: remember that code elsewhere supposes that no redraw class names
+    //     use the same names as normal classes with "NR" suffix so we must put
+    //     "NR" at the end instead of using more natural basename+"NR"+suffix
+    regClass.regnameNR = regClass.regname + GetNoRedrawClassSuffix();
+    wndclass.style &= ~(CS_HREDRAW | CS_VREDRAW);
+    wndclass.lpszClassName = regClass.regnameNR.wx_str();
+    if ( !::RegisterClass(&wndclass) )
+    {
+        wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"),
+                       regClass.regname));
+        ::UnregisterClass(regClass.regname.c_str(), wxhInstance);
+        return NULL;

     }
 
     }
 

-    delete [] (wxChar*) *ppClassName;
-    *ppClassName = NULL;
+    gs_regClassesInfo.push_back(regClass);

 
 

-    return retval;
+    // 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.wx_str();

 }
 
 }
 

-bool wxApp::UnregisterWindowClasses()
+bool wxApp::IsRegisteredClassName(const wxString& name)

 {
 {

-    bool retval = true;
-
-#ifndef __WXMICROWIN__
-    if ( !UnregisterAndFreeClassName(&wxMDIFrameClassName) )
-        retval = false;
-
-    if ( !UnregisterAndFreeClassName(&wxMDIFrameClassNameNoRedraw) )
-        retval = false;
-
-    if ( !UnregisterAndFreeClassName(&wxMDIChildFrameClassName) )
-        retval = false;
+    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 ( !UnregisterAndFreeClassName(&wxMDIChildFrameClassNameNoRedraw) )
-        retval = false;
+    return false;
+}

 
 

-    if ( !UnregisterAndFreeClassName(&wxCanvasClassName) )
-        retval = false;
+void wxApp::UnregisterWindowClasses()
+{
+    const size_t count = gs_regClassesInfo.size();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        const ClassRegInfo& regClass = gs_regClassesInfo[n];
+        if ( !::UnregisterClass(regClass.regname.c_str(), wxhInstance) )
+        {
+            wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
+                           regClass.regname));
+        }

 
 

-    if ( !UnregisterAndFreeClassName(&wxCanvasClassNameNR) )
-        retval = false;
-#endif // __WXMICROWIN__
+        if ( !::UnregisterClass(regClass.regnameNR.c_str(), wxhInstance) )
+        {
+            wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
+                           regClass.regnameNR));
+        }
+    }

 
 

-    return retval;
+    gs_regClassesInfo.clear();

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


@@ -916,7 +886,7 @@ int CallDllGetVersion(wxDynamicLibrary& dll)
     HRESULT hr = (*pfnDllGetVersion)(&dvi);
     if ( FAILED(hr) )
     {
     HRESULT hr = (*pfnDllGetVersion)(&dvi);
     if ( FAILED(hr) )
     {

-        wxLogApiError(_T("DllGetVersion"), hr);
+        wxLogApiError(wxT("DllGetVersion"), hr);

 
         return 0;
     }
 
         return 0;
     }


@@ -944,10 +914,7 @@ int wxApp::GetComCtl32Version()
         // 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
         // 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

-        wxDynamicLibrary dllComCtl32(_T("comctl32.dll"),
-                                     wxDL_VERBATIM |
-                                     wxDL_QUIET |
-                                     wxDL_GET_LOADED);
+        wxLoadedDLL dllComCtl32(wxT("comctl32.dll"));

         if ( !dllComCtl32.IsLoaded() )
         {
             s_verComCtl32 = 0;
         if ( !dllComCtl32.IsLoaded() )
         {
             s_verComCtl32 = 0;


@@ -962,7 +929,7 @@ int wxApp::GetComCtl32Version()
         if ( !s_verComCtl32 )
         {
             // InitCommonControlsEx is unique to 4.70 and later
         if ( !s_verComCtl32 )
         {
             // InitCommonControlsEx is unique to 4.70 and later

-            void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
+            void *pfn = dllComCtl32.GetSymbol(wxT("InitCommonControlsEx"));

             if ( !pfn )
             {
                 // not found, must be 4.00
             if ( !pfn )
             {
                 // not found, must be 4.00


@@ -972,7 +939,7 @@ int wxApp::GetComCtl32Version()
             {
                 // many symbols appeared in comctl32 4.71, could use any of
                 // them except may be DllInstall()
             {
                 // many symbols appeared in comctl32 4.71, could use any of
                 // them except may be DllInstall()

-                pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
+                pfn = dllComCtl32.GetSymbol(wxT("InitializeFlatSB"));

                 if ( !pfn )
                 {
                     // not found, must be 4.70
                 if ( !pfn )
                 {
                     // not found, must be 4.70


@@ -985,9 +952,6 @@ int wxApp::GetComCtl32Version()
                 }
             }
         }
                 }
             }
         }

-
-        // we shouldn't unload it here as we didn't really load it above
-        dllComCtl32.Detach();

     }
 
     return s_verComCtl32;
     }
 
     return s_verComCtl32;


@@ -1002,7 +966,7 @@ int wxApp::GetShell32Version()
         // we're prepared to handle the errors
         wxLogNull noLog;
 
         // we're prepared to handle the errors
         wxLogNull noLog;
 

-        wxDynamicLibrary dllShell32(_T("shell32.dll"), wxDL_VERBATIM);
+        wxDynamicLibrary dllShell32(wxT("shell32.dll"), wxDL_VERBATIM);

         if ( dllShell32.IsLoaded() )
         {
             s_verShell32 = CallDllGetVersion(dllShell32);
         if ( dllShell32.IsLoaded() )
         {
             s_verShell32 = CallDllGetVersion(dllShell32);


@@ -1042,61 +1006,6 @@ int wxApp::GetShell32Version()
 
 #endif // !__WXWINCE__
 
 
 #endif // !__WXWINCE__
 

-// ----------------------------------------------------------------------------
-// Yield to incoming messages
-// ----------------------------------------------------------------------------
-
-bool wxApp::Yield(bool onlyIfNeeded)
-{
-    // MT-FIXME
-    static bool s_inYield = false;
-
-    if ( s_inYield )
-    {
-        if ( !onlyIfNeeded )
-        {
-            wxFAIL_MSG( wxT("wxYield called recursively" ) );
-        }
-
-        return false;
-    }
-
-    // set the flag and don't forget to reset it before returning
-    s_inYield = true;
-    wxON_BLOCK_EXIT_SET(s_inYield, false);
-
-
-#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();
-
-    // ensure the logs will be flashed again when we exit
-    wxON_BLOCK_EXIT0(wxLog::Resume);
-#endif // wxUSE_LOG
-
-
-    // we don't want to process WM_QUIT from here - it should be processed in
-    // the main event loop in order to stop it
-    wxEventLoopGuarantor dummyLoopIfNeeded;
-    MSG msg;
-    while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
-            msg.message != WM_QUIT )
-    {
-#if wxUSE_THREADS
-        wxMutexGuiLeaveOrEnter();
-#endif // wxUSE_THREADS
-
-        if ( !wxTheApp->Dispatch() )
-            break;
-    }
-
-    // if there are pending events, we must process them.
-    ProcessPendingEvents();
-
-    return true;
-}
-

 #if wxUSE_EXCEPTIONS
 
 // ----------------------------------------------------------------------------
 #if wxUSE_EXCEPTIONS
 
 // ----------------------------------------------------------------------------


@@ -1111,10 +1020,10 @@ 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_ICONERROR|
                 MB_TASKMODAL
                 MB_ABORTRETRYIGNORE |
                 MB_ICONERROR|
                 MB_TASKMODAL


@@ -1125,7 +1034,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: