EAMGJ

Introducción:

Toda la parte gráfica de Java se base en la clase Graphics, por lo que este trabajo se dedicará casi exclusivamente al uso de esta clase para manejar formas, fuentes de caracteres e imágenes sobre la pantalla. Y, aunque para el uso normal de gráficos no sea necesario, por lo que el lector puede obviar esa parte, se ha incluido un amplio repaso al sistema de repintado de Java, de forma que si el lector tiene curiosidad por saber exactamente como funciona el sistema de repintado y poder crear sus propios mecanismos, tenga suficiente información como para acometer esa tarea, no sin esfuerzo, pero al menos, sí con los conocimientos suficientes.

El API 2D de Java introducido en el JDK 1.2 proporciona gráficos avanzados en dos dimensiones, texto, y capacidades de manejo de imágenes para los programas Java a través de la extensión del AWT. Este paquete de rendering soporta líneas artísticas, texto e imágenes en un marco de trabajo flexible y lleno de potencia para desarrollar interfaces de usuario, programas de dibujo sofisticados y editores de imágenes.

Para ello, Java proporciona la clase Graphics, que permite mostrar texto a través del método drawString(), pero también tiene muchos otros métodos de dibujo. Para cualquier programador, es esencial el entendimiento de la clase Graphics, antes de adentrarse en el dibujo de cualquier cosa en Java. Esta clase proporciona el entorno de trabajo para cualquier operación gráfica que se realice dentro del AWT. Juega dos importantes papeles: por un lado, es el contexto gráfico, es decir, contiene la información que va a afectar a todas las operaciones gráficas, incluyendo los colores de fondo y texto, la fuente de caracteres, la localización y dimensiones del rectángulo en que se va a pintar, e incluso dispone de información sobre el eventual destino de las operaciones gráficas (pantalla o imagen). Por otro lado, la clase Graphics proporciona métodos que permiten el dibujo de primitivas, figuras y la manipulación de fonts de caracteres y colores. También hay clases para la manipulación de imágenes, doble-buffering,etc.

Para poder pintar, un programa necesita un contexto gráfico válido, representado por una instancia de la clase Graphics. Pero, como esta clase es abstracta, no se puede instanciar directamente; así que debemos crear un componente y pasarlo al programa como un argumento a los métodos paint() o update().

Los dos métodos anteriores, paint() y update(), junto con el método repaint() son los que están involucrados en la presentación de gráficos en pantalla. El AWT, para reducir el tiempo que necesitan estos métodos para realizar el repintado en pantalla de gráficos, tiene dos axiomas: Primero, el AWT repinta solamente aquellos Componentes que necesitan ser repintados, bien porque estuviesen cubiertos por otra ventana o porque se pida su repintado directamente .
Segundo, si un Componente estaba tapado y se destapa, el AWT repinta solamente la porción del Componente que estaba oculta

En la ejecución deun applet podemos observar como se realiza este proceso। Ignorar la zona de texto de la parte superior del applet de momento, y centrar la mirada en la parte coloreada। Utilizando otra ventana, tapar y destapar parte de la zona que ocupa el applet. Se observará que solamente el trozo de applet que estaba cubierto es el que se repinta. Yendo un poco más allá, solamente aquellos componentes que estén ocultos y se vuelvan a ver serán los que se repinten, sin tener en cuenta su posición dentro de la jerarquía de componentes.

La pantalla en Java se incrementa de izquierda a derecha y de arriba hacia abajo, tal como muestra la figura:Los pixels de la pantalla son pues: posición 0 + ancho de la पंताल्ला

El Sistema de Coordenadas
Cada uno de los Componentes de Java tiene su propio sistema de coordenadas, que va desde la posición (0,0) hasta la posición determinada por su anchura total y altura total, menos una unidad; la unidad de medida son pixels de pantalla। Como se puede apreciar en la figura siguiente, la esquina superior izquierda del Componente es la posición que coincide con las coordenadas (0,0). La coordenada en el eje de abscisas se incrementa hacia la derecha y en las ordenadas hacia abajo.

A la hora de pintar un Componente, se debe tener en cuenta además del tamaño de ese Componente, el tamaño del borde del Componente, si lo tuviera। Por ejemplo, un borde que ocupa un píxel alrededor de un Componente, haría que la coordenada de la esquina superior izquierda pasase de ser (0,0) a ser ahora (1,1), y reduciendo además la anchura y altura totales del Componente en dos pixeles, uno por cada lado.

