Discussion :

[domxaline]

bonjour
j'ai écrit cette prg
en compilant j'ai erreur suivant
"Erreur : la méthode principale est introuvable dans la classe FenetreTest, définissez la méthode principale comme suit :
public static void main(String[] args)"
veuillez m'aidez svp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
import java.awt.Color;
import java.awt.font.*;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JPanel;
 
public class Panneau extends JPanel
{
	 private int posX=-50;
	 private int posY=-50;
	 private int drawSize=50;
	 //boolean pour le mode morphing et pour savoir si la taille doit être réduite
	 private boolean morph=false,reduce=false;
	 private String forme="ROND";	  
 
 
	 /* voici nos deux couleurs */
	 private Color couleurForme=Color.red;
	 private Color couleurFond=Color.white;
 
	 //le compteur de rafraîchissement
	 private int increment=0;	
 
	 public void paintComponent (Graphics g)
	 { 
	  //affectation de la couleur de fond
	  g.setColor (couleurFond);		     
	  g.fillRect (0,0,this.getWidth ( ),this.getHeight ( ));
 
	  //affectation de la couleur de la forme
	  g.setColor(couleurForme);
	  //si le mode morphing est activé, on peint le morphing
	  //g.setColor (Color.red);	    
	  if(this.morph)
	     drawMorph(g);	    
	  else	 	    
	     draw(g);	    
	 }
/* méthode qui redéfinit la couleur du fond */
	 public void setCouleurFond(Color color)
	 {
		 this.couleurFond=color;
		 repaint();
	 }
	 /* methode qui redéfinit la couleur du forme*/
	 public void setCouleurForme(Color color)
	 {
		 this.couleurForme=color;
		 repaint();
	 }
 
	 private void draw(Graphics g)
	 {
	  if(this.forme.equals("ROND")) 
	  {
	   g.fillOval(posX,posY,50,50);
	  }
	  if(this.forme.equals("CARRE")||this.forme.equals("CARRÉ"))
	  {
	   g.fillRect(posX,posY,50,50);
	  } 	  
	  if(this.forme.equals("TRIANGLE"))
	  { 		 
	   int s1X=posX+50/2;
	   int s1Y=posY; 	     
	   int s2X=posX+50;
	   int s2Y=posY+50;   	     
	   int s3X=posX;
	   int s3Y=posY+50;    	          	     
	   int[]ptsX={s1X,s2X,s3X};
	   int[]ptsY={s1Y,s2Y,s3Y};    	          	     
	   g.fillPolygon(ptsX,ptsY,3);
	  }
	  if(this.forme.equals("ETOILE"))
	  {    		 
	   int s1X=posX+50/2;
	   int s1Y=posY;
	   int s2X=posX+50;
	   int s2Y=posY+50;
	   g.drawLine(s1X,s1Y,s2X,s2Y);   	      
	   int s3X=posX;
	   int s3Y=posY+50/3;
	   g.drawLine(s2X,s2Y,s3X,s3Y);    	      
	   int s4X=posX+50;
	   int s4Y=posY+50/3;
	   g.drawLine(s3X,s3Y,s4X,s4Y);    	      
	   int s5X=posX;
	   int s5Y=posY+50;
	   g.drawLine(s4X,s4Y,s5X,s5Y);
	   g.drawLine(s5X,s5Y,s1X,s1Y);
	  }
	 } 
 
