Graficos en Java

package Graficos;import java.awt.*;import java.awt.event.*;

// Clase de control del ejemploclass Grafico01 extends Frame {

// Contructor de la clase public java1517() { this.setTitle( "Graficos, En Java" ); this.setSize( 400,300 ); this.setVisible( true );

// Clase anidada que permite terminar la ejecución de la animación this.addWindowListener( // Definición de la clase anónima para controlar el cierre de // la ventana new WindowAdapter() { public void windowClosing( WindowEvent evt ) { // Se concluye el programa System.exit( 0 ); } } ); } // Método de control del programa public static void main( String[] args ) { // Se instancia un objeto de esta clase new java1517(); }

// Se sobrecarga el método paint() public void paint( Graphics g ) { // Trasladamos el origen de coordenadas que se sitúa en la // esquina superior izquierda, para evitar el problema que se // produce con insets. g.translate( this.getInsets().left,this.getInsets().top );

// Obtenemos la lista completa de fuentes del sistema String[] fuentes = GraphicsEnvironment.getLocalGraphicsEnvironment(). getAvailableFontFamilyNames();

// Fijamos una fuente cualquiera, la quinta de la lista por ejemplo, // le cambiamos el estilo a Negrita y su tamaño a 14 puntos g.setFont( new Font( fuentes[4],Font.PLAIN,14 ) );

// Obtenemos la altura de la fuente seleccionada int alto = g.getFontMetrics().getHeight(); // Fijamos la coordena Y utilizando la altura de la fuente como valor int y = alto;

// Presentamos un rótulo general para la presentación String rotulo = "Algunas de las fuentes disponibles son:"; g.drawString( rotulo,5,y ); // Cambiamos a color rojo g.setColor( Color.red );

// Presentamos una pequeña lista de todas las fuentes del sistema // indicando el nombre que tiene almacenado el sistema para ellas, // le cambiamos el estino a Negrita y Oblicua for( int i=78; i < 84; i++ ) { g.setFont( new Font( fuentes[i],Font.BOLD | Font.ITALIC,18) ); alto = g.getFontMetrics().getHeight(); g.drawString( fuentes[i], 160-(g.getFontMetrics().stringWidth(fuentes[i]))/2,y+=alto ); }

// Cambiamos a color azul g.setColor( Color.blue ); // Volvemos a coger la fuente del rótulo y le cambiamos el estilo a // fuente Normal de 15 puntos g.setFont( new Font( fuentes[4],Font.PLAIN,15 ) ); alto = g.getFontMetrics().getHeight(); // Presentamos otro rótulo y += alto; g.drawString( "Información sobre la fuente de este texto: ",5,y ); // Presentamos información sobre la fuente actual y += alto; g.drawString( "" + g.getFont(),5,y );

// Presentamos otro rótulo y += 2*alto; g.drawString( "Anaximandro Fernandez Guerrero: ",5,y );

// Creamos un array de letras para presentarlo char aTexto[] = {'g','r','a','f','i','c','o','s',' ','e','n',' ','J','a','v','a'}; y += alto; // Presentamos en pantalla el array de letras, saltándonos el // primero y no presentado el último g.drawChars( aTexto,0,16,5,y ); } }

package Graficos;

//Dibujar líneas, rectángulos u óvalos con base en la entrada del usuario.import java.awt.Graphics;import javax.swing.*;

public class Grafico02 extends JApplet{

int opcion; // la opcion del usuario en cuanto a cuál figura dibujar

// inicializar el subprograma, obteniendo la opción del usuariopublic void init(){

String entrada; // la entrada del usuario// obtener la opción del usuarioentrada = JOptionPane.showInputDialog("Escriba 1 para dibujar líneas\n" +

"Escriba 2 para dibujar rectángulos\n" +"Escriba 3 para dibujar óvalos\n" );

opcion = Integer.parseInt( entrada ); // convertir entrada en int} // fin del método init// dibujar figuras en el fondo del subprogramapublic void paint( Graphics g ){

super.paint( g ); // llamar al método paint heredado de JAppletfor ( int i = 0; i < 30; i++ ) // iterar 10 veces (0-9){

switch ( opcion ) // determinar la figura a dibujar{

case 1: // dibujar una líneag.drawLine( 10, 10, 250, 10 + i * 10 );break; // fin de procesamiento de case

