]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/app.cpp
To have better support for themed and custom backgrounds for wxMSW wxComboCtrl, use...
[wxWidgets.git] / src / msw / app.cpp
index 32779c348d776699b85e21e4d0f5e6e039fa5f63..324dd87457c9d087802a6bdb3048286777660552 100644 (file)
@@ -50,6 +50,8 @@
 #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/dc.h"
     typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
 #endif // defined(DLLVERSIONINFO)
 
+#ifndef ATTACH_PARENT_PROCESS
+    #define ATTACH_PARENT_PROCESS ((DWORD)-1)
+#endif
 
 // ---------------------------------------------------------------------------
 // global variables
 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__
-WXDLLIMPEXP_CORE       wxChar *wxCanvasClassName;
-WXDLLIMPEXP_CORE       wxChar *wxCanvasClassNameNR;
-#else
-WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName = NULL;
-WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR = NULL;
-#endif
-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
+{
+    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
+{
+
+wxVector<ClassRegInfo> gs_regClassesInfo;
+
+} // anonymous namespace
 
 // ----------------------------------------------------------------------------
 // private functions
@@ -189,11 +202,6 @@ void *wxGUIAppTraits::BeforeChildWaitLoop()
     return new ChildWaitLoopData(wd, winActive);
 }
 
-void wxGUIAppTraits::AlwaysYield()
-{
-    wxYield();
-}
-
 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
 {
     wxEndBusyCursor();
@@ -225,14 +233,20 @@ bool wxGUIAppTraits::DoMessageFromThreadWait()
     return evtLoop->Dispatch();
 }
 
-DWORD wxGUIAppTraits::WaitForThread(WXHANDLE hThread)
+DWORD wxGUIAppTraits::WaitForThread(WXHANDLE hThread, int flags)
 {
-    // if we don't have a running event loop, we shouldn't wait for the
-    // messages as we never remove them from the message queue and so we enter
-    // an infinite loop as MsgWaitForMultipleObjects() keeps returning
-    // WAIT_OBJECT_0 + 1
-    if ( !wxEventLoop::GetActive() )
+    // 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
              (
@@ -288,6 +302,8 @@ wxEventLoopBase* wxGUIAppTraits::CreateEventLoop()
 
 #ifndef __WXWINCE__
 
+#if wxUSE_DYNLIB_CLASS
+
 #include <wx/dynlib.h>
 
 namespace
@@ -326,7 +342,7 @@ public:
         {
             if ( !::FreeConsole() )
             {
-                wxLogLastError(_T("FreeConsole"));
+                wxLogLastError(wxT("FreeConsole"));
             }
         }
     }
@@ -337,7 +353,7 @@ public:
     {
         if ( m_ok == -1 )
         {
-            wxConsoleStderr * const self = wx_const_cast(wxConsoleStderr *, this);
+            wxConsoleStderr * const self = const_cast<wxConsoleStderr *>(this);
             self->m_ok = self->DoInit();
 
             // no need to call IsHistoryUnchanged() as we just initialized
@@ -385,7 +401,7 @@ private:
     GetConsoleCommandHistory_t m_pfnGetConsoleCommandHistory;
     GetConsoleCommandHistoryLength_t m_pfnGetConsoleCommandHistoryLength;
 
-    DECLARE_NO_COPY_CLASS(wxConsoleStderr)
+    wxDECLARE_NO_COPY_CLASS(wxConsoleStderr);
 };
 
 bool wxConsoleStderr::DoInit()
@@ -395,7 +411,7 @@ bool wxConsoleStderr::DoInit()
     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);
@@ -428,7 +444,7 @@ bool wxConsoleStderr::DoInit()
 
     if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )
     {
-        wxLogLastError(_T("GetConsoleScreenBufferInfo"));
+        wxLogLastError(wxT("GetConsoleScreenBufferInfo"));
         return false;
     }
 