	 /* méthode qui peint le morphing */
	 private void drawMorph(Graphics g)
	 {   
	  //on incrémente le tour
	  increment++;   
	  //on regarde si on doit réduire ou non
	  if(drawSize>=50)reduce=true;
	  if(drawSize<=10)reduce=false;    	  
	  if(reduce)
	    drawSize=drawSize-getUsedSize();
	  else
	    drawSize=drawSize+getUsedSize();
 
	  if(this.forme.equals("ROND"))
	  {
	   g.fillOval(posX, posY, drawSize, drawSize);
	  }
	  if(this.forme.equals("CARRE")||this.forme.equals("CARRÉ")) 
	  {		  
	   g.fillRect(posX, posY, drawSize,drawSize);
	  }
	  if(this.forme.equals("TRIANGLE"))
	  {
	   int s1X=posX+drawSize/2;
	   int s1Y=posY;
	   int s2X=posX+drawSize;
	   int s2Y=posY+drawSize;
	   int s3X=posX;
	   int s3Y=posY+drawSize;    		  
	   int[]ptsX={s1X,s2X,s3X};
	   int[]ptsY={s1Y,s2Y,s3Y};    		  
	   g.fillPolygon(ptsX,ptsY,3); 		  
	  }
	  if(this.forme.equals("ETOILE"))
	  {
	   int s1X=posX+drawSize/2;
	   int s1Y=posY;
	   int s2X=posX+drawSize;
	   int s2Y=posY+drawSize;
	   g.drawLine(s1X,s1Y,s2X,s2Y);    		  
	   int s3X=posX;
	   int s3Y=posY+drawSize/3;
	   g.drawLine(s2X,s2Y,s3X,s3Y);   		  
	   int s4X=posX+drawSize;
	   int s4Y=posY+drawSize/3;
	   g.drawLine(s3X,s3Y,s4X,s4Y);    		  
	   int s5X=posX;
	   int s5Y=posY+drawSize;
	   g.drawLine(s4X,s4Y,s5X,s5Y);
	   g.drawLine(s5X,s5Y,s1X,s1Y);
	  }
	 }
	  /* méthode qui retourne le nombre à retrancher ou ajouter pour le morphing */    
	 private int getUsedSize()
	 {
	  int res=0; 
	  //si le nombre de tours est 10
	  //on réinitialise l'incrément et on retourne 1
	  if(increment/10==1)
	  {
	   increment=0;
	   res=1;
	  }
	  return res;	  
	 }
 
	 public int getDrawSize()
	 {
	  return drawSize;
	 }
 
	 public boolean isMorph()
	 {
	  return morph;
	 }
 
	 public void setMorph(boolean bool)
	 {
	  this.morph=bool;
	  //on réinitialise la taille
	  drawSize=50;
	 }
 
	 public void setForme(String form)
	 {
	  this.forme=form.toUpperCase();
	 }      
 
	 public int getPosX( ) 
	 {
	  return posX;
	 }
 
	 public void setPosX (int posX)
	 {
	  this.posX=posX;
	 }
 
	 public int getPosY ( )
	 {
	  return posY;
	 }
 
	 public void setPosY (int posY)
	 {
	  this.posY=posY;
	 } 
	}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
import java.awt.Color;
public class Point 
{
 //Couleur du point
 private Color color=Color.red;
 //Taille
 private int size=10;
 //Position sur l'axe X:initialisé au dehors du conteneur
 private int x=-10;
 //Position sur l'axe Y: initialis& au dehors du conteneur
 private int y=-10;
 //Type de point
 private String type="ROND";
 
 /* Constructeur par défaut */
 public Point()
 {
 
 }
 /* Constructeur avec paramètres*/
 // @param x, @param y, @param size, @param color, @param type
 public Point(int x, int y, int size, Color color, String type)
 {
	 this.size=size;
	 this.x=x;
	 this.y=y;
	 this.color=color;
	 this.type=type;
 }
 //*************************************************************
 //           ACCESSEURS
 //*************************************************************
 public Color getColor()
 {
	 return color;
 }
 public void setColor(Color color)
 {
	 this.color=color;
 }
 
 public int getSize()
 {
	 return size;
 }
 public void setSize(int size)
 {
	 this.size=size;
 }
 
 public int getX()
 {
	 return x;
 }
 public void setX(int x)
 {
	 this.x=x;
 }
 
 public int getY()
 {
	 return y;
 }
 public void setY(int y)
 {
	 this.y=y;
 }
 
 public String getType()
 {
	 return type;
 }
 public void setType(String type)
 {
	 this.type=type;
 }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
 
import javax.swing.JPanel;
 
public class DrawPanel extends JPanel
{
 //Couleur du pointeur
 private Color pointerColor=Color.red;
 
 //Forme du pointeur
 private String pointerType="CIRCLE";
 
