inline void change_current_window(LPARAM lParam)
{
std::list<HWND> l_hwnd;
EnumDesktopWindows(NULL, EnumWindowsProc, (LPARAM)&l_hwnd);
int wheelData = (int)(((PMSLLHOOKSTRUCT)lParam)->mouseData) >> 16;
HWND previous = NULL;
HWND currentHwnd = GetForegroundWindow();
if( wheelData < 0 )
{
std::list<HWND>::iterator it = l_hwnd.begin();
it++;
SetWindowPos( currentHwnd, HWND_BOTTOM, 0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
setWindow( *it );
}
else
{
for( std::list<HWND>::iterator it = l_hwnd.begin(); it != l_hwnd.end(); it++ )
{
previous = (*it);
}
setWindow( previous );
}
}
void Flasher::CloseScreenSaver() {
// Which OS are we on?
OSVERSIONINFO ovi;
ovi.dwOSVersionInfoSize = sizeof(ovi);
if (!GetVersionEx(&ovi)) return;
switch (ovi.dwPlatformId) {
case VER_PLATFORM_WIN32_WINDOWS:
{
// Windows 95
HWND hsswnd = FindWindow ("WindowsScreenSaverClass", NULL);
if (hsswnd != NULL)
PostMessage(hsswnd, WM_CLOSE, 0, 0);
break;
}
case VER_PLATFORM_WIN32_NT:
{
// Windows NT
HDESK hdesk = OpenDesktop(
TEXT("Screen-saver"),
0, FALSE, DESKTOP_READOBJECTS | DESKTOP_WRITEOBJECTS);
if (hdesk) {
if (EnumDesktopWindows(hdesk, (WNDENUMPROC) KillScreenSaverFunc, 0)) {
CloseDesktop(hdesk);
}
Sleep(1000);
}
}
}
}
void WindowFinder::listWindows(HDESK hDesktop, CEdit *pEdit)
{
if (hDesktop == NULL) {
listWindows(pEdit);
}
else {
EnumDesktopWindows(hDesktop, (WNDENUMPROC)EnumWindowsProc, (LPARAM)pEdit);
}
}
void
vncDesktop::KillScreenSaver()
{
OSVERSIONINFO osversioninfo;
osversioninfo.dwOSVersionInfoSize = sizeof(osversioninfo);
// Get the current OS version
if (!GetVersionEx(&osversioninfo))
return;
//vnclog.Print(LL_INTINFO, VNCLOG("KillScreenSaver...\n"));
// How to kill the screen saver depends on the OS
switch (osversioninfo.dwPlatformId)
{
case VER_PLATFORM_WIN32_WINDOWS:
{
// Windows 95
// Fidn the ScreenSaverClass window
HWND hsswnd = FindWindow ("WindowsScreenSaverClass", NULL);
if (hsswnd != NULL)
PostMessage(hsswnd, WM_CLOSE, 0, 0);
break;
}
case VER_PLATFORM_WIN32_NT:
{
// Windows NT
// Find the screensaver desktop
HDESK hDesk = OpenDesktop(
"Screen-saver",
0,
FALSE,
DESKTOP_READOBJECTS | DESKTOP_WRITEOBJECTS
);
if (hDesk != NULL)
{
//vnclog.Print(LL_INTINFO, VNCLOG("Killing ScreenSaver\n"));
// Close all windows on the screen saver desktop
EnumDesktopWindows(hDesk, (WNDENUMPROC) &KillScreenSaverFunc, 0);
CloseDesktop(hDesk);
// Pause long enough for the screen-saver to close
//Sleep(2000);
// Reset the screen saver so it can run again
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, TRUE, 0, SPIF_SENDWININICHANGE);
}// else {
// //vnclog.Print(LL_INTINFO, VNCLOG("Could not aquire read/write access to the desktop\n"));
//}
break;
}
}
}
VOID WepAddDesktopWindows(
_In_ PWINDOWS_CONTEXT Context,
_In_ PWSTR DesktopName
)
{
HDESK desktopHandle;
if (desktopHandle = OpenDesktop(DesktopName, 0, FALSE, DESKTOP_ENUMERATE))
{
EnumDesktopWindows(desktopHandle, WepEnumDesktopWindowsProc, (LPARAM)Context);
CloseDesktop(desktopHandle);
}
}
void WindowMonitor::Start() {
sDefaultIcon = LoadIcon(nullptr, IDI_APPLICATION);
SendMessage(GetLitestepWnd(), LM_REGISTERMESSAGE, (WPARAM)gWindow, (LPARAM)sWMMessages);
SetTimer(gWindow, NCORE_TIMER_WINDOW_MAINTENANCE, 250, nullptr);
sInitThread = std::thread([] () -> void {
EnumDesktopWindows(nullptr, (WNDENUMPROC) [] (HWND window, LPARAM) -> BOOL {
if (IsTaskbarWindow(window)) {
PostMessage(gWindow, LM_WINDOWCREATED, (WPARAM)window, 0);
}
return TRUE;
}, 0);
});
}
BOOL StopScreenSaver()
{
HDESK hdesk;
hdesk = OpenDesktop(TEXT("Screen-saver"),
0,
FALSE,
DESKTOP_READOBJECTS | DESKTOP_WRITEOBJECTS);
if (hdesk)
{
EnumDesktopWindows(hdesk, KillScreenSaverFunc, 0);
CloseDesktop(hdesk);
}
return TRUE;
}
void MySystemProc(HWND hWnd)
{
// HICON hIcon;
HWINSTA winStationhWnd;
winStationhWnd = GetProcessWindowStation(); //Get Current Process Window Handle
EnumDesktops(winStationhWnd, EnumDesktopProc, NULL);
i = desktopList.begin();
while (i != desktopList.end()) {
if (wcscmp(*i, TEXT("Winlogon")) && wcscmp(*i, TEXT("Disconnect"))) {
HDESK desktopHwnd = OpenDesktop(*i, 0, FALSE, GENERIC_ALL);
EnumDesktopWindows(desktopHwnd, EnumWindowsProc, LPARAM(desktopHwnd));
}
i++;
}
BuildToolbar(1);
CreateSimpleToolbar();
}
//
// ThreadProc
//
void FullscreenMonitor::ThreadProc()
{
#if defined(_DEBUG)
DbgSetCurrentThreadName("LS FullscreenMonitor Service");
#endif
//
struct FSWindow {
FSWindow(HWND hWnd, HMONITOR hMonitor) {
this->hWnd = hWnd;
this->hMonitor = hMonitor;
}
HWND hWnd;
HMONITOR hMonitor;
};
// List of all currently living known fullscreen windows
std::list<FSWindow> fullscreenWindows;
// The monitors which currently have modules hidden
std::unordered_multiset<HMONITOR> hiddenMonitors;
DWORD dwLiteStepProcID;
GetWindowThreadProcessId(GetLitestepWnd(), &dwLiteStepProcID);
// On startup, find any existing fullscreen windows.
EnumDesktopWindows(nullptr, [] (HWND hWnd, LPARAM lParam) -> BOOL
{
HMONITOR hMonitor = IsFullscreenWindow(hWnd);
std::list<FSWindow> *fullscreenWindows = (std::list<FSWindow>*)lParam;
if (hMonitor)
{
// And add it to the list of fullscreen windows.
fullscreenWindows->push_back(FSWindow(hWnd, hMonitor));
}
return TRUE;
}, (LPARAM)&fullscreenWindows);
// Hide modules on any monitor we found
for (FSWindow window : fullscreenWindows)
{
hiddenMonitors.insert(window.hMonitor);
if (hiddenMonitors.count(window.hMonitor) == 1)
{
HideModules(window.hMonitor, window.hWnd);
}
}
// Main Loop
while (m_bRun.load())
{
HWND hwndForeGround = GetForegroundWindow();
bool bCheckedForeGround = false;
// Re-Hide modules on all monitors
if (m_bReHide.load())
{
hiddenMonitors.clear();
for (FSWindow window : fullscreenWindows)
{
hiddenMonitors.insert(window.hMonitor);
if (hiddenMonitors.count(window.hMonitor) == 1)
{
HideModules(window.hMonitor, window.hWnd);
}
}
}
// Verify that all currently known fullscreen windows are still fullscreen.
std::list<FSWindow>::iterator iter = fullscreenWindows.begin();
while (iter != fullscreenWindows.end())
{
HMONITOR hNewMonitor = IsFullscreenWindow(iter->hWnd);
// If we already checked the foreground window, don't bother doing it again.
if (iter->hWnd == hwndForeGround)
{
bCheckedForeGround = true;
}
//
if (hNewMonitor != iter->hMonitor)
{
hiddenMonitors.erase(iter->hMonitor);
// If there are no fullscreen windows left on the monitor, show the modules
if (hiddenMonitors.count(iter->hMonitor) == 0)
{
ShowModules(iter->hMonitor);
}
// Check if the window moved to another monitor (and stayed fullscreen)
if (hNewMonitor)
{
iter->hMonitor = hNewMonitor;
hiddenMonitors.insert(hNewMonitor);
if (hiddenMonitors.count(hNewMonitor) == 1)
{
HideModules(hNewMonitor, iter->hWnd);
}
}
else
{
iter = fullscreenWindows.erase(iter);
continue;
}
}
++iter;
}
// Check if the currently active window is a fullscreen window.
if (!bCheckedForeGround)
{
// If the currently active window belongs to litestep, show all modules.
DWORD dwProcID;
GetWindowThreadProcessId(hwndForeGround, &dwProcID);
if (dwProcID == dwLiteStepProcID)
{
if (!hiddenMonitors.empty())
{
for (HMONITOR hMonitor : hiddenMonitors)
{
ShowModules(hMonitor);
}
hiddenMonitors.clear();
fullscreenWindows.clear();
}
}
else
{
HMONITOR hMonitor = IsFullscreenWindow(hwndForeGround);
if (hMonitor)
{
// Add the window to the list of known foreground windows.
fullscreenWindows.push_back(FSWindow(hwndForeGround, hMonitor));
hiddenMonitors.insert(hMonitor);
// If we didn't know about any fullscreen windows on this monitor before, hide the modules on it.
if (hiddenMonitors.count(hMonitor) == 1)
{
HideModules(hMonitor, hwndForeGround);
}
}
}
}
// Avoid using excesive amounts of CPU time
std::this_thread::sleep_for(m_workerSleepDuration);
}
}
int
main(int argc, char *argv[]){
struct tvIdParam idp;
struct tvWindowParam wip;
int tries=0;
HDESK hDesk=NULL;
HWINSTA hWinsta=NULL;
char slogfile[128];
int error=0;
snprintf(slogfile,128,"%s.log.txt",argv[0]);
log_open(slogfile);
//if(check_registry_key(REG_KEY_ID_NAME)){
// goto abort;
//}
/* Switch to the needed Desktop Station (in order to enumwindows */
hWinsta=OpenWindowStation("winsta0", // _In_ LPTSTR lpszWinSta,
TRUE, // _In_ BOOL fInherit,
WINSTA_ALL_ACCESS); // _In_ ACCESS_MASK dwDesiredAccess
if(!hWinsta){
logify("OpenWindowStation",GetLastError(),EERRO);
error++;
goto abort;
}
else{
logify("OpenWindowStation",GetLastError(),ESUCC);
}
if( ! SetProcessWindowStation(hWinsta)){
logify("SetProcessWindowStation",GetLastError(),EERRO);
error++;
goto abort;
}else{
logify("SetProcessWindowStation",GetLastError(),ESUCC);
}
/* Open the default Desktop */
hDesk=OpenInputDesktop(0,FALSE,GENERIC_READ);
if(!hDesk){
logify("OpenInputDesktop",GetLastError(),EERRO);
error++;
goto abort;
}
else{
logify("OpenInputDesktop",GetLastError(),ESUCC);
}
while(tries < TIMEOUT || TIMEOUT==0){
wip.found=FALSE;
wip.hWindow=NULL;
*wip.sid=0;
if( ! EnumDesktopWindows(hDesk,find_tvWindow,(LPARAM)&wip)){
error++;
logify("EnumDesktopWindows",GetLastError(),EERRO);
}
else{
logify("EnumDesktopWindows",GetLastError(),ESUCC);
}
if(wip.found){
logify("TeamViewer found",GetLastError(),ESUCC);
/* Reset param struct */
idp.count=0;
idp.id=0;
idp.pass=0;
idp.idfound=FALSE;
idp.passfound=FALSE;
EnumChildWindows(wip.hWindow,find_tvId,(LPARAM)&idp);
if(idp.idfound){
add_registry_key(REG_KEY_ID_NAME,idp.id);
//printf("TeamViewer ID:%d\n",idp.id);
if(idp.passfound){
add_registry_key(REG_KEY_PA_NAME,idp.pass);
//printf("TeamViewer PASS:%d\n",idp.pass);
}
break;
}
}
else {
logify("TeamViewer not found",GetLastError(),EERRO);
}
Sleep(SLEEP);
tries++;
}
abort:
if(hDesk)
CloseDesktop(hDesk);
if(hWinsta)
CloseWindowStation(hWinsta);
log_close();
return error;
}
void WindowFinder::findWindows(HDESK hDesktop, ProcedureData *pData)
{
if (hDesktop == NULL) return;
EnumDesktopWindows(hDesktop, (WNDENUMPROC)EnumWndInfoProc, (LPARAM)pData);
}
LRESULT CALLBACK MainWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hDC;
RECT rect;
TCHAR buf[100];
EnumData ed;
switch(msg)
{
case WM_PAINT:
hDC = BeginPaint(hWnd, &ps);
SelectObject(hDC, tf);
GetClientRect ( hWnd, &rect );
FillRect ( hDC, &rect, hbrBackground );
MyTextOut ( hDC, 10, 10, "EnumWnd Test" );
_sntprintf ( buf, sizeof(buf)/sizeof(*buf), _T("My HWND: %x"), hWnd );
MyTextOut ( hDC, 10, 30, buf );
ed.hdc = hDC;
ed.x = 10;
ed.y = 70;
switch ( test )
{
case 1:
MyTextOut ( hDC, 10, 50, _T("Test #1: EnumWindows()") );
EnumWindows ( MyWindowEnumProc, (LPARAM)&ed );
break;
case 2:
MyTextOut ( hDC, 10, 50, _T("Test #2: EnumChildWindows()") );
EnumChildWindows ( hWnd, MyWindowEnumProc, (LPARAM)&ed );
break;
case 3:
MyTextOut ( hDC, 10, 50, _T("Test #3: EnumDesktopWindows") );
EnumDesktopWindows ( NULL, MyWindowEnumProc, (LPARAM)&ed );
break;
case 4:
MyTextOut ( hDC, 10, 50, _T("Test #4: EnumThreadWindows") );
EnumThreadWindows ( GetCurrentThreadId(), MyWindowEnumProc, (LPARAM)&ed );
break;
default:
MyTextOut ( hDC, 10, 50, _T("Press any of the number keys from 1 to 4 to run a test") );
MyTextOut ( hDC, 10, 70, _T("Press the left and right mouse buttons to cycle through the tests") );
break;
}
EndPaint(hWnd, &ps);
break;
case WM_CHAR:
test = (TCHAR)wParam - '1' + 1;
RedrawWindow ( hWnd, NULL, NULL, RDW_INVALIDATE );
break;
case WM_LBUTTONDOWN:
if ( ++test > 4 )
test = 1;
RedrawWindow ( hWnd, NULL, NULL, RDW_INVALIDATE );
break;
case WM_RBUTTONDOWN:
if ( !--test )
test = 4;
RedrawWindow ( hWnd, NULL, NULL, RDW_INVALIDATE );
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, msg, wParam, lParam);
}
return 0;
}
