• SlyFerret Said:

Code:



 
// Save As: main.h
//
#ifndef MAIN_H
#define MAIN_H

#define _WIN32_WINNT 0x0500
#define WIN32_LEAN_AND_MEAN

// Include the following header files
#include <windows.h>
#include <iostream>
#include <stdio.h>
#include <process.h>
#include <math.h>

// Define the preprocessor macros
// These will do a "Find and Replace" before
// the compiler gets the code.
//
// That means that, any time you see SIXTY_SECONDS in the
// code, the preprocessor will replace it with the numer 60
// before compile time
#define SIXTY_SECONDS        60
#define THIRTY_SECONDS        30
#define DIVISION_AMOUNT        0.08

// Global variables used in the application
DWORD dwThreadID        = 0;
HANDLE hTimerThread        = NULL;
BOOL isEnabled            = FALSE;
UINT scrTimerSeconds    = NULL;

// Function prototyping. The functions need to be defined
// before they can be used inside the application.
VOID CALLBACK TimerProc(HWND hwnd,
                        UINT uMsg,
                        UINT_PTR idEvent,
                        DWORD dwTime);

unsigned _stdcall TimerThread(LPVOID lpParam);

UINT GetScreenSaverTimeOut(void);

BOOL EnableScreenSaver(HANDLE hThread);
BOOL DisableScreenSaver(HANDLE hThread);

void ExitCleanUp(void);

#endif // End of MAIN_H
 

Code:


// Save As: main.cpp
//
// Tell the preprocessor to include the main.h file
// this is where all function prototyping and global
// variables are defined.
#include "main.h"