@@ -445,7 +461,7 @@ bool wxConsoleStderr::DoInit()
         if ( !::ReadConsoleOutputCharacterA(m_hStderr, buf, WXSIZEOF(buf),
                                             pos, &ret) )
         {
-            wxLogLastError(_T("ReadConsoleOutputCharacterA"));
+            wxLogLastError(wxT("ReadConsoleOutputCharacterA"));
             return false;
         }
     } while ( wxStrncmp("    ", buf, WXSIZEOF(buf)) != 0 );
@@ -460,7 +476,7 @@ bool wxConsoleStderr::DoInit()
         if ( !::ReadConsoleOutputCharacterA(m_hStderr, m_data.data(), m_dataLen,
                                             pos, &ret) )
         {
-            wxLogLastError(_T("ReadConsoleOutputCharacterA"));
+            wxLogLastError(wxT("ReadConsoleOutputCharacterA"));
             return false;
         }
     }
@@ -471,14 +487,25 @@ bool wxConsoleStderr::DoInit()
 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 )
     {
         buf.extend(len);
-        const int len2 = m_pfnGetConsoleCommandHistory(buf.data(), len, CMD_EXE);
-        wxASSERT_MSG( len2 == len, _T("failed getting history?") );
+
+        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?") );
+        }
     }
 
     return len;
@@ -486,7 +513,7 @@ int wxConsoleStderr::GetCommandHistory(wxWxCharBuffer& buf) 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;
@@ -500,13 +527,13 @@ bool wxConsoleStderr::IsHistoryUnchanged() const
 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) )
     {
-        wxLogLastError(_T("GetConsoleScreenBufferInfo"));
+        wxLogLastError(wxT("GetConsoleScreenBufferInfo"));
         return false;
     }
 
@@ -516,21 +543,21 @@ bool wxConsoleStderr::Write(const wxString& text)
 
     if ( !::SetConsoleCursorPosition(m_hStderr, csbi.dwCursorPosition) )
     {
-        wxLogLastError(_T("SetConsoleCursorPosition"));
+        wxLogLastError(wxT("SetConsoleCursorPosition"));
         return false;
     }
 
     DWORD ret;
-    if ( !::FillConsoleOutputCharacter(m_hStderr, _T(' '), m_dataLen,
+    if ( !::FillConsoleOutputCharacter(m_hStderr, wxT(' '), m_dataLen,
                                        csbi.dwCursorPosition, &ret) )
     {
-        wxLogLastError(_T("FillConsoleOutputCharacter"));
+        wxLogLastError(wxT("FillConsoleOutputCharacter"));
         return false;
     }
 
     if ( !::WriteConsole(m_hStderr, text.wx_str(), text.length(), &ret, NULL) )
     {
-        wxLogLastError(_T("WriteConsole"));
+        wxLogLastError(wxT("WriteConsole"));
         return false;
     }
 
@@ -553,6 +580,20 @@ 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__
 
 // ===========================================================================
@@ -596,20 +637,6 @@ bool wxApp::Initialize(int& argc, wxChar **argv)
     // ensure that base cleanup is done if we return too early
     wxCallBaseCleanup callBaseCleanup(this);
 
-#ifdef __WXWINCE__
-    wxString tmp = GetAppName();
-    tmp += wxT("ClassName");
-    wxCanvasClassName = wxStrdup( tmp.wc_str() );
-    tmp += wxT("NR");
-    wxCanvasClassNameNR = wxStrdup( tmp.wc_str() );
-    HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
-    if (hWnd)
-    {
-        SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
-        return false;
-    }
-#endif
-
 #if !defined(__WXMICROWIN__)
     InitCommonControls();
 #endif // !defined(__WXMICROWIN__)
@@ -626,8 +653,6 @@ bool wxApp::Initialize(int& argc, wxChar **argv)
 
     wxOleInitialize();
 
-    RegisterWindowClasses();
-
 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     wxSetKeyboardHook(true);
 #endif
@@ -638,143 +663,93 @@ 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 *newChars = new wxChar[length];
-    wxStrncpy(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].regname == 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);
 
-    // the fields which are common to all classes
     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);