 //Position X du pointeur
 private int posX=-10, oldX=-10;
 
 //Position Y du pointeur
 private int posY=-10, oldY=-10;
 
 //pour savoir si on doit dessiner ou non
 private boolean erasing=true;
 
 //Taille du pointeur
 private int pointerSize=15;
 
 //Collection de points!
 private ArrayList<Point>points=new ArrayList<Point>();
 
 /* Constructeur*/
 public DrawPaint()
 {
	 this.addMouseListener(new MouseAdapter()
	 {
		 public void mousePressed(MouseEvent e)
		 {
			 points.add(new Point(e.getX()-(pointerSize/2),e.getY()-(pointerSize/2),pointerSize,pointerColor,pointerType));
		     repaint();
		 }
	 });
 
	 this.addMouseMotionListener(new MouseMotionListener()
	 {
		 public void mouseDragged(MouseEvent e)
		 {
			//On récupère les coordonnées de la souris
			//et on enlève la moitié de la taille du pointeur
			//pour centrer le tracé
			 points.add(new Point(e.getX()-(pointerSize/2),e.getY()-(pointerSize/2),pointerSize,pointerColor,pointerType));
		     repaint();
		 }
		 public void mouseMoved(MouseEvent e)
		 {
 
		 }
	 });
	 }
    /* Vous la connaissez maintenant, celle-là ;*/
    public void paintComponent(Graphics g)
    {
    	g.setColor(Color.white);
        g.fillRect(0,0, this.getWidth(), this.getHeight());
        //Si on doit effacer, on ne passe pas dans le else=>pas de dessin
        if(this.erasing)
        {
        	this.erasing=false;
        }
        else
        {
        	//on parcourt notre collection de points
        	for(Point p:this.points)
        	{
        		//on récupère la couleur
        		g.setColor((p.getColor());
        		//Selon le type de point
        		if(p.getType().equals("SQUARE"))
        		{
        			g.fillRect(p.getX(), p.getY(), p.getSize(),p.getSize());
        		}
        		else
        		{
        			g.fillOval(p.getX(),p.getY(),p.getSize(), p.getSize());
        		}
        	}
        }
    }
    /* Efface le contenu */
    public void erase()
    {
    	this.erasing=true;
    	this.points=new ArrayList<Point>();
    	repaint();  	
    }
    /* Définit la couleur du pointeur */
    public void setPointerColor(Color c)
    {
    	this.pointerColor=c;
    }
 
    /* Définit la forme du pointeur */
    public void setPointerType(String str)
    {
    	this.pointerType=str;
    }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.ImageIcon;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.KeyStroke;
 
public class FenetreTest extends JFrame 
{
	//*******************
	/*      Le Menu    */ 
	//*******************
	private JMenuBar menuBar=new JMenuBar();
	JMenu fichier=new JMenu("Fichier"),
	      edition=new JMenu("Edition"),
	      forme=new JMenu("Forme du pointeur"),
	      couleur=new JMenu("Couleur du pointeur");
	JMenuItem nouveau=new JMenuItem("Effacer"),
	          quitter=new JMenuItem("Quitter"),
	          rond=new JMenuItem("ROND"),
	          carre=new JMenuItem("Carré"),
	          bleu=new JMenuItem("Bleu"),
	          rouge=new JMenuItem("Rouge"),
	          vert=new JMenuItem("Vert");
 
	/************************************************/
	//         LA BARRE D'OUTILS
	//***********************************************
	JToolBar toolBar=new JToolBar();
	JButton square=new JButton(new ImageIcon("images/carré.jpg")),
	        circle=new JButton(new ImageIcon("images/rond.jpg")),
	        red=new JButton(new ImageIcon("images/rouge.jpg")),
	        green=new JButton(new ImageIcon("images/vert.jpg")),
	        blue=new JButton(new ImageIcon("images/bleu.jpg"));
	/*****************************************/
	//         LES ECOUTEURS
	//****************************************
    private FormeListener fListener=new FormeListener();
	private CouleurListener cListener=new CouleurListener();
 
	//Notre zone de dessin
	private DrawPanel drawPanel=new DrawPanel();
 
	 public FenetreTest()
	 {
	  //this.setTitle("Animation");
	  this.setSize(700, 500);
	  this.setLocationRelativeTo(null);
	  this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	  //On initalise le menu
	  this.initMenu();
	  //Idem pour la barre d'outils
	  this.initToolBar();
	  //On positionne notre zone de dessin
	  this.getContentPane().add(drawPanel,BorderLayout.CENTER);
	  this.setVisible(true);
	 }
 
	 //*************************************
	 //      Initialise le menu
	 //*************************************
	  private void initMenu()
	  {
	   nouveau.addActionListener(new ActionListener()
	   {
		   public void actionPerformed(ActionEvent arg0)
		   {
			   drawPanel.erase();
		   }
	   });
	   nouveau.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N,KeyEvent.CTRL_DOWN_MASK));
	   quitter.addActionListener(new ActionListener()
	   {
		   public void actionPerformed(ActionEvent arg0)
		   {
			   System.exit(0);
		   }
	   });
	   quitter.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_W,KeyEvent.CTRL_DOWN_MASK));
	   fichier.add(nouveau);
	   fichier.addSeparator();
	   fichier.add(quitter);
	   fichier.setMnemonic('F');
 