Las dimensiones de un Componente se pueden conocer a través de sus métodos getWidth() y getHeight()। El método getInsets(), permite conocer el tamaño del borde। El siguiente trozo de código muestra la forma de conocer exactamente la anchura y altura de la zona disponible, en un Componente, para poder pintar en su interior.public void paintComponent( Graphics g ) { ... Insets borde = getInsets(); int anchura = getWidth() - borde.left - borde.right; int altura = getHeight() - borde.top - borde.bottom; ... /* La primera posición disponible para pintar sería (x,y), donde x es al menos borde.left, e y es al menos borde.height */ }

Pintando en AWT
En AWT hay dos mecanismos por los que se producen las operaciones de repintado, dependiendo de quién sea el que ordena ese repintado, el sistema o la aplicación.

En el caso de que sea el sistema el que ordena el repintado, él es quien indica a un Componente que debe regenerar su contenido, y las razones más normales por las que hace esto son:

El Componente se hace visible por primera vez en la pantalla
El Componente ha cambiado de tamaño
El Componente se ha deteriorado y necesita ser regenerado; por ejemplo, estaba medio tapado por otro Componente que ahora se ha movido, con lo cual hay una zona del Componente que estaba oculta y ahora debe mostrarse।

El AWT proporciona un API muy simple para pintar componentes। Cuando se utilice hay que seguir unas cuantas normas।

En la mayoría de los programas, todo el código de pintado de clientes debe ser colocado dentro del ámbito del método paint()

Los programas pueden lanzar una futura llamada a paint() invocando previamente a repaint(), pero no deberían nunca llamar directamente a paint()।

En componentes con salida gráfica compleja, repaint() debería ser invocado con argumentos para definir el rectángulo que necesita actualización, en lugar de invocar la versión sin argumentos, que hace que sea repintado el componente completo।

Como una llamada a repaint(), lo primero que hace es una llamada a update(), que es lanzada a paint() por defecto, los componentes normales (heavyweight) pueden sobrescribir el método update() para realizar repintado incremental si lo desean. Los componentes ligeros (lightweight) no soportan el repintado incremental।

Las extensiones de java।awt.Container, deberían sobrescribir el método paint() para asegurarse de que siempre se invoca a super.paint() para asegurarse de que los hijos se repintan

Los componentes con salida gráfica compleja deberían hacer uso del rectángulo de clipping, o de selección de área, para delimitar las zonas de dibujo a aquellas áreas que interseccionan con la zona que se va a repintar

El Método paint()
callback para ese repintado, que es igual tanto para los Componentes normales como para los Componentes lightweight। Esto significa que un programa debe colocar su código de repintado dentro de un método sobrecargado, y será Java quién se encargará de invocarlo en el momento del repintado। Este método se encuentra en java.awt.Component.

Independientemente de quién sea el originador de la petición de repintado, el AWT utiliza un mecanismo de callback para ese repintado, que es igual tanto para los Componentes normales como para los Componentes lightweight। Esto significa que un programa debe colocar su código de repintado dentro de un método sobrecargado, y será Java quién se encargará de invocarlo en el momento del repintado. Este método se encuentra en java.awt.Component.

El ejemplo java1502।java, es un poco más entretenido que el código anterior, pero en esencia es igual, y proporciona al lector un buen ejemplo de cómo se utiliza el método paint() en un programa AWT। La imagen que genera el ejemplo es la que reproduce la figura।public void paint( Graphics g ) { // Se calcula el tamaño de la zona Dimension tam = getSize(); // Ahora el diámetro int d = Math।min( tam।width,tam।height ); int x = (tam.width - d) / 2; int y = (tam.height - d) / 2; // Se pinta el círculo, fijando el color al de frente g.fillOval( x,y,d,d ); // Se pinta la circunferencia de borde, en color negro g.setColor( Color.black ); g.drawOval( x,y,d,d ); }

Aclarando que hay 1 sin fin d ejemplos en la red hacerca d graficos d जावा

Conclusión:
Durante este trabajo se vio la parte grafica de java, en el cual nos dio los conocimientos necesarios para desarrollar plataformas diferente en cuanto a diseño se refiere, dando nos la pauta a empezar a crear el escenario para nuestra simulación de nuestro proyecto, en el cual simulábamos la velocidad de un carro a través de la PC. Así mismo hemos introducido a la noción de contexto gráfico, cuando se creo el primer applet, en el cual muestra un mensaje. Se estudiaron algunas funciones gráficas definidas en la clase Graphics, y tres clases que sirven de apoyo para dibujar en el contexto gráfico: la clase Color que describe los colores, la clase Font que nos permite crear fuentes de texto y la clase FontMetrics que nos proporciona sus características.