case 2: // dibujar un rectángulog.drawRect( 10 + i * 10, 10 + i * 10,50 + i * 10, 50 + i

* 10 );break; // fin de procesamiento de case

case 3: // dibujar un óvalog.drawOval( 10 + i * 10, 10 + i * 10,50 + i * 10, 50 + i

* 10 );break; // fin de procesamiento de case

default: // dibujar cadena indicando que se escribió un valor incorrecto

g.drawString( "Se escribió un valor incorrecto",10, 20 + i * 15 );

} // fin de instrucción switch} // fin de instrucción for

} // fin del método paint} // fin de la clase PruebaSwitch


// Clase de control del ejemploclass Grafico03 extends Frame {

// Función de control de la aplicación public static void main( String[] args ) { // Se instancia un objeto de la clase new java1516(); }

// Contructor de la clase public Grafico03 () { this.setTitle( "Graficos, En Java" ); this.setSize( 475,275 ); this.setVisible( true );

// Clase anidada que permite terminar la ejecución de la animación this.addWindowListener( // Definición de la clase anónima para controlar el cierre de // la ventana new WindowAdapter() { public void windowClosing( WindowEvent evt ) { // Se concluye el programa System.exit( 0 ); } } ); }

// Se sobrecarga el método paint() public void paint( Graphics g ){ g.setColor( Color.red ); // Trasladamos el origen de coordenadas que se sitúa en la // esquina superior izquierda, para evitar el problema que se // produce con insets. De este modo el origen de coordenadas sí // que lo dejamos situado en la zona cliente del objeto Frame // que es la que se utiliza para pintas g.translate( this.getInsets().left,this.getInsets().top ); // Línea simple g.drawLine( 10,0,50,50 ); g.setColor( Color.black ); g.drawString( "drawLine",10,62 ); g.setColor( Color.red );

// Se crean dos arrays de coordenadas para pintar una // polilínea int x1Datos[] = {80,130,80,130}; int y1Datos[] = {0,50,50,0}; g.drawPolyline( x1Datos,y1Datos,4 ); g.setColor( Color.black ); g.drawString( "drawPolyline",70,62 ); g.setColor( Color.red );

// Rectángulo g.drawRect( 150,0,50,50 ); g.setColor( Color.black ); g.drawString( "drawRect",150,62 ); g.setColor( Color.red ); // Rectángulo relleno g.fillRect( 220,0,50,50 ); g.setColor( Color.black ); g.drawString( "fillRect",225,62 ); g.setColor( Color.red ); // Rectángulo redondeado g.drawRoundRect( 300,0,50,50,10,10 ); g.setColor( Color.black ); g.drawString( "drawRoundRect",280,62 ); g.setColor( Color.red ); // Rectángulo redondeado relleno g.fillRoundRect( 385,0,50,50,10,10 ); g.setColor( Color.black ); g.drawString( "fillRoundRect",375,62 ); // Pinta un rectángulo 3D, sobresaliendo de la pantalla // No parece demasiado 3D g.setColor( Color.gray );//draw the 3D stuff in gray g.draw3DRect( 10,90,55,25,true ); // Rectángulo 3D, pulsado g.draw3DRect( 70,90,50,25,false ); g.setColor( Color.black ); g.drawString( "draw3DRect",30,140 ); // Rectángulo 3D relleno. Se ha puesto un fondo gris // con lo cual se puede apreciar mucho mejor el efecto // de tres dimensiones // Fondo gris g.setColor( Color.gray ); g.fillRect( 145,75,130,55 ); g.fill3DRect( 155,90,50,25,true ); // Rectángulo 3D relleno, pulsado g.fill3DRect( 215,90,50,25,false ); g.setColor( Color.red ); // De todos modos, la apariencia de tres dimensiones // con 3DRect no es demasiado buena, porque es necesario // seleccionar muy bien la paleta de colores para que // se genere la ilusión de 3D g.setColor( Color.black ); g.drawString( "fill3DRect",180,140 ); g.setColor( Color.red );

// Pinta un ángulo de 255 grados inscrito en un rectángulo g.drawRect( 300,77,50,50 );

