Comment faire un JMenu avoir un comportement Button dans un JMenuBar

Question

Je suis en train de faire une JMenu se comporter comme un JButton mais je vais avoir quelques problèmes et nous espérons que quelqu'un ici peut aider!

J'ai ajouté un menuListener à l'élément JMenu avec cela, mais je ne peux pas obtenir le menu contextuel / focus de quitter pour me permettre de cliquer correctement le JMenu répété fois pour déclencher cette fonction et j'espérais que quelqu'un pourrait me dire ce que je « fais mal. Merci.

public void menuSelected(MenuEvent e)
        {
            ... // do stuff here code
            JMenu source = (JMenu)e.getSource();
            source.setSelected(false);
            source.setPopupMenuVisible(false);

        }

Answer 1

Pas tout à fait sûr de ce que vous demandez ...

Mais JMenuBar hérite de Container - si vous préférez ajouter un JButton à ce qu'un JMenu vous pouvez simplement appeler -

JMenuBar menuBar = ....
JButton myButton = ....
menuBar.add(myButton);

Answer 2

Cet exemple de code fonctionne en éclipse, à nouveau préoccupé par la façon dont vous l'utilisez?

public class MyMenuFrame extends JFrame {


    public MyMenuFrame() throws HeadlessException {
        super("My Frame");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 300);
        Container pane = this.getContentPane();
        pane.setLayout(new BorderLayout());
        pane.add(new JLabel("Hi there"), BorderLayout.PAGE_START);
        this.setVisible(true);
        JMenuBar menubar = new JMenuBar();
        JMenu menu = new JMenu("File");

        menu.addMenuListener(new MenuListener() {

            @Override
            public void menuSelected(MenuEvent e) {
                System.out.println("a");

            }

            @Override
            public void menuDeselected(MenuEvent e) {
                System.out.println("a");

            }

            @Override
            public void menuCanceled(MenuEvent e) {
                System.out.println("a");

            }
        });
        menubar.add(menu);
        this.setJMenuBar(menubar );
    }

    public static void main(String[] args) {
        new MyMenuFrame();
    }
}

Answer 3

Je sais que c'est un vieux fil, mais je pense que je pourrais avoir une solution. Je suis tombé en face ce problème dans l'une de mes applications, et a trouvé une solution de contournement. Essayez d'utiliser un JMenuItem au lieu d'un JMenu. Il aura le même L & F comme JMenu lorsque vous connectez à un JMenuBar. La seule chose que vous devez faire est de définir la taille de votre nouveau « bouton », comme gestionnaire de mise en page (même si vous avez défini pas) redimensionne cette composante en fonction de ses propres règles:

http://www.javaworld.com /javaworld/jw-09-2000/jw-0922-javatraps.html

La façon de le faire se trouve sous ce lien (si vous vous sentez mal à l'aise en cliquant sur le lien, Google pour « setsize doesnt travail » - ce sera dans les dix premiers résultats). Si vous ne définissez pas la taille correctement, votre nouveau « bouton » remplira l'espace restant de votre JMenuBar.

essayez ce code:

menuItem.setMinimumSize(someMenu.getSize());
menuItem.setPreferredSize(someMenu.getSize());
menuItem.setMaximumSize(someMenu.getSize());
menuItem.setActionCommand("ActionText");

setActionCommand méthode () établira une commande d'action, de sorte que lorsque vous cliquez sur votre nouveau « bouton » ce sera la commande d'action adoptée par l'argument de l'événement d'action au procédé mis en oeuvre d'action, de sorte que vous pouvez facilement identifier:

public void actionPerformed(ActionEvent e) {
    System.out.println(e.getActionCommand());
}

Hope this helps!

Answer 4

Il est très difficile de déterminer ce que vous essayez de faire ici. Mais je ne pense pas que vous utilisez correctement JMenu.

A JMenu est l'objet qui représente un menu. Il est séparé de la barre de menu (JMenuBar) et de l'élément de menu (JMenuItem). Un JMenuBar contient généralement plusieurs JMenus (Fichier, Edition, etc) qui à son tour contient plusieurs JMenuItems (Nouveau, Ouvrir, Fermer). Les JMenuItems sont ce qui est cliqué et « agit comme un bouton » dans le menu.

Pour obtenir un élément de menu pour agir comme un bouton, il suffit d'ajouter au menu. Par exemple:

JMenu fileMenu = new JMenu("File");
JMenuItem newChoice = new JMenuItem("New");
newChoice.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent evt) {
        newHasBeenSelected();
    }
});
fileMenu.add(newChoice);

