Discussion :

[CaRadek]

Bonjour à toutes et à tous, je débute dans la programmation en Java ne soyez pas trop dur avec moi svp.

Je cherche depuis une class A a accéder a des composants d'une class B qui elle est un menu ( JMenu ou JMenuBar )

Par conséquence les composants que je cherche a "contrôler" sont de type JMenuItem ou JMenu

Comment puis je faire ?

Merci

[radtriste]

Bonjour à toutes et à tous, je débute dans la programmation en Java ne soyez pas trop dur avec moi svp.

Je cherche depuis une class A a accéder a des composants d'une class B qui elle est un menu ( JMenu ou JMenuBar )

Par conséquence les composants que je cherche a "contrôler" sont de type JMenuItem ou JMenu

Comment puis je faire ?

Merci

euh ... Avant de commencer par la, as-tu deja programme en Java ? sais-tu ce qu'est la Programmation Objet ? Sinon, je t'invite a d'abord faire quelques tutoriels de base


Sinon, pourrais-tu etre plus explicite ? donnez un exemple concret ?

Pour repondre, brievement a ce que j'ai compris de ta question :

Code :

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

1
2
3
4
5
6
7
8
 
public class A
{
    public A(B b)
    {
        JMenuItem item = b.getSelectedItem();
    }
}

[nsanabi]

Je cherche depuis une class A a accéder a des composants d'une class B qui elle est un menu ( JMenu ou JMenuBar )

il est vrai que ce que tu cherche à faire n'est pas très claire.
jeter un coup d'oeil sur ce post

[CaRadek]

Excusez moi si je n'ai pas été assez claire dans mes explications :

Pour répondre à vos questions :

En développement JAVA oui j'ai commencé mais que commencé.... Mon application fonctionne déjà partiellement.

Pour mon problème :

Alors j'ai une JMenuBar avec des composants on va nommer class A:

Code :

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

1
2
3
4
5
6
7
8
9
 
// La class A
public class MenuBarPrincipale extends JMenuBar{
 
    public MenuBarPrincipale(){
// Ajout de mes composants JMENU ....
 
    }
}

J'ai une class B depuis laquelle je veux pouvoir interagir sur ma class A, ajouter un JMenuItem, supprimer un JMenuItem intégré dans un JMenu de ma class A

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
 
// La class B
public class GestionJmenu {
 
    private JMenu jMenu;
 
    public GestionJmenu(JMenu menu){
        jMenu = menu;
    }
 
    public void addMenu(){
       jMenu.add(unItem)
    }
 
    public void delMenu(){
     jMenu.remove(unItem)
    }
 
}

Bon voila grossièrement ce que ca donne, mais je ne sais pas comment lier mon (JMenu menu) à mon menu de ma JMenuBar ....

[sovo]

Essai de faire ceci

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
 
// La class A
public class MenuBarPrincipale extends JMenuBar{
    private JMenu Menu;
    private GestionJmenu GestMen 
 
    public MenuBarPrincipale(){
          //Instance d'un JMenu
          Menu = new JMenu();
          Menu.setText("Fichier");
 
          //Instance de GestionJmenu pour la manipulation des menu
          GestionJmenu GestMen = new GestionJmenu(Menu);
          GestMen.addMenu();
          GestMen.delMenu
 
 
          add(Menu);
    }
}

Maintenant je trouve que ta classe GestionJmenu n'est pas tres optimise.

Voila ce que je te proposerais

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
 
public class GestionJmenu {
 
    private JMenu jMenu;
 
    public GestionJmenu(JMenu menu){
        jMenu = menu;
    }
 
    public void addMenu(JMenuItem unItem){
       jMenu.add(unItem)
    }
 
    public void delMenu(JMenuItem unItem){
     jMenu.remove(unItem)
    }
 
    //Cette methode est importante car elle te permet de récupérer le menu 
   //que tu as modifie, sinon ca ne sert a rien d'avoir fait ces traitement
    public JMenu getMenu(){
           return jMenu
    }
 
}

tu utilises maintenant comme ceci :

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
 