g.drawArc( 300,77,50,50,0,225 ); g.setColor( Color.black ); g.drawString( "drawArc",305,140 ); g.setColor( Color.red ); // Angulo relleno de 255 grados inscrito en un rectángulo g.drawRect( 385,77,50,50 ); g.fillArc( 385,77,50,50,0,225 ); g.setColor( Color.black ); g.drawString( "fillArc",395,140 ); g.setColor( Color.red ); // Elipse, con el eje grande horizontal g.drawOval( 10,165,50,25 ); // Círculo g.drawOval( 70,150,50,50 ); g.setColor( Color.black ); g.drawString( "drawOval",35,218 ); g.setColor( Color.red );

// Elipse rellena, con el eje grande vertical g.fillOval( 170,150,25,50 ); // Círculo relleno g.fillOval( 210,150,50,50 ); g.setColor( Color.black ); g.drawString( "fillOval",185,218 ); g.setColor( Color.red ); // Polígono int x2Datos[] = {300,350,300,350}; int y2Datos[] = {150,200,200,150}; g.drawPolygon( x2Datos,y2Datos,4 ); g.setColor( Color.black ); g.drawString( "drawPolygon",290,218 ); g.setColor( Color.red ); // Polígono relleno int x3Datos[] = {385,435,385,435}; int y3Datos[] = {150,200,200,150}; g.fillPolygon( x3Datos,y3Datos,4 ); g.setColor( Color.black ); g.drawString( "fillPolygon",385,218 ); }}

Muestra un grafico estatico

package Graficos;

import java.awt.*;import java.awt.event.*;

// Clase de control del ejemploclass Grafico04 extends Frame { // Referencia a la imagen Image imagen; // Constructor de la clase public java1518() { this.setTitle( "Graficos, En Java" ); this.setSize( 275,250 ); // Recogemos en la variable "imagen" el fichero de imagen que // se indica, y que se supone situado en el mismo directorio y // disco que la clase del ejemplo imagen = Toolkit.getDefaultToolkit().getImage( "monitor.gif" ); // Se hace visible el Frame, que en la pantalla da origen a // la ventana, aunque la primera imagen no es visible en el // mismo momento en que aparece la ventana en pantalla, porque // hasta que se invoque por primera vez el método paint(), no // se colocará una imagen en el contendor this.setVisible( true );

// Clase anónima anidada que permite terminar la ejecución del // programa, controlando el botón de cierre del Frame this.addWindowListener( new WindowAdapter() { public void windowClosing( WindowEvent evt ) { // Se sale al sistema System.exit( 0 ); } } ); } public static void main( String[] args ) { // Se instancia un objeto de la clase new Grafico04 (); }

// Se sobrecarga el método para pintar la imagen public void paint( Graphics g ) { // Se traslada el origen para evitar el efecto del borde g.translate( this.getInsets().left,this.getInsets().top ); // Ahora se pinta la imagen a la mitad de su tamaño g.drawImage( imagen,0,0, imagen.getWidth(this)/2,imagen.getHeight(this)/2,this ); } }

Muestra un grafico en movimiento


// Clase de control del ejemploclass Grafico05 extends Frame { // Referencia a la imagen Image imagen; public java1519() { this.setTitle( "Graficos, En Java" ); this.setSize( 275,250 ); // Recogemos en la variable "imagen" el fichero de imagen que // se indica, y que se supone situado en el mismo directorio y // disco que la clase del ejemplo imagen = Toolkit.getDefaultToolkit().getImage( "monitor.gif" ); // Se hace visible el Frame, que en la pantalla da origen a // la ventana, aunque la primera imagen no es visible en el // mismo momento en que aparece la ventana en pantalla, porque // hasta que se invoque por primera vez el método paint(), no // se colocará una imagen en el contendor this.setVisible( true );

// Clase anónima anidada que permite terminar la ejecución del // programa, controlando el botón de cierre del Frame this.addWindowListener( new WindowAdapter() { public void windowClosing( WindowEvent evt ) { // Se sale al sistema System.exit( 0 ); } } ); } public static void main( String[] args ) { // Se instancia un objeto de la clase new Grafico05(); } // Se sobrecarga el método para pintar la imagen public void paint( Graphics g ) { // Se traslada el origen para evitar el efecto del borde g.translate( this.getInsets().left,this.getInsets().top ); // Se utiliza un objeto MediaTracker para bloquear la tarea hasta // que la imagen esté cargada completamente, antes de intentar // pintarla en pantalla. Si la carga de la imagen falla en el

