FAQ Java GUIConsultez toutes les FAQ

1
2
Image img = new BufferedImage(150,52,BufferedImage.TYPE_INT_RGB); 
Graphics2D g2d = (Graphics2D)img.getGraphics();

1
2
3
/** Ecriture dans une image 'img' */ 
Graphics2D g2d = (Graphics2D)img.getGraphics(); 
g2d.drawString("HelloWord",x,y);

1
2
3
4
Graphics2D g2d = (Graphics2D)img.getGraphics(); 
g2d.setFont(new Font("Serif",Font.PLAIN,12)); 
g2d.setColor(Color.RED); 
g2d.drawString("HelloWord",x,y);

1
2
3
4
Graphics2D g2d = ...; 
FontMetrics fontMetrics = g2d.getFontMetrics(); 
int longueur = fontMetrics.stringWidth("MonTexte"); 
int hauteur = fontMetrics.getHeight();

1
2
3
4
5
6
Graphics2D g2d = ...; 
/** Lissage du texte uniquement : */ 
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_ON); 
  
/** Lissage du texte et des dessins */ 
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);

1
2
3
4
Graphics2D g2d = ...; 
/** 80 % de transparence */ 
g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8f )); 
g2d.drawXXX(...);

1
2
3
4
Graphics2D g2d = ...; 
/** Définit une épaisseur de 5 pixels */ 
g2d.setStroke(new BasicStroke( 5.0f )); 
g2d.drawXXX(...);

1
2
3
4
5
6
7
8
9
10
11
Graphics2D g2d = ...; 
float epaisseur=3; /** taille de la ligne */ 
float[] style = {10,5}; /** les pointillés seront deux fois plus long que les blancs */ 
g2d.setStroke( new BasicStroke(  
        epaisseur, 
        BasicStroke.CAP_BUTT, 
        BasicStroke.JOIN_MITER, 
        10.0f, 
        style, 
        0 
        ));

1
2
3
Graphics2D g2d = ...; 
g2d.setPaint(new GradientPaint(xDebut,yDebut,colDebut,xFin,yFin,colFin,cyclique); 
g2d.fillXXX(...);

1
2
3
Graphics2D g2d = ...; 
g2d.setPaint(new TexturePaint(bufferedImage, new Rectangle(x,y,largeur,hauteur)); 
g2d.fillXXX(...);

1
2
3
4
5
6
7
8
/** Désactivation de l'anti-aliasing */ 
g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF); 
g2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF); 
/** Demande de rendu rapide */ 
g2D.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED); 
g2D.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED); 
g2D.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_OFF); 
g2D.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public class DoubleBufferingSoftware extends Frame{ 
   // boucle d'affichage 
   RenderingThread renderingThread = new RenderingThread(); 
   // buffer mémoire (2eme buffer) 
   Graphics buffer; 
   // image mémoire correspondant au buffer 
   Image image;  
   int x = 0; // coordonnée x de l'affichage du texte 
  
   public DoubleBufferingSoftware(){ 
      //affichage 
      setSize( 400, 400 ); 
      setVisible( true ); 
  
      // on démarre la bouche d'affichage 
      renderingThread.start(); 
  
   } 
   public void update(Graphics g){ 
      paint(g); 
   } 
   public void paint( Graphics g ){ 
     //création du buffer si il n'existe pas 
     if(buffer==null){ 
        image = createImage(400,400); 
        buffer = image.getGraphics(); 
      } 
     //on dessine sur le buffer mémoire 
      buffer.setColor( Color.white ); 
      buffer.fillRect( 0, 0, 400, 400 ); 
      buffer.setColor( Color.black ); 
      buffer.drawString( "affichage d'une ligne de texte", x, 200 ); 
      x++; 
      if(x>400) x = 0; 
      // finalement, le buffer mémoire est dessiné dans le buffer d'affichage 
      g.drawImage(image, 0, 0, this); 
   } 
   class RenderingThread extends Thread { 
     /** 
      *  Ce thread appelle le rafraîchissement de notre fenêtre  
      *  toutes les 10 millisecondes 
      */ 
      public void run(){ 
         while(true){ 
            try { 
               repaint();  
               sleep( 10 ); 
            } catch ( Exception e ) {}  
         } 
      } 
   }    
   public static void main(String[] args){new DoubleBufferingSoftware();} 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public class DoubleBufferingHardware extends Frame{ 
   // boucle d'affichage 
   RenderingThread renderingThread = new RenderingThread();  
   // variable permettant d'utiliser la mémoire VRAM 
   BufferStrategy strategy;  
   // buffer mémoire où les images et les textes sont appliqués 
   Graphics buffer;  
   int x = 0; // coordonnée x de l'affichage du texte 
  
   public DoubleBufferingHardware(){ 
      setSize( 400, 400 ); 
      setVisible( true ); 
  
      // inhibe la méthode courante d'affichage du composant  
      setIgnoreRepaint( true );   
  
      // on crée deux buffers dans la VRAM donc c'est du double-buffering 
      createBufferStrategy( 2 );  
  
      // récupère les buffers graphiques dans la mémoire VRAM 
      strategy = getBufferStrategy();  
      buffer = strategy.getDrawGraphics(); 
      renderingThread.start();   
   } 
  
   public void graphicalRender(){ 
      buffer.setColor( Color.black );  
      buffer.fillRect( 0, 0, 400, 400 );  
      buffer.setColor( Color.white );  
      buffer.drawString( "affichage d'une ligne de texte", x, 200 ); 
      x++;  
      if ( x > 400 ) x = 0;  
      //on envoie toutes les données du buffer mémoire vers le buffer d'affichage 
      strategy.show();  
   } 
  
   class RenderingThread extends Thread{ 
     /** 
      *  Ce thread appelle le rafraîchissement de notre fenêtre  
      *  toutes les 10 millisecondes 
      */ 
      public void run(){ 
         while( true ){ 
            try { 
                // on appelle notre propre méthode de rafraîchissement 
               graphicalRender(); 
               sleep( 5 ); 
            } catch ( Exception e ) {}  
         } 
      } 
   }    
   public static void main(String[] args){new DoubleBufferingHardware();} 
}

createBufferStrategy( 2 );

createBufferStrategy( 3 );

InputStream ttf;

ttf = getServletContext().getResourceAsStream("fonts/ARIALN.TTF");

ttf = new FileInputStream("/aaa/bbb/ccc/ARIALN.TTF");

1
2
3
4
5
6
7
8
9
10
11
12
13
Font arialNarrow; 
try { 
   arialNarrow = Font.createFont(Font.TRUETYPE_FONT, ttf); 
} 
catch (Exception e) { //Une solution de rechange, au cas où... 
   arialNarrow = new Font("Arial", Font.PLAIN, 1); 
} 
finally { 
   try { 
      ttf.close(); 
   } 
   catch (Exception ignore) {} 
}

Font arialNarrowBold = arialNarrow.deriveFont(Font.BOLD);

1
2
3
4
5
6
7
8
9
10
BufferedImage bi = ImageIO.read("fichier.jpg"); 
Graphics2D g2d = bi.createGraphics(); 
//Antialiasing 
g2d.setRenderingHint( 
   RenderingHints.KEY_TEXT_ANTIALIASING, 
   RenderingHints.VALUE_TEXT_ANTIALIAS_ON); 
g2d.setFont(arialNarrow.deriveFont(48f)); 
//et maintenant on peut écrire en Arial Narrow de taille 48 
g2d.setFont(arialNarrowBold.deriveFont(24f)); 
//et là du Arial Narrow gras taille 24