// La class A
public class MenuBarPrincipale extends JMenuBar{
    private JMenu Menu;
    private GestionJmenu GestMen 
 
    public MenuBarPrincipale(){
          //Instance d'un JMenu
          Menu = new JMenu();
          Menu.setText("Fichier");
 
          //Instance de GestionJmenu pour la manipulation des menu
          GestionJmenu GestMen = new GestionJmenu(Menu);
          GestMen.addMenu();
          GestMen.delMenu
 
          //Pour prendre en compte les modification faite dans GestionJmenu
          Menu = GestMenu.getMenu(); 
          add(Menu);
    }
}

[CaRadek]

Merci de ta réponse, mais je pense n'avoir pas été assez claire dans ma demande excusez moi. bon je reprends en détails :

Ma JMenuBar :

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
 
public class MenuBarPrincipale extends JMenuBar{
 
    public MenuBarPrincipale(){
 
      		add(getJMenuTest1());
    		add(getJMenuTest2());
    		add(getJMenuTest3());    	
    }
 
    private JMenu getJMenuTest1() {
		if (jMenuTest1 == null) {
			jMenuTest1 .setText("Test 1");
			jMenuTest1 .add(getJMenuItem1());
			jMenuTest1 .addSeparator();
			jMenuTest1 .add(getJMenuItem1());
			jMenuTest1 .add(getJMenuItem2());
		}
		return jMenuTest1 ;
	}
 
.....
// Création des autres menus et des menuItems ....
}

Ma class de "Gestion" de mes menus :

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
public class GestionJmenu {
 
	private JMenu jMenu;
 
	public GestionJmenu(JMenu menu){
		jMenu = menu;
	}
 
	public void addMenu(JMenuItem unItem){
		jMenu.add(unItem);
		 refresh();
	}
 
	public void addSep(){
		jMenu.addSeparator();
		refresh();
	} 
 
	public void delMenu(JMenuItem unItem){
		jMenu.remove(unItem);
		refresh();
	}  
 
	private void refresh(){
		jMenu.repaint();
		jMenu.revalidate();
	}
}

L'ajout depuis une class ( n'importe laquelle ..... on va dire la class LanceTest() )

Code :

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

1
2
3
4
5
6
7
8
 
 
// un JButton avec un ActionListener par exemple
 
	public void actionPerformed(ActionEvent e) {
		JMenuItem item = new JMenuItem("Item Ajoute");
		new GestionJmenu(jMenuTest1).addMenu(item);
	}

Donc la fameuse interrogation est : comment lui passer en paramètre un jMenuTest1 qui ne se trouve pas dans la class utilisée ...

---------------------------

Je pensais mettre le nom des Jmenu dans la class GestionJmenu avec un appel du style :

Code :

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

1
2
3
4
5
private MenuBarPrincipale menubar;
 
private JMenu test1 = menuBar.jMenuTest1 ;
private JMenu test2 = menuBar.jMenuTest2 ;
private JMenu test3 = menuBar.jMenuTest3 ;

ce qui aurait réglé mon problème
Mais bon ca ne marche évidement pas ...

En espérant être plus claire, excusez moi si ce n'est pas le cas

[radtriste]

Si j'ai bien compris, tu veux utiliser les differents menus de ta JMenuBar a l'interieur de ta methode actionPerformed.

Voila comment je ferais :

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
 
public class MenuBarPrincipale extends JMenuBar{
 
    // Declare tes menus en private ici
    private JMenu jMenuTest1;
    private JMenu jMenuTest2;
    private JMenu jMenuTest3;
 
    public MenuBarPrincipale(){
 
      		add(getJMenuTest1());
    		add(getJMenuTest2());
    		add(getJMenuTest3());
 
    		// En considerant que tu ajoute les bouton ici
    		// Tu lui envoie en parametre ta MenuBarPrincipale
    		add(new PersoButton(this));
    }
 
