void DockWnd::setTip(const char *text)
{
m_tip = text;
QString tip = m_unreadText;
if (tip.isEmpty())
tip = i18n(text);
#ifdef WIN32
if (_Shell_NotifyIconW && IsWindowUnicode(winId())){
NOTIFYICONDATAW notifyIconData;
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
memset(notifyIconData.szTip, 0, sizeof(notifyIconData.szTip));
unsigned size = tip.length();
if (size >= sizeof(notifyIconData.szTip) / sizeof(wchar_t))
size = sizeof(notifyIconData.szTip) / sizeof(wchar_t) - 1;
memcpy(notifyIconData.szTip, tip.unicode(), size * sizeof(wchar_t));
notifyIconData.uCallbackMessage = 0;
notifyIconData.uFlags = NIF_TIP;
notifyIconData.uID = 0;
_Shell_NotifyIconW(NIM_MODIFY, ¬ifyIconData);
}else{
NOTIFYICONDATAA notifyIconData;
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
strncpy(notifyIconData.szTip, tip.local8Bit(), sizeof(notifyIconData.szTip));
notifyIconData.uCallbackMessage = 0;
notifyIconData.uFlags = NIF_TIP;
notifyIconData.uID = 0;
Shell_NotifyIconA(NIM_MODIFY, ¬ifyIconData);
}
#else
#ifndef QT_MACOSX_VERSION
if (wharfIcon == NULL){
if (isVisible()){
#endif
QToolTip::remove(this);
QToolTip::add(this, tip);
#ifndef QT_MACOSX_VERSION
}
}else{
if (wharfIcon->isVisible()){
QToolTip::remove(wharfIcon);
QToolTip::add(wharfIcon, tip);
}
}
#endif
#endif
}
void DockWnd::setTip(const char *text)
{
m_tip = text;
QString tip = m_unreadText;
if (tip.isEmpty()){
tip = i18n(text);
tip = tip.replace(QRegExp("\\&"), "");
}
#ifdef WIN32
if (IsWindowUnicode(winId())){
__NOTIFYICONDATAW notifyIconData;
memset(¬ifyIconData, 0, sizeof(notifyIconData));
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
unsigned size = tip.length();
if (size >= sizeof(notifyIconData.szTip) / sizeof(wchar_t))
size = sizeof(notifyIconData.szTip) / sizeof(wchar_t) - 1;
memcpy(notifyIconData.szTip, tip.unicode(), size * sizeof(wchar_t));
notifyIconData.uFlags = NIF_TIP;
Shell_NotifyIconW(NIM_MODIFY, (NOTIFYICONDATAW*)¬ifyIconData);
}else{
__NOTIFYICONDATAA notifyIconData;
memset(¬ifyIconData, 0, sizeof(notifyIconData));
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
strncpy(notifyIconData.szTip, tip.local8Bit(), sizeof(notifyIconData.szTip));
notifyIconData.uFlags = NIF_TIP;
Shell_NotifyIconA(NIM_MODIFY, (NOTIFYICONDATAA*)¬ifyIconData);
}
#else
#if !defined(QT_MACOSX_VERSION) && !defined(QT_MAC)
if (wharfIcon == NULL){
if (isVisible()){
#endif
QToolTip::remove(this);
QToolTip::add(this, tip);
#if !defined(QT_MACOSX_VERSION) && !defined(QT_MAC)
}
}else{
if (wharfIcon->isVisible()){
QToolTip::remove(wharfIcon);
QToolTip::add(wharfIcon, tip);
}
}
#endif
#endif
}
void mySetCaption(QWidget *w, const QString &caption)
{
inSetCaption = true;
if (IsWindowUnicode(w->winId())){
unsigned size = caption.length();
wchar_t *text = new wchar_t[size + 1];
memcpy(text, caption.unicode(), sizeof(wchar_t) * size);
text[size] = 0;
SendMessageW(w->winId(), WM_SETTEXT, 0, (LPARAM)text);
delete[] text;
}else{
SendMessageA(w->winId(), WM_SETTEXT, 0, (LPARAM)(const char*)caption.local8Bit());
}
inSetCaption = false;
}
void Ctrl::sProcessMSG(MSG& msg)
{
if (msg.message == WM_HOTKEY) {
if(msg.wParam >= 0 && (int)msg.wParam < Ctrl::hotkey.GetCount())
Ctrl::hotkey[(int)msg.wParam]();
return;
}
if(msg.message != WM_SYSKEYDOWN && msg.message != WM_SYSKEYUP
|| PassWindowsKey((dword)msg.wParam) || msg.wParam == VK_MENU) //17.11 Mirek - fix to get windows menu invoked on Alt+Space
TranslateMessage(&msg); // 04/09/07: TRC fix to make barcode reader going better
if(IsWindowUnicode(msg.hwnd))
DispatchMessageW(&msg);
else
DispatchMessage(&msg);
}
void ShortcutsPlugin::init()
{
if (m_bInit)
return;
QWidget *main = getMainWindow();
if (main){
if (IsWindowUnicode(main->winId())){
oldProc = (WNDPROC)SetWindowLongW(main->winId(), GWL_WNDPROC, (LONG)keysWndProc);
}else{
oldProc = (WNDPROC)SetWindowLongA(main->winId(), GWL_WNDPROC, (LONG)keysWndProc);
}
m_bInit = true;
applyKeys();
}
}
ShortcutsPlugin::~ShortcutsPlugin()
{
#ifdef WIN32
QWidget *main = getMainWindow();
if (main && oldProc){
if (IsWindowUnicode(main->winId())){
SetWindowLongW(main->winId(), GWL_WNDPROC, (LONG)oldProc);
}else{
SetWindowLongA(main->winId(), GWL_WNDPROC, (LONG)oldProc);
}
}
#endif
releaseKeys();
free_data(shortcutsData, &data);
}
BOOL wined3d_register_window(HWND window, struct wined3d_device *device)
{
struct wined3d_wndproc *entry;
wined3d_wndproc_mutex_lock();
if (wined3d_find_wndproc(window))
{
wined3d_wndproc_mutex_unlock();
WARN("Window %p is already registered with wined3d.\n", window);
return TRUE;
}
if (wndproc_table.size == wndproc_table.count)
{
unsigned int new_size = max(1, wndproc_table.size * 2);
struct wined3d_wndproc *new_entries;
if (!wndproc_table.entries) new_entries = HeapAlloc(GetProcessHeap(), 0, new_size * sizeof(*new_entries));
else new_entries = HeapReAlloc(GetProcessHeap(), 0, wndproc_table.entries, new_size * sizeof(*new_entries));
if (!new_entries)
{
wined3d_wndproc_mutex_unlock();
ERR("Failed to grow table.\n");
return FALSE;
}
wndproc_table.entries = new_entries;
wndproc_table.size = new_size;
}
entry = &wndproc_table.entries[wndproc_table.count++];
entry->window = window;
entry->unicode = IsWindowUnicode(window);
/* Set a window proc that matches the window. Some applications (e.g. NoX)
* replace the window proc after we've set ours, and expect to be able to
* call the previous one (ours) directly, without using CallWindowProc(). */
if (entry->unicode)
entry->proc = (WNDPROC)SetWindowLongPtrW(window, GWLP_WNDPROC, (LONG_PTR)wined3d_wndproc);
else
entry->proc = (WNDPROC)SetWindowLongPtrA(window, GWLP_WNDPROC, (LONG_PTR)wined3d_wndproc);
entry->device = device;
wined3d_wndproc_mutex_unlock();
return TRUE;
}
BOOL WINAPI RemoveWindowSubclass(HWND hWnd, SUBCLASSPROC pfnSubclass, UINT_PTR uID)
{
LPSUBCLASS_INFO stack;
LPSUBCLASSPROCS prevproc = NULL;
LPSUBCLASSPROCS proc;
BOOL ret = FALSE;
TRACE ("(%p, %p, %lx)\n", hWnd, pfnSubclass, uID);
/* Find the Subclass to remove */
stack = GetPropW (hWnd, COMCTL32_wSubclass);
if (!stack)
return FALSE;
proc = stack->SubclassProcs;
while (proc) {
if ((proc->id == uID) &&
(proc->subproc == pfnSubclass)) {
if (!prevproc)
stack->SubclassProcs = proc->next;
else
prevproc->next = proc->next;
if (stack->stackpos == proc)
stack->stackpos = stack->stackpos->next;
Free (proc);
ret = TRUE;
break;
}
prevproc = proc;
proc = proc->next;
}
if (!stack->SubclassProcs && !stack->running) {
TRACE("Last Subclass removed, cleaning up\n");
/* clean up our heap and reset the original window procedure */
if (IsWindowUnicode (hWnd))
SetWindowLongPtrW (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
else
SetWindowLongPtrA (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
Free (stack);
RemovePropW( hWnd, COMCTL32_wSubclass );
}
return ret;
}
void DockWnd::setIcon(const char *icon)
{
#ifndef WIN32
#if !defined(QT_MACOSX_VERSION) && !defined(QT_MAC)
if (wharfIcon)
wharfIcon->set(icon, NULL);
#endif
#endif
drawIcon = Pict(icon);
#ifndef WIN32
#if !defined(QT_MACOSX_VERSION) && !defined(QT_MAC)
if (!inTray){
repaint();
return;
}
#endif
#endif
#ifdef WIN32
QWidget::setIcon(drawIcon);
if (_Shell_NotifyIconW && IsWindowUnicode(winId())){
NOTIFYICONDATAW notifyIconData;
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
notifyIconData.szTip[0] = 0;
notifyIconData.uCallbackMessage = 0;
notifyIconData.uFlags = NIF_ICON;
notifyIconData.uID = 0;
_Shell_NotifyIconW(NIM_MODIFY, ¬ifyIconData);
}else{
NOTIFYICONDATAA notifyIconData;
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
notifyIconData.szTip[0] = 0;
notifyIconData.uCallbackMessage = 0;
notifyIconData.uFlags = NIF_ICON;
notifyIconData.uID = 0;
Shell_NotifyIconA(NIM_MODIFY, ¬ifyIconData);
}
#else
#if !defined(QT_MACOSX_VERSION) && !defined(QT_MAC)
if (wharfIcon)
return;
#endif
repaint();
#endif
}
void WinDockPlugin::init()
{
if (m_bInit)
return;
pMain = getMainWindow();
if (pMain){
if (IsWindowUnicode(pMain->winId())){
oldProc = (WNDPROC)SetWindowLongW(pMain->winId(), GWL_WNDPROC, (LONG)dockWndProc);
}else{
oldProc = (WNDPROC)SetWindowLongA(pMain->winId(), GWL_WNDPROC, (LONG)dockWndProc);
}
appBarMessage(ABM_NEW);
m_bInit = true;
setBarState();
pMain->installEventFilter(this);
}
}
/******************************************************************
* WDML_ServerHandleExecute
*
*
*/
static WDML_QUEUE_STATE WDML_ServerHandleExecute(WDML_CONV* pConv, WDML_XACT* pXAct)
{
HDDEDATA hDdeData = DDE_FNOTPROCESSED;
BOOL fAck = FALSE, fBusy = FALSE;
if (!(pConv->instance->CBFflags & CBF_FAIL_EXECUTES))
{
LPVOID ptr = GlobalLock(pXAct->hMem);
DWORD size = GlobalSize(pXAct->hMem);
if (ptr)
{
if (pConv->instance->unicode) /* Unicode server, try to map A->W */
hDdeData = map_A_to_W( pConv->instance->instanceID, ptr, size );
else if (!IsWindowUnicode( pConv->hwndClient )) /* ASCII server and client, try to map W->A */
hDdeData = map_W_to_A( pConv->instance->instanceID, ptr, size );
else
hDdeData = DdeCreateDataHandle(pConv->instance->instanceID, ptr, size, 0, 0, CF_TEXT, 0);
GlobalUnlock(pXAct->hMem);
}
hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_EXECUTE, 0, (HCONV)pConv,
pConv->hszTopic, 0, hDdeData, 0L, 0L);
}
switch ((ULONG_PTR)hDdeData)
{
case (ULONG_PTR)CBR_BLOCK:
return WDML_QS_BLOCK;
case DDE_FACK:
fAck = TRUE;
break;
case DDE_FBUSY:
fBusy = TRUE;
break;
default:
FIXME("Unsupported returned value %p\n", hDdeData);
/* fall through */
case DDE_FNOTPROCESSED:
break;
}
WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, (UINT_PTR)pXAct->hMem, 0, 0);
return WDML_QS_HANDLED;
}
void DockWnd::quit()
{
#ifdef WIN32
if (IsWindowUnicode(winId())){
__NOTIFYICONDATAW notifyIconData;
memset(¬ifyIconData, 0, sizeof(notifyIconData));
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hWnd = winId();
Shell_NotifyIconW(NIM_DELETE, (NOTIFYICONDATAW*)¬ifyIconData);
}else{
__NOTIFYICONDATAA notifyIconData;
memset(¬ifyIconData, 0, sizeof(notifyIconData));
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hWnd = winId();
Shell_NotifyIconA(NIM_DELETE, (NOTIFYICONDATAA*)¬ifyIconData);
}
#endif
}
void DockWnd::setIcon(const char *icon)
{
#ifndef WIN32
#if !defined(QT_MACOSX_VERSION) && !defined(QT_MAC)
if (wharfIcon)
wharfIcon->set(icon, NULL);
#endif
#endif
drawIcon = Pict(icon);
#ifndef WIN32
#if !defined(QT_MACOSX_VERSION) && !defined(QT_MAC)
if (!inTray){
repaint();
return;
}
#endif
#endif
#ifdef WIN32
QWidget::setIcon(drawIcon);
if (IsWindowUnicode(winId())){
__NOTIFYICONDATAW notifyIconData;
memset(¬ifyIconData, 0, sizeof(notifyIconData));
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
notifyIconData.uFlags = NIF_ICON;
Shell_NotifyIconW(NIM_MODIFY, (NOTIFYICONDATAW*)¬ifyIconData);
}else{
__NOTIFYICONDATAA notifyIconData;
memset(¬ifyIconData, 0, sizeof(notifyIconData));
notifyIconData.cbSize = sizeof(notifyIconData);
notifyIconData.hIcon = topData()->winIcon;
notifyIconData.hWnd = winId();
notifyIconData.uFlags = NIF_ICON;
Shell_NotifyIconA(NIM_MODIFY, (NOTIFYICONDATAA*)¬ifyIconData);
}
#else
#if !defined(QT_MACOSX_VERSION) && !defined(QT_MAC)
if (wharfIcon)
return;
#endif
repaint();
#endif
}
ShortcutsPlugin::~ShortcutsPlugin()
{
#ifdef WIN32
QWidget *main = getMainWindow();
if (main && oldProc) {
if (IsWindowUnicode(main->winId())) {
SetWindowLongW(main->winId(), GWL_WNDPROC, (LONG)oldProc);
} else {
SetWindowLongA(main->winId(), GWL_WNDPROC, (LONG)oldProc);
}
}
#else
#ifndef USE_KDE
qt_set_x11_event_filter(oldFilter);
#endif
#endif
releaseKeys();
free_data(shortcutsData, &data);
}
MainWindow::MainWindow(Geometry &geometry)
: QMainWindow(NULL, "mainwnd",
WType_TopLevel | WStyle_Customize |
WStyle_Title | WStyle_NormalBorder| WStyle_SysMenu
#ifdef __OS2__
| WStyle_MinMax
#endif
),
EventReceiver(LowestPriority)
{
m_grip = NULL;
h_lay = NULL;
m_bNoResize = false;
SET_WNDPROC("mainwnd");
m_icon = "SIM";
setIcon(Pict(m_icon.c_str()));
setTitle();
#ifdef WIN32
pMain = this;
if (IsWindowUnicode(winId())){
oldProc = (WNDPROC)SetWindowLongW(winId(), GWL_WNDPROC, (LONG)wndProc);
}else{
oldProc = (WNDPROC)SetWindowLongA(winId(), GWL_WNDPROC, (LONG)wndProc);
}
#endif
bar = NULL;
main = new MainWindowWidget(this);
setCentralWidget(main);
lay = new QVBoxLayout(main);
QStatusBar *status = statusBar();
status->hide();
status->installEventFilter(this);
local::restoreGeometry(this, geometry);
}
BOOL
IsDlgItemUnicode(
IN HWND hWnd,
IN int ControlId
)
/*++
Routine Description:
Determines if the supplied dialog item is a Unicode control.
Arguments:
hWnd - Supplies the window (dialog box) handle that contains the
control.
ControlId - Supplies the control id.
Return Value:
BOOL - Returns TRUE if the control is Unicode, FALSE if ANSI.
--*/
{
HWND hWndControl;
DbgHandleAssert( hWnd );
//
// Get the handle for the supplied control so that it can be determined
// if it is ANSI or UNICODE.
//
hWndControl = GetDlgItem( hWnd, ControlId );
DbgHandleAssert( hWndControl );
return IsWindowUnicode( hWndControl );
}
LRESULT OnDDExecute(HWND hwnd, WPARAM wparam, LPARAM lparam)
{
UINT_PTR lo, hi;
UnpackDDElParam(WM_DDE_EXECUTE, lparam, &lo, &hi);
ScopedMem<WCHAR> cmd;
DDEACK ack = { 0 };
LPVOID command = GlobalLock((HGLOBAL)hi);
if (!command)
goto Exit;
if (IsWindowUnicode((HWND)wparam))
cmd.Set(str::Dup((const WCHAR*)command));
else
cmd.Set(str::conv::FromAnsi((const char*)command));
const WCHAR *currCmd = cmd;
while (!str::IsEmpty(currCmd)) {
const WCHAR *nextCmd = NULL;
if (!nextCmd) nextCmd = HandleSyncCmd(currCmd, ack);
if (!nextCmd) nextCmd = HandleOpenCmd(currCmd, ack);
if (!nextCmd) nextCmd = HandleGotoCmd(currCmd, ack);
if (!nextCmd) nextCmd = HandlePageCmd(currCmd, ack);
if (!nextCmd) nextCmd = HandleSetViewCmd(currCmd, ack);
if (!nextCmd) {
ScopedMem<WCHAR> tmp;
nextCmd = str::Parse(currCmd, L"%S]", &tmp);
}
currCmd = nextCmd;
}
Exit:
GlobalUnlock((HGLOBAL)hi);
lparam = ReuseDDElParam(lparam, WM_DDE_EXECUTE, WM_DDE_ACK, *(WORD *)&ack, hi);
PostMessage((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, lparam);
return 0;
}
static LRESULT CALLBACK DevView_EditWndProc(HWND hwndEdit, UINT nMessage, WPARAM wParam, LPARAM lParam)
{
struct DevViewInfo *pDevViewInfo;
struct DevViewEntry *pEnt;
LRESULT rc;
HWND hwndDevView;
LONG_PTR l;
l = GetWindowLongPtr(hwndEdit, GWLP_USERDATA);
pEnt = (struct DevViewEntry *) l;
if (IsWindowUnicode(hwndEdit))
rc = CallWindowProcW(pEnt->pfnEditWndProc, hwndEdit, nMessage, wParam, lParam);
else
rc = CallWindowProcA(pEnt->pfnEditWndProc, hwndEdit, nMessage, wParam, lParam);
if (nMessage == WM_SETTEXT)
{
hwndDevView = GetParent(hwndEdit);
pDevViewInfo = GetDevViewInfo(hwndDevView);
DevView_TextChanged(hwndDevView, pEnt - pDevViewInfo->pEntries, (LPCTSTR) lParam);
}
return rc;
}
void InitMainWindow(HWND hwnd) {
BOOL isUnicode = IsWindowUnicode(hwnd);
if (isUnicode) {
if (IsWindowClassW(hwnd, L"VirtualDub")) {
g_hWndVDub = hwnd;
__VDProjectUI_MainWndProcOrig = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
}
} else {
if (IsWindowClassA(hwnd, "VirtualDub")) {
g_hWndVDub = hwnd;
__VDProjectUI_MainWndProcOrig = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
}
}
if (g_hWndVDub) {
LoadPlugins();
if (!g_bAPIOverride) {
HINSTANCE hInst = (HINSTANCE)GetWindowLongPtr(g_hWndVDub, GWLP_HINSTANCE);
if (hInst) {
if (WinAPIOverride32Init(hInst)) {
LoadFakeAPIDefinitionArray(FakeApiInfos);
g_bAPIOverride = true;
}
}
}
if (__VDProjectUI_MainWndProcOrig) {
if (isUnicode)
SetWindowLongPtrW(g_hWndVDub, GWLP_WNDPROC, (LONG)__VDProjectUI_MainWndProc);
else
SetWindowLongPtrA(g_hWndVDub, GWLP_WNDPROC, (LONG)__VDProjectUI_MainWndProc);
}
PostMessage(g_hWndVDub, WM_NULL, 0, 0);
}
}
void CCustomIOCPBaseList::ProcessMsgEvent()
{
MSG Msg;
while (PeekMessage(&Msg, 0, 0, 0, PM_NOREMOVE)) {
BOOL Unicode;
BOOL MsgExists;
Unicode = (Msg.hwnd == 0) || IsWindowUnicode(Msg.hwnd);
if (Unicode) {
MsgExists = PeekMessageW(&Msg, 0, 0, 0, PM_REMOVE);
} else {
MsgExists = PeekMessageA(&Msg, 0, 0, 0, PM_REMOVE);
}
if (MsgExists) {
TranslateMessage(&Msg);
if (Unicode) {
DispatchMessageW(&Msg);
} else {
DispatchMessageA(&Msg);
}
}
}
}
LRESULT CALLBACK MCWindowProc(HWND hwnd, UINT msg, WPARAM wParam,
LPARAM lParam)
{
static Boolean isactive = True;
KeySym keysym;
MCStack *target;
_Drawable _dw;
Drawable dw = &_dw;
dw->type = DC_WINDOW;
dw->handle.window = (MCSysWindowHandle)hwnd;
MCScreenDC *pms = (MCScreenDC *)MCscreen;
MCStack *omousestack = MCmousestackptr;
uint2 button;
Boolean down;
char buffer[XLOOKUPSTRING_SIZE];
MCPoint t_mouseloc;
t_mouseloc = MCPointMake(LOWORD(lParam), HIWORD(lParam));
// IM-2014-01-28: [[ HiDPI ]] Convert screen to logical coords
t_mouseloc = ((MCScreenDC*)MCscreen)->screentologicalpoint(t_mouseloc);
// MW-2005-02-20: Seed the SSL random number generator
#ifdef MCSSL
SeedSSL(msg, wParam, lParam);
#endif
if (curinfo == NULL)
curinfo = &dummycurinfo;
switch (msg)
{
#ifdef FEATURE_RELAUNCH_SUPPORT
case WM_COPYDATA:
{
LRESULT t_result;
COPYDATASTRUCT *t_data;
t_data = (COPYDATASTRUCT *)lParam;
t_result = 0;
if (t_data -> dwData == CWM_RELAUNCH)
{
MCresult -> clear();
MCParameter *t_first_parameter = NULL;
MCParameter *t_current_parameter = NULL;
extern char *strndup(const char *, unsigned int);
char *t_command_line = strndup((char *)t_data -> lpData, t_data -> cbData);
char *sptr = t_command_line;
while(*sptr)
{
if (*sptr == '\\')
*sptr = '/';
sptr++;
}
sptr = t_command_line;
while(*sptr)
{
char *t_argument;
int t_argument_length;
while (isspace(*sptr))
sptr++;
t_argument_length = 0;
if (*sptr == '"')
{
t_argument = ++sptr;
while (*sptr && *sptr != '"')
{
sptr++;
t_argument_length += 1;
}
}
else
{
t_argument = sptr;
while(*sptr && !isspace(*sptr))
{
sptr++;
t_argument_length += 1;
}
}
if (t_argument_length != 0)
{
MCParameter *t_parameter;
MCString t_param;
t_param . set(t_argument, t_argument_length);
t_parameter = new MCParameter(t_param);
if (t_first_parameter == NULL)
t_first_parameter = t_parameter;
else
t_current_parameter -> setnext(t_parameter);
t_current_parameter = t_parameter;
}
if (*sptr)
sptr++;
}
if (MCdispatcher -> gethome() -> message(MCM_relaunch, t_first_parameter, False, True) != ES_NORMAL)
t_result = 0;
else
{
MCExecPoint t_ep;
MCresult -> fetch(t_ep);
if (t_ep . getsvalue() == "background")
t_result = (LRESULT)HWND_BOTTOM;
else
t_result = MCdefaultstackptr -> getwindow() == NULL ? (LRESULT)HWND_BOTTOM : (LRESULT)(MCdefaultstackptr -> getwindow() -> handle . window);
}
while(t_first_parameter != NULL)
{
MCParameter *t_next;
t_next = t_first_parameter -> getnext();
delete t_first_parameter;
t_first_parameter = t_next;
}
free(t_command_line);
MCresult -> clear();
}
return t_result;
}
#endif
case CWM_TASKBAR_NOTIFICATION:
((MCScreenDC *)MCscreen) -> processtaskbarnotify(hwnd, wParam, lParam);
break;
case WM_DISPLAYCHANGE:
case WM_SETTINGCHANGE:
{
if (hwnd != ((MCScreenDC *)MCscreen) -> getinvisiblewindow())
break;
((MCScreenDC *)MCscreen) -> processdesktopchanged(true);
}
break;
case WM_PALETTECHANGED:
dw->handle.window = (MCSysWindowHandle)wParam;
if (MCdispatcher->findstackd(dw) == NULL)
{
dw->handle.window = (MCSysWindowHandle)hwnd;
MCStack *sptr = MCdispatcher->findstackd(dw);
if (sptr != NULL)
sptr->dirtyall();
}
break;
case WM_PAINT:
{
MCStack *t_stack;
t_stack = MCdispatcher -> findstackd(dw);
if (t_stack != nil)
t_stack -> onpaint();
}
break;
case WM_SETFOCUS: //FocusIn
if (curinfo->dispatch)
{
if (MCtracewindow == DNULL || hwnd != (HWND)MCtracewindow->handle.window)
{
dw->handle.window = (MCSysWindowHandle)GetFocus();
MCdispatcher->wkfocus(dw);
}
curinfo->handled = True;
}
else
{
MCEventnode *tptr = new MCEventnode(hwnd, msg, wParam, lParam, 0,
MCmodifierstate, MCeventtime);
pms->appendevent(tptr);
}
break;
case WM_KILLFOCUS: //FocusOut:
if (curinfo->dispatch)
{
if (MCtracewindow == DNULL || hwnd != (HWND)MCtracewindow->handle.window)
MCdispatcher->wkunfocus(dw);
curinfo->handled = True;
}
else
{
MCEventnode *tptr = new MCEventnode(hwnd, msg, wParam, lParam, 0,
MCmodifierstate, MCeventtime);
pms->appendevent(tptr);
}
break;
case WM_SYSKEYDOWN:
case WM_SYSCHAR:
case WM_CHAR:
case WM_KEYDOWN:
{
if (wParam == VK_CONTROL)
break;
char t_input_char;
t_input_char = (char)wParam;
if (IsWindowUnicode(hwnd))
{
if (wParam >= 128)
{
bool t_is_unicode;
WCHAR t_wide[1];
// MW-2012-07-25: [[ Bug 9200 ]] Make sure we roundtrip the input character
// through 1252 *not* the active code page (which could be anything).
t_wide[0] = (WCHAR)wParam;
t_is_unicode = (WideCharToMultiByte(1252, 0, t_wide, 1, &t_input_char, 1, NULL, NULL) == 0);
if (!t_is_unicode)
{
WCHAR t_reverse_wide[1];
t_is_unicode = MultiByteToWideChar(1252, 0, &t_input_char, 1, t_reverse_wide, 1) == 0;
if (!t_is_unicode)
t_is_unicode = t_reverse_wide[0] != t_wide[0];
}
if (t_is_unicode && (msg == WM_CHAR || msg == WM_SYSCHAR))
{
if (MCactivefield)
{
MCString t_unicode_string;
t_unicode_string . set((char *)t_wide, 2);
// MW-2012-02-03: [[ Unicode Block ]] Use the new finsert method to insert
// text in unicode mode.
MCactivefield -> finsertnew(FT_IMEINSERT, t_unicode_string, LCH_UNICODE, true);
}
break;
}
}
}
else if (wParam >= 128 && (((MCScreenDC *)MCscreen) -> system_codepage) != (((MCScreenDC *)MCscreen) -> input_codepage))
{
WCHAR t_unicode_char;
MultiByteToWideChar((((MCScreenDC *)MCscreen) -> input_codepage), 0, &t_input_char, 1, &t_unicode_char, 1);
bool t_is_unicode;
t_is_unicode = (WideCharToMultiByte((((MCScreenDC *)MCscreen) -> system_codepage), 0, &t_unicode_char, 1, &t_input_char, 1, NULL, NULL) == 0);
if (!t_is_unicode)
{
WCHAR t_reverse_unicode_char;
t_is_unicode = MultiByteToWideChar((((MCScreenDC *)MCscreen) -> system_codepage), 0, &t_input_char, 1, &t_reverse_unicode_char, 1) == 0;
if (!t_is_unicode)
t_is_unicode = t_reverse_unicode_char != t_unicode_char;
}
if (t_is_unicode)
{
if (MCactivefield)
{
MCString t_unicode_string;
t_unicode_string . set((char *)&t_unicode_char, 2);
// MW-2012-02-03: [[ Unicode Block ]] Use the new finsert method to insert
// text in unicode mode.
MCactivefield -> finsertnew(FT_IMEINSERT, t_unicode_string, LCH_UNICODE, true);
}
break;
}
}
if (msg == WM_CHAR || msg == WM_SYSCHAR)
wParam = t_input_char;
buffer[0] = buffer[1] = 0;
if (msg == WM_CHAR || msg == WM_SYSCHAR)
buffer[0] = lastchar = wParam;
// MW-2010-11-17: [[ Bug 3892 ]] Ctrl+Alt can be the same as AltGr.
// If we are a CHAR message *and* have a non-control character *and* have Ctrl+Alt set, we discard the modifiers
if ((msg == WM_CHAR || msg == WM_SYSCHAR) && wParam >= 32 && (MCmodifierstate & (MS_CONTROL | MS_ALT)) == (MS_CONTROL | MS_ALT))
MCmodifierstate = 0;
if (curinfo->keysym == 0) // event came from some other dispatch
keysym = pms->getkeysym(wParam, lParam);
else
keysym = curinfo->keysym;
lastkeysym = keysym;
if (MCmodifierstate & MS_CONTROL)
if (wParam == VK_CANCEL || keysym == '.')
{
if (MCallowinterrupts && !MCdefaultstackptr->cantabort())
curinfo->abort = True;
else
MCinterrupt = True;
}
else
if (msg == WM_KEYDOWN)
buffer[0] = lastchar = wParam;
if (curinfo->dispatch)
{
if (MCtracewindow == DNULL || hwnd != (HWND)MCtracewindow->handle.window)
{
uint2 count = LOWORD(lParam);
while (count--)
{
if (!MCdispatcher->wkdown(dw, buffer, keysym)
&& (msg == WM_SYSKEYDOWN || msg == WM_SYSCHAR))
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
if (count || lParam & 0x40000000)
MCdispatcher->wkup(dw, buffer, keysym);
}
curinfo->handled = curinfo->reset = True;
}
}
else
{
MCEventnode *tptr = new MCEventnode(hwnd, msg, wParam, lParam, keysym,
MCmodifierstate, MCeventtime);
pms->appendevent(tptr);
}
}
break;
case WM_KEYUP:
case WM_SYSKEYUP:
{
if (curinfo->keysym == 0) // event came from some other dispatch
keysym = pms->getkeysym(wParam, lParam);
else
keysym = curinfo->keysym;
if (keysym == lastkeysym)
buffer[0] = lastchar;
else
buffer[0] = 0;
buffer[1] = 0;
if (curinfo->dispatch)
{
if (MCtracewindow == DNULL || hwnd != (HWND)MCtracewindow->handle.window)
{
MCeventtime = GetMessageTime(); //krevent->time;
MCdispatcher->wkup(dw, buffer, keysym);
curinfo->handled = curinfo->reset = True;
}
}
else
{
MCEventnode *tptr = new MCEventnode(hwnd, msg, wParam, lParam, 0,
MCmodifierstate, MCeventtime);
pms->appendevent(tptr);
}
}
break;
case WM_IME_STARTCOMPOSITION:
if (!MCinlineinput)
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
break;
case WM_IME_ENDCOMPOSITION:
if (!MCinlineinput)
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
break;
case WM_IME_CHAR:
{
if (!MCactivefield)
break;
uint2 unicodekey = MAXUINT2;
uint4 destlen;
if (IsWindowUnicode(hwnd))
{
unicodekey = wParam;
destlen = 2;
}
else
{
char multibytechar[3];
multibytechar[0] = HIBYTE((WORD)wParam) ;
multibytechar[1] = LOBYTE((WORD)wParam) ;
multibytechar[2] = '\0';
MCU_multibytetounicode(multibytechar, 2, (char *)&unicodekey, 2,
destlen, MCS_langidtocharset(LOWORD(GetKeyboardLayout(0))));
}
MCString unicodestr;
unicodestr.set((char *)&unicodekey, destlen);
// MW-2012-02-03: [[ Unicode Block ]] Use the new finsert method to insert
// text in unicode mode.
MCactivefield->finsertnew(FT_IMEINSERT, unicodestr, 0, true);
}
break;
case WM_IME_COMPOSITION:
{
if (!MCinlineinput)
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
if (!MCactivefield)
break;
DWORD dwindex = 0;
if (lParam & GCS_RESULTSTR)
{
MCactivefield->stopcomposition(True,False);
dwindex = GCS_RESULTSTR;
}
else if (lParam & GCS_COMPSTR)
{
MCactivefield->startcomposition();
dwindex = GCS_COMPSTR;
}
HIMC hIMC = ImmGetContext(hwnd);
if (!hIMC || !dwindex)
break;
int2 cursorpos = LOWORD(ImmGetCompositionStringA(hIMC, GCS_CURSORPOS,
NULL, 0));
MCactivefield->setcompositioncursoroffset(cursorpos << 1);
uint2 compstrsize = 0;
char *compstring = NULL;
compstrsize = (uint2)ImmGetCompositionStringW(hIMC, dwindex, NULL, 0);
compstring = new char[compstrsize+sizeof(WCHAR)];
ImmGetCompositionStringW(hIMC, dwindex, compstring, compstrsize);
MCString unicodestr(compstring, compstrsize);
// MW-2012-02-03: [[ Unicode Block ]] Use the new finsert method to insert
// text in unicode mode.
MCactivefield->finsertnew(FT_IMEINSERT, unicodestr, 0, true);
delete compstring;
ImmReleaseContext(hwnd, hIMC);
}
break;
case WM_IME_NOTIFY: //sent when IME opens windows
switch (wParam)
{
case IMN_OPENCANDIDATE:
{
HIMC hIMC = ImmGetContext(hwnd);
DWORD imeprop = ImmGetProperty(GetKeyboardLayout(0), IGP_PROPERTY);
if (imeprop & IME_PROP_AT_CARET)
{
if (MCactivefield)
{
uint1 i;
for (i = 0; i < 4; i++)
{
MCRectangle r;
CANDIDATEFORM cdf;
cdf.dwIndex = i;
cdf.dwStyle = CFS_CANDIDATEPOS;
MCactivefield->getcompositionrect(r, -1);
cdf.ptCurrentPos.x = r.x;
cdf.ptCurrentPos.y = r.y + r.height + 32;
cdf.rcArea.right = 1;
cdf.rcArea.left = r.x;
cdf.rcArea.top = r.y + r.height + 32;
cdf.rcArea.bottom = 1;
ImmSetCandidateWindow(hIMC, &cdf);
}
}
}
}
break;
case IMN_SETOPENSTATUS:
{
COMPOSITIONFORM cpf;
HIMC hIMC = ImmGetContext(hwnd);
cpf.dwStyle = CFS_DEFAULT;
cpf.ptCurrentPos.x = 0;
cpf.ptCurrentPos.y = 0;
ImmSetCompositionWindow(hIMC, &cpf);
ImmReleaseContext(hwnd, hIMC);
}
break;
}
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
break;
case WM_SETCURSOR:
if (curinfo->live && !pms->isgrabbed() && LOWORD(lParam) != HTCLIENT)
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
MCmousestackptr = MCdispatcher->findstackd(dw);
if (MCmousestackptr != NULL)
{
MCmousestackptr->resetcursor(True);
if (pms->getmousetimer() == 0)
pms->setmousetimer(timeSetEvent(LEAVE_CHECK_INTERVAL, 100,
mouseproc, 0, TIME_ONESHOT));
}
if (omousestack != MCmousestackptr)
{
if (omousestack != NULL && omousestack != MCtracestackptr)
omousestack->munfocus();
if (MCmousestackptr != NULL && MCmousestackptr != MCtracestackptr)
MCmousestackptr->enter();
}
break;
case WM_CAPTURECHANGED:
if (curinfo->live)
{
if (pms->isgrabbed())
{
MCStack *sptr = MCdispatcher->findstackd(dw);
if (sptr != NULL)
{
if (lastdown != 0)
sptr->mup(lastdown);
buffer[0] = 0x1B; // escape
buffer[1] = '\0';
Boolean oldlock = MClockmessages;
MClockmessages = True;
sptr->kdown(buffer, XK_Escape);
sptr->kup(buffer, XK_Escape);
MClockmessages = oldlock;
sptr->munfocus();
pms->setgrabbed(False);
curinfo->handled = True;
}
capturehwnd = NULL;
}
}
break;
case WM_MOUSEMOVE: //MotionNotify:
case WM_NCMOUSEMOVE:
// IM-2013-09-23: [[ FullscreenMode ]] Update mouseloc with MCscreen getters & setters
MCStack *t_old_mousestack;
MCPoint t_old_mouseloc;
MCscreen->getmouseloc(t_old_mousestack, t_old_mouseloc);
if (t_old_mouseloc.x != t_mouseloc.x || t_old_mouseloc.y != t_mouseloc.y)
{
MCscreen->setmouseloc(t_old_mousestack, t_mouseloc);
if (curinfo->dispatch)
{
if (msg != WM_NCMOUSEMOVE)
MCscreen->setmouseloc(MCdispatcher->findstackd(dw), t_mouseloc);
if (MCtracewindow == DNULL || hwnd != (HWND)MCtracewindow->handle.window)
{
if (t_old_mousestack != NULL && MCmousestackptr != t_old_mousestack)
t_old_mousestack->munfocus();
if (msg == WM_MOUSEMOVE)
{
MCPoint t_clickloc;
MCStack *t_stackptr;
MCscreen->getclickloc(t_stackptr, t_clickloc);
MCdispatcher->wmfocus(dw, t_mouseloc.x, t_mouseloc.y);
if (capturehwnd != NULL && MCbuttonstate != 0 && !dragclick && (MCU_abs(t_mouseloc.x - t_clickloc.x) >= MCdragdelta || MCU_abs(t_mouseloc.y - t_clickloc.y) >= MCdragdelta))
{
dragclick = True;
MCdispatcher -> wmdrag(dw);
}
}
else
if (MCmousestackptr != NULL)
MCmousestackptr->munfocus();
curinfo->handled = True;
}
}
else
{
MCEventnode *tptr = new MCEventnode(hwnd, msg, wParam, lParam, 0,
MCmodifierstate, MCeventtime);
pms->appendevent(tptr);
}
}
if (msg == WM_NCMOUSEMOVE)
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
break;
case WM_APP:
if (MCmousestackptr != NULL && MCdispatcher->getmenu() == NULL)
{
POINT p;
if (!GetCursorPos(&p)
|| !MCU_point_in_rect(MCmousestackptr->getrect(),
(int2)p.x, (int2)p.y))
{
if (MCmousestackptr != MCtracestackptr)
MCmousestackptr->munfocus();
}
else
pms->setmousetimer(timeSetEvent(LEAVE_CHECK_INTERVAL, 100,
mouseproc, 0, TIME_ONESHOT));
}
curinfo->handled = True;
break;
case WM_LBUTTONDOWN:
case WM_MBUTTONDOWN:
case WM_RBUTTONDOWN:
case WM_LBUTTONUP:
case WM_MBUTTONUP:
case WM_RBUTTONUP:
case WM_LBUTTONDBLCLK:
case WM_MBUTTONDBLCLK:
case WM_RBUTTONDBLCLK:
if (msg == WM_LBUTTONDOWN || msg == WM_LBUTTONUP
|| msg == WM_LBUTTONDBLCLK)
button = 1;
else
if (msg == WM_MBUTTONDOWN || msg == WM_MBUTTONUP
|| msg == WM_MBUTTONDBLCLK)
button = 2;
else
button = 3;
if (msg == WM_LBUTTONUP || msg == WM_MBUTTONUP || msg == WM_RBUTTONUP)
{
if (curinfo->live && !pms->isgrabbed())
{
ReleaseCapture();
capturehwnd = NULL;
}
MCbuttonstate &= ~(1L << (button - 1));
down = False;
lastdown = 0;
}
else
{
if (curinfo->live && !pms->isgrabbed())
{
SetCapture(hwnd);
capturehwnd = hwnd;
lastdown = button;
}
MCbuttonstate |= 1L << (button - 1);
down = True;
if (msg == WM_LBUTTONDBLCLK || msg == WM_MBUTTONDBLCLK
|| msg == WM_RBUTTONDBLCLK)
doubledown = True;
}
if (curinfo->dispatch)
{
if (MCtracewindow == DNULL || hwnd != (HWND)MCtracewindow->handle.window)
if (down)
if (doubledown)
MCdispatcher->wdoubledown(dw, button);
else
{
if (doubleclick && MCeventtime - clicktime < MCdoubletime
&& MCU_abs(MCclicklocx - t_mouseloc.x) < MCdoubledelta
&& MCU_abs(MCclicklocy - t_mouseloc.y) < MCdoubledelta)
tripleclick = True;
else
tripleclick = False;
doubleclick = False;
// IM-2013-09-23: [[ FullscreenMode ]] Update clickloc with MCscreen getters & setters
MCscreen->setclickloc(MCmousestackptr, t_mouseloc);
dragclick = False;
MCdispatcher->wmfocus(dw, t_mouseloc.x, t_mouseloc.y);
MCdispatcher->wmdown(dw, button);
}
else
{
if (doubledown)
{
doubledown = False;
doubleclick = True;
clicktime = MCeventtime;
MCdispatcher->wdoubleup(dw, button);
}
else
MCdispatcher->wmup(dw, button);
}
curinfo->handled = curinfo->reset = True;
}
else
{
MCEventnode *tptr = new MCEventnode(hwnd, msg, wParam, lParam, 0,
MCmodifierstate, MCeventtime);
pms->appendevent(tptr);
}
break;
case WM_SIZE:
{
MCStack *target = MCdispatcher->findstackd(dw);
if (target != NULL)
{
if (wParam == SIZE_MINIMIZED)
target->iconify();
else
if (target->isiconic())
{
MCstacks->restack(target);
target->view_configure(true);
target->uniconify();
SetWindowPos((HWND)target -> getwindow() -> handle . window, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
}
else
target->view_configure(true);
curinfo->handled = True;
}
}
break;
case WM_MOVE:
MCdispatcher->configure(dw);
curinfo->handled = True;
break;
case WM_CLOSE:
MCdispatcher->wclose(dw);
curinfo->handled = True;
break;
case WM_GETMINMAXINFO:
target = MCdispatcher->findstackd(dw);
if (target != NULL)
target->constrain(lParam);
break;
case WM_ERASEBKGND:
break;
case WM_TIMER:
curinfo->handled = True;
if (MCmousestackptr != NULL && MCdispatcher->getmenu() == NULL)
{
int2 x, y;
pms->querymouse(x, y);
MCRectangle rect;
if (pms->getwindowgeometry(MCmousestackptr->getw(), rect)
&& capturehwnd == NULL && !pms->getgrabbed()
&& !MCU_point_in_rect(rect, x, y))
{
MCmousestackptr->munfocus();
MCmousestackptr = NULL;
}
}
break;
case WM_CANCELMODE:
if (pms->isgrabbed())
{
buffer[0] = 0x1B;
buffer[1] = '\0';
Boolean oldlock = MClockmessages;
MClockmessages = True;
MCdispatcher->wkdown(dw, buffer, XK_Escape);
MCdispatcher->wkup(dw, buffer, XK_Escape);
MClockmessages = oldlock;
curinfo->handled = True;
pms->setgrabbed(False);
MCmousex = MCmousey = -1; // prevent button msg from reopening menu
MCdispatcher->wmfocus(dw, MCmousex, MCmousey);
}
break;
case MM_MCINOTIFY:
if (wParam == MCI_NOTIFY_SUCCESSFUL)
{
MCPlayer *tptr = MCplayers;
while (tptr != NULL)
{
if (lParam == (LPARAM)tptr->getDeviceID())
{
if (tptr->isdisposable())
tptr->playstop();
else
tptr->message_with_args(MCM_play_stopped, tptr->getname());
break;
}
tptr = tptr->getnextplayer();
}
curinfo->handled = True;
}
break;
case WM_USER:
{
uint2 i;
for (i = 0 ; i < MCnsockets ; i++)
{
if (MCsockets[i]->fd == 0)
MCsockets[i]->readsome();
if (wParam == MCsockets[i]->fd && !MCsockets[i]->shared)
break;
}
if (i < MCnsockets)
{
if (WSAGETSELECTERROR(lParam))
{
MCsockets[i]->error = new char[16 + I4L];
sprintf(MCsockets[i]->error, "Error %d on socket",
WSAGETSELECTERROR(lParam));
MCsockets[i]->doclose();
}
else
{
/* I.M
* TODO - look in to this further:
* we sometimes get FD_READ, but there's no data ready to read
* so trying to read when using SSL results in us getting stuck
* in SSTATE_RETRYREAD, which won't be cleared until data is
* available to read. As a quick fix, we can check the socket with select()
*/
int t_events = 0;
TIMEVAL t_time = {0,0};
fd_set rmaskfd, wmaskfd, emaskfd;
FD_ZERO(&rmaskfd);
FD_ZERO(&wmaskfd);
FD_ZERO(&emaskfd);
FD_SET(wParam, &rmaskfd);
FD_SET(wParam, &emaskfd);
select(0, &rmaskfd, &wmaskfd, &emaskfd, &t_time);
if (FD_ISSET(wParam, &emaskfd))
t_events = t_events;
if (FD_ISSET(wParam, &rmaskfd))
t_events |= FD_READ;
if (FD_ISSET(wParam, &wmaskfd))
t_events |= FD_WRITE;
switch (WSAGETSELECTEVENT(lParam))
{
case FD_OOB: // bogus, from MCS_read_socket
case FD_READ:
if (t_events & FD_READ)
MCsockets[i]->readsome();
break;
case FD_WRITE:
MCsockets[i]->writesome();
MCsockets[i]->setselect();
break;
case FD_CONNECT:
MCsockets[i]->writesome();
MCsockets[i]->readsome();
MCsockets[i]->setselect();
break;
case FD_ACCEPT:
MCsockets[i]->acceptone();
break;
case FD_CLOSE:
MCsockets[i]->readsome();
#ifdef MCSSL
if (MCsockets[i]->fd != 0 && !MCsockets[i]->secure)
#else
if (MCsockets[i]->fd != 0)
#endif
MCsockets[i]->doclose();
break;
}
}
}
curinfo->handled = True;
break;
}
case WM_WINDOWPOSCHANGING:
{
((MCScreenDC *)MCscreen) -> restackwindows(hwnd, msg, wParam, lParam);
// return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
}
break;
case WM_POWERBROADCAST:
MCS_reset_time();
return TRUE;
case WM_THEMECHANGED:
case WM_SYSCOLORCHANGE:
if (hwnd == pms->getinvisiblewindow() && MCcurtheme && MCcurtheme->getthemeid() == LF_NATIVEWIN)
{
MCcurtheme->unload();
MCcurtheme->load();
// MW-2011-08-17: [[ Redraw ]] The theme has changed so redraw everything.
MCRedrawDirtyScreen();
}
break;
case WM_ACTIVATEAPP:
if (wParam != isactive)
{
MCstacks->hidepalettes(!wParam);
((MCScreenDC *)MCscreen) -> hidebackdrop(!wParam);
if (MCdefaultstackptr != NULL)
MCdefaultstackptr->getcard()->message(wParam ? MCM_resume : MCM_suspend);
isactive = wParam;
if (!wParam)
{
if (pms->taskbarhidden)
{ //we are suspended, show menu bar for other process
pms->showtaskbar();
pms->taskbarhidden = True;
}
}
else
{
if (pms->taskbarhidden)
{
pms->taskbarhidden = False;
pms->hidetaskbar();
}
}
}
break;
case WM_INPUTLANGCHANGE:
{
LCID t_locale_id;
t_locale_id = MAKELCID(lParam, SORT_DEFAULT);
char t_info[8];
GetLocaleInfoA(t_locale_id, LOCALE_IDEFAULTANSICODEPAGE, t_info, 8);
((MCScreenDC *)MCscreen) -> input_codepage = atoi(t_info);
((MCScreenDC *)MCscreen) -> system_codepage = GetACP();
}
break;
case WM_NCACTIVATE:
if (MCactivatepalettes && wParam == FALSE && MCstacks->getactive())
{
MCStack *sptr = MCdispatcher->findstackd(dw);
if (sptr != NULL && sptr->getmode() == WM_PALETTE)
wParam = TRUE;
}
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
case WM_MOUSEWHEEL:
case WM_MOUSEHWHEEL:
if (MCmousestackptr != NULL)
{
MCObject *mfocused = MCmousestackptr->getcard()->getmfocused();
if (mfocused == NULL)
mfocused = MCmousestackptr -> getcard();
if (mfocused != NULL)
{
int4 val = (short)HIWORD(wParam);
if (msg == WM_MOUSEWHEEL)
{
if (val < 0)
mfocused->kdown("", XK_WheelUp);
else
mfocused->kdown("", XK_WheelDown);
}
else if (msg == WM_MOUSEHWHEEL)
{
if (val < 0)
mfocused->kdown("", XK_WheelLeft);
else
mfocused->kdown("", XK_WheelRight);
}
}
}
break;
default:
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
}
return 0;
}
/******************************************************************
* WDML_ServerNameProc
*
*
*/
static LRESULT CALLBACK WDML_ServerNameProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
HWND hwndClient;
HSZ hszApp, hszTop;
HDDEDATA hDdeData = 0;
WDML_INSTANCE* pInstance;
UINT uiLo, uiHi;
switch (iMsg)
{
case WM_DDE_INITIATE:
/* wParam -- sending window handle
LOWORD(lParam) -- application atom
HIWORD(lParam) -- topic atom */
TRACE("WM_DDE_INITIATE message received!\n");
hwndClient = (HWND)wParam;
pInstance = WDML_GetInstanceFromWnd(hwndServer);
TRACE("idInst=%ld, threadID=0x%lx\n", pInstance->instanceID, GetCurrentThreadId());
if (!pInstance) return 0;
/* don't free DDEParams, since this is a broadcast */
UnpackDDElParam(WM_DDE_INITIATE, lParam, &uiLo, &uiHi);
hszApp = WDML_MakeHszFromAtom(pInstance, uiLo);
hszTop = WDML_MakeHszFromAtom(pInstance, uiHi);
if (!(pInstance->CBFflags & CBF_FAIL_CONNECTIONS))
{
BOOL self = FALSE;
CONVCONTEXT cc;
CONVCONTEXT* pcc = NULL;
WDML_CONV* pConv;
char buf[256];
if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
{
self = TRUE;
}
/* FIXME: so far, we don't grab distant convcontext, so only check if remote is
* handled under DDEML, and if so build a default context
*/
if ((GetClassNameA(hwndClient, buf, sizeof(buf)) &&
strcmp(buf, WDML_szClientConvClassA) == 0) ||
(GetClassNameW(hwndClient, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
lstrcmpW((LPWSTR)buf, WDML_szClientConvClassW) == 0))
{
pcc = &cc;
memset(pcc, 0, sizeof(*pcc));
pcc->cb = sizeof(*pcc);
pcc->iCodePage = IsWindowUnicode(hwndClient) ? CP_WINUNICODE : CP_WINANSI;
}
if ((pInstance->CBFflags & CBF_FAIL_SELFCONNECTIONS) && self)
{
TRACE("Don't do self connection as requested\n");
}
else if (hszApp && hszTop)
{
WDML_SERVER* pServer = (WDML_SERVER*)GetWindowLongA(hwndServer, GWL_WDML_SERVER);
/* check filters for name service */
if (!pServer->filterOn || DdeCmpStringHandles(pServer->hszService, hszApp) == 0)
{
/* pass on to the callback */
hDdeData = WDML_InvokeCallback(pInstance, XTYP_CONNECT,
0, 0, hszTop, hszApp, 0, (DWORD)pcc, self);
if ((UINT)hDdeData)
{
pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
hszApp, hszTop);
if (pConv && pcc) pConv->wStatus |= ST_ISLOCAL;
}
}
}
else if (pInstance->servers)
{
/* pass on to the callback */
hDdeData = WDML_InvokeCallback(pInstance, XTYP_WILDCONNECT,
0, 0, hszTop, hszApp, 0, (DWORD)pcc, self);
if (hDdeData == (HDDEDATA)CBR_BLOCK)
{
/* MS doc is not consistent here */
FIXME("CBR_BLOCK returned for WILDCONNECT\n");
}
else if ((UINT)hDdeData != 0)
{
HSZPAIR* hszp;
hszp = (HSZPAIR*)DdeAccessData(hDdeData, NULL);
if (hszp)
{
int i;
for (i = 0; hszp[i].hszSvc && hszp[i].hszTopic; i++)
{
pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
hszp[i].hszSvc, hszp[i].hszTopic);
if (pConv && pcc) pConv->wStatus |= ST_ISLOCAL;
}
DdeUnaccessData(hDdeData);
}
if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
}
}
}
return 0;
case WM_DDE_REQUEST:
FIXME("WM_DDE_REQUEST message received!\n");
return 0;
case WM_DDE_ADVISE:
FIXME("WM_DDE_ADVISE message received!\n");
return 0;
case WM_DDE_UNADVISE:
FIXME("WM_DDE_UNADVISE message received!\n");
return 0;
case WM_DDE_EXECUTE:
FIXME("WM_DDE_EXECUTE message received!\n");
return 0;
case WM_DDE_POKE:
FIXME("WM_DDE_POKE message received!\n");
return 0;
case WM_DDE_TERMINATE:
FIXME("WM_DDE_TERMINATE message received!\n");
return 0;
}
return DefWindowProcA(hwndServer, iMsg, wParam, lParam);
}
bool CConEmuCtrl::key_PicViewSlideshow(const ConEmuChord& VkState, bool TestOnly, const ConEmuHotKey* hk, CRealConsole* pRCon)
{
if (!pRCon)
return false;
//if (TestOnly) -- ниже, доп.проверки
// return true;
if (VkState.Vk == VK_PAUSE)
{
// SlideShow в PicView2 подзадержался
if (gpConEmu->isPictureView() /*&& !IsWindowUnicode(hPictureView)*/)
{
bool lbAllowed = true;
if (IsWindowUnicode(gpConEmu->hPictureView))
{
// На будущее, если будет "встроенный" SlideShow - вернуть на это сообщение TRUE
UINT nMsg = RegisterWindowMessage(L"PicView:HasSlideShow");
DWORD_PTR nRc = 0;
LRESULT lRc = SendMessageTimeout(gpConEmu->hPictureView, nMsg, 0,0, SMTO_NORMAL, 1000, &nRc);
if (!lRc || nRc == TRUE)
lbAllowed = false;
}
if (!lbAllowed)
return false;
if (TestOnly)
return true;
gpConEmu->bPicViewSlideShow = !gpConEmu->bPicViewSlideShow;
if (gpConEmu->bPicViewSlideShow)
{
if (gpSet->nSlideShowElapse<=500) gpSet->nSlideShowElapse=500;
gpConEmu->dwLastSlideShowTick = GetTickCount() - gpSet->nSlideShowElapse;
}
return true;
}
}
else if (gpConEmu->bPicViewSlideShow)
{
//KillTimer(hWnd, 3);
if ((VkState.Vk == 0xbd/* -_ */) || (VkState.Vk == 0xbb/* =+ */))
{
if (TestOnly)
return true;
if (VkState.Vk == 0xbb)
{
gpSet->nSlideShowElapse = 1.2 * gpSet->nSlideShowElapse;
}
else
{
gpSet->nSlideShowElapse = gpSet->nSlideShowElapse / 1.2;
if (gpSet->nSlideShowElapse<=500) gpSet->nSlideShowElapse=500;
}
return true;
}
//else
//{
// //bPicViewSlideShow = false; // отмена слайдшоу
// return false;
//}
}
return false;
}
void ProcessAttach()
{
#define FOR_COMMON
#ifdef FOR_COMMON
GetInjectWindow();
if (NULL == g_hCalc)
{
return;
}
#else
HWND hParent = ::FindWindow(NULL, "计算器");
g_hCalc = hParent;
#endif
////检查窗口口是否UNICODE
g_bUnicode = IsWindowUnicode(g_hCalc);
#ifdef HOOK_HOME
//对进程所有窗口进行遍历，并更改消息过程函数。
//消息过程函数需要临界区同步
InitializeCriticalSection(&g_cs);
if (g_bUnicode)
{
//不要忘记主窗口的消息过程函数的替换
g_hWnd[g_nCount] = g_hCalc;
g_OldProc[g_nCount] = (WNDPROC)::SetWindowLongW(g_hCalc,
GWL_WNDPROC,
(LONG)WindowProc);
g_nCount++;
EnumChildWindows(g_hCalc,
EnumChildProc_Unicode,
g_bUnicode);
}
else
{
g_hWnd[g_nCount] = g_hCalc;
g_OldProc[g_nCount] = (WNDPROC)::SetWindowLongA(g_hCalc,
GWL_WNDPROC,
(LONG)WindowProc);
g_nCount++;
EnumChildWindows(g_hCalc,
EnumChildProc,
g_bUnicode);
}
#else
#ifdef WIN7
g_hCalc = ::GetWindow(hParent, GW_CHILD);
if (g_hCalc == NULL)
{
::MessageBox(NULL, "没找到计算器", NULL, MB_OK);
return TRUE;
}
#endif
if (g_bUnicode)
{
//修改窗口过程函数
g_pfnOld = (WNDPROC)::SetWindowLongW(g_hCalc,
GWL_WNDPROC,
(LONG)WindowProc);
}
else
{
//修改窗口过程函数
g_pfnOld = (WNDPROC)::SetWindowLongA(g_hCalc,
GWL_WNDPROC,
(LONG)WindowProc);
}
#endif //end for HOOK_HOME
}
LRESULT VDDualCallWindowProcW32(WNDPROC wp, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
return (IsWindowUnicode(hwnd) ? CallWindowProcW : CallWindowProcA)(wp, hwnd, msg, wParam, lParam);
}
BOOL WINAPI SetWindowSubclass (HWND hWnd, SUBCLASSPROC pfnSubclass,
UINT_PTR uIDSubclass, DWORD_PTR dwRef)
{
LPSUBCLASS_INFO stack;
LPSUBCLASSPROCS proc;
TRACE ("(%p, %p, %lx, %lx)\n", hWnd, pfnSubclass, uIDSubclass, dwRef);
/* Since the window procedure that we set here has two additional arguments,
* we can't simply set it as the new window procedure of the window. So we
* set our own window procedure and then calculate the other two arguments
* from there. */
/* See if we have been called for this window */
stack = GetPropW (hWnd, COMCTL32_wSubclass);
if (!stack) {
/* allocate stack */
stack = Alloc (sizeof(SUBCLASS_INFO));
if (!stack) {
ERR ("Failed to allocate our Subclassing stack\n");
return FALSE;
}
SetPropW (hWnd, COMCTL32_wSubclass, stack);
/* set window procedure to our own and save the current one */
if (IsWindowUnicode (hWnd))
stack->origproc = (WNDPROC)SetWindowLongPtrW (hWnd, GWLP_WNDPROC,
(DWORD_PTR)COMCTL32_SubclassProc);
else
stack->origproc = (WNDPROC)SetWindowLongPtrA (hWnd, GWLP_WNDPROC,
(DWORD_PTR)COMCTL32_SubclassProc);
}
else {
/* Check to see if we have called this function with the same uIDSubClass
* and pfnSubclass */
proc = stack->SubclassProcs;
while (proc) {
if ((proc->id == uIDSubclass) &&
(proc->subproc == pfnSubclass)) {
proc->ref = dwRef;
return TRUE;
}
proc = proc->next;
}
}
proc = Alloc(sizeof(SUBCLASSPROCS));
if (!proc) {
ERR ("Failed to allocate subclass entry in stack\n");
if (IsWindowUnicode (hWnd))
SetWindowLongPtrW (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
else
SetWindowLongPtrA (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
Free (stack);
RemovePropW( hWnd, COMCTL32_wSubclass );
return FALSE;
}
proc->subproc = pfnSubclass;
proc->ref = dwRef;
proc->id = uIDSubclass;
proc->next = stack->SubclassProcs;
stack->SubclassProcs = proc;
return TRUE;
}
LRESULT VDDualDefWindowProcW32(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam);
}
int InjectCode ()
{
HANDLE hProcess = 0; // Process handle
HMODULE hUser32 = 0; // Handle of user32.dll
BYTE *pCodeRemote; // Address of InjectFunc() in the remote process.
BYTE *pGetSASWndRemote; // Address of GetSASWnd() in the remote process.
HANDLE hThread = 0; // The handle and ID of the thread executing
DWORD dwThreadId = 0; // the remote InjectFunc().
INJDATA DataLocal; // INJDATA structure
BOOL fUnicode; // TRUE if remote process is Unicode
int nSuccess = 0; // Subclassing succeded?
DWORD dwNumBytesCopied = 0; // Number of bytes written to the remote process.
DWORD size; // Calculated function size (= AfterFunc() - Func())
int SearchSize; // SASWindowProc() dummy addr. search size
int nDummyOffset; // Offset in SASWindowProc() of dummy addr.
BOOL FoundDummyAddr; // Dummy INJDATA reference found in SASWindowProc() ?
HWND hSASWnd; // Window handle of Winlogon process
BYTE *p;
// Enable Debug privilege (needed for some processes)
if (!EnablePrivilege(SE_DEBUG_NAME, TRUE))
return 0;
// Get handle of "USER32.DLL"
hUser32 = GetModuleHandle("user32");
if (!hUser32)
return 0;
// Get remote process ID
PID = GetPIDFromName(szProcessName);
if (PID == -1)
return 0;
// Open remote process
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
if (!hProcess)
return 0;
__try
{
// Initialize INJDATA for GetSASWnd() call
strcpy(DataLocal.szClassName, "SAS Window class");
strcpy(DataLocal.szWindowName, "SAS window");
DataLocal.fnFindWindow = (FINDWINDOW) GetProcAddress(hUser32, "FindWindowA");
if (DataLocal.fnFindWindow == NULL)
__leave;
// Allocate memory in the remote process and write a copy of initialized INJDATA into it
size = sizeof(INJDATA);
pDataRemote = (PBYTE) VirtualAllocEx(hProcess, 0, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (!pDataRemote)
__leave;
if (!WriteProcessMemory(hProcess, pDataRemote, &DataLocal, size, &dwNumBytesCopied) || dwNumBytesCopied != size)
__leave;
// Allocate memory in remote process and write a copy of GetSASWnd() into it
size = (PBYTE)AfterGetSASWnd - (PBYTE)GetSASWnd;
pGetSASWndRemote = (PBYTE) VirtualAllocEx(hProcess, 0, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (!pGetSASWndRemote)
__leave;
if (!WriteProcessMemory(hProcess, pGetSASWndRemote, &GetSASWnd, size, &dwNumBytesCopied) || dwNumBytesCopied != size)
__leave;
// Start execution of remote GetSASWnd()
hThread = CreateRemoteThread(hProcess,
NULL,
0,
(LPTHREAD_START_ROUTINE) pGetSASWndRemote,
pDataRemote,
0 ,
&dwThreadId);
// Failed
if (!hThread)
__leave;
// Wait for GetSASWnd() to terminate and get return code (SAS Wnd handle)
WaitForSingleObject(hThread, INFINITE);
GetExitCodeThread(hThread, (PDWORD) &hSASWnd);
// Didn't found "SAS window"
if (!hSASWnd)
__leave;
// Cleanup
VirtualFreeEx(hProcess, pGetSASWndRemote, 0, MEM_RELEASE);
VirtualFreeEx(hProcess, pDataRemote, 0, MEM_RELEASE);
pGetSASWndRemote = NULL;
pDataRemote = NULL;
// Allocate memory in remote process and write a copy of SASWindowProc() into it
size = (PBYTE)AfterSASWindowProc - (PBYTE)SASWindowProc;
pSASWinProcRemote = (PBYTE) VirtualAllocEx(hProcess, 0, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (!pSASWinProcRemote)
__leave;
if (!WriteProcessMemory(hProcess, pSASWinProcRemote, &SASWindowProc, size, &dwNumBytesCopied) || dwNumBytesCopied != size)
__leave;
// Is remote process unicode ?
fUnicode = IsWindowUnicode(hSASWnd);
// Initialize the INJDATA structure
DataLocal.fnSetWindowLong = (SETWINDOWLONG) GetProcAddress(hUser32, fUnicode ? "SetWindowLongW" : "SetWindowLongA");
DataLocal.fnCallWindowProc = (CALLWINDOWPROC) GetProcAddress(hUser32, fUnicode ? "CallWindowProcW": "CallWindowProcA");
DataLocal.fnSASWndProc = (WNDPROC) pSASWinProcRemote;
DataLocal.hwnd = hSASWnd;
if (DataLocal.fnSetWindowLong == NULL ||
DataLocal.fnCallWindowProc == NULL)
{
__leave;
}
// Allocate memory in the remote process and write a copy of initialized INJDATA into it
size = sizeof(INJDATA);
pDataRemote = (PBYTE) VirtualAllocEx(hProcess, 0, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (!pDataRemote)
__leave;
if (!WriteProcessMemory(hProcess, pDataRemote, &DataLocal, size, &dwNumBytesCopied) || dwNumBytesCopied != size)
__leave;
// Change dummy INJDATA address in SASWindowProc() by the real INJDATA pointer
p = (PBYTE)&SASWindowProc;
size = (PBYTE)AfterSASWindowProc - (PBYTE)SASWindowProc;
SearchSize = size - sizeof(DWORD) + 1;
FoundDummyAddr = FALSE;
for (; SearchSize > 0; p++, SearchSize--)
{
if (*(DWORD *)p == DUMMY_ADDR) // Found
{
nDummyOffset = p - (PBYTE)&SASWindowProc;
if (!WriteProcessMemory(hProcess, pSASWinProcRemote + nDummyOffset, &pDataRemote, sizeof(pDataRemote), &dwNumBytesCopied) ||
dwNumBytesCopied != sizeof(pDataRemote))
{
__leave;
}
FoundDummyAddr = TRUE;
break;
}
}
// Couldn't change the dummy INJDATA addr. by the real addr. in SASWindowProc() !?!
// Don't execute the remote copy of SASWindowProc() because the pData pointer is invalid !
if (!FoundDummyAddr)
{
__leave;
}
// Allocate memory in the remote process and write a copy of InjectFunc() to the allocated memory
size = (PBYTE)AfterInjectFunc - (PBYTE)InjectFunc;
pCodeRemote = (PBYTE) VirtualAllocEx(hProcess, 0, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (!pCodeRemote)
__leave;
if (!WriteProcessMemory(hProcess, pCodeRemote, &InjectFunc, size, &dwNumBytesCopied) || dwNumBytesCopied != size)
__leave;
// Start execution of remote InjectFunc()
hThread = CreateRemoteThread(hProcess,
NULL,
0,
(LPTHREAD_START_ROUTINE) pCodeRemote,
pDataRemote,
0 ,
&dwThreadId);
if (!hThread)
__leave;
// Wait for InjectFunc() to terminate and get return code
WaitForSingleObject(hThread, INFINITE);
GetExitCodeThread(hThread, (PDWORD) &nSuccess);
// InjectFunc() successfull
// if (nSuccess)
// MessageBeep(0);
}
__finally
{
// Failed ?
if (!nSuccess)
{
// Release memory for INJDATA and SASWindowProc()
if (pDataRemote)
VirtualFreeEx(hProcess, pDataRemote, 0, MEM_RELEASE);
if (pSASWinProcRemote)
VirtualFreeEx(hProcess, pSASWinProcRemote, 0, MEM_RELEASE);
pDataRemote = NULL;
pSASWinProcRemote = NULL;
}
// Release remote GetSASWnd()
if (pGetSASWndRemote)
VirtualFreeEx(hProcess, pGetSASWndRemote, 0, MEM_RELEASE);
// Release remote InjectFunc() (no longer needed)
if (pCodeRemote)
VirtualFreeEx(hProcess, pCodeRemote, 0, MEM_RELEASE);
if (hThread)
CloseHandle(hThread);
}
CloseHandle(hProcess);
// Disable the DEBUG privilege
EnablePrivilege(SE_DEBUG_NAME, FALSE);
return nSuccess; // 0=failure; 1=success
}
bool Ctrl::GetMsg(MSG& msg)
{
if(!PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) return false;
return IsWindowUnicode(msg.hwnd) ? PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE)
: PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
}
int WINAPI
WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpszCmdLine,
int nCmdShow)
{
WNDCLASSW wc;
HWND hWnd;
WCHAR WindowTextW[256];
char WindowTextA[256];
wc.lpszClassName = L"UnicodeClass";
wc.lpfnWndProc = UnicodeWndProc;
wc.style = 0;
wc.hInstance = hInstance;
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
if (RegisterClassW(&wc) == 0)
{
fprintf(stderr, "RegisterClassW failed (last error 0x%lu)\n",
GetLastError());
return 1;
}
printf("Unicode class registered, WndProc = 0x%p\n", wc.lpfnWndProc);
hWnd = CreateWindowA("UnicodeClass",
"Unicode Window",
WS_OVERLAPPEDWINDOW,
0,
0,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL,
NULL,
hInstance,
NULL);
if (hWnd == NULL)
{
fprintf(stderr, "CreateWindowA failed (last error 0x%lu)\n",
GetLastError());
return 1;
}
printf("Window created, IsWindowUnicode returns %s\n", IsWindowUnicode(hWnd) ? "TRUE" : "FALSE");
printf("Calling GetWindowTextW\n");
if (! GetWindowTextW(hWnd, WindowTextW, sizeof(WindowTextW) / sizeof(WindowTextW[0])))
{
fprintf(stderr, "GetWindowTextW failed (last error 0x%lu)\n", GetLastError());
return 1;
}
printf("GetWindowTextW returned Unicode string \"%S\"\n", WindowTextW);
printf("Calling GetWindowTextA\n");
if (! GetWindowTextA(hWnd, WindowTextA, sizeof(WindowTextA) / sizeof(WindowTextA[0])))
{
fprintf(stderr, "GetWindowTextA failed (last error 0x%lu)\n", GetLastError());
return 1;
}
printf("GetWindowTextA returned Ansi string \"%s\"\n", WindowTextA);
printf("\n");
SavedWndProcW = (WNDPROC) GetWindowLongW(hWnd, GWL_WNDPROC);
printf("GetWindowLongW returned 0x%p\n", SavedWndProcW);
SavedWndProcA = (WNDPROC) GetWindowLongA(hWnd, GWL_WNDPROC);
printf("GetWindowLongA returned 0x%p\n", SavedWndProcA);
printf("\n");
printf("Subclassing window using SetWindowLongW, new WndProc 0x%p\n", UnicodeSubclassProc);
SetWindowLongW(hWnd, GWL_WNDPROC, (LONG) UnicodeSubclassProc);
printf("After subclass, IsWindowUnicode %s, WndProcA 0x%lx, WndProcW 0x%lx\n",
IsWindowUnicode(hWnd) ? "TRUE" : "FALSE", GetWindowLongA(hWnd, GWL_WNDPROC),
GetWindowLongW(hWnd, GWL_WNDPROC));
printf("Calling GetWindowTextW\n");
if (! GetWindowTextW(hWnd, WindowTextW, sizeof(WindowTextW) / sizeof(WindowTextW[0])))
{
fprintf(stderr, "GetWindowTextW failed (last error 0x%lu)\n", GetLastError());
return 1;
}
printf("GetWindowTextW returned Unicode string \"%S\"\n", WindowTextW);
printf("\n");
printf("Subclassing window using SetWindowLongA, new WndProc 0x%p\n", AnsiSubclassProc);
SetWindowLongA(hWnd, GWL_WNDPROC, (LONG) AnsiSubclassProc);
printf("After subclass, IsWindowUnicode %s, WndProcA 0x%lx, WndProcW 0x%lx\n",
IsWindowUnicode(hWnd) ? "TRUE" : "FALSE", GetWindowLongA(hWnd, GWL_WNDPROC),
GetWindowLongW(hWnd, GWL_WNDPROC));
printf("Calling GetWindowTextW\n");
if (! GetWindowTextW(hWnd, WindowTextW, sizeof(WindowTextW) / sizeof(WindowTextW[0])))
{
fprintf(stderr, "GetWindowTextW failed (last error 0x%lu)\n", GetLastError());
return 1;
}
printf("GetWindowTextW returned Unicode string \"%S\"\n", WindowTextW);
DestroyWindow(hWnd);
return 0;
}