	   carre.addActionListener(fListener);
	   rond.addActionListener(fListener);
	   forme.add(rond);
	   forme.add(carre);
 
	   rouge.addActionListener(cListener);
	   vert.addActionListener(cListener);
	   bleu.addActionListener(cListener);
	   couleur.add(rouge);
	   couleur.add(vert);
	   couleur.add(bleu);
 
	   edition.setMnemonic('E');
	   edition.add(forme);
	   edition.addSeparator();
	   edition.add(couleur);
 
	   menuBar.add(fichier);
	   menuBar.add(edition);
 
	   this.setJMenuBar(menuBar);
	 }
	   /* Initialise 1 barre d'outils*/
	   private void initToolBar()
	   {
		  JPanel panneau=new JPanel();
			square.addActionListener(fListener);
			circle.addActionListener(fListener);
			red.addActionListener(cListener);
			green.addActionListener(cListener);
			blue.addActionListener(cListener);
 
			toolBar.add(square);
			toolBar.add(circle);
 
			toolBar.addSeparator();
			toolBar.add(red);
			toolBar.add(bleu);
			toolBar.add(green);
 
			this.getContentPane().add(toolBar,BorderLayout.NORTH);
		  }
 
		  //ECOUTEUR POUR LE CHANGEMENT DE FORME
		  //*************************************
		  class FormeListener implements ActionListener
		  {
			  public void actionPerformed(ActionEvent e)
			  {
				  if(e.getSource().getClass().getName().equals("javax.swing.JMenuItem"))
				  {
					  if(e.getSource()==carre)drawPanel.setPointerType("SQUARE");
					  else drawPanel.setPointerType("CIRCLE");
				  }
				  else
				  {
					  if(e.getSource()==carre)drawPanel.setPointerType("SQUARE");
					  else drawPanel.setPointerType("CIRCLE");
				  }
			  }
		  }
			  //ECOUTEUR POUR LE CHANGEMENT DE COULEUR
			  //***************************************
			  class CouleurListener implements ActionListener
			  {
				  public void actionPerformed(ActionEvent e)
				  {
					  System.out.println(e.getSource().getClass().getName());
					  if(e.getSource().getClass().getName().equals("javax.swing.JMenuItem"))
					  {
						  System.out.println("OK!");
						  if(e.getSource()==vert)drawPanel.setPointerColor(Color.green);
						  else
							  if(e.getSource()==bleu)drawPanel.setPointerColor(Color.blue);
							  else drawPanel.setPointerColor(Color.red);
					  }
					  else
					  {
						  if(e.getSource()==green)drawPanel.setPointerColor(Color.green);
						  else
						  {
							  if(e.getSource()==bleu)drawPanel.setPointerColor(Color.blue);
							  else drawPanel.setPointerColor(Color.red);
						  }
					  }
				  }
	 public static void main(String[] args)
	  {
	    FenetreTest fen=new FenetreTest();
	  }
	}}