+    wndclass.hInstance     = wxGetInstance();
+    wndclass.hCursor       = ::LoadCursor(NULL, IDC_ARROW);
+    wndclass.hbrBackground = (HBRUSH)wxUIntToPtr(bgBrushCol + 1);
+    wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | extraStyles;
 
-    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) )
+    ClassRegInfo regClass(name);
+    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;
+    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(), wxGetInstance());
+        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(), wxGetInstance()) )
+        {
+            wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
+                           regClass.regname));
+        }
 
-    if ( !UnregisterAndFreeClassName(&wxCanvasClassNameNR) )
-        retval = false;
-#endif // __WXMICROWIN__
+        if ( !::UnregisterClass(regClass.regnameNR.c_str(), wxGetInstance()) )
+        {
+            wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
+                           regClass.regnameNR));
+        }
+    }
 
-    return retval;
+    gs_regClassesInfo.clear();
 }
 
 void wxApp::CleanUp()
@@ -796,11 +771,6 @@ void wxApp::CleanUp()
     // which case the registration will fail after the first time if we don't
     // unregister the classes now
     UnregisterWindowClasses();
-
-#ifdef __WXWINCE__
-    free( wxCanvasClassName );
-    free( wxCanvasClassNameNR );
-#endif
 }
 
 // ----------------------------------------------------------------------------
@@ -861,6 +831,10 @@ void wxApp::WakeUpIdle()
             }
         }
     }
+#if wxUSE_THREADS
+    else
+        wxWakeUpMainThread();
+#endif // wxUSE_THREADS
 }
 
 // ----------------------------------------------------------------------------
@@ -927,7 +901,7 @@ int CallDllGetVersion(wxDynamicLibrary& dll)
     HRESULT hr = (*pfnDllGetVersion)(&dvi);
     if ( FAILED(hr) )
     {
-        wxLogApiError(_T("DllGetVersion"), hr);
+        wxLogApiError(wxT("DllGetVersion"), hr);
 
         return 0;
     }
@@ -951,8 +925,11 @@ int wxApp::GetComCtl32Version()
         // we're prepared to handle the errors
         wxLogNull noLog;
 
-        // the DLL should really be available
-        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;
@@ -967,7 +944,7 @@ int wxApp::GetComCtl32Version()
         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
@@ -977,7 +954,7 @@ int wxApp::GetComCtl32Version()
             {
                 // 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
@@ -1004,7 +981,7 @@ int wxApp::GetShell32Version()
         // 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);
@@ -1044,61 +1021,6 @@ int wxApp::GetShell32Version()
 
 #endif // !__WXWINCE__
 
-// ----------------------------------------------------------------------------
-// Yield to incoming messages
-// ----------------------------------------------------------------------------
-
-bool wxApp::Yield(bool onlyIfNeeded)
-{
-    // MT-FIXME
-    static bool 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();
-#endif // wxUSE_LOG
-
-    if ( s_inYield )
-    {
-        if ( !onlyIfNeeded )
-        {
-            wxFAIL_MSG( wxT("wxYield called recursively" ) );
-        }
-
-        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
-    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();
-
-#if wxUSE_LOG
-    // let the logs be flashed again
-    wxLog::Resume();
-#endif // wxUSE_LOG
-
-    s_inYield = false;
-
-    return true;
-}
-
 #if wxUSE_EXCEPTIONS
 
 // ----------------------------------------------------------------------------
@@ -1113,10 +1035,10 @@ bool wxApp::OnExceptionInMainLoop()
             ::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."),
-                _T("Unhandled exception"),
+                wxT("Unhandled exception"),
                 MB_ABORTRETRYIGNORE |
                 MB_ICONERROR|
                 MB_TASKMODAL
@@ -1127,7 +1049,7 @@ terminate the program,\r\n\
             throw;
 
         default:
-            wxFAIL_MSG( _T("unexpected MessageBox() return code") );
+            wxFAIL_MSG( wxT("unexpected MessageBox() return code") );
             // fall through
 
         case IDRETRY: