java - llamar - ¿Cómo funciona PaintComponent?

paintcomponent java ejemplo

Question

Esta podría ser una pregunta muy novato. Estoy empezando a aprender Java

No entiendo el funcionamiento del método paintComponent. Sé que si quiero dibujar algo, debo anular el método paintComponent.

public void paintComponent(Graphics g)
{
...
}

Pero cuando se llama? Nunca veo algo como "object.paintComponent (g)" pero aún se dibuja cuando el programa se está ejecutando.

¿Y cuál es el parámetro Graphics? ¿De dónde es? El parámetro debe ser proporcionado cuando se llama al método. Pero como dije antes, parece que este método nunca se llama explícitamente. Entonces, ¿quién proporciona este parámetro? ¿Y por qué tenemos que lanzarlo a Graphics2D?

public void paintComponent(Graphics g)
{
...
Graphics2D g2= (Graphics2D) g;
...
}

Answer 1

Dos cosas que puedes hacer aquí:

1. Leer pintura en AWT y Swing
2. Use un depurador y ponga un punto de interrupción en el método paintComponent. Luego, recorra la stacktrace y vea cómo proporciona el parámetro Graphics.

Solo por información, esta es la pila de fichas que obtuve del ejemplo del código que publiqué al final:

Thread [AWT-EventQueue-0] (Suspended (breakpoint at line 15 in TestPaint))
TestPaint.paintComponent(Graphics) line: 15
TestPaint(JComponent).paint(Graphics) line: 1054
JPanel(JComponent).paintChildren(Graphics) line: 887
JPanel(JComponent).paint(Graphics) line: 1063
JLayeredPane(JComponent).paintChildren(Graphics) line: 887
JLayeredPane(JComponent).paint(Graphics) line: 1063
JLayeredPane.paint(Graphics) line: 585
JRootPane(JComponent).paintChildren(Graphics) line: 887
JRootPane(JComponent).paintToOffscreen(Graphics, int, int, int, int, int, int) line: 5228
RepaintManager$PaintManager.paintDoubleBuffered(JComponent, Image, Graphics, int, int, int, int) line: 1482
RepaintManager$PaintManager.paint(JComponent, JComponent, Graphics, int, int, int, int) line: 1413
RepaintManager.paint(JComponent, JComponent, Graphics, int, int, int, int) line: 1206
JRootPane(JComponent).paint(Graphics) line: 1040
GraphicsCallback$PaintCallback.run(Component, Graphics) line: 39
GraphicsCallback$PaintCallback(SunGraphicsCallback).runOneComponent(Component, Rectangle, Graphics, Shape, int) line: 78
GraphicsCallback$PaintCallback(SunGraphicsCallback).runComponents(Component[], Graphics, int) line: 115
JFrame(Container).paint(Graphics) line: 1967
JFrame(Window).paint(Graphics) line: 3867
RepaintManager.paintDirtyRegions(Map<Component,Rectangle>) line: 781
RepaintManager.paintDirtyRegions() line: 728
RepaintManager.prePaintDirtyRegions() line: 677
RepaintManager.access$700(RepaintManager) line: 59
RepaintManager$ProcessingRunnable.run() line: 1621
InvocationEvent.dispatch() line: 251
EventQueue.dispatchEventImpl(AWTEvent, Object) line: 705
EventQueue.access$000(EventQueue, AWTEvent, Object) line: 101
EventQueue$3.run() line: 666
EventQueue$3.run() line: 664
AccessController.doPrivileged(PrivilegedAction<T>, AccessControlContext) line: not available [native method]
ProtectionDomain$1.doIntersectionPrivilege(PrivilegedAction<T>, AccessControlContext, AccessControlContext) line: 76
EventQueue.dispatchEvent(AWTEvent) line: 675
EventDispatchThread.pumpOneEventForFilters(int) line: 211
EventDispatchThread.pumpEventsForFilter(int, Conditional, EventFilter) line: 128
EventDispatchThread.pumpEventsForHierarchy(int, Conditional, Component) line: 117
EventDispatchThread.pumpEvents(int, Conditional) line: 113
EventDispatchThread.pumpEvents(Conditional) line: 105
EventDispatchThread.run() line: 90

El parámetro Graphics viene de aquí:

RepaintManager.paintDirtyRegions(Map) line: 781

El fragmento involucrado es el siguiente:

Graphics g = JComponent.safelyGetGraphics(
dirtyComponent, dirtyComponent);
// If the Graphics goes away, it means someone disposed of
// the window, don''t do anything.
if (g != null) {
g.setClip(rect.x, rect.y, rect.width, rect.height);
try {
dirtyComponent.paint(g); // This will eventually call paintComponent()
} finally {
g.dispose();
}
}

Si le echas un vistazo, verás que recupera los gráficos del JComponent mismo (indirectamente con javax.swing.JComponent.safelyGetGraphics(Component, Component) ) que a su vez lo toma de su primer "padre de peso pesado" (recortado a los límites del componente) que él mismo toma de su recurso nativo correspondiente.

En cuanto al hecho de que tiene que transmitir los Graphics a un Graphics2D , sucede que al trabajar con el Window Toolkit, Graphics realmente amplía Graphics2D , sin embargo, podría usar otros Graphics que no "tienen que" se extienden Graphics2D (no ocurren muy a menudo pero AWT / Swing te permite hacer eso).

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.JPanel;
class TestPaint extends JPanel {
public TestPaint() {
setBackground(Color.WHITE);
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawOval(0, 0, getWidth(), getHeight());
}
public static void main(String[] args) {
JFrame jFrame = new JFrame();
jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jFrame.setSize(300, 300);
jFrame.add(new TestPaint());
jFrame.setVisible(true);
}
}

Answer 2

La (muy) corta respuesta a su pregunta es que paintComponent se llama "cuando debe ser". A veces es más fácil pensar en el sistema Java Swing GUI como una "caja negra", donde la mayoría de los internos se manejan sin demasiada visibilidad.

Hay una serie de factores que determinan cuándo se debe volver a pintar un componente, desde moverse, cambiar el tamaño, cambiar el enfoque, estar oculto por otros marcos, y así sucesivamente. Muchos de estos eventos se detectan de forma auto-mágica, y se llama internamente a paintComponent cuando se determina que esa operación es necesaria.

He trabajado con Swing durante muchos años, y no creo haber llamado alguna paintComponent directamente a paintComponent , o incluso haberlo visto directamente desde otra cosa. Lo más cerca que he llegado es usando los métodos de repaint() para activar mediante programación un repintado de ciertos componentes (que supongo que llama a los métodos paintComponent correctos en paintComponent descendente).

En mi experiencia, paintComponent rara vez se reemplaza directamente. Admito que hay tareas de renderizado personalizadas que requieren dicha granularidad, pero Java Swing ofrece un conjunto (bastante) robusto de JComponents y Layouts que se pueden usar para hacer gran parte del trabajo pesado sin tener que anular directamente paintComponent . Supongo que mi punto aquí es asegurarme de que no se puede hacer algo con JComponents y Layouts nativos antes de que intentes rodar tus propios componentes renderizados a medida.

Answer 3

Las partes internas del sistema GUI llaman a ese método, y pasan el parámetro Graphics como un contexto gráfico sobre el que puede dibujar.

Answer 4

Llamar a object.paintComponent(g) es un error.

En cambio, este método se llama automáticamente cuando se crea el panel. El método paintComponent() también se puede llamar explícitamente mediante el método paintComponent() definido en la clase Component .

El efecto de llamar a repaint() es que Swing borra automáticamente el gráfico en el panel y ejecuta el método paintComponent para volver a dibujar los gráficos en este panel.