// intervalo de un segundo, el programa se termina. Sin el uso de // un objeto de tipo MediaTracker, si la imagen es pequeña, apenas // se notará el uso de MediaTracker, pero sí que es importante a la // hora de cargar imágenes muy grandes o gran cantidad de ellas MediaTracker tracker = new MediaTracker( this ); // Se añade la imagen a la lista del tracker tracker.addImage( imagen,1 ); try { // Se bloquea la tarea durante un segundo, mientras se // intenta la carga de la imagen. En caso de que la imagen // sea mayor que la que se utiliza en este ejemplo, puede // ser necesario aumentar este tiempo if( !tracker.waitForID(1,1000) ) { System.out.println( "Fallo en la carga de la imagen" ); System.exit( 0 ); } } catch( InterruptedException e ) { System.out.println( e ); } // Ahora se pinta la imagen a la mitad de su tamaño normal g.drawImage( imagen,0,0, imagen.getWidth(this)/2,imagen.getHeight(this)/2,this ); // Y se presenta en pantalla this.repaint(); } }


class Grafico06 extends Frame { // Referencias a los objetos de tipo Image que se van a presentar en // pantalla Image imagenFuente,imagen1,imagen2,imagen3,imagen4,imagen5; // Contructor de la clase public Grafico06() { this.setTitle( "Graficos, En Java" ); this.setSize( 415,260 ); // Se carga la imagen desde el fichero que se indique, que se // supone situado en el directorio actual del disco duro imagenFuente = Toolkit.getDefaultToolkit().getImage( "monitor.gif" ); // Se crean cinco instancias escaladas de la imagen anterior, todas // del mismo tamaño pero utilizando un algoritmo diferente en el // escalado de cada una de ellas, para

imagen1 = imagenFuente.getScaledInstance( 136,120, Image.SCALE_AREA_AVERAGING ); imagen2 = imagenFuente.getScaledInstance( 136,120, Image.SCALE_SMOOTH ); imagen3 = imagenFuente.getScaledInstance( 136,120, Image.SCALE_FAST ); imagen4 = imagenFuente.getScaledInstance( 136,120, Image.SCALE_REPLICATE ); imagen5 = imagenFuente.getScaledInstance( 136,120, Image.SCALE_DEFAULT ); // Se hace visible el marco de la ventana. En este momento todavía no // es visible ninguna de las imágenes que se han creado anteriormente this.setVisible(true);

// Clase anidada que permite terminar la ejecución de la animación this.addWindowListener( // Definición de la clase anónima para controlar el cierre de // la ventana new WindowAdapter() { public void windowClosing( WindowEvent evt ) { // Se concluye el programa System.exit( 0 ); } } ); } // Método de control del programa public static void main( String[] args ) { // Se instancia un objeto de esta clase new Grafico06(); } // Método paint() sobreescrito public void paint( Graphics g ) { // Se traslada el origen para evitar el efecto del borde g.translate( this.getInsets().left,this.getInsets().top ); // Se utiliza un objeto MediaTracker para bloquear la tarea hasta // que las imágenes estén cargadas completamente, antes de intentar // pintarlas en pantalla. MediaTracker tracker = new MediaTracker( this ); // Se añaden las imágenes a la lista del tracker tracker.addImage( imagenFuente,1 ); tracker.addImage( imagen1,1 ); tracker.addImage( imagen2,1 ); tracker.addImage( imagen3,1 ); tracker.addImage( imagen4,1 ); tracker.addImage( imagen5,1 ); try{ // Se bloquea la tarea durante el tiempo necesario para la carga // de todas las imágenes tracker.waitForAll(); } catch( InterruptedException e ) { System.out.println( e ); } // Comprobamos si ha habido algún error en la carga de las imágenes // y su manipulación. Si todo ha ido bien, las cinco imágenes // aparecerán en pantalla simultáneamente

if( !tracker.isErrorAny() ) { g.drawImage( imagen1,0,0,this ); g.drawImage( imagen2,137,0,this ); g.drawImage( imagen3,275,0,this ); g.drawImage( imagen4,70,120,this ); g.drawImage( imagen5,210,120,this ); } else { System.out.println( "Error en la carga de imágenes" ); System.exit( 1 ); } } }

package Graficos;


