Creando un protector de pantalla desde cero

Los protectores de pantalla o screen savers, son programas mostrados por Windows después de cierto tiempo de inactividad. La idea principal de un protector de pantalla es la de mantener cierto movimiento en la pantalla y así evitar que esta se dañe. Sin embargo, hoy en día las pantallas son bastante mejores haciendo que los protectores de pantalla sean utilizados principalmente para decoración.

Un protector de pantalla no es nada del otro mundo, es simplemente otro programa como los que haces a menudo en Visual Studio, Borland, Code Gear o cualquier otra IDE. La única diferencia es que responde a ciertos parámetros que por lo general no utilizamos en nuestros programas del día a día.

Este artículo no te va a enseñar a crear gráficos tridimensionales o animaciones sorprendentes, simplemente te va a dar todo lo que necesitas para poder crear un protector de pantalla, el diseño y estilo de protector de pantalla te lo dejo completamente a tí.

Extensión de los archivos de protector de pantallas (*.SCR)

Si estás leyendo esto, probablemente ya te has dado cuenta que los protectores de pantalla tienen la extensión SCR que significa screen saver.

En realidad la extensión no significa nada, es simplemente para que windows la reconozca como un protector de pantalla. Si no me crees prueba haciendo lo siguiente:

1. Haz una copia de un protector de pantalla (por lo general en C:\Windows\System32\*.scr)
2. Cámbiale la extensión scr por exe
3. Abre una línea de comandos (Command prompt) y dirígete a la ruta dónde creaste la copia.
4. Escribe el nombre del archivo seguido por un /s (separado por un espacio). Ejemplo: C:>saver.exe /s

Lo que deberías ver es que el protector de pantalla comienza a ejecutarse.

Es por esta razón que nosotros vamos a crear un programa ejecutable (*.exe) configurado como protector de pantalla y al final lo único que vamos a hacer es cambiarle la extensión por scr.

¿Qué parámetros debe procesar tu programa?

Para poder crear un protector de pantalla, tu programa tiene que poder procesar alguno o todos los siguientes parámetros:

Cómo procesar los parámetros

Todos los programas comienzan siempre con la función main (aplicaciones de consola) o winmain (aplicaciones de entorno visual). Estas funciones son las que reciben los parámetros y es por esta razón que vamos a procesar los parámetros dentro de dichas funciones.

La forma de procesar los parámetros depende del tipo de aplicación que queremos crear y el lenguaje a utilizar. El ejemplo más simple que se puede hacer es con una aplicación de consola en C++ y por eso ese será nuestro primer ejemplo.

Lo primero que voy a hacer es crear mi programa en consola. Este programa simplemente va a mostrar números en la pantalla hasta que el usuario cierre la consola. Aquí va el código:

#include <stdio.h>
#include <windows.h>

int main(int argc, char* argv[])
{
	int n = 0;
	while ( true )
	{
		printf("%d ", n++);
		Sleep(100);
	}
	return 0;
}

Ahora, vamos a convertirlo en un protector de pantalla. Para esto necesitamos detectar los parámetros que recibimos a la función main. La variable argc indica la cantidad de parámetros que se han recibido y la variable argv guarda los parámetros en un arreglo de cadenas. Para que quede un poco más claro, cuando Windows desea ejecutar un programa por lo general lo llama usando su nombre como por ejemplo miprograma.exe. Cuando le envía parámetros a un programa los escribe después de la invocación y separados por espacios, estos parámetros son los que vienen dentro de argv. Por ejemplo si windows ejecuta el comando:

miprograma.exe C:\users\copstone\desktop /s

A la función main de miprograma.exe le llegaría que hay 2 parámetros (argc = 2) y que argv tiene dos cadenas en argv[0] está la cadena C:\Users\copstone\desktop y en la segunda cadena argv[1] está /s.

La idea de un protector de pantalla es que solamente se ejecute cuando se le envíe el parámetro /s por lo que vamos a modificar el código para que solamente se ejecute cuando nos llegue este parámetro.

#include <stdio.h>
#include <windows.h>

int main(int argc, char* argv[])
{
	if (argc > 1 && argv[1][0] == '/' && argv[1][1] == 's')
	{
		int n = 0;
		while ( true )
		{
			printf("%d ", n++);
			Sleep(100);
		}
	}
	return 0;
}

