Aplicaciones a pantalla completa

Introducción

El propósito del siguiente artículo es introducir los conceptos básicos necesarios para desarrollar cualquier tipo de aplicación en Java utilizando el modo Full-Screen (pantalla completa) disponible a partir de la versión 1.4 del JDK de SUN. La mayoría de aplicaciones que utilizan este modo son los videojuegos, pero eso no implica que no se pueda utilizar en aplicaciones de ámbito general.

Para comprender el funcionamiento de este modo de pantalla veremos un ejemplo sencillo, el típico "Hola Mundo", pero en este caso utilizando una aplicación a pantalla completa. Una vez visto el ejemplo el paso de cualquier tipo de aplicación en Swing o AWT a pantalla completa es inmediato.

Este artículo está destinado tanto a usuarios noveles de Java como a usuarios avanzados. Espero que sea de gran ayuda tanto para unos como para otros.

MODO EXCLUSIVO A PANTALLA COMPLETA

A muchos programadores que hayan utilizado la API de Microsoft Direct X este concepto les resultará bastante familiar, para otros programadores quizás este concepto les sea totalmente nuevo. De una o de otra forma hay que decir que el modo exclusivo a pantalla completa es una potente característica del J2SE a partir de su versión 1.4 que permite al programador suspender el entorno de ventanas del sistema operativo para que el dibujado pueda ser aplicado directamente en la pantalla. Esto puede sonar un poco confuso pero veremos exactamente a que nos referimos a continuación.

En las aplicaciones Java con las interfaces gráficas tradicionales, AWT es el responsable de propagar los eventos de "pintar" del sistema operativo, a través del un hilo manejador de eventos, e invocando el método Component.paint de AWT siempre que sea necesario (redibujado de pantalla, al pasar el ratón por encima, etc.). Pues bien, en el modo exclusivo a pantalla completa, el dibujado se puede hacer activamente a través de la propia aplicación. Esto permite reducir gran cantidad de recursos que eran consumidos por el hilo de AWT, y que normalmente no son necesarios en este tipo de aplicaciones como puede ser un videojuego.

Utilizar este modo a pantalla completa en las interfaces gráficas tradicionales implica que se tendrá que limitar a la profundidad de color y al tamaño de pantalla que elija el usuario. Esto puede ser controlado por el programador a través de la clase DisplayMode, más adelante veremos como podemos utilizar esta clase para establecer el modo de pantalla que nosotros queramos.

Finalmente, muchas otras técnicas avanzadas, como por ejemplo page-flipping (que se tratará con profundidad en posteriores artículos) o visores estereoscópicos (sistemas que utilizan conjuntos separados de imágenes para cada ojo) requieren, en algunas plataformas, que una aplicación este principalmente en modo exclusivo a pantalla completa.

java.awt.GraphicsDevice

La gestión del modo exclusivo a pantalla completa de Java se hace a través de un objeto de la clase GraphicsDevice. Para obtener una lista de todos los dispositivos de pantalla (en sistemas multi-monitor puede que tengamos más de un dispositivo) se puede invocar el método getScreenDevices de la clase java.awt.GraphicsEnvironment (que representa a nuestro entorno gráfico de ventanas). Para el dispositivo primario por defecto se puede invocar directamente el método getDefaultScreenDevice.

Entonces lo primero que tenemos que hacer si queremos usar el modo a pantalla completa es obtener esa referencia al dispositivo gráfico que representará a nuestro monitor. Esto lo hacemos en nuestro código de la siguiente manera:

 

 

...
// Obtenemos la referencia al entorno de ventanas
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
// Obtenemos el dispositivo gráfico primario (por defecto)
GraphicsDevice      gd = ge.getDefaultScreenDevice();
...

 

 

Una vez obtenida la referencia al dispositivo gráfico podremos invocar alguno de los métodos siguientes:

public boolean isFullScreenSupported()

Este método devuelve verdadero si el modo exclusivo a pantalla completa está disponible, es decir, si el hardware y el sistema operativo de la máquina tienen soporte para utilizarlo. En sistemas donde el modo exclusivo no esté disponible probablemente sea mejor ejecutar la aplicación en una ventana de tamaño fijo y predefinido que establecer una ventana a pantalla completa.

public void setFullScreenWindow(Window w)

Este método entra en el modo exclusivo a pantalla completa utilizando la ventana que se le pase como argumento. Si el modo exclusivo no esta disponible, la ventana se posiciona en el punto (0, 0) y se redimensiona hasta ajustarse completamente a la pantalla. Si utilizamos este método con un argumento nulo saldremos del modo exclusivo a pantalla completa.

Básicamente esto es todo lo que se necesita saber para empezar a utilizar el modo a pantalla completa (sencillo, ¿verdad?). Veamos un primer ejemplo con una clase muy básica, esto nos hará descubrir que aún es necesario algún que otro concepto…

HolaMundo.java

Vamos a ir comentando en detalle todo aquello que nos vayamos encontrando en el código de la clase:

 

 