    private JMenu getJMenuTest1() {
		if (jMenuTest1 == null) {
			jMenuTest1 .setText("Test 1");
			jMenuTest1 .add(getJMenuItem1());
			jMenuTest1 .addSeparator();
			jMenuTest1 .add(getJMenuItem1());
			jMenuTest1 .add(getJMenuItem2());
		}
		return jMenuTest1 ;
	}
 
.....
// Création des autres menus et des menuItems ....

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
 
// Cree ta propre classe JButton pour que ce soit plus claire
 
public class PersoButon extends JButton implements ActionListener
{
    private MenuBarPrincipale bar;
 
    public PersoButton(MenuBarPrincipale bar)
    {
        this.bar = bar;
    }
    // Tu peux declarer ta methode actionPerformed ici et l'ajouter aux JButton que tu crees
 
	public void actionPerformed(ActionEvent e) {
		JMenuItem item = new JMenuItem("Item Ajoute");
		new GestionJmenu(bar.getJMenuTest1() ).addMenu(item);
	}
}

Si j'ai bien tout compris, sa doit marcher

[CaRadek]

Pouvez vous m'eclairer sur certains points :

- vous dites " Declare tes menus en private ici " mais faisant cela il me sera impossible de les appeler depuis une autre class
- dans votre exemple l'actionlistener est directement lié a la JMenuBar, alors que moi le jbutton ( dans cet exemple ) peut se trouver dans un JToolBar donc bien dissocié de la JMenuBar

[radtriste]

Pouvez vous m'eclairer sur certains points :

- vous dites " Declare tes menus en private ici " mais faisant cela il me sera impossible de les appeler depuis une autre class
- dans votre exemple l'actionlistener est directement lié a la JMenuBar, alors que moi le jbutton ( dans cet exemple ) peut se trouver dans un JToolBar donc bien dissocié de la JMenuBar

- Tu declares tes menus en private, puis tu utilises ce qu'on appelle des getters et setters pour les recuperer

- Cela ne fait rien que le JButton soit tres eloigne graphiquement de ta JMenuBar, il suffit de passer au JButton la reference de ta JMenuBar en parametre
Tout ceci peut tres bien se faire dans une autre classe :

Code :

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

1
2
3
4
5
6
7
8
9
 
public class Main
{
    public static void main(String[] args)
    {
        MenuBarPrincipale menu = new MenuBarPrincipale();
        PersoButton button = new PersoButton(menu);
    }
}

avec MenuBarPrincipale etant sensiblement ressemblant :

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
 
public class MenuBarPrincipale extends JMenuBar{
 
    // Declare tes menus en private ici
    private JMenu jMenuTest1;
    private JMenu jMenuTest2;
    private JMenu jMenuTest3;
 
    public MenuBarPrincipale(){
 
      		add(getJMenuTest1());
    		add(getJMenuTest2());
    		add(getJMenuTest3());
    }
 
    private JMenu getJMenuTest1() {
		if (jMenuTest1 == null) {
			jMenuTest1 .setText("Test 1");
			jMenuTest1 .add(getJMenuItem1());
			jMenuTest1 .addSeparator();
			jMenuTest1 .add(getJMenuItem1());
			jMenuTest1 .add(getJMenuItem2());
		}
		return jMenuTest1 ;
	}
 
.....
// Création des autres menus et des menuItems ....

et PersoButton n'a pas change :

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
 
// Cree ta propre classe JButton pour que ce soit plus claire
 
public class PersoButon extends JButton implements ActionListener
{
    private MenuBarPrincipale bar;
 
    public PersoButton(MenuBarPrincipale bar)
    {
        this.bar = bar;
    }
    // Tu peux declarer ta methode actionPerformed ici et l'ajouter aux JButton que tu crees
 
	public void actionPerformed(ActionEvent e) {
		JMenuItem item = new JMenuItem("Item Ajoute");
		new GestionJmenu(bar.getJMenuTest1() ).addMenu(item);
	}
}

[HNoury]

Une autre solution serait de créer une méthode dans la classe A faisant ce que tu veux, et de l'appeler depuis la classe B

Personnellement (mais je suis autodidacte), je fais une classe principale à l'ouverture qui instancie toutes les autres classes, et dans les constructeurs, avec des "this.CetteInstance" je rappelle dans toutes les instances de classes nécessaires, celles qu'elles devront "piloter".