En este nuevo código simplemente hemos agregado el if de la línea 6 que contiene a todo el código anterior. Este if solamente será válido si nos han llegado por lo menos 2 argumentos ( > 1 ) y si el segundo argumento tiene como primer caractér el / y segundo caractér la s.

Utilizamos el segundo argumento porque por lo general el primero es el nombre de nuestro ejecutable. Ten cuidado si trabajas con aplicaciones CLR en Visual Studio porque el primer argumento no es el nombre del ejecutable sino el que debes utilizar.

Ahora puedes tratar de correr tu programa pero como no recibe ningún parámetro se va a cerrar de forma automática.

Instalando el protector de pantalla

Este paso es bastante simple.

Busca el ejecutable de tu programa y simplemente cámbiale la extensión de .exe a .scr. Si no puedes ver las extensiones probablemente tengas que activar la opción para no ocultar extensiones en las propiedades de la carpeta.

Una vez que le hayas cambiado la extensión al ejecutable a scr, simplemente copia el archivo en C:\Windows\System32 o C:\Windows\System dependiendo de tu versión de Windows. Si no estás seguro en cuál simplemente busca la que ya tenga archivos de tipo scr.

Listo!! ya está instalado tu protector de pantalla, ahora simplemente entra a la selección de protector de pantalla, elige el que tiene el nombre de tu ejecutable y guarda los cambios. Espera un tiempo sin utilizar la computadora y verás que el protector de pantalla que se activa es tu programa de consola.

Observaciones

Obviamente, tu programa no se parece a un protector de pantalla por las siguientes razones:

• No se cierra al presionar una tecla o mover el cursor del mouse.
• Muestra el borde de la ventana con los botones y el título.
• No ocupa toda la pantalla.

Lo que quiero que analices, no es que tan bien se vé el protector de pantalla sino que ya sabes crear uno y no es nada del otro mundo. Todo lo mencionado anteriormente se puede corregir con un poco más de código.

Ahora que ya sabes como crear un protector de pantalla vamos a ir un poco más allá y vamos a crear un protector de pantalla que cumpla con todas las características que nos faltaron en el programa anterior para que parezca un protector de pantalla de verdad. Para que esto sea más fácil vamos a crear un programa de entorno visual que nos permita tener un poco más de control sobre la ventana en sí.

Mi primer protector de pantalla en entorno visual

El objetivo es crear un protector de pantalla que muestre un círculo rojo rebotando por la pantalla.

Voy a mostrar el código para dos de mis IDE’s favoritas Visual Studio y Code Gear. Lo primero que vamos a hacer es crear el programa que muestra el círculo rojo rebotando y al último lo vamos a convertir en un protector de pantalla.

Lo primero que tienes que hacer es crear una aplicación de entorno visual (Windows Form o VCL Forms Application). Ahora debes tener una aplicación que tiene un formulario en él. Este será nuestro formulario donde aparecerá el círculo rojo rebotando.

Declara 4 variables de tipo entero en el formulario (x, y, dx, dy) estas las vamos a utilizar para guardar las coordenadas del círculo y el desplazamiento en ambos ejes. A continuación te muestro la declaración de esas variables dentro del formulario (línea 7):

//
// Form1.h
//
public ref class Form1 : public System::Windows::Forms::Form
{
private:
	int x, y, dx, dy;

//
// Form1.h
//
class TForm1 : public TForm
{
private:
	int x, y, dx, dy;

Inicializa las variables en el constructor del formulario:

Form1(void)
{
	InitializeComponent();
	x = y = dx = dy = 10;
}

__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner)
{
	x = y = dx = dy = 10;
}

Agrega un componente de tipo timer a tu formulario y asegúrate de que su propiedad enabled esté en true. Luego programa el evento del timer (Tick o OnTimer) para que dibuje y mueva el círculo rebotando por la pantalla.

private: System::Void timer1_Tick(System::Object^  sender, System::EventArgs^  e)
{
	// Obtiene y limpia el área de dibujo
	Graphics ^g = this->CreateGraphics();
	g->Clear(Color::Black);

	// Dibuja el circulo rojo con diámetro 30
	g->FillEllipse(Brushes::Red, x, y, 30, 30);

	// Verifica si a chocado para cambiar de sentido
	if (x + dx <= 0 || x + dx + 30 > this->ClientSize.Width)
	    dx *= -1;
	if (y + dy <= 0 || y + dy + 30 > this->ClientSize.Height)
	    dy *= -1;

	// Mueve el circulo
	x += dx;
	y += dy;
}

void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
	// Limpia el área de dibujo
	this->Canvas->Brush->Color = clBlack;
	this->Canvas->FillRect(this->ClientRect);

	// Dibuja el circulo rojo con diámetro 30
	this->Canvas->Brush->Color = clRed;
	this->Canvas->Ellipse(x, y, x + 30, y + 30);

	// Verifica si a chocado para cambiar de sentido
	if (x + dx <= 0 || x + dx + 30 > this->ClientWidth)
	    dx *= -1;
	if (y + dy <= 0 || y + dy + 30 > this->ClientHeight)
	    dy *= -1;

	// Mueve el circulo
	x += dx;
	y += dy;
}