// AWT-SWING
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
// DEFINICIÓN DE LA CLASE
public class HolaMundo extends JFrame {

 

 

Podemos ver que en primer lugar estamos importando los paquetes básicos de AWT y Swing por si se quisieran añadir botones, paneles, escuchadores de eventos, etc. Se presupone un mínimo conocimiento de Java con lo que supongo que estas primeras líneas todo el mundo las entenderá.

El primer dato importante a tener en cuenta está en la declaración de la clase, como podéis ver, la clase extiende de JFrame. Esto es obvio puesto que estamos implementando una interfaz gráfica y por tanto debemos hacer que nuestra clase herede de Window. En este caso eso se consigue heredando de JFrame, pero también podríamos haber heredado directamente de la clase Window, o también de la clase Frame. Cada uno puede tener una manera concreta de programar sus interfaces, así que aquí que cada uno herede de lo que cree oportuno, siempre que todo herede de la clase Window no habrá problema.

 

 

// ATRIBUTOS DE LA CLASE
// Referencia al dispositivo gráfico
private  GraphicsDevice gd = null;

 

 

Definiremos un atributo de la clase con la referencia al dispositivo gráfico primario del sistema, que es en definitiva la que nos dará acceso al modo exclusivo a pantalla completa.

Continuemos viendo el código del constructor:

 

 

public HolaMundo() {
// Primero obtenemos una referencia al entorno gráfico de ventanas
GraphicsEnvironment ge =
GraphicsEnvironment.getLocalGraphicsEnvironment();
// Obtenemos una referencia al dispositivo gráfico primario
gd = ge.getDefaultScreenDevice();
// Si no hay soporte adecuado lo mostramos por pantalla
if(!gd.isFullScreenSupported())
System.out.println("WARNING: No hay soporte.n");
else
System.out.println("INFO: Detectado soporten");
try {
// Activamos el modo a pantalla completa
gd.setFullScreenWindow(this);
// Inicializamos toda la interfaz gráfica
initMainInterface();
}
catch(Throwable e) {
e.printStackTrace();
System.out.println("ERROR CRITICO: "+e.getMessage());
exit();
}
}//constructor

 

 

Bien, pues tal y como se comentó al principio obtenemos la referencia al entorno de ventanas y a partir de ella el dispositivo primario de gráficos. Una vez lo tenemos podemos comprobar si nuestro sistema tiene soporte para utilizar el modo exclusivo (no importa si no tiene, puesto que en ese caso se ejecutará en una ventana de tamaño la resolución actual del sistema). A continuación estableceremos el modo a pantalla completa e inicializaremos la interfaz gráfica con todos los elementos que queramos. No es tema de este artículo tratar las excepciones, además supongo que son de sobra conocidas por los que lean el artículo, basta decir que se captura cualquier excepción que se pueda generar y que se muestra la traza y se termina la aplicación invocando al método exit().

Veamos el código de los métodos nuevos que aparecen aquí, initMainInterface() y exit()

 

 

public void initMainInterface() throws Exception {
// WindowListener para cerrar la aplicación al cerrar la ventana
this.addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(WindowEvent e) {
exit();
}
});
// Aqui añadimos una etiqueta en la "ventana" con la cadena HolaMundo
this.getContentPane().add(new JLabel("HOLA MUNDO!"));
this.setVisible(true);
}//initMainInterface

 

 

Este código no os debe parecer extraño si alguna vez habéis hecho alguna ventana con Java. En primer lugar establecemos un escuchador de eventos para cuando se cierre la ventana de la aplicación, en cuyo caso invocaremos el método exit. Después añadimos una etiqueta a nuestra ventana, y la hacemos visible.

Cómo podéis ver el código no cambia en absoluto al realizar la aplicación a pantalla completa (al menos no de momento y para las aplicaciones "normales"). Podríamos añadir cualquier tipo de componente que nos ofrece AWT o Swing y utilizarla en nuestra aplicación a pantalla completa sin ningún problema.

Por último veamos el código para salir de la aplicación:

 

 

public void exit() {
// salimos del modo a pantalla completa
gd.setFullScreenWindow(null);
// salimos de la aplicación
System.exit(0);
}//exit

 

 

Basta con salir del modo a pantalla completa (es necesario para no dejar el modo exclusivo más tiempo del que se debiera) y hacer un System.exit().

Conclusión

Pues con esto ya tenemos nuestra primera aplicación que utiliza el modo exclusivo a pantalla completa en Java. Es bastante sencillo, sin embargo, cuando probéis a ejecutar la aplicación os surgirán preguntas y comentarios como: "Muy bonito, ¿pero cómo especifico la resolución que yo quiera a pantalla completa?" "¿Cuáles son las mejoras que obtengo al hacer mi aplicación de esta manera?" "No da la impresión de que este en un modo a pantalla completa. Esto no creo que sirva de mucho." "El aspecto sigue siendo el mismo" "¿Con esto pretendes que haga un juego? Pues vaya…".

Tranquilos, este primer tutorial es muy básico y tampoco quería profundizar demasiado. Sólo quería mostrar la sencillez de Java para trabajar a pantalla completa (siempre que el sistema tenga soporte, claro). Este artículo pretende ser una pequeña introducción al tema y nada más. Puede que esta información a alguien ya le resulte suficiente para desarrollar alguna aplicación que necesite estar en "primer plano" por así decirlo (sin que se vea la barra de tareas de Windows o de Linux, o cosas así).

Antonio Calero
http://www.javahispano.org/articles.article.action?id=79

Leave A Comment?