static LRESULT CALLBACK WndProc( _In_ HWND hWnd, _In_ UINT message, _In_ WPARAM wParam, _In_ LPARAM lParam) { HWND hTest; int iwnd = get_iwnd(hWnd, TRUE); ok(GetCurrentThreadId() == dwThreadId, "Thread 0x%lx instead of 0x%lx\n", GetCurrentThreadId(), dwThreadId); if (message > WM_USER || IsDWmMsg(message) || IseKeyMsg(message)) return DefWindowProcW(hWnd, message, wParam, lParam); RECORD_MESSAGE(iwnd, message, SENT, wParam, lParam); switch(message) { case WM_DESTROY: if (GetParent(hWnd)) { /* child window */ ok(EnumThreadWindows(dwThreadId, EnumProc, (LPARAM)hWnd), "Child window %p (%d) enumerated\n", hWnd, iwnd); ok(!EnumChildWindows(GetParent(hWnd), EnumProc, (LPARAM)hWnd), "Child window %p (%d) not enumerated\n", hWnd, iwnd); ok(!EnumThreadWindows(dwThreadId, EnumProc, (LPARAM)GetParent(hWnd)), "Parent window of %p (%d) not enumerated\n", hWnd, iwnd); } else { /* top-level window */ ok(!EnumThreadWindows(dwThreadId, EnumProc, (LPARAM)hWnd), "Window %p (%d) not enumerated in WM_DESTROY\n", hWnd, iwnd); } if (hWnd == hWndList[3]) { hTest = SetParent(hWndList[4], hWndList[2]); ok_hwnd(hTest, hWndList[1]); hTest = SetParent(hWndList[5], hWndList[1]); ok_hwnd(hTest, hWndList[2]); ok_hwnd(GetParent(hWndList[1]), NULL); ok_hwnd(GetParent(hWndList[2]), NULL); ok_hwnd(GetParent(hWndList[3]), hWndList[1]); ok_hwnd(GetParent(hWndList[4]), hWndList[2]); ok_hwnd(GetParent(hWndList[5]), hWndList[1]); } break; } return DefWindowProcW(hWnd, message, wParam, lParam); }
void CMainFrame::OnEndSession (BOOL bEnding) { // If we are running as a service, then do not end the program at logoff // Instead, just remove the icon from the system tray. if (NTSERVICENAME[0] || (WINDOWS95_SERVICE && WM_ENDSESSION_LPARAM && isWindows95 ())) { if (TRAY_ICON) { ((CPrime95App *)AfxGetApp())->TrayMessage (NIM_DELETE, NULL, 0); WINDOWS95_TRAY_ADD = 1; } // In addition a Windows NT service must take special actions. MFC was // not designed to be used in a NT service as it uses Global Atoms which are // cleared at logoff. This fix from knowledge base article Q164166 seems // to fix the problem. if (NTSERVICENAME[0]) { DWORD dwProcessId, dwThreadId; dwThreadId = GetWindowThreadProcessId (m_hWnd, &dwProcessId); EnumThreadWindows (dwThreadId, EnumProc, (LPARAM) dwThreadId); } } // If we aren't running as a service, just do normal processing else CMDIFrameWnd::OnEndSession (bEnding); }
EXPORT LONG SetIME(LPCSTR pwszKLID) { HMODULE hDllUser32; hDllUser32 = LoadLibrary("user32"); if (hDllUser32) { HKL (WINAPI *pfnLoadKeyboardLayout)(LPCSTR, UINT); pfnLoadKeyboardLayout = (HKL (WINAPI *)(LPCSTR, UINT)) GetProcAddress(hDllUser32, "LoadKeyboardLayoutW"); if (pfnLoadKeyboardLayout) { HWND hTop = NULL; DWORD dwThreadID; dwThreadID = GetCurrentThreadId(); EnumThreadWindows(dwThreadID, FindWindowProc, (LPARAM)&hTop); if (hTop) { HKL kLayout = NULL; SetWindowLong(hTop, GWL_EXSTYLE, GetWindowLong(hTop, GWL_EXSTYLE) | WS_EX_LAYERED); kLayout = pfnLoadKeyboardLayout(pwszKLID, 1); SendMessage(hTop, WM_INPUTLANGCHANGEREQUEST, SC_RESTORE, (LPARAM)&kLayout); } } FreeLibrary(hDllUser32); } return GetLastError(); }
LRESULT CALLBACK CBaseTrayIcon::WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CBaseTrayIcon *icon = (CBaseTrayIcon *)GetWindowLongPtr(hwnd, GWLP_USERDATA); switch(uMsg) { case WM_DESTROY: PostQuitMessage(0); break; case MSG_QUIT: DestroyWindow(hwnd); break; case MSG_TRAYICON: { UINT trayMsg = LOWORD(lParam); if (icon) { switch (trayMsg) { case WM_LBUTTONUP: if (!icon->m_bPropPageOpen) { icon->m_bPropPageOpen = TRUE; RECT desktopRect; GetWindowRect(GetDesktopWindow(), &desktopRect); SetWindowPos(icon->m_hWnd, 0, (desktopRect.right / 2) - PROP_WIDTH_OFFSET, (desktopRect.bottom / 2) - PROP_HEIGHT_OFFSET, 0, 0, SWP_NOZORDER | SWP_NOSIZE); CBaseDSPropPage::ShowPropPageDialog(icon->m_pFilter, icon->m_hWnd); icon->m_bPropPageOpen = FALSE; } else { EnumThreadWindows(GetCurrentThreadId(), enumWindowCallback, (LPARAM)icon->m_hWnd); } break; } } } break; } return DefWindowProc(hwnd, uMsg, wParam, lParam); }
HWND FindHandle(DWORD dwThreadId, string wdwClass, long x, long y) { int size,cnt=0; string str; char buffer[256]={0}; HWND handle; EnumThreadWindows(dwThreadId,EnumThreadWndProc,(LPARAM) &handle); do { if (GetParent(handle)!=NULL && GetParent(handle)!=handle && GetParent(handle)!=GetDesktopWindow() ) handle = GetParent(handle); else break; } while (true); POINT Point; Point.x = x; Point.y = y; handle = ChildWindowFromPoint(handle,Point); if (handle!=NULL) { GetClassName(handle,buffer,256); if (StrCmpNI(buffer,wdwClass.c_str(),wdwClass.length())==0) { return handle; } } return 0; }
BOOL CWinampScrobbler::StartScrobbling(HINSTANCE hInstance, HWND hWndWinamp, HWND hWndWinampML, CStdString strWorkingDir) { if ( ( hWndWinamp != NULL) && ( ::IsWindow(hWndWinamp)) ) { m_hWndWinamp = hWndWinamp; m_hWndWinampML = hWndWinampML; m_Controller.Init(FALSE, hWndWinamp, hWndWinampML); BOOL bRet = CScrobbler::StartScrobbling(strWorkingDir, hInstance); EnumThreadWindows( GetCurrentThreadId(), CWinampScrobbler::enumWndProc, (LPARAM)this ); if( m_bootstrap.bootStrapRequired() ) { PRINTF(DEBUG_FLOW, "CWinampScrobbler::StartScrobbling", "Bootstrap is required" ); m_bootstrap.setParentHwnd( m_mainWinAmpWnd ); m_bootstrap.sethWndWinampML( m_hWndWinampML ); m_bootstrap.setScrobSub( m_Submitter ); m_bootstrap.setModuleHandle( hInstance ); m_bootstrap.startBootStrap(); } return bRet; } return FALSE; }
void TEnumWindows::EnumWindows (TEnumMethod em) { LPARAM lParam = reinterpret_cast<LPARAM> (this); mDoingChildWindows = (em == emTopLevelWindows); EnumThreadWindows (GetCurrentThreadId(), WndEnumProc, lParam); }
HWND FindThreadWindow(DWORD threadId, wchar_t *windowClass) { struct EnumWindowsArg arg; arg.windowClass = windowClass; arg.foundWindow = NULL; EnumThreadWindows(threadId, findChildWindowProc, reinterpret_cast<LPARAM>(&arg)); return arg.foundWindow; }
static unsigned mbModalFlag(void) { BOOL has = FALSE; if (!(HIWORD(GetVersion()) & 0x8000)) // NT can always open task modal return MB_TASKMODAL; EnumThreadWindows(GetCurrentThreadId(), (WNDENUMPROC)threadHasWnd, (LPARAM)&has); return has ? MB_TASKMODAL : MB_SYSTEMMODAL; }
static Bool winInstallColormapShadowGDI (ColormapPtr pColormap) { ScreenPtr pScreen = pColormap->pScreen; winScreenPriv(pScreen); winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo; winCmapPriv(pColormap); /* * Tell Windows to install the new colormap */ if (SelectPalette (pScreenPriv->hdcScreen, pCmapPriv->hPalette, FALSE) == NULL) { ErrorF ("winInstallColormapShadowGDI - SelectPalette () failed\n"); return FALSE; } /* Realize the palette */ if (GDI_ERROR == RealizePalette (pScreenPriv->hdcScreen)) { ErrorF ("winInstallColormapShadowGDI - RealizePalette () failed\n"); return FALSE; } /* Set the DIB color table */ if (SetDIBColorTable (pScreenPriv->hdcShadow, 0, WIN_NUM_PALETTE_ENTRIES, pCmapPriv->rgbColors) == 0) { ErrorF ("winInstallColormapShadowGDI - SetDIBColorTable () failed\n"); return FALSE; } /* Redraw the whole window, to take account for the new colors */ BitBlt (pScreenPriv->hdcScreen, 0, 0, pScreenInfo->dwWidth, pScreenInfo->dwHeight, pScreenPriv->hdcShadow, 0, 0, SRCCOPY); /* Save a pointer to the newly installed colormap */ pScreenPriv->pcmapInstalled = pColormap; #ifdef XWIN_MULTIWINDOW /* Redraw all windows */ if (pScreenInfo->fMultiWindow) EnumThreadWindows (g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0); #endif return TRUE; }
extern "C" BOOL APIENTRY DllMain( PVOID hModule, ULONG ulReason, PCONTEXT pctx ) { char pszBuffer[ 10 ], pszModuleName[ MAX_PATH ]; BOOL fResult = TRUE; // DLL is instantiated. if ( ulReason == DLL_PROCESS_ATTACH ) { GetModuleFileName( NULL, pszModuleName, sizeof( pszModuleName ) ); if( strstr( _strupr( pszModuleName ), ATTACH_PROCESS_NAME ) ) //if we are attaching to Visual C++ process { hDebug = _lcreat( "d:\\debug.txt", 0 ); //temporary pszStatus[0] = '\0'; DWORD nThreadID = GetCurrentThreadId(); EnumThreadWindows( nThreadID, (WNDENUMPROC) EnumCbck, 0 ); if( ghDeveloperStudioWnd ) { wsprintf( pszBuffer, "%ld", (DWORD) ghDeveloperStudioWnd ); ghEvent = OpenEvent( EVENT_MODIFY_STATE, TRUE, pszBuffer ); if( ghEvent ) { wsprintf( pszBuffer, "M%ld", (DWORD) ghDeveloperStudioWnd ); ghMutex = OpenMutex( MUTEX_ALL_ACCESS, FALSE, pszBuffer ); if( !ghMutex ) { fResult = FALSE; CloseHandle( ghEvent ); } } else fResult = FALSE; } else fResult = FALSE; } } else if ( ulReason == DLL_PROCESS_DETACH ) { // If we got here and ghMutex is not NULL, it means that dll is unloading // from a process space of Visual C, and we can close a mutex handle if( ghMutex ) CloseHandle( ghMutex ); } return fResult; }
LONG _declspec(dllexport) ToggleFullScreen() { HWND hTop = NULL; DWORD dwThreadID; dwThreadID = GetCurrentThreadId(); EnumThreadWindows(dwThreadID, FindWindowProc, (LPARAM)&hTop); if (hTop) { /* Determine the current state of the window */ if ( GetWindowLong(hTop, GWL_STYLE) & WS_CAPTION ) { /* Has a caption, so isn't maximised */ int cx, cy; cx = GetSystemMetrics(SM_CXSCREEN); cy = GetSystemMetrics(SM_CYSCREEN); /* Remove border, caption, and edges */ SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_EXSTYLE) & ~WS_BORDER); SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) & ~WS_CAPTION); SetWindowLong(hTop, GWL_EXSTYLE, GetWindowLong(hTop, GWL_STYLE) & ~WS_EX_CLIENTEDGE); SetWindowLong(hTop, GWL_EXSTYLE, GetWindowLong(hTop, GWL_STYLE) & ~WS_EX_WINDOWEDGE); SetWindowPos(hTop, HWND_TOP, 0, 0, cx, cy, SWP_SHOWWINDOW); /* Now need to find the child text area window * and set it's size accordingly */ EnumChildWindows(hTop, EnumChildProc, 0); } else { /* Already full screen, so restore all the previous styles */ SetWindowLong(hTop, GWL_EXSTYLE, GetWindowLong(hTop, GWL_EXSTYLE) | WS_BORDER); SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) | WS_CAPTION); SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) | WS_SYSMENU); SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) | WS_MINIMIZEBOX); SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) | WS_MAXIMIZEBOX); SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) | WS_SYSMENU); SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) | WS_EX_CLIENTEDGE); SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) | WS_EX_WINDOWEDGE); SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) | WS_THICKFRAME); SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) | WS_DLGFRAME); SendMessage(hTop, WM_SYSCOMMAND, SC_RESTORE, 0); SendMessage(hTop, WM_SYSCOMMAND, SC_MAXIMIZE, 0); } } return GetLastError(); }
DWORD SendShutdownMessages( HWND hwndDesktop, PCSR_THREAD pcsrt, DWORD dwClientFlags) { HWND hwnd; DWORD cmd; /* * Find a top-level window owned by the thread. */ hwnd = NULL; EnumThreadWindows((DWORD)pcsrt->ClientId.UniqueThread, &FindWindowFromThread, (LPARAM)&hwnd); if (!hwnd) return CMDEND_NOWINDOW; /* * This'll send WM_QUERYENDSESSION / WM_ENDSESSION messages to all * the windows of this hwnd's thread. */ cmd = MySendEndSessionMessages(hwnd, pcsrt, FALSE, dwClientFlags); switch (cmd) { case CMDEND_APPSAYSOK: /* * This thread says ok... continue on to the next thread. */ break; case CMDEND_USERSAYSKILL: /* * The user hit the "end-task" button on the hung app dialog. * If this is a wow app, kill just this app and continue to * the next wow app. */ if (!(pcsrt->Flags & CSR_THREAD_DESTROYED)) { if (WowExitTask(pcsrt)) break; } /* otherwise fall through */ case CMDEND_USERSAYSCANCEL: case CMDEND_APPSAYSNOTOK: /* * Exit out of here... either the user wants to kill or cancel, * or the app says no. */ return cmd; } return CMDEND_APPSAYSOK; }
// // IsFullscreenWindow // HMONITOR FullscreenMonitor::IsFullscreenWindow(HWND hWnd) { if (!IsWindow(hWnd)) { return nullptr; } HMONITOR hMonFS = nullptr; EnumThreadWindows(GetWindowThreadProcessId(hWnd, nullptr), _EnumThreadFSWnd, (LPARAM)&hMonFS); return hMonFS; }
HWND launch_putty(int action, char *path) { STARTUPINFO si; PROCESS_INFORMATION pi; DWORD wait; HWND pwin; struct process_record *pr; char buf[BUFSIZE]; memset(&si, 0, sizeof(STARTUPINFO)); si.cb = sizeof(STARTUPINFO); memset(&pi, 0, sizeof(PROCESS_INFORMATION)); sprintf(buf, "%s -%s \"%s\"", config->putty_path, action ? "edit" : "load", path); if (!CreateProcess(config->putty_path, buf, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) return NULL; wait = WaitForInputIdle(pi.hProcess, LAUNCH_TIMEOUT); if (wait != 0) { CloseHandle(pi.hProcess); CloseHandle(pi.hThread); return NULL; }; CloseHandle(pi.hThread); pwin = NULL; EnumThreadWindows(pi.dwThreadId, FindPuttyWindowCallback, (LPARAM) &pwin); if (!pwin) { CloseHandle(pi.hProcess); return NULL; }; pr = (struct process_record *) malloc(sizeof(struct process_record)); pr->pid = pi.dwProcessId; pr->tid = pi.dwThreadId; pr->hprocess = pi.hProcess; pr->window = pwin; pr->path = dupstr(path); item_insert((void *) &process_handles, &nprocesses, pi.hProcess); nprocesses -= 1; item_insert((void *) &process_records, &nprocesses, pr); return pwin; };
void CSearchDlg::OnClose() { SaveBarState(SEARCH_PARAMS_PROFILE); // MORPH leuk_he:run as ntservice v1.. workarround a mfc bug if (RunningAsService()) { DWORD dwProcessId; DWORD dwThreadId= GetWindowThreadProcessId(m_hWnd,&dwProcessId); EnumThreadWindows(dwThreadId, EnumProc,(LPARAM) dwThreadId); } // MORPH leuk_he:run as ntservice v1.. CFrameWnd::OnClose(); }
static BOOL CALLBACK myspace_links_enumwindowsproc(HWND hwnd, LPARAM lParam) { char szBuf[32]; //LOG(LOG_DEBUG, "Links: enumwindowsproc"); if (GetClassNameA(hwnd, szBuf, 32)) { if (!strcmp(szBuf, MIRANDACLASS)) { //LOG(LOG_DEBUG, "Links: enumwindowsproc - found Miranda window"); EnumThreadWindows(GetWindowThreadProcessId(hwnd, NULL), myspace_linsk_enumthreadwindowsproc, lParam); } } return TRUE; }
LONG _declspec(dllexport) SetAlpha(LONG nTrans) { HWND hTop = NULL; EnumThreadWindows(GetCurrentThreadId(), FindWindowProc, (LPARAM)&hTop); if(hTop != NULL) { if(nTrans == 255) { SetWindowLong(hTop, GWL_EXSTYLE, GetWindowLong(hTop, GWL_EXSTYLE) & ~WS_EX_LAYERED); }else{ SetWindowLong(hTop, GWL_EXSTYLE, GetWindowLong(hTop, GWL_EXSTYLE) | WS_EX_LAYERED); SetLayeredWindowAttributes(hTop, 0, (BYTE)nTrans, LWA_ALPHA); } } return GetLastError(); }
static int ExtractLinks() { static WCHAR szNotepad[16]; PROCESS_INFORMATION pi = {0}; STARTUPINFO si = {sizeof(STARTUPINFO)}; lstrcpy(szNotepad, L"Notepad.exe"); GetStartupInfo(&si); if(!CreateProcess(0, szNotepad, 0, 0, 0, 0, 0, 0, &si, &pi)) return 0; WaitForInputIdle(pi.hProcess, INFINITE); EnumThreadWindows(pi.dwThreadId, NotepadMainWndFindProc, 0); CloseHandle(pi.hThread); CloseHandle(pi.hProcess); return 0; }
LONG _declspec(dllexport) EnableTopMost(LONG bEnable) { HWND hTop = NULL; DWORD dwThreadID; dwThreadID = GetCurrentThreadId(); EnumThreadWindows(dwThreadID, FindWindowProc, (LPARAM)&hTop); if(hTop) { if (bEnable == 0) { SetWindowPos(hTop, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE); }else{ SetWindowPos(hTop, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE); } } return GetLastError(); }
LRESULT CALLBACK CBaseTrayIcon::WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CBaseTrayIcon *icon = (CBaseTrayIcon *)GetWindowLongPtr(hwnd, GWLP_USERDATA); switch(uMsg) { case WM_DESTROY: Shell_NotifyIcon(NIM_DELETE, &icon->m_NotifyIconData); PostQuitMessage(0); break; case MSG_QUIT: DestroyWindow(hwnd); break; case MSG_TRAYICON: { UINT trayMsg = LOWORD(lParam); if (icon) { switch (trayMsg) { case WM_LBUTTONUP: if (!icon->m_bPropPageOpen) { icon->OpenPropPage(); } else { EnumThreadWindows(GetCurrentThreadId(), enumWindowCallback, (LPARAM)icon->m_hWnd); } break; case WM_RBUTTONUP: case WM_CONTEXTMENU: if (icon->m_bPropPageOpen) { break; } HMENU hMenu = icon->GetPopupMenu(); if (hMenu) { POINT p; GetCursorPos(&p); SetForegroundWindow(hwnd); int cmd = TrackPopupMenu(hMenu, TPM_RETURNCMD, p.x, p.y, 0, hwnd, NULL); PostMessage(hwnd, WM_NULL, 0, 0); icon->ProcessMenuCommand(hMenu, cmd); DestroyMenu(hMenu); } break; } } } break; } return DefWindowProc(hwnd, uMsg, wParam, lParam); }
LONG _declspec(dllexport) EnableMaximize(LONG bEnable) { HWND hTop = NULL; DWORD dwThreadID; dwThreadID = GetCurrentThreadId(); EnumThreadWindows(dwThreadID, FindWindowProc, (LPARAM)&hTop); if (hTop) { if (bEnable == 0) SendMessage(hTop, WM_SYSCOMMAND, SC_RESTORE, 0); else SendMessage(hTop, WM_SYSCOMMAND, SC_MAXIMIZE, 0); } return GetLastError(); }
LONG _declspec(dllexport) EnableCaption(LONG bCaption) { HWND hTop = NULL; DWORD dwThreadID; dwThreadID = GetCurrentThreadId(); EnumThreadWindows(dwThreadID, FindWindowProc, (LPARAM)&hTop); if (hTop) { if (bCaption == 0) SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) & ~WS_CAPTION); else SetWindowLong(hTop, GWL_STYLE, GetWindowLong(hTop, GWL_STYLE) | WS_CAPTION); } return GetLastError(); }
static Bool winRedrawScreenShadowGDI(ScreenPtr pScreen) { winScreenPriv(pScreen); winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo; /* Redraw the whole window, to take account for the new colors */ BitBlt(pScreenPriv->hdcScreen, 0, 0, pScreenInfo->dwWidth, pScreenInfo->dwHeight, pScreenPriv->hdcShadow, 0, 0, SRCCOPY); #ifdef XWIN_MULTIWINDOW /* Redraw all windows */ if (pScreenInfo->fMultiWindow) EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0); #endif return TRUE; }
static Bool winBltExposedRegionsShadowGDI (ScreenPtr pScreen) { winScreenPriv(pScreen); winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo; winPrivCmapPtr pCmapPriv = NULL; HDC hdcUpdate; PAINTSTRUCT ps; /* BeginPaint gives us an hdc that clips to the invalidated region */ hdcUpdate = BeginPaint (pScreenPriv->hwndScreen, &ps); /* Realize the palette, if we have one */ if (pScreenPriv->pcmapInstalled != NULL) { pCmapPriv = winGetCmapPriv (pScreenPriv->pcmapInstalled); SelectPalette (hdcUpdate, pCmapPriv->hPalette, FALSE); RealizePalette (hdcUpdate); } /* Our BitBlt will be clipped to the invalidated region */ BitBlt (hdcUpdate, 0, 0, pScreenInfo->dwWidth, pScreenInfo->dwHeight, pScreenPriv->hdcShadow, 0, 0, SRCCOPY); /* EndPaint frees the DC */ EndPaint (pScreenPriv->hwndScreen, &ps); #ifdef XWIN_MULTIWINDOW /* Redraw all windows */ if (pScreenInfo->fMultiWindow) EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, (LPARAM)pScreenPriv->hwndScreen); #endif return TRUE; }
LONG _declspec(dllexport) SetAlpha(LONG nTrans) { HMODULE hDllUser32; hDllUser32 = LoadLibrary("user32"); if (hDllUser32) { BOOL (WINAPI *pfnSetLayeredWindowAttributes)(HWND,DWORD,BYTE,DWORD); pfnSetLayeredWindowAttributes = (BOOL (WINAPI *)(HWND,DWORD,BYTE,DWORD)) GetProcAddress(hDllUser32, "SetLayeredWindowAttributes"); if (pfnSetLayeredWindowAttributes) { HWND hTop = NULL; DWORD dwThreadID; dwThreadID = GetCurrentThreadId(); EnumThreadWindows(dwThreadID, FindWindowProc, (LPARAM)&hTop); if (hTop) { if (nTrans == 255) { SetWindowLong(hTop, GWL_EXSTYLE, GetWindowLong(hTop, GWL_EXSTYLE) & ~WS_EX_LAYERED); } else { SetWindowLong(hTop, GWL_EXSTYLE, GetWindowLong(hTop, GWL_EXSTYLE) | WS_EX_LAYERED); pfnSetLayeredWindowAttributes( hTop, 0, (BYTE)nTrans, LWA_ALPHA); } } } FreeLibrary(hDllUser32); } return GetLastError(); }
int winapi_EnumThreadWindows(lua_State* L) { DWORD threadId; LUASTACK_SET(L); threadId = (DWORD)lua_tonumber(L, 1); if (lua_isfunction(L, 2)) { EnumThreadWindows(threadId, EnumProc, (LPARAM)L); } else { const char *msg = lua_pushfstring(L, "function expected but got %s", luaL_typename(L, 2)); luaL_argerror(L, 2, msg); } LUASTACK_CLEAN(L, 0); return 0; }
static HWND GetVimWindow() { if (hTopWindow) { return hTopWindow; } HMODULE hDllKernel32 = LoadLibrary("kernel32"); if (hDllKernel32) { HWND (WINAPI *pfnGetConsoleWindow)(); pfnGetConsoleWindow = (HWND (WINAPI *)()) GetProcAddress(hDllKernel32, "GetConsoleWindow"); if (pfnGetConsoleWindow && (hTopWindow = (HWND) pfnGetConsoleWindow())) { ShowWindow(hTopWindow, SW_SHOW); return hTopWindow; } } DWORD dwThreadID = GetCurrentThreadId(); EnumThreadWindows(dwThreadID, FindWindowProc, (LPARAM)&hTopWindow); return hTopWindow; }
HWND GetMainWindow( DWORD dwOwnerPID ) { HWND hWnd = 0; HANDLE hThreadSnap = INVALID_HANDLE_VALUE; THREADENTRY32 te32; // Take a snapshot of all running threads hThreadSnap = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 ); if( hThreadSnap == INVALID_HANDLE_VALUE ) return( 0 ); // Fill in the size of the structure before using it. te32.dwSize = sizeof(THREADENTRY32 ); // Retrieve information about the first thread, // and exit if unsuccessful if( !Thread32First( hThreadSnap, &te32 ) ) { CloseHandle( hThreadSnap ); // Must clean up the snapshot object! return( 0 ); } // Now walk the thread list of the system, // and display information about each thread // associated with the specified process do { if( te32.th32OwnerProcessID == dwOwnerPID ) { EnumThreadWindows(te32.th32ThreadID, EnumProc, (LPARAM)&hWnd); if(hWnd) break; } } while( Thread32Next(hThreadSnap, &te32 ) ); // Don't forget to clean up the snapshot object. CloseHandle( hThreadSnap ); return( hWnd ); }
bool WinReviveNetworkResource(uint16 * _wfileName) { bool result = false; HWND windowHandle = null; NETRESOURCE nr = { 0 }; nr.dwType = RESOURCETYPE_DISK; nr.lpRemoteName = _wfileName; if(_wfileName[0] != '\\' || _wfileName[1] == '\\') { uint16 volumePathName[MAX_LOCATION]; if(GetVolumePathName(_wfileName, volumePathName, MAX_LOCATION)) { uint16 remoteName[MAX_LOCATION]; DWORD size = MAX_LOCATION; volumePathName[wcslen(volumePathName)-1] = 0; if(WNetGetConnection(volumePathName, remoteName, &size) == ERROR_CONNECTION_UNAVAIL) { nr.lpRemoteName = remoteName; nr.lpLocalName = volumePathName; } else return false; } else return false; } EnumThreadWindows(GetCurrentThreadId(), EnumThreadWindowsProc, (LPARAM)&windowHandle); if(!windowHandle) { EnumWindows(EnumThreadWindowsProc, (LPARAM)&windowHandle); } if(WNetAddConnection3(windowHandle, &nr, null, null, CONNECT_INTERACTIVE|CONNECT_PROMPT) == NO_ERROR) result = true; return result; }