// 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
- // RegisterClassWithUniqueNames()
- wxString basename;
+ 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,
- regnameNR;
+ wxString regname;
+ wxString regnameNR;
};
namespace
return new ChildWaitLoopData(wd, winActive);
}
-void wxGUIAppTraits::AlwaysYield()
-{
- wxYield();
-}
-
void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
{
wxEndBusyCursor();
delete data;
}
+#if wxUSE_THREADS
bool wxGUIAppTraits::DoMessageFromThreadWait()
{
// we should return false only if the app should exit, i.e. only if
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
(
QS_ALLPOSTMESSAGE
);
}
+#endif // wxUSE_THREADS
wxPortId wxGUIAppTraits::GetToolkitVersion(int *majVer, int *minVer) const
{
#ifndef __WXWINCE__
+#if wxUSE_DYNLIB_CLASS
+
#include <wx/dynlib.h>
namespace
{
if ( !::FreeConsole() )
{
- wxLogLastError(_T("FreeConsole"));
+ wxLogLastError(wxT("FreeConsole"));
}
}
}
GetConsoleCommandHistory_t m_pfnGetConsoleCommandHistory;
GetConsoleCommandHistoryLength_t m_pfnGetConsoleCommandHistoryLength;
- DECLARE_NO_COPY_CLASS(wxConsoleStderr)
+ wxDECLARE_NO_COPY_CLASS(wxConsoleStderr);
};
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);
if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )
{
- wxLogLastError(_T("GetConsoleScreenBufferInfo"));
+ wxLogLastError(wxT("GetConsoleScreenBufferInfo"));
return false;
}
if ( !::ReadConsoleOutputCharacterA(m_hStderr, buf, WXSIZEOF(buf),
pos, &ret) )
{
- wxLogLastError(_T("ReadConsoleOutputCharacterA"));
+ wxLogLastError(wxT("ReadConsoleOutputCharacterA"));
return false;
}
} while ( wxStrncmp(" ", buf, WXSIZEOF(buf)) != 0 );
if ( !::ReadConsoleOutputCharacterA(m_hStderr, m_data.data(), m_dataLen,
pos, &ret) )
{
- wxLogLastError(_T("ReadConsoleOutputCharacterA"));
+ wxLogLastError(wxT("ReadConsoleOutputCharacterA"));
return false;
}
}
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 )
if ( len2 != len )
{
- wxFAIL_MSG( _T("failed getting history?") );
+ wxFAIL_MSG( wxT("failed getting history?") );
}
}
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;
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;
}
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;
}
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__
// ===========================================================================
const size_t count = gs_regClassesInfo.size();
for ( size_t n = 0; n < count; n++ )
{
- if ( gs_regClassesInfo[n].basename == name )
+ if ( gs_regClassesInfo[n].regname == name )
return gs_regClassesInfo[n].regname.c_str();
}
wxZeroMemory(wndclass);
wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
- wndclass.hInstance = wxhInstance;
+ wndclass.hInstance = wxGetInstance();
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);
+ ClassRegInfo regClass(name);
wndclass.lpszClassName = regClass.regname.wx_str();
if ( !::RegisterClass(&wndclass) )
{
return NULL;
}
- // 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);
+ ::UnregisterClass(regClass.regname.c_str(), wxGetInstance());
return NULL;
}
for ( size_t n = 0; n < count; n++ )
{
const ClassRegInfo& regClass = gs_regClassesInfo[n];
- if ( !::UnregisterClass(regClass.regname.c_str(), wxhInstance) )
+ if ( !::UnregisterClass(regClass.regname.c_str(), wxGetInstance()) )
{
wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
regClass.regname));
}
- if ( !::UnregisterClass(regClass.regnameNR.c_str(), wxhInstance) )
+ if ( !::UnregisterClass(regClass.regnameNR.c_str(), wxGetInstance()) )
{
wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
regClass.regnameNR));
}
}
}
+#if wxUSE_THREADS
+ else
+ wxWakeUpMainThread();
+#endif // wxUSE_THREADS
}
// ----------------------------------------------------------------------------
HRESULT hr = (*pfnDllGetVersion)(&dvi);
if ( FAILED(hr) )
{
- wxLogApiError(_T("DllGetVersion"), hr);
+ wxLogApiError(wxT("DllGetVersion"), hr);
return 0;
}
// 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(_T("comctl32.dll"));
+ wxLoadedDLL dllComCtl32(wxT("comctl32.dll"));
if ( !dllComCtl32.IsLoaded() )
{
s_verComCtl32 = 0;
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
{
// 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
// 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);
#endif // !__WXWINCE__
-// ----------------------------------------------------------------------------
-// Yield to incoming messages
-// ----------------------------------------------------------------------------
-
-WX_DECLARE_OBJARRAY(MSG, wxMSGArray);
-
-#include <wx/arrimpl.cpp>
-WX_DEFINE_OBJARRAY(wxMSGArray);
-
-static wxMSGArray g_arrMSG;
-
-bool wxApp::DoYield(bool onlyIfNeeded, long eventsToProcess)
-{
- if ( m_isInsideYield )
- {
- if ( !onlyIfNeeded )
- {
- wxFAIL_MSG( wxT("wxYield called recursively" ) );
- }
-
- return false;
- }
-
- // set the flag and don't forget to reset it before returning
- m_isInsideYield = true;
- m_eventsToProcessInsideYield = eventsToProcess;
-
- wxON_BLOCK_EXIT_SET(m_isInsideYield, 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
-
- wxEventCategory cat;
- switch (msg.message)
- {
- case WM_NCMOUSEMOVE:
- case WM_NCLBUTTONDOWN:
- case WM_NCLBUTTONUP:
- case WM_NCLBUTTONDBLCLK:
- case WM_NCRBUTTONDOWN:
- case WM_NCRBUTTONUP:
- case WM_NCRBUTTONDBLCLK:
- case WM_NCMBUTTONDOWN:
- case WM_NCMBUTTONUP:
- case WM_NCMBUTTONDBLCLK:
-
- case WM_KEYFIRST:
- case WM_KEYDOWN:
- case WM_KEYUP:
- case WM_CHAR:
- case WM_DEADCHAR:
- case WM_SYSKEYDOWN:
- case WM_SYSKEYUP:
- case WM_SYSCHAR:
- case WM_SYSDEADCHAR:
- case WM_KEYLAST:
- case WM_HOTKEY:
- case WM_IME_STARTCOMPOSITION:
- case WM_IME_ENDCOMPOSITION:
- case WM_IME_COMPOSITION:
- case WM_IME_KEYLAST:
- case WM_COMMAND:
- case WM_SYSCOMMAND:
-
- case WM_IME_SETCONTEXT:
- case WM_IME_NOTIFY:
- case WM_IME_CONTROL:
- case WM_IME_COMPOSITIONFULL:
- case WM_IME_SELECT:
- case WM_IME_CHAR:
- case WM_IME_KEYDOWN:
- case WM_IME_KEYUP:
-
- case WM_MOUSEHOVER:
- case WM_NCMOUSELEAVE:
- case WM_MOUSELEAVE:
-
- case WM_CUT:
- case WM_COPY:
- case WM_PASTE:
- case WM_CLEAR:
- case WM_UNDO:
-
- case WM_MOUSEFIRST:
- case WM_MOUSEMOVE:
- case WM_LBUTTONDOWN:
- case WM_LBUTTONUP:
- case WM_LBUTTONDBLCLK:
- case WM_RBUTTONDOWN:
- case WM_RBUTTONUP:
- case WM_RBUTTONDBLCLK:
- case WM_MBUTTONDOWN:
- case WM_MBUTTONUP:
- case WM_MBUTTONDBLCLK:
- case WM_MOUSELAST:
- case WM_MOUSEWHEEL:
- cat = wxEVT_CATEGORY_USER_INPUT;
-
- case WM_TIMER:
- cat = wxEVT_CATEGORY_TIMER;
-
- default:
- // there are too many of these types of messages to handle them in this switch
- cat = wxEVT_CATEGORY_UI;
- }
-
- if (cat & eventsToProcess)
- {
- if ( !wxTheApp->Dispatch() )
- break;
- }
- else
- {
- // remove the message and store it
- PeekMessage(&msg, (HWND)0, 0, 0, PM_REMOVE)
- g_arrMSG.Add(msg);
- }
- }
-
- // if there are pending events, we must process them.
- ProcessPendingEvents();
-
- // put back unprocessed events in the queue
- DWORD id = GetCurrentThreadId();
- for (size_t i=0; i<g_arrMSG.GetCount(); i++)
- {
- PostThreadMessage(id, g_arrMSG[i].message, g_arrMSG[i].wParam, g_arrMSG[i].lParam);
- }
-
- g_arrMSG.Clear();
-
- return true;
-}
-
#if wxUSE_EXCEPTIONS
// ----------------------------------------------------------------------------
::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
throw;
default:
- wxFAIL_MSG( _T("unexpected MessageBox() return code") );
+ wxFAIL_MSG( wxT("unexpected MessageBox() return code") );
// fall through
case IDRETRY:
projects / wxWidgets.git / blobdiff