class Grafico07 extends Frame { Image imagenFuente; // Imagen cargada de disco int iniAncho; int iniAlto; // Ancho y Alto para cada imagen de la animación int finAncho; int finAlto; // Valores del borde para el objeto contenedor int insetArriba; int insetIzqda; // Referencias a objetos utilizados en el doble buffer Image imgDobleBuffer; Graphics contextoDobleBuffer; // Indicador del uso o no del doble buffer boolean usarDobleBuffer = true;

// Método de control del programa public static void main( String[] args ) { // Se instancia un objeto de esta clase Grafico07 obj = new java1521(); // Se declaran las variables locales que indican el desplazamiento // y la escala de las imágenes double delta = 0; double escala = 0;

// Se utiliza el doble buffer o no, dependiendo de los valores que se // hayan introducido en la línea de comandos. Por defecto, se utiliza // el doble buffer, y cualquier otro argumento en la línea de // comandos deshabilitará su uso if( args.length == 0 ) { obj.usarDobleBuffer = true;

System.out.println( "Doble Buffer Activado" ); } else { obj.usarDobleBuffer = false; System.out.println( "Doble Buffer Desactivado" ); } // Bucle de control de la animación, que seguirá funcionando, hasta // que se cierre la ventana con el botón de cierre del marco de esa // ventana while( true ) { // Control de la dirección en que se realiza la animación, de // forma que vaya creciendo hasta su tamaño normal y luego vuelva // a decrecer if( escala >= 0.999 ) delta = -0.005; if( escala <= 0.015 ) delta = 0.005; // Se establece el ancho y alto para la nueva imagen que se va a // presentar en la animación obj.finAncho = (int)( escala*obj.iniAncho ); obj.finAlto = (int)( escala*obj.iniAlto ); // Se presenta la imagen obj.repaint(); // Se actualiza la escala para la siguiente imagen escala += delta;

// Se retrasa la presentación, de forma que la animación se // encuentre en un rango aproximado de 20 imágenes por segundo try { Thread.currentThread().sleep( 50 ); } catch( InterruptedException e ) { System.out.println( e ); } } }

// Contructor de la clase public Grafico07() { // Se carga la imagen desde el fichero que se indique, que se // supone situado en el directorio actual del disco duro imagenFuente = Toolkit.getDefaultToolkit().getImage( "monitor.gif" ); // Se utilza un objeto MediaTracker para bloquear la tarea hasta // que la imagen se haya cargado o hayan transcurrido 10 segundos // desde que se inicia la carga MediaTracker tracker = new MediaTracker( this ); tracker.addImage( imagenFuente,1 ); try { if( !tracker.waitForID( 1,10000 ) ) { System.out.println( "Error en la carga de la imagen" ); System.exit( 1 ); } } catch( InterruptedException e ) { System.out.println( e ); } // La imagen ya está cargada, así que se establece la anchura y

// altura de la ventana, para que sus dimensiones se adecúen a la // imagen iniAncho = imagenFuente.getWidth( this ); iniAlto = imagenFuente.getHeight( this ); // Se hace visible el Frame this.setVisible( true ); // Se obtienen los datos de insets del objeto, para que sean // compensados en la presentación de las imágenes insetArriba = this.getInsets().top; insetIzqda = this.getInsets().left;

// Se usan las dimensiones de insets y el tamaño de la imagen // fuente para establecer el tamaño total del Frame this.setSize( insetIzqda+iniAncho,insetArriba+iniAlto ); this.setTitle( "Graficos, En Java" ); this.setBackground( Color.yellow ); // Creamos una imagen para el uso del doble buffer, que será la que // se utilice en el intercambio para la renderización de la imagen // en el buffer oculto. También se obtiene el contexto gráfico con // el que se va a pintar imgDobleBuffer = this.createImage( iniAncho,iniAlto ); contextoDobleBuffer = imgDobleBuffer.getGraphics(); // Clase anidada que permite terminar la ejecución de la animación this.addWindowListener( // Definición de la clase anónima para controlar el cierre de // la ventana new WindowAdapter() { public void windowClosing( WindowEvent evt ) { // Se concluye el programa System.exit( 0 ); } } ); } // Se sobreescribe el método update() para eliminar el borrado // innecesario de la pantalla y el parpadeo que originaría este // borrado. Esto requiere que el método paint() sea el que controle // el borrado de la pantalla public void update( Graphics g ) { paint( g ); }