// Main entry point into the application
int main(int argc, char* argv[])
{
	// Register an exit function to do necessary cleanup
	// when the application is terminated.
	atexit(ExitCleanUp);

	// Get the number of seconds before Windows is scheduled
	// to turn on the screen saver feature
	scrTimerSeconds = (UINT)GetScreenSaverTimeOut();
	
	// Test the value returned by Windows and do the
	// appropriate calculations.
	if (scrTimerSeconds > SIXTY_SECONDS)
	{
		scrTimerSeconds = (UINT)floor(scrTimerSeconds / DIVISION_AMOUNT);
	}
	else
	{
		// Sixty seconds is the lowest Windows will let you
		// set the screen saver timeout, so we should never
		// get to this point. If something went wrong, though
		// we assign the value of thiry seconds.
		scrTimerSeconds = THIRTY_SECONDS;
	}

	// Create a new thread to handle the timer that
	// injects the mouse move event.
	hTimerThread = (HANDLE)_beginthreadex(NULL,
										  0,
										  (unsigned int (__stdcall *)(void *))TimerThread,
										  (LPVOID)scrTimerSeconds,
										  0,
										  (PUINT)&dwThreadID);

	// Test if the handle to the thread is valid. If it's
	// not, we terminate the process. It would be an 
	// extreme case, if this failed.
	if (!hTimerThread)
	{
		printf("Cannot start time thread.\n");
		return -1;
	}

	// Create a variable to handle the user input
	char in		= 'a';

	// Start a loop to react to the user input. If the
	// variable 'in' is 'q' the program will exit. All
	// other options process the request and return to the
	// loop.
	while ('q' != in)
	{
		// Clears the console screen.
		system("cls");

		// Outputs the information to the screen.
		std::string message = (isEnabled == TRUE) ? "Screen saver is currently enabled" : "Screen saver is currently disabled";
		std::cout << message.c_str() << std::endl << std::endl;
		std::cout << "Please select from the following options..." << std::endl << std::endl;
		message = "";
		message = (isEnabled == FALSE) ? "e = Enabled screen saver" : "d = Disable screen saver";
		std::cout << message.c_str() << std::endl;
		std::cout << "q = Quit the application" << std::endl << std:: endl;
		
		message = "";

		// Waits for the user to select an option.
		std::cin >> in;

		// Checks that option and reacts to it appropriately.
		switch (in)
		{
			// 'e' = Enable the screen saver; allow it to come on.
		case 'e':
			EnableScreenSaver(hTimerThread);
			isEnabled = TRUE;
			break;
			// 'd' = Disable the screen saver; do not allow it to come on.
		case 'd':
			DisableScreenSaver(hTimerThread);
			isEnabled = FALSE;
			break;
			// 'q' = Quit the program
		case 'q':
			// The atexit() function will handle the thread
			// cleanup, so we just return 0, which means to
			// exit the program.
			std::cout << "Waiting to exit..." << std::endl;
			return 0;
			break;
		default:
			// Handles all other values, by starting the while loop
			// all over again
			break;
		}

	}

	// End the application
	return 0;
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
//
// TimerProc()
//
// Called by the SetTimer() function. This is called every
// time the timer reaches the end of its time interval.
//
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
VOID CALLBACK TimerProc(HWND hwnd,
						UINT uMsg,
						UINT_PTR idEvent,
						DWORD dwTime)
{
	// Create the INPUT structure and assign it the values
	INPUT input				= {0};

	input.type				= INPUT_MOUSE;
	input.mi.dx				= 0; // the number of pixels to move in the x direction
	input.mi.dy				= 0; // the number of pixels to move in the y direction
	input.mi.dwFlags		= MOUSEEVENTF_MOVE;

	// Send the INPUT structure to inject the mouse move.
	SendInput(1, &input, sizeof(input) );
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
//
// TimerThread()
//
// Called by the _beginthreadex() as the starting function
// of the newly created thread. Basically, that means that,
// when the thread is created, the threads purpose is to
// handle the execution of this function
//
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
unsigned _stdcall TimerThread(LPVOID lpParam)
{
	// Create the timer and send it the scrTimerSeconds,
	// passed in with the lpParam function argument.
	SetTimer(NULL, 0, (UINT)lpParam, (TIMERPROC)TimerProc);

	// Start a message loop to keep the thread alive and
	// also listen for the WM_QUIT message
	MSG theMsg;
	while (GetMessage(&theMsg, NULL, 0, 0))
	{
		DispatchMessage(&theMsg);
	}

	// Turn off the timer
	KillTimer(NULL, 0);
	return 0;
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
//
// GetScreenSaverTimeOut()
//
// Requests the number of seconds before Windows turns on
// the screen saver, after inactivity
//
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
UINT GetScreenSaverTimeOut(void)
{
	UINT seconds	= 0;

	SystemParametersInfo(SPI_GETSCREENSAVETIMEOUT, NULL, (PVOID)&seconds, NULL);

	return (UINT)seconds;
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
//
// EnableScreenSaver()
//
// Enables the screen saver by suspending the timer thread
//
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
BOOL EnableScreenSaver(HANDLE hThread)
{
	SuspendThread(hThread);
	return TRUE;
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
//
// DisableScreenSaver()
//
// Disables the screen saver by resuming the timer thread
//
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
BOOL DisableScreenSaver(HANDLE hThread)
{
	ResumeThread(hThread);
	return TRUE;
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
//
// ExitCleanUp()
//
// Performs the necessary cleanup when the application is
// terminated
//
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
void ExitCleanUp(void)
{
	// Check to see if the isEnabled flag is set to TRUE.
	// If it is, that means the thread is suspended and
	// will not recieve the WM_QUIT message.
	if (isEnabled == TRUE)
	{
		DisableScreenSaver(hTimerThread);
	}

	// Safely stop the thread by sending it the WM_QUIT message.
	PostThreadMessage(dwThreadID, WM_QUIT, 0, 0);

	// Wait for the thread to exit.
	WaitForSingleObject(hTimerThread, INFINITE);
	
	// Clean up by closing the thread handle.
	CloseHandle(hTimerThread);

	// Output the final message because the thread was closed
	std::cout << "Thread closed and cleaned up." << std::endl << std::endl;
}

Attachment: ScrSlayerLean.zip (51.33 KB) 49 View(s)

•  Report Topic

•  Print Topic