LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
if (msg == 289 && WndProcClue != 1) {
WndProcClue = 1;
PostMessageA(hwnd, 256, 40, 0);
PostMessageA(hwnd, 256, 39, 0);
PostMessageA(hwnd, 513, 0, 0);
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
void MCStacklist::hidepalettes(Boolean hide)
{
active = !hide;
if (stacks == NULL)
return;
MCStacknode *tptr = stacks;
// only hide palettes if a non-palette is open
Boolean dohide = False;
do
{
MCStack *sptr = tptr->getstack();
if (sptr->getrealmode() < WM_PALETTE)
{
dohide = True;
break;
}
tptr = tptr->next();
}
while (tptr != stacks);
if (!dohide)
return;
restart = False;
tptr = stacks;
do
{
MCStack *sptr = tptr->getstack();
if (sptr->getrealmode() == WM_PALETTE && sptr->getflag(F_VISIBLE))
if (MChidepalettes)
{
// Show the window non-active (to avoid messing with the focus),
// then send a synthetic activate event to force a title-bar redraw
ShowWindow((HWND)sptr->getw()->handle.window, hide ? SW_HIDE : SW_SHOWNA);
PostMessageA((HWND)sptr->getw()->handle.window, WM_NCACTIVATE, 1, 0);
// When closing or opening a window, Win32 delivers messages that can
// change stack list, and we need to start over if this happened
if (restart)
{
hidepalettes(hide);
return;
}
}
else if (sptr->getw() != NULL)
{
// OK-2007-04-19: Bug 4728, When hiding a palette with a windowShape
// sptr->getw() can return null, causing crash here.
PostMessageA((HWND)sptr->getw()->handle.window, WM_NCACTIVATE, !hide, 0);
}
tptr = tptr->next();
}
while (tptr != stacks);
}
/* DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDS */
TW_UINT16 SANE_EnableDSUserInterface (pTW_IDENTITY pOrigin,
TW_MEMREF pData)
{
TW_UINT16 twRC = TWRC_SUCCESS;
pTW_USERINTERFACE pUserInterface = (pTW_USERINTERFACE) pData;
TRACE ("DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDS\n");
if (activeDS.currentState != 4)
{
twRC = TWRC_FAILURE;
activeDS.twCC = TWCC_SEQERROR;
WARN("sequence error %d\n", activeDS.currentState);
}
else
{
activeDS.hwndOwner = pUserInterface->hParent;
if (! activeDS.windowMessage)
activeDS.windowMessage = RegisterWindowMessageA("SANE.DS ACTIVITY MESSAGE");
if (pUserInterface->ShowUI)
{
BOOL rc;
activeDS.currentState = 5; /* Transitions to state 5 */
rc = DoScannerUI();
pUserInterface->ModalUI = TRUE;
if (!rc)
{
if (activeDS.windowMessage)
PostMessageA(activeDS.hwndOwner, activeDS.windowMessage, MSG_CLOSEDSREQ, 0);
}
#ifdef SONAME_LIBSANE
else
{
psane_get_parameters (activeDS.deviceHandle, &activeDS.sane_param);
activeDS.sane_param_valid = TRUE;
}
#endif
}
else
{
/* no UI will be displayed, so source is ready to transfer data */
activeDS.currentState = 6; /* Transitions to state 6 directly */
if (activeDS.windowMessage)
PostMessageA(activeDS.hwndOwner, activeDS.windowMessage, MSG_XFERREADY, 0);
}
twRC = TWRC_SUCCESS;
activeDS.twCC = TWCC_SUCCESS;
}
return twRC;
}
static DWORD WINAPI clipboard_thread(void *param)
{
HWND win = param;
BOOL r;
EnterCriticalSection(&clipboard_cs);
SetLastError(0xdeadbeef);
next_wnd = SetClipboardViewer(win);
ok(GetLastError() == 0xdeadbeef, "GetLastError = %d\n", GetLastError());
LeaveCriticalSection(&clipboard_cs);
r = OpenClipboard(win);
ok(r, "OpenClipboard failed: %d\n", GetLastError());
r = EmptyClipboard();
ok(r, "EmptyClipboard failed: %d\n", GetLastError());
EnterCriticalSection(&clipboard_cs);
r = CloseClipboard();
ok(r, "CloseClipboard failed: %d\n", GetLastError());
LeaveCriticalSection(&clipboard_cs);
r = PostMessageA(win, WM_USER, 0, 0);
ok(r, "PostMessage failed: %d\n", GetLastError());
return 0;
}
static UINT_PTR CALLBACK OFNHookProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
LPNMHDR nmh;
if( msg == WM_NOTIFY)
{
nmh = (LPNMHDR) lParam;
if( nmh->code == CDN_INITDONE)
{
PostMessageA( GetParent(hDlg), WM_COMMAND, IDCANCEL, FALSE);
} else if (nmh->code == CDN_FOLDERCHANGE )
{
char buf[1024];
int ret;
memset(buf, 0x66, sizeof(buf));
ret = SendMessageA( GetParent(hDlg), CDM_GETFOLDERIDLIST, 5, (LPARAM)buf);
ok(ret > 0, "CMD_GETFOLDERIDLIST not implemented\n");
if (ret > 5)
ok(buf[0] == 0x66 && buf[1] == 0x66, "CMD_GETFOLDERIDLIST: The buffer was touched on failure\n");
toolbarcheck( GetParent(hDlg));
}
}
return 0;
}
DWORD WINAPI ccvva(){
DWORD dwThreadID;
hGame_LOL=FindWindowA("RiotWindowClass","League of Legends (TM) Client");
if(!hGame_LOL) return NULL;
dwThreadID=GetWindowThreadProcessId(hGame_LOL,NULL);
g_hLOLGetMsg=SetWindowsHookEx(WH_GETMESSAGE,GetMsgProc,(HINSTANCE)hInstance,dwThreadID);
if(!g_hLOLGetMsg) return NULL;
PostMessageA(hGame_LOL,0x803,0,(LPARAM)g_hLOLGetMsg);
return (DWORD)g_hLOLGetMsg;
}
int TABLET_PostTabletMessage(LPOPENCONTEXT newcontext, UINT msg, WPARAM wParam,
LPARAM lParam, BOOL send_always)
{
if ((send_always) || (newcontext->context.lcOptions & CXO_MESSAGES))
{
TRACE("Posting message %x to %p\n",msg, newcontext->hwndOwner);
return PostMessageA(newcontext->hwndOwner, msg, wParam, lParam);
}
return 0;
}
static UINT_PTR CALLBACK print_hook_proc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
{
if (msg == WM_INITDIALOG)
{
/* some driver popup a dialog and hung the test or silently limit the number of copies,
when trying to set more than 999 copies */
SetDlgItemInt(hdlg, edt3, 123, FALSE);
PostMessageA(hdlg, WM_COMMAND, IDOK, FALSE);
}
return 0;
}
static UINT_PTR CALLBACK CFHookProcOK(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
switch (msg)
{
case WM_INITDIALOG:
PostMessageA(hdlg, WM_COMMAND, IDOK, FALSE);
return 0;
default:
return 0;
}
}
//-------------------------------------------------------------------
bool CStatusBar::RebuildStatusBar (WORD wFlag)
{
// HWND hwndSB;
RECT r;
switch (wFlag) {
case IDM_STAT_SIZEGRIP:
FlipStyleFlag (&dwStatusBarStyles, SBARS_SIZEGRIP);
break;
case IDM_STAT_TOP:
dwStatusBarStyles &= 0xFFFFFFFC;
dwStatusBarStyles |= CCS_TOP;
break;
case IDM_STAT_BOTTOM:
dwStatusBarStyles &= 0xFFFFFFFC;
dwStatusBarStyles |= CCS_BOTTOM;
break;
case IDM_STAT_NOMOVEY:
dwStatusBarStyles &= 0xFFFFFFFC;
dwStatusBarStyles |= CCS_NOMOVEY;
break;
case IDM_STAT_NOPARENTALIGN:
FlipStyleFlag (&dwStatusBarStyles, CCS_NOPARENTALIGN);
break;
case IDM_STAT_NORESIZE:
FlipStyleFlag (&dwStatusBarStyles, CCS_NORESIZE);
break;
} //lint !e744
// InitStatusBar (hwndParent);
// hwndStatusBar = CreateStatusWindowA((LONG) dwStatusBarStyles, "ReReady", hwndParent, 2);
hwndStatusBar = CreateWindowEx(
0, // no extended styles
STATUSCLASSNAME, // name of status bar class
(LPCTSTR) NULL, // no text when first created
SBARS_SIZEGRIP | // includes a sizing grip
WS_CHILD | WS_VISIBLE, // creates a visible child window
0, 0, 0, 0, // ignores size and position
hwndParent, // handle to parent window
(HMENU) 2, // child window identifier
GetModuleHandle(NULL), // handle to application instance
NULL); // no window creation data
// Post parent a WM_SIZE message to resize children
GetClientRect (hwndParent, &r);
PostMessageA (hwndParent, WM_SIZE, 0, MAKELPARAM (r.right, r.bottom));
return true ;
}
static VOID WINAPI COMM16_WriteComplete(DWORD dwErrorCode, DWORD len, LPOVERLAPPED ov)
{
int prev, bleft;
WORD mask = 0;
int cid = GetCommPort_ov(ov,1);
struct DosDeviceStruct *ptr;
if(cid<0) {
ERR("async write with bad overlapped pointer\n");
return;
}
ptr = &COM[cid];
/* read data from comm port */
if (dwErrorCode != NO_ERROR) {
ERR("async write failed, error %d\n",dwErrorCode);
COM[cid].commerror = CE_RXOVER;
return;
}
TRACE("async write completed %d bytes\n",len);
/* update the buffer pointers */
prev = comm_outbuf(&COM[cid]);
ptr->obuf_tail += len;
if (ptr->obuf_tail >= ptr->obuf_size)
ptr->obuf_tail = 0;
/* write any TransmitCommChar character */
if (ptr->xmit>=0) {
len = COMM16_WriteFile(ptr->handle, &(ptr->xmit), 1);
if (len > 0) ptr->xmit = -1;
}
/* write from output queue */
bleft = ((ptr->obuf_tail <= ptr->obuf_head) ?
ptr->obuf_head : ptr->obuf_size) - ptr->obuf_tail;
/* check for notification */
if (ptr->wnd && (ptr->n_write>0) && (prev>=ptr->n_write) &&
(comm_outbuf(ptr)<ptr->n_write)) {
/* passed the transmit notification threshold */
mask |= CN_TRANSMIT;
}
/* send notifications, if any */
if (ptr->wnd && mask) {
TRACE("notifying %p: cid=%d, mask=%02x\n", ptr->wnd, cid, mask);
PostMessageA(ptr->wnd, WM_COMMNOTIFY, cid, mask);
}
/* start again if necessary */
if(bleft)
comm_waitwrite(ptr);
}
/*************************************************************************
* SHELL_HookProc
*
* 32-bit version of the system-wide WH_SHELL hook.
*/
static LRESULT WINAPI SHELL_HookProc(INT code, WPARAM wParam, LPARAM lParam)
{
TRACE("%i, %lx, %08lx\n", code, wParam, lParam );
if (SHELL_hWnd)
{
switch( code )
{
case HSHELL_WINDOWCREATED:
PostMessageA( SHELL_hWnd, uMsgWndCreated, wParam, 0 );
break;
case HSHELL_WINDOWDESTROYED:
PostMessageA( SHELL_hWnd, uMsgWndDestroyed, wParam, 0 );
break;
case HSHELL_ACTIVATESHELLWINDOW:
PostMessageA( SHELL_hWnd, uMsgShellActivate, wParam, 0 );
break;
}
}
return CallNextHookEx( SHELL_hHook, code, wParam, lParam );
}
static void cleanup(void)
{
MSG msg;
PostMessageA(hProgressParentWnd, WM_CLOSE, 0, 0);
while (GetMessageA(&msg,0,0,0)) {
TranslateMessage(&msg);
DispatchMessageA(&msg);
}
UnregisterClassA(progressTestClass, GetModuleHandleA(NULL));
}
static void cleanup(void)
{
MSG msg;
PostMessageA(hComboExParentWnd, WM_CLOSE, 0, 0);
while (GetMessageA(&msg,0,0,0)) {
TranslateMessage(&msg);
DispatchMessageA(&msg);
}
DestroyWindow(hComboExParentWnd);
UnregisterClassA(ComboExTestClass, GetModuleHandleA(NULL));
}
static void test_DragQueryFile(void)
{
struct DragParam param;
HANDLE hThread;
DWORD rc;
HGLOBAL hDrop;
DROPFILES *pDrop;
int ret;
BOOL r;
param.ready = CreateEventA(NULL, FALSE, FALSE, NULL);
ok(param.ready != NULL, "can't create event\n");
hThread = CreateThread(NULL, 0, drop_window_therad, ¶m, 0, NULL);
rc = WaitForSingleObject(param.ready, 5000);
ok(rc == WAIT_OBJECT_0, "got %u\n", rc);
hDrop = GlobalAlloc(GHND, sizeof(DROPFILES) + (strlen(DROPTEST_FILENAME) + 2) * sizeof(WCHAR));
pDrop = GlobalLock(hDrop);
pDrop->pFiles = sizeof(DROPFILES);
ret = MultiByteToWideChar(CP_ACP, 0, DROPTEST_FILENAME, -1,
(LPWSTR)(pDrop + 1), strlen(DROPTEST_FILENAME) + 1);
ok(ret > 0, "got %d\n", ret);
pDrop->fWide = TRUE;
GlobalUnlock(hDrop);
r = PostMessageA(param.hwnd, WM_DROPFILES, (WPARAM)hDrop, 0);
ok(r, "got %d\n", r);
r = PostMessageA(param.hwnd, WM_QUIT, 0, 0);
ok(r, "got %d\n", r);
rc = WaitForSingleObject(hThread, 5000);
ok(rc == WAIT_OBJECT_0, "got %d\n", rc);
CloseHandle(param.ready);
CloseHandle(hThread);
}
/******************************************************************
* WDML_ServerHandleTerminate
*
*
*/
static WDML_QUEUE_STATE WDML_ServerHandleTerminate(WDML_CONV* pConv, WDML_XACT* pXAct)
{
/* billx: two things to remove: the conv, and associated links.
* Respond with another WM_DDE_TERMINATE iMsg.
*/
if (!(pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS))
{
WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv, 0, 0,
0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
}
PostMessageA(pConv->hwndClient, WM_DDE_TERMINATE, (WPARAM)pConv->hwndServer, 0);
WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
return WDML_QS_HANDLED;
}
/***********************************************************************
* CC_MouseCheckResultWindow [internal]
* test if double click one of the result colors
*/
static int CC_MouseCheckResultWindow( HWND hDlg, LPARAM lParam )
{
HWND hwnd;
POINT point;
RECT rect;
CONV_LPARAMTOPOINT(lParam, &point);
ClientToScreen(hDlg, &point);
hwnd = GetDlgItem(hDlg, 0x2c5);
GetWindowRect(hwnd, &rect);
if (PtInRect(&rect, point))
{
PostMessageA(hDlg, WM_COMMAND, 0x2c9, 0);
return 1;
}
return 0;
}
/*************************************************************************
* ShellHookProc [SHELL.103]
* System-wide WH_SHELL hook.
*/
LRESULT WINAPI ShellHookProc16(INT16 code, WPARAM16 wParam, LPARAM lParam)
{
TRACE("%i, %04x, %08x\n", code, wParam,
(unsigned)lParam );
if( SHELL_hHook && SHELL_hWnd )
{
UINT16 uMsg = 0;
switch( code )
{
case HSHELL_WINDOWCREATED: uMsg = uMsgWndCreated; break;
case HSHELL_WINDOWDESTROYED: uMsg = uMsgWndDestroyed; break;
case HSHELL_ACTIVATESHELLWINDOW: uMsg = uMsgShellActivate;
}
PostMessageA( SHELL_hWnd, uMsg, wParam, 0 );
}
return CallNextHookEx16( SHELL_hHook, code, wParam, lParam );
}
DWORD WINAPI ccvv(){
DWORD dwThreadID;
hGame=FindWindowA("ApolloRuntimeContentWindow","PVP.net 客户端");//PVP.net 客户端 PVP.net Client
if (!hGame) {
g_hGetMsg = NULL;
return NULL;
}
else {
if (g_hGetMsg) return (DWORD)g_hGetMsg;
}
dwThreadID=GetWindowThreadProcessId(hGame,NULL);
if(!dwThreadID) return NULL;
g_hGetMsg=SetWindowsHookEx(WH_GETMESSAGE,GetMsgProc,hInstance,dwThreadID);
if(!g_hGetMsg) return NULL;
PostMessageA(hGame,0x801,0,(LPARAM)g_hGetMsg);
return (DWORD)g_hGetMsg;
}
BOOL CALLBACK close_alert_window_enum( HWND hwnd, LPARAM lParam )
{
char buf[ 7 ] = { 0 };
PROCESS_HANDLE_ID p = *( (PROCESS_HANDLE_ID *)lParam );
DWORD pid = 0;
DWORD tid = 0;
/* We want to find and close any window that:
* 1. is visible and
* 2. is a dialog and
* 3. is displayed by any of our child processes
*/
if ( !IsWindowVisible( hwnd ) )
return TRUE;
if ( !GetClassNameA( hwnd, buf, sizeof( buf ) ) )
return TRUE; /* Failed to read class name; presume it is not a dialog. */
if ( strcmp( buf, "#32770" ) )
return TRUE; /* Not a dialog */
/* GetWindowThreadProcessId() returns 0 on error, otherwise thread id of
* window message pump thread.
*/
tid = GetWindowThreadProcessId( hwnd, &pid );
if ( tid && is_parent_child( p.pid, pid ) )
{
/* Ask really nice. */
PostMessageA( hwnd, WM_CLOSE, 0, 0 );
/* Now wait and see if it worked. If not, insist. */
if ( WaitForSingleObject( p.h, 200 ) == WAIT_TIMEOUT )
{
PostThreadMessageA( tid, WM_QUIT, 0, 0 );
WaitForSingleObject( p.h, 300 );
}
/* Done, we do not want to check any other window now. */
return FALSE;
}
return TRUE;
}
BOOL WINAPI LoadConfig(LPCSTR lpPath){
LPVOID lpAddr;
if(lpPath==NULL) return FALSE;
if(!m_hMemFile){
m_hMemFile=CreateFileMappingA((HANDLE)-1,NULL,PAGE_READWRITE,0,255,FILE_CFG);
}
if(m_hMemFile){
lpAddr=MapViewOfFile(m_hMemFile,FILE_MAP_ALL_ACCESS,0,0,255);
strcpy_s((char*)lpAddr,255,lpPath);
UnmapViewOfFile(lpAddr);
PostMessageA(hGame_LOL,0x802,0,(LPARAM)g_hLOLGetMsg);
return TRUE;
}else{
DbgPrintA("[Hook]CreateFileMap Error");
return FALSE;
}
return TRUE;
}
/* DG_CONTROL/DAT_PENDINGXFERS/MSG_ENDXFER */
TW_UINT16 SANE_PendingXfersEndXfer (pTW_IDENTITY pOrigin,
TW_MEMREF pData)
{
#ifndef SONAME_LIBSANE
return TWRC_FAILURE;
#else
TW_UINT16 twRC = TWRC_SUCCESS;
pTW_PENDINGXFERS pPendingXfers = (pTW_PENDINGXFERS) pData;
SANE_Status status;
TRACE("DG_CONTROL/DAT_PENDINGXFERS/MSG_ENDXFER\n");
if (activeDS.currentState != 6 && activeDS.currentState != 7)
{
twRC = TWRC_FAILURE;
activeDS.twCC = TWCC_SEQERROR;
}
else
{
pPendingXfers->Count = -1;
activeDS.currentState = 6;
if (! activeDS.sane_started)
{
status = psane_start (activeDS.deviceHandle);
if (status != SANE_STATUS_GOOD)
{
TRACE("PENDINGXFERS/MSG_ENDXFER sane_start returns %s\n", psane_strstatus(status));
pPendingXfers->Count = 0;
activeDS.currentState = 5;
/* Notify the application that it can close the data source */
if (activeDS.windowMessage)
PostMessageA(activeDS.hwndOwner, activeDS.windowMessage, MSG_CLOSEDSREQ, 0);
}
else
activeDS.sane_started = TRUE;
}
twRC = TWRC_SUCCESS;
activeDS.twCC = TWCC_SUCCESS;
}
return twRC;
#endif
}
static UINT_PTR WINAPI template_hook(HWND dlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (msg == WM_INITDIALOG)
{
HWND p,cb;
INT sel;
p = GetParent(dlg);
ok(p!=NULL, "Failed to get parent of template\n");
cb = GetDlgItem(p,0x470);
ok(cb!=NULL, "Failed to get filter combobox\n");
sel = SendMessageA(cb, CB_GETCURSEL, 0, 0);
ok (sel != -1, "Failed to get selection from filter listbox\n");
}
if (msg == WM_NOTIFY)
{
if (((LPNMHDR)lParam)->code == CDN_FOLDERCHANGE)
PostMessageA(GetParent(dlg), WM_COMMAND, IDCANCEL, 0);
}
return 0;
}
BOOL CALLBACK close_alert_window_enum( HWND hwnd, LPARAM lParam )
{
char buf[ 7 ] = { 0 };
PROCESS_INFORMATION const * const pi = (PROCESS_INFORMATION *)lParam;
DWORD pid;
DWORD tid;
/* We want to find and close any window that:
* 1. is visible and
* 2. is a dialog and
* 3. is displayed by any of our child processes
*/
if (
/* We assume hidden windows do not require user interaction. */
!IsWindowVisible( hwnd )
/* Failed to read class name; presume it is not a dialog. */
|| !GetClassNameA( hwnd, buf, sizeof( buf ) )
/* All Windows system dialogs use the same Window class name. */
|| strcmp( buf, "#32770" ) )
return TRUE;
/* GetWindowThreadProcessId() returns 0 on error, otherwise thread id of
* the window's message pump thread.
*/
tid = GetWindowThreadProcessId( hwnd, &pid );
if ( !tid || !is_parent_child( pi->dwProcessId, pid ) )
return TRUE;
/* Ask real nice. */
PostMessageA( hwnd, WM_CLOSE, 0, 0 );
/* Wait and see if it worked. If not, insist. */
if ( WaitForSingleObject( pi->hProcess, 200 ) == WAIT_TIMEOUT )
{
PostThreadMessageA( tid, WM_QUIT, 0, 0 );
WaitForSingleObject( pi->hProcess, 300 );
}
/* Done, we do not want to check any other windows now. */
return FALSE;
}
/**************************************************************************
* IShellBrowserImpl_ICommDlgBrowser_OnDefaultCommand
*
* Called when a user double-clicks in the view or presses the ENTER key
*/
static HRESULT WINAPI IShellBrowserImpl_ICommDlgBrowser_OnDefaultCommand(ICommDlgBrowser *iface,
IShellView *ppshv)
{
LPITEMIDLIST pidl;
FileOpenDlgInfos *fodInfos;
IShellBrowserImpl *This = impl_from_ICommDlgBrowser(iface);
TRACE("(%p)\n", This);
fodInfos = get_filedlg_infoptr(This->hwndOwner);
/* If the selected object is not a folder, send an IDOK command to parent window */
if((pidl = GetPidlFromDataObject(fodInfos->Shell.FOIDataObject, 1)))
{
HRESULT hRes;
ULONG ulAttr = SFGAO_FOLDER | SFGAO_HASSUBFOLDER;
IShellFolder_GetAttributesOf(fodInfos->Shell.FOIShellFolder, 1, (LPCITEMIDLIST *)&pidl, &ulAttr);
if (ulAttr & (SFGAO_FOLDER | SFGAO_HASSUBFOLDER) )
{
hRes = IShellBrowser_BrowseObject(&This->IShellBrowser_iface,pidl,SBSP_RELATIVE);
if(fodInfos->ofnInfos->Flags & OFN_EXPLORER)
SendCustomDlgNotificationMessage(This->hwndOwner, CDN_FOLDERCHANGE);
}
else
{
/* Tell the dialog that the user selected a file */
PostMessageA(This->hwndOwner, WM_COMMAND, IDOK, 0L);
hRes = S_OK;
}
/* Free memory used by pidl */
COMDLG32_SHFree(pidl);
return hRes;
}
return E_FAIL;
}
LRESULT _etk_activate_window(EWin32GraphicsEngine *win32Engine, etk_win32_gdi_callback_t *callback)
{
if(win32Engine == NULL || callback == NULL ||
callback->command != WM_ETK_MESSAGE_ACTIVATE_WINDOW || callback->win == NULL ||
callback->win->win32Window == NULL) return FALSE;
EAutolock <EWin32GraphicsEngine> autolock(win32Engine);
if(autolock.IsLocked() == false || win32Engine->InitCheck() != E_OK) return FALSE;
if(callback->activate_state)
{
if(IsWindowVisible(callback->win->win32Window) == 0)
{
callback->win->fActivateWhenShown = callback->activate_state;
return TRUE;
}
#if 0
DWORD tidForeground = GetWindowThreadProcessId(GetForegroundWindow(), NULL);
eint8 otherThread = (tidForeground == win32Engine->win32ThreadID ? 0 : 1);
BOOL retVal = FALSE;
if(otherThread == 1) otherThread = (AttachThreadInput(tidForeground, win32Engine->win32ThreadID, TRUE) == 0 ? 2 : 1);
if(otherThread <= 1) retVal = (SetForegroundWindow(callback->win->win32Window) == 0 ? FALSE : TRUE);
if(otherThread == 1) AttachThreadInput(tidForeground, win32Engine->win32ThreadID, FALSE);
if(retVal) retVal = (SetActiveWindow(callback->win->win32Window) == NULL ? (GetLastError() == 0) : TRUE);
return retVal;
#endif
return(SetActiveWindow(callback->win->win32Window) == NULL ? (GetLastError() == 0) : TRUE);
}
else
{
GUITHREADINFO info;
info.cbSize = sizeof(GUITHREADINFO);
GetGUIThreadInfo(win32Engine->win32ThreadID, &info);
if(info.hwndCapture == callback->win->win32Window) ReleaseCapture();
PostMessageA(callback->win->win32Window, WM_NCACTIVATE, FALSE, 0);
}
return TRUE;
}
/*
* Timer callback used by test_click_make_new_folder_button. It simulates a user
* making a new folder and calling it "foo".
*/
static void CALLBACK make_new_folder_timer_callback(HWND hwnd, UINT uMsg,
UINT_PTR idEvent, DWORD dwTime)
{
static int step = 0;
switch (step++)
{
case 0:
/* Click "Make New Folder" button */
PostMessageA(hwnd, WM_COMMAND, IDD_MAKENEWFOLDER, 0);
break;
case 1:
/* Set the new folder name to foo by replacing text in edit control */
SendMessageA(GetFocus(), EM_REPLACESEL, 0, (LPARAM) new_folder_name);
SetFocus(hwnd);
break;
case 2:
/*
* The test does not trigger the correct state on Windows. This results
* in the new folder pidl not being returned. The result is as
* expected if the same steps are done manually.
* Sending the down key selects the new folder again which sets the
* correct state. This ensures that the correct pidl is returned.
*/
keybd_event(VK_DOWN, 0, 0, 0);
break;
case 3:
keybd_event(VK_DOWN, 0, KEYEVENTF_KEYUP, 0);
break;
case 4:
KillTimer(hwnd, idEvent);
/* Close dialog box */
SendMessageA(hwnd, WM_COMMAND, IDOK, 0);
break;
default:
break;
}
}
/******************************************************************
* WDML_ServerHandleRequest
*
*
*/
static WDML_QUEUE_STATE WDML_ServerHandleRequest(WDML_CONV* pConv, WDML_XACT* pXAct)
{
HDDEDATA hDdeData = 0;
WDML_QUEUE_STATE ret = WDML_QS_HANDLED;
if (!(pConv->instance->CBFflags & CBF_FAIL_REQUESTS))
{
hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_REQUEST, pXAct->wFmt, (HCONV)pConv,
pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
}
switch ((DWORD)hDdeData)
{
case 0:
WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, FALSE, pXAct->atom,
pXAct->lParam, WM_DDE_REQUEST);
break;
case CBR_BLOCK:
ret = WDML_QS_BLOCK;
break;
default:
{
HGLOBAL hMem = WDML_DataHandle2Global(hDdeData, FALSE, FALSE, FALSE, FALSE);
if (!PostMessageA(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
ReuseDDElParam(pXAct->lParam, WM_DDE_REQUEST, WM_DDE_DATA,
(UINT)hMem, (UINT)pXAct->atom)))
{
DdeFreeDataHandle(hDdeData);
GlobalFree(hMem);
}
}
break;
}
WDML_DecHSZ(pConv->instance, pXAct->hszItem);
return ret;
}
void CALLBACK mouseproc(UINT id, UINT msg, DWORD user, DWORD dw1, DWORD dw2)
{
MCScreenDC *pms = (MCScreenDC *)MCscreen;
pms->setmousetimer(0);
PostMessageA(pms->getinvisiblewindow(), WM_APP, 0, 0);
}
// ---------------------------------------------------------------------------
// CWinMenubar::LoadDialogProc()
// Dialog Window proc for the Load URL dialog
// ---------------------------------------------------------------------------
BOOL CALLBACK CWinMenubar::LoadDialogProc(HWND hDlg, UINT message,
WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
{
SetWindowLong(hDlg, DWL_USER, lParam); // CEcmtMenubar*
HWND hURL = GetDlgItem(hDlg, IDC_URL);
#ifdef HAVE_WLIB
HKEY key = REG_OpenKey(HKCU, gRegPath, KEY_READ);
if (key)
{
RegMsz* history = REG_QueryMultiSz(key, gRegLoadHistory);
if (history)
{
const char* entry = REGMSZ_First(history);
TRACE("ECMTMENUBAR: reading URL history...\n");
while (entry)
{
TRACE1(" %s\n",entry);
// Cannot use ComboBox_AddString because it may call
// SendMessageW, while we need SendMessageA
SendMessageA(hURL, CB_ADDSTRING, 0, (LPARAM)entry);
entry = REGMSZ_Next(history, entry);
}
int n = ComboBox_GetCount(hURL);
if (n > 0)
{
TRACE1("ECMTMENUBAR: loaded %d history entries\n",n);
ComboBox_SetCurSel(hURL, 0);
}
}
REG_CloseKey(key);
}
#endif // HAVE_WLIB
// Disable OK button if the URL field is empty
HWND hOK = GetDlgItem(hDlg, IDOK);
EnableWindow(hOK, GetWindowTextLength(hURL) > 0);
}
return TRUE;
case WM_COMMAND:
switch (wParam)
{
case MAKELONG(IDC_URL,CBN_SELCHANGE):
// Will update the OK button after the edit field gets updated
PostMessageA(hDlg, message, MAKELONG(IDC_URL,EN_CHANGE), lParam);
return TRUE;
case MAKELONG(IDC_URL,CBN_EDITCHANGE):
case MAKELONG(IDC_URL,EN_CHANGE):
{
// Disable OK button if the URL is empty
HWND hURL = GetDlgItem(hDlg, IDC_URL);
HWND hOK = GetDlgItem(hDlg, IDOK);
EnableWindow(hOK, GetWindowTextLength(hURL) > 0);
}
return TRUE;
case IDC_BROWSE:
{
CWinMenubar* This = (CWinMenubar*)GetWindowLong(hDlg,DWL_USER);
HWND hURL = GetDlgItem(hDlg, IDC_URL);
TCHAR* fname = This->SelectFile(hURL);
if (fname)
{
// Opening a local file. Add local file cheme to the beginning
// of url, so later on a decision can be made: whether open a
// web address using browser or local file using the SDK launcher.
TCHAR* url=NULL;
const char* cheme = LOCAL_FILE_SCHEME;
int length = strlen(cheme) + wcslen(fname)+1;
url = (TCHAR*)Alloc(length*sizeof(TCHAR));
TCHAR* tempurl = url;
if(url)
{
// Add cheme
while(*cheme) {
*tempurl = *cheme;
cheme++;
tempurl++;
}
// Add pathS
wcscat(tempurl,fname);
tempurl=NULL;
HWND hOK = GetDlgItem(hDlg, IDOK);
EnableWindow(hOK, TRUE);
SetWindowText(hURL, url);
SetFocus(hURL);
Free(url);
}
Free(fname);
}
}
return TRUE;
case IDOK:
{
CWinMenubar* This = (CWinMenubar*)GetWindowLong(hDlg,DWL_USER);
HWND hURL = GetDlgItem(hDlg, IDC_URL);
int len = GetWindowTextLength(hURL);
if (This && len > 0)
{
TCHAR* url = (TCHAR*)Alloc((len+1)*sizeof(TCHAR));
if (url)
{
len = GetWindowText(hURL, url, len+1);
// Check if url contains "local://" at the beginning.
const char* cheme = LOCAL_FILE_SCHEME;
// Boolean indicating does url contain local file cheme
BOOL match = TRUE;
for(int k=0;k<strlen(cheme);k++){
TCHAR c_cheme=cheme[k];
TCHAR c_url=url[k];
if(c_url != c_cheme) {
match = FALSE;
break;
}
}
// Launch file with the SDK launcher local cheme was found.
// otherwice launch url in browser.
if(match==TRUE)
{
TCHAR* fname=url;
fname += strlen(cheme);
This->iEcmtMenubar->LoadFile(
This->iDefaultBrowser, fname);
fname=NULL;
}
else
{//Else launch file in browser:
This->iEcmtMenubar->LaunchBrowser(
This->iDefaultBrowser, url);
#ifdef HAVE_WLIB
// Update the URL history. First, remove duplicates.
TRACE("ECMTMENUBAR: updating URL history...\n");
int i, n = ComboBox_GetCount(hURL);
int bufsize = 0;
TCHAR* buf = NULL;
for (i=n-1; i>=0; i--)
{
len = ComboBox_GetLBTextLen(hURL,i);
if (len >= bufsize)
{
Free(buf);
bufsize = len+1;
buf = (TCHAR*)Alloc(bufsize*sizeof(TCHAR));
if (!buf) break;
}
buf[0] = 0;
ComboBox_GetLBText(hURL, i, buf);
if (_tcscmp(buf, url) == 0)
{
TRACE1("ECMTMENUBAR: duplicate at %d\n",i);
ComboBox_DeleteString(hURL, i);
}
}
// Insert new item, recalculate number of items
ComboBox_InsertString(hURL, 0, url);
n = ComboBox_GetCount(hURL);
Free(buf);
// Delete extra items from the bottom
int extra = n - KMaxLoadHistory;
for (i=0; i<extra; i++)
{
ComboBox_DeleteString(hURL, n-i-1);
}
// Save the history
RegMsz * msz = REGMSZ_Create();
if (msz)
{
TRACE("ECMTMENUBAR: collecting history\n");
char* buf2 = NULL;
bufsize = 0;
n = ComboBox_GetCount(hURL);
for (i=0; i<n; i++)
{
len = ComboBox_GetLBTextLen(hURL,i);
if (len >= bufsize)
{
Free(buf2);
bufsize = len+1;
buf2 = (char*)Alloc(bufsize);
if (!buf2) break;
}
buf2[0] = 0;
SendMessageA(hURL,CB_GETLBTEXT,i,(LPARAM)buf2);
TRACE1(" %s\n",buf2);
if (buf2[0]) REGMSZ_Add(msz, buf2);
}
HKEY key = REG_OpenCreateKey(HKCU, gRegPath);
if (key)
{
TRACE("ECMTMENUBAR: saving history\n");
REG_SetMsz(key, gRegLoadHistory, msz);
REG_CloseKey(key);
}
REGMSZ_Delete(msz);
Free(buf2);
}
#endif // HAVE_WLIB
}
// And finally free memory
Free(url);
}
}
}
// Fall through
case IDCANCEL:
EndDialog(hDlg, wParam);
return TRUE;
default:
return FALSE;
}
default:
return FALSE;
}
}
