[código] Mapeo de imágenes en java

En este pequeño ejemplo veremos algunas cosas interesantes como, cargar imagenes en un JPanel, asignarles manualmente un mapa para identificar regiones de la imagen mediante las coordenadas, manejos de eventos del mouse, clases internas anónimas, entre otras.

El objetivo de nuestro mini-programa es hacer que al pasar el mouse por encima de la imagen, nos diga que imagen es (en este caso que sistema operativo):

Miremos el código y una explicación breve del mismo:

// Demostración de un mapa de imágenes.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MapaImagenes extends JFrame {
    private JLabel estado;
    // establecer componentes de escucha del ratón
    public MapaImagenes() {
        estado = new JLabel();
        MiPanel mipanel = new MiPanel();
        getContentPane().add(mipanel);
        getContentPane().add(estado, BorderLayout.SOUTH);
        setSize(630,140);
        setVisible(true);
    }  // fin del método init
    private class MiPanel extends JPanel {
        private ImageIcon imagenMapa;
        private final String leyendas[] = { "Debian Gnu/Linux",
        "Fedora", "Kubuntu", "Linspire", "MacOS X", "Mandriva", "Ubuntu" };
        public MiPanel() {
            this.addMouseListener(
                    new MouseAdapter() { // clase interna anónima
                // indicar cuando el puntero del ratón salga del área del subprograma
                public void mouseExited( MouseEvent evento ) {
                    actualizarEstado( "Puntero fuera de la ventana" );
                }
            } // fin de la clase interna anónima
            ); // fin de la llamada a addMouseListener
            this.addMouseMotionListener(
                new MouseMotionAdapter() { // clase interna anónima
                // determinar el icono sobre el cual aparecerá el ratón
                public void mouseMoved( MouseEvent evento ) {
                    actualizarEstado( traducirPosicion(
                            evento.getX(), evento.getY() ) );
                }
            } // fin de la clase interna anónima
            ); // fin de la llamada a addMouseMotionListener
            imagenMapa = new ImageIcon( "cajas.png" );  // obtener la imagen
        }
        // mostrar imagenMapa
        public void paint( Graphics g ) {
            super.paint( g );
            imagenMapa.paintIcon( this, g, 0, 0 );
        }
        // devolver leyenda del tip correspondiente, con base en las coordenadas del ratón
        public String traducirPosicion( int x, int y ) {
            // si las coordenadas están fuera de la imagen, regresar inmediatamente
            if ( x >= imagenMapa.getIconWidth() || y >= imagenMapa.getIconHeight() )
                return "";
            // determinar número de icono (0 - 6)
            int anchuraIcono = imagenMapa.getIconWidth() / 7;
            int numeroIcono = x / anchuraIcono;
            return leyendas[ numeroIcono ]; // devolver la leyenda del icono apropiado
        }
    }
    //Poner estado
    private void actualizarEstado(String texto) {
        estado.setText(texto);
    }
    public static void main(String args[]) {
        JFrame.setDefaultLookAndFeelDecorated(true);
        MapaImagenes ventana = new MapaImagenes();
        ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
} // fin de la clase MapaImagenes

Lo primero interesante, y es algo que me han preguntado muchísimo, es el hecho de declarar una clase dentro de otra clase (línea 17), lo que se conoce como una clase interna. Al hacer esto, podemos proceder sobre esa clase de una manera normal, como si de una clase normal se tratase. Pero también existen las clases internas anónimas, como la que declaramos en las líneas 22 y 30, muy útiles cuando necesitas ahorrarte el trabajo de crear una clase aparte para manejar los eventos. En el caso de las clases internas anónimas (comúnmente utilizadas con interfaces), las creamos como si estuviéramos inicializando un objeto, pero declarando dentro de corchetes ( { } ) los métodos que necesitemos usar.

Pero miremos esto un poco más a fondo… en la línea 29 añadimos un listener que se activa al mover el mouse sobre el panel. Para añadirlo usamos el método addMouseMotionListener, al cual debemos pasarle como argumento un objeto de la clase MouseMotionAdapter, y justo ahí (línea 30) declaramos la clase interna anónima (como parte de los parámetros del métodoaddMouseMotionListener). Luego, es necesario declarar los métodos de dicha clase/objeto (línea 32), que en este caso es el método mouseMoved que se ejecutará cada vez que el usuario mueva el mouse.

Finalmente, como resultado de los eventos que genere el método mouseMoved, el método traducirPosicion (línea 46) es utilizado para determinar qué mensaje mostrar al usuario, de acuerdo a la posición del puntero del mouse.

Implementar función de cerrar ventana sin declarar listeners

(Algo que también me han preguntado mucho) En antiguas versiones de Java, especialmente cuando solo usábamos AWT para las interfaces gráficas, era necesario declarar un método listener que “escuchara” eventos sobre la venta, y determinara que hacer cuando el usuario le diera clic a la X de cerrar. Si no colocamos esto, al darle clic a dicho botón nuestra aplicación no hace nada Pero es posible evitar la declaración de dichos métodos, realizando esta sencilla operación (en el ejemplo anterior, línea 63):

ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

donde ventana es un objeto tipo JFrame.

Descargar código fuente

7 Comentarios | deja el tuyo