1. En este ejercicio vamos a practicar con el modo a pantalla completa de Java, para ver que no resulta tan complicado como pueda parecer el trabajar con él.
public Ej2()
{
...
// Tomamos el dispositivo grafico
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gd = ge.getDefaultScreenDevice();
// Mostramos dialogo para elegir un modo grafico
DlgModos dlg = new DlgModos(gd, this);
dlg.show();
// Activamos el modo a pantalla completa, con el modo grafico seleccionado
gd.setFullScreenWindow(this);
gd.setDisplayMode(dlg.modoSeleccionado);
}
Compilad y ejecutad el programa. Es IMPORTANTE elegir un modo
gráfico compatible con nuestra pantalla, pues realmente todos los que
muestra no lo son. Para evitar pantallazos y cambios de configuración,
podéis elegir el mismo modo que tenéis activo para Windows (normalmente,
unos 1024 x 768 con 16 o 32 bits de profundidad de color). Si os fuese
demasiado lento, podéis elegir uno de menor resolución (320 x 240, por
ejemplo), aunque procurad mantener la misma profundidad de color que
tengáis. En general, es cuestión de ir probando hasta que alguno se vea.
Veréis que el frame pasa a pantalla completa (aunque todavía se verá la
barra superior de la ventana, eso lo solucionaremos luego).
public class Ej2 extends JFrame implements Runnable
{
public static final int ANCHO = 320;
public static final int ALTO = 240;
MiCanvas mc = new MiCanvas();
Thread t = new Thread(this);
int yObj = 0;
int anchoPantalla;
int altoPantalla;
public Ej2()
{
...
DlgModos dlg = new DlgModos(gd, this);
dlg.show();
anchoPantalla = dlg.modoSeleccionado.getWidth();
altoPantalla = dlg.modoSeleccionado.getHeight();
...
}
public void paint(Graphics g)
{
if(backbuffer == null)
backbuffer = createImage(ANCHO, ALTO);
// Dibujamos los gráficos en el backbuffer
Graphics off_g = backbuffer.getGraphics();
off_g.clearRect(0, 0, ANCHO, ALTO);
...
// Volcamos el backbuffer a pantalla, segun el tamaño de la misma
g.drawImage(backbuffer, 0, 0, anchoPantalla, altoPantalla, this);
g.dispose();
}
Observad cómo la imagen del backbuffer siempre será de 320 x 240,
tal y como la definimos en createImage. Esto nos permite dibujar
independientemente de la resolución final, y luego nosotros escalaremos
el resultado según la resolución que tengamos elegida.
public Ej2()
{
this.setUndecorated(true);
...
}
que hace que la ventana no tenga decoración, y con eso se quita la
barra.
Después, añadimos en ese mismo constructor un evento de teclado (KeyListener)
que recogerá las siguientes pulsaciones de teclas:
Añadimos un evento con todo lo anterior:
public Ej2()
{
...
addKeyListener(new KeyAdapter()
{
public void keyPressed(KeyEvent e)
{
if (e.getKeyCode()==KeyEvent.VK_ESCAPE)
{
System.exit(0);
} else if (e.getKeyCode()==KeyEvent.VK_UP) {
if (yObj > 0)
yObj--;
} else if (e.getKeyCode()==KeyEvent.VK_DOWN) {
if (yObj < ALTO)
yObj++;
}
}
});
}
¿Qué método utilizamos en el código para saber qué tecla se ha
pulsado? ¿Con qué lo comparamos en cada caso para saber si se ha pulsado
la tecla indicada?
Como ahora las figuras las movemos por teclado, quitamos la línea que
aumenta la coordenada Y automáticamente en el método run, y hacemos que el
bucle sea infinito:
public void run()
{
while (true)
{
// Quitamos esta linea: yObj++;
mc.repaint();
try
{
Thread.currentThread().sleep(100);
} catch (Exception ex) {}
}
}
public class Ej2 extends JFrame implements Runnable
{
public static final int ANCHO = 320;
public static final int ALTO = 240;
MiCanvas mc = new MiCanvas();
Thread t = new Thread(this);
int yObj = 0;
int anchoPantalla;
int altoPantalla;
Image figura;
public Ej2()
{
...
Toolkit tk = Toolkit.getDefaultToolkit();
figura = tk.createImage("figura.png");
...
}
public void paint(Graphics g)
{
if(backbuffer == null)
backbuffer = createImage(ANCHO, ALTO);
// Dibujamos los gráficos en el backbuffer
Graphics off_g = backbuffer.getGraphics();
off_g.clearRect(0, 0, ANCHO, ALTO);
off_g.drawImage(figura, 0, yObj,
figura.getWidth(this), figura.getHeight(this), this);
// Quitamos estas lineas, ya no las necesitamos:
// off_g.setColor(Color.blue);
// off_g.fillRect(5, yObj, 100, 25);
// off_g.setColor(Color.green);
// off_g.fillOval(125, yObj, 100, 50);
// Volcamos el backbuffer a pantalla, segun el tamaño de la misma
g.drawImage(backbuffer, 0, 0, anchoPantalla, altoPantalla, this);
g.dispose();
}
Vemos que dibujamos la figura en la coordenada X = 0, y variaremos su
Y desde las flechas del teclado, como antes.
PARA ENTREGAR