// Método paint() sobreescrito public void paint( Graphics g ) { // Si se está utilizando el doble buffer if( usarDobleBuffer ) { // Se vuelca en pantalla la imagen que previamente se había // construido en el buffer oculto g.drawImage( imgDobleBuffer,insetIzqda,insetArriba,this ); // Se escala y pinta la siguiente imagen en el buffer oculto // utilizando las variables de instancia "finAncho" y "finAlto" // para determinar el tamaño de esa imagen. De esta forma // cuando se vuelva a invocar a paint() la imagen estará lista // para su presentación en pantalla. contextoDobleBuffer.clearRect( 0,0,iniAncho,iniAlto ); contextoDobleBuffer.drawImage( imagenFuente,0,0,finAncho,finAlto,this );

} else { g.clearRect( insetIzqda,insetArriba,iniAncho,iniAlto ); g.drawImage( imagenFuente, insetIzqda,insetArriba,finAncho,finAlto,this); } } }

import java.awt.*;import java.awt.event.*;import javax.swing.*;// Implementa un adaptador anónimopublic class GUIada { public static void main(String [] args) { JFrame v = new JFrame("Graficos en Java"); v.addWindowListener( new WindowAdapter () { public void windowClosing(WindowEvent e) { System.exit(0); } } ); v.getContentPane().add(new VentanaBalon()); v.setSize(300,300); v.setVisible(true); }}import java.awt.*;import java.awt.event.*;import javax.swing.*;public class VentanaBalon extends JPanel implements ActionListener { Balon balon; JButton creceB; JButton decreceB; public VentanaBalon() { creceB = new JButton("Crece"); decreceB = new JButton("Decrece"); balon = new Balon(20,150,150); setLayout(new FlowLayout()); add(creceB); add(decreceB); creceB.addActionListener(this); decreceB.addActionListener(this); } public void paintComponent(Graphics g) { super.paintComponent(g); balon.display(g); } public void actionPerformed(ActionEvent e) { if (e.getSource() == creceB)

balon.cambia(10); else balon.cambia(-10); repaint(); }}import java.awt.*;public class Balon { protected int radio; protected int x,y; public Balon(int n, int vx, int vy) { radio = n; x = vx; y = vy; } public void cambia(int n) { radio += n; } public void display(Graphics g) { g.drawOval(x-radio,y-radio,radio*2,radio*2); }}

Gráficos que muestra por pantalla mensajes en movimiento

package Graficos;

import java.awt.*;import java.applet.Applet;