Si vous essayez de créer un menu contextuel, vous devez utiliser JPopupMenu au lieu de JMenu, et vous n'avez pas besoin JMenuBar. Voici les tutoriels Java sur les menus: http: // java. sun.com/docs/books/tutorial/uiswing/components/menu.html

Et voici les docs Java pour JMenuBar , JMenu , JPopupMenu et JMenuItem .

Si vous modifiez votre question et donner une explication plus détaillée de ce que vous faites, je pourrais être en mesure de donner une aide plus spécifique.

Answer 5

Ok j'ai décidé d'enquêter sur ce un peu plus par ce qui suit le reslut et semble agir comme un JButton mais apparaît comme un JMenu sur un JMenuBar. Code ci-dessous. (Note simplement l'ajout d'un actionListener à un droit de travail na pas JMenu qui est la raison de la MouseListener. Vous ajoutez un actionListener à la menubutton comme un bouton normal et aussi longtemps que vous n'ajoutez pas menuitems au menubutton (que vous pourriez techniquement) il apparaît comme un JMenu sur la JMenuBar mais se comportent comme un bouton.

import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.lang.reflect.Method;
import java.util.EventListener;   
import javax.swing.ImageIcon;
import javax.swing.JMenu;

public class MenuButton extends JMenu {

private boolean startedIn = false;
private ActionListener action;

public MenuButton(String title) {
    super(title);
    removeListeners(this);
    this.addMouseListener(new MenuButtonListener());

}

public MenuButton(ImageIcon icon) {
    super();
    removeListeners(this);
    this.addMouseListener(new MenuButtonListener());
    this.setIcon(icon);
}

public void addActionListener(ActionListener a) {
    action = a;
}
    //we need to remove all the listeners already associated with a JMenu. If we do
//not do this, then it will not behave as expected because some mouseclicks are eaten 
//by these listeners. There is no easy way to do that, the following method is a 
//workaroundprovided in the java bug database. 
static private void removeListeners(Component comp) {
    Method[] methods = comp.getClass().getMethods();
    for (int i = 0; i < methods.length; i++) {
        Method method = methods[i];
        String name = method.getName();
        if (name.startsWith("remove") && name.endsWith("Listener")) {

            Class[] params = method.getParameterTypes();
            if (params.length == 1) {
                EventListener[] listeners = null;
                try {
                    listeners = comp.getListeners(params[0]);
                } catch (Exception e) {
                    // It is possible that someone could create a listener
                    // that doesn't extend from EventListener. If so, ignore
                    // it
                    System.out.println("Listener " + params[0]
                            + " does not extend EventListener");
                    continue;
                }
                for (int j = 0; j < listeners.length; j++) {
                    try {
                        method.invoke(comp, new Object[] { listeners[j] });
                        // System.out.println("removed Listener " + name +
                        // " for comp " + comp + "\n");
                    } catch (Exception e) {
                        System.out
                                .println("Cannot invoke removeListener method "
                                        + e);
                        // Continue on. The reason for removing all
                        // listeners is to
                        // make sure that we don't have a listener holding
                        // on to something
                        // which will keep it from being garbage collected.
                        // We want to
                        // continue freeing listeners to make sure we can
                        // free as much
                        // memory has possible
                    }
                }
            } else {
                // The only Listener method that I know of that has more
                // than
                // one argument is removePropertyChangeListener. If it is
                // something other than that, flag it and move on.
                if (!name.equals("removePropertyChangeListener"))
                    System.out.println("    Wrong number of Args " + name);
            }
        }
    }
}

public class MenuButtonListener extends MouseAdapter {

    boolean within = false;
    boolean pressed = false;


    public void mousePressed(MouseEvent e) {
        MenuButton.this.setSelected(true);
        pressed = true;
        //System.out.println("pressed");
    }

    public void mouseReleased(MouseEvent e) {
        //System.out.println("released");
        MenuButton.this.setSelected(false);
        if (action != null && within && pressed) {
            action.actionPerformed(new ActionEvent(this,
                    ActionEvent.ACTION_PERFORMED, null));
            MenuButton.this.setSelected(false);
        }
        pressed = false;
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        within = true;
    }

    @Override
    public void mouseExited(MouseEvent e) {
        within = false;
    }
}
}