Hecho esto ya deberías poder ejecutar tu programa y ver como un círculo rojo rebota sobre un fondo negro.

Ahora vamos a corregir todo lo necesario para que parezca un protector de pantalla.

Cerrar el programa al mover al presionar una tecla o mover el mouse

Para cerrar el programa cuando se presione una tecla simplemente debes programar el evento KeyPress del formulario y llamar al método Close para cerrar el programa.

private: System::Void Form1_KeyPress(System::Object^  sender, System::Windows::Forms::KeyPressEventArgs^  e)
{
	this->Close();
}

void __fastcall TForm1::FormKeyPress(TObject *Sender, wchar_t &Key)
{
	this->Close();
}

Para controlar el mouse es un poco más difícil ya que el evento MouseMove es muy sensible y hará que nuestro programa se cierre a penas comience. Para solucionar este problema tenemos que agregar unas cuantas variables más. Agrega las variables enteras mouseX y mouseY a tu formulario y en el constructor colócale el valor –1 a ambas. (Este paso es muy similar al de las variables x, y, dx y dy).

Las nuevas variables las vamos a utilizar para calcular la distancia (usando la teoría de pitágoras) que se ha movido el mouse, si la distancia es mayor a 30 entonces recién consideraremos cerrar nuestro programa. Aquí te va el código del evento MouseMove.

private: System::Void Form1_MouseMove(System::Object^  sender, System::Windows::Forms::MouseEventArgs^  e)
{
	// Si es la primera vez que se ejecuta asignamos mouseX y mouseY
	if (mouseX == -1 || mouseY == -1)
	{
		mouseX = e->X;
		mouseY = e->Y;
	}

	// Calculamos la distancia usando pitagoras
	double distancia = Math::Sqrt( Math::Pow((e->X - mouseX), 2) + Math::Pow((e->Y - mouseY), 2) );

	// Determinamos si la distancia fue suficiente
	if (distancia > 30.0)
		this->Close();

	// Guardamos la posicion del mouse para la siguiente comparacion
	mouseX = e->X;
	mouseY = e->Y;
}

void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift, int X, int Y)
{
	// El X e Y utilizado son los parametros a esta funcion
	// Si es la primera vez que se ejecuta asignamos mouseX y mouseY
	if (mouseX == -1 || mouseY == -1)
	{
		mouseX = X;
		mouseY = Y;
	}

	// Calculamos la distancia usando pitagoras debes incluir math.h
	double distancia = sqrt( pow((X - mouseX), 2) + pow((Y - mouseY), 2) );

	// Determinamos si la distancia fue suficiente
	if (distancia > 30.0)
		this->Close();

	// Guardamos la posicion del mouse para la siguiente comparacion
	mouseX = X;
	mouseY = Y;
}

Prueba tu programa debería terminar cuando presionas alguna tecla y cuando mueves el mouse un poco rápido. Si mueves el mouse despacio el programa no acabará ya que la distancia no está siendo mayor a 30.

Ocultando el borde de la ventana

Para ocultar el borde simplemente tienes que cambiar la propiedad que indica el estilo del borde por el adecuado que en este caso es none. Esta propiedad se puede cambiar desde el diseño del formulario o con código, te recomiendo poner el código en el constructor. Más adelante está el código del constructor con esta línea incorporada.

Ocupando toda la pantalla

Para ocupar la pantalla también tienes que configurar una propiedad que indica el estado de la ventana, en este caso el valor debe ser maximized. Aquí te va el código completo del constructor para cambiar el borde y ocupar toda la pantalla.