public class Persiana extends Applet implements Runnable { Image imagenFondo; Image offI; Graphics offG; int posicion; String texto[]; Font font; Font font1; Font font2; Font font3; boolean puedePintar; Thread thrd; MediaTracker mdt;

public void init() { mdt = new MediaTracker( this );

// Instanciación de los objetos fuente que vamos a utilizar durante // la presentación del texto en su desplazamiento por la persiana font = new Font( "Arial",0,15 ); font1 = new Font( "Helv",1,23 ); font2 = new Font( "TimesNewRoman",1,30 ); font3 = new Font( "Arial",1,16 );

// Cadenas de texto correspondientes al primer grupo de información // que se va a presentar en la ventana

texto[0] = "Este Tutorial de Java proporciona suficientes conocimientos"; texto[1] = "para que, tanto los programadores noveles como aquellos que ya"; texto[2] = "conocen las bondades del lenguaje Java, puedan acercarse en un"; texto[3] = "caso y profundizar en el otro, en los más diversos aspectos del"; texto[4] = "lenguaje. Se recorren casi todas las características de Java,"; texto[5] = "desde las más sencillas como puede ser la descripción de los"; texto[6] = "tipos soportados por el lenguaje, hasta las más complicadas"; texto[7] = "como la implementación de un entorno cliente-servidor o el"; texto[8] = "desarrollo de un modelo de arquitectura Modelo-Vista completo.";

// Información que se presentará a continuación del título // del segundo bloque de información de la persiana texto[9] = "Se hace un profundo recorrido por el Abstract Window Toolkit,"; texto[10] = "presentado todos los elementos que lo componen en su actual"; texto[11] = "versión, con múltiples líneas de código fuente para que el"; texto[12] = "navegante pueda ir comprobando cómo se usan y cómo Java"; texto[13] = "utiliza los recursos que pone en manos del programador."; texto[14] = "También hay múltiples applets Java en funcionamiento a lo"; texto[15] = "largo del Tutorial, de forma que se puede ir comprobando"; texto[16] = "la apariencia que presentan los applets sobre el browser que"; texto[17] = "estemos utilizando.";

// Bloque final de información texto[18] = "Como compendio a todo lo desarrollado en este Tutorial de"; texto[19] = "Java, se presentan varias aplicaciones autónomas y algunos"; texto[20] = "applets listos para utilizar, con toda la información"; texto[21] = "necesaria para su implementación y uso.";

// Recuperamos la imagen que se va a utilizar como fondo de la // cadena que represente el título principal de la persiana imagenFondo = getImage( getCodeBase(),"fondo.gif" ); try { offI = createImage( 700,55 ); offG = offI.getGraphics(); } catch( Exception e ) { offG = null; } return; }

public void update( Graphics g ) { if( puedePintar ) paint( g ); }

public void paint( Graphics g ) { if( offG != null ) { paintApplet( offG ); g.drawImage( offI,0,0,this ); return; } paintApplet( g ); }

public void paintApplet( Graphics g ) { // Presentamos la imagen de fondo y el título principal que // queremos asignar a la infromación que va a ir presentando // la persiana. // Para hacer un poco más atractiva la visualización del título // hacemos que aparezca una especie de sombra de la cadena de // texto. Para ello, simplemente la volvemos a escribir pero // desplazada g.setColor( Color.black ); g.fillRect( 0,0,600,700 ); g.setFont( font2 ); g.drawImage( imagenFondo,0,-posicion,this ); g.setColor( Color.white ); g.drawString( "Tutorial de Java",200,50-posicion ); g.setColor( Color.blue ); g.drawString( "Turorial de Java",198,48-posicion ); g.setColor( Color.orange ); g.setFont( font1 ); g.fillRect( 130,60-posicion,190,24 ); g.setColor( Color.black ); g.drawString( "Presentación",150,80-posicion ); g.setColor( Color.white ); g.setFont( font ); for( int i=0; i < 9; i++ ) g.drawString( texto[i],5,105+i*19-posicion );

// Creamos otro rectángulo de color para colocar el título que // encabeza al grupo de cadenas que van a seguir desplazándose // por la persiana g.setColor( Color.white ); g.fillRect( 120,265-posicion,180,26 ); g.setColor( Color.red ); g.setFont( font1 ); g.drawString( "AWT",180,287-posicion ); g.setColor( Color.white ); g.setFont( font ); for( int j=9; j < 18; j++ ) g.drawString( texto[j],5,140+j*19-posicion );

// Presentamos el siguiente grupo de información, creando una // cabecera para indicar de qué se trata la información que va a // aparecer en la persiana g.setColor( Color.red ); g.fillRect( 120,471-posicion,200,30 ); g.setColor( Color.white ); g.setFont( font1 ); g.drawString( "Ejemplos",165,493-posicion ); g.setColor( Color.white ); g.setFont( font ); for( int j=18; j < 22; j++ ) g.drawString( texto[j],5,177+j*19-posicion );

// Esta es la misma información que la del principio g.setFont( font2 ); g.drawImage( imagenFondo,0,600-posicion,this ); g.setColor( Color.white ); g.drawString( "Tutorial de Java",200,650-posicion ); g.setColor( Color.blue ); g.drawString( "Tutorial de Java",198,648-posicion ); }

public void start() { // Creamos un nuevo thread y lo arrancamos thrd = new Thread( this ); thrd.start(); }

public void stop() { thrd.stop(); }

public void run() { for( puedePintar=false; true; puedePintar=false ) { try { puedePintar = true; repaint(); // Si estamos al principio, alargamos un poco la espera if( posicion == 0 ) { Thread.currentThread(); Thread.sleep( 5000 ); } posicion++; // Cuando lleguemos al final del texto, volvemos al // principio, para repetir todos los mensajes if( posicion == 600 ) posicion = 0; Thread.currentThread(); // Aqui podemos hacer más rápido o más lento el // desplazamiento del texto por la persiana Thread.sleep( 100 ); } catch( InterruptedException e ) { ; } } }

// El constructor del applet se limita a crear el array de texto que // contendrá todas las cadenas o líneas de texto que se irán pasando // por la ventana public Persiana() { texto = new String[22]; } }

//------------------------------------------ Final del fichero Persiana.java

Documents

Graficos en Java