Form1(void)
{
	InitializeComponent();
	x = y = dx = dy = 10;
	mouseX = mouseY = -1;
	this->FormBorderStyle = Windows::Forms::FormBorderStyle::None;
	this->WindowState = FormWindowState::Maximized;
}

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
{
	x = y = dx = dy = 10;
	mouseX = mouseY = -1;
	this->BorderStyle = TFormBorderStyle::bsNone;
	this->WindowState = TWindowState::wsMaximized;
}

Transformando nuestro programa en protector de pantalla

Hasta ahora lo único que hemos hecho es crear un programa que funciona como un protector de pantalla, lo único que falta es que Windows lo reconozca como uno.

Lo primero que tienes que hacer es encontrar la función main de tu proyecto. Por lo general se encuentra en el archivo cpp que se llama igual que el proyecto.

Ahora solo tienes que agregarle la condición para que solo se corra la aplicación cuando nos llegue el parámetro /s. Aquí te va el código de la función main en la que solamente he agregado la línea 3, todo el resto es código autogenerado por el IDE.

int main(array<System::String ^> ^args)
{
	if (args->Length > 0 && args[0] == "/s")
	{
		// Enabling Windows XP visual effects before any controls are created
		Application::EnableVisualStyles();
		Application::SetCompatibleTextRenderingDefault(false);

		// Create the main window and run it
		Application::Run(gcnew Form1());
	}
	return 0;
}

WINAPI _tWinMain(HINSTANCE, HINSTANCE, LPTSTR, int)
{
	if (ParamCount() >= 1 && ParamStr(1) == "/s")
	{
		try
		{
			Application->Initialize();
			Application->MainFormOnTaskBar = true;
			Application->CreateForm(__classid(TForm1), &Form1);
			Application->Run();
		}
		catch (Exception &exception)
		{
			Application->ShowException(&exception);
		}
		catch (...)
		{
			try
			{
				throw Exception("");
			}
			catch (Exception &exception)
			{
				Application->ShowException(&exception);
			}
		}
	}
	return 0;
}

Ya está terminado, ahora solamente sigue los pasos de la sección “Instalando el protector de pantalla”, es decir, cámbiale la extensión al archivo y ubícalo en la carpeta de sistema de Windows.

Observaciones

Así como verificas que el parámetro sea /s, también puedes agregar una verificación por si es /c y ejecutar un segundo formulario que puede contener la configuración de tu protector de pantalla.

En este artículo he mostrado cómo crear protectores de pantalla en base a formularios Windows. Sin embargo no siempre es la mejor manera de crearlos y se pueden crear utilizando el API de Windows. Por el momento esto es suficiente para que comiences a crear tus propios protectores de pantalla, más adelante mostraré como crearlos usando el API de Windows.

Autor: alfredo

Comentarios (4)

Angelo Diaz dice:

abril 15, 2010 a las 8:46 am

Muy bueno el post, pero solo falto el codigo para C#. Gracias de todas maneras

Responder

Carmen Cruz dice:

julio 6, 2010 a las 1:43 pm

Muchas gracias por tu artículo, me ha sido de gran utilidad.

Responder

Juan Carlos dice:

abril 23, 2011 a las 7:36 pm

Me gusto bastante tu post porque siempre he dicho que lo mejor es saber de el porque de las cosas, pero la verdad yo no se de programación y fijate que necesito urgentemente un descansador de pantalla que se ejecute siempre siempre que se deje de teclear o mover el mouse, sin importar que se este ejecutando un video en media player, en internet o cualquier otro programa que reprodusca video, además necesito que el protector de pantalla cierre todos los programas que se esten ejecutando como internet explorer, mozila, ares, emule y otros, que el descansador de pantalla se active despues de 1 minuto de inactividad del teclado o mouse y que le pueda modificar algún texto para que aparesca en pantalla.

Si me lo pudieras crear o alguna otra forma de conseguirlo te lo agradeceria de toda la vida, pues me es muy útil.

Responder

Juan Carlos dice:

abril 25, 2011 a las 5:22 pm

Muy bueno el post, pero yo no se de programación y quisiera un descansador de pantalla que al activarse cierre todos los programas, también que el descansador se active aunque haya video en reproducción.

Si me pudieras ayudar te lo agradeceria de toda la vida.

Responder