Come fare un JMenu hanno un comportamento pulsante in un JMenuBar

Question

Stavo cercando di fare un JMenu si comporti come un JButton ma sto avendo qualche problema e si spera che qualcuno qui può aiutare!

Ho una menuListener alla voce JMenu con questo, ma non posso ottenere il menu a comparsa / focus di lasciare per permettermi di fare clic adeguatamente il JMenu ripetuto volte per attivare questa funzione e speravo che qualcuno potrebbe dirmi quello che ho 'm facendo male. Grazie.

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

        }

Answer 1

Non del tutto sicuro di quello che stai chiedendo ...

Ma JMenuBar eredita da Container - se si preferisce aggiungere una JButton ad esso che un JMenu si può semplicemente chiamare -

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

Answer 2

Questo esempio di codice viene eseguito in eclissi, di nuovo preoccupati per come lo si utilizza?

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

So che questo è un vecchio thread, ma penso che potrei avere una soluzione. Mi sono imbattuto attraversavano questo problema in una delle mie applicazioni, e ho trovato una soluzione. Provare a utilizzare un JMenuItem invece di un JMenu. Avrà lo stesso L & F come JMenu quando si collega a una JMenuBar. L'unica cosa che dovete fare è impostare la dimensione del vostro nuovo "bottone", come Layout Manager (anche se non è stato impostato uno) si ridimensiona il componente in base alle proprie regole:

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

Il modo per farlo è trovato sotto quel link (se si sente a disagio, facendo clic sul link, google per "lavoro setSize pretende molto" - sarà il tra i primi dieci risultati). Se non si imposta la dimensione correttamente, il "bottone" nuovo riempirà lo spazio rimanente del vostro JMenuBar.

provare questo codice:

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

setActionCommand () metodo impostare un comando di azione, in modo che quando si fa clic con il nuovo "bottone" questo sarà il comando di azione approvato dal l'argomento evento azione per il metodo di azione eseguita, in modo che si può facilmente identificarlo:

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

Spero che questo aiuti!

Answer 4

E 'molto difficile determinare quello che stai cercando di fare qui. Ma non credo che si sta utilizzando correttamente JMenu.

Una JMenu è l'oggetto che rappresenta un Menu. E 'separata dalla barra dei menu (JMenuBar) e dalla voce di menu (JMenuItem). Un JMenuBar di solito contiene più JMenus (File, Modifica, ecc) che a loro volta contengono più JMenuItems (New, Open, Close). I JMenuItems sono ciò che è cliccato e "si comporta come un pulsante" nel menu.

Per ottenere una voce di menu di agire come un pulsante, è sufficiente aggiungere al menu. Ad esempio:

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

Se si sta cercando di creare un menu pop-up, è necessario utilizzare JPopupMenu invece di JMenu, e non hai bisogno di un JMenuBar. Qui ci sono i tutorial Java sul menu: http: // java. sun.com/docs/books/tutorial/uiswing/components/menu.html

E qui ci sono la documentazione Java per JMenuBar , JMenu , JPopupMenu , e JMenuItem .

Se si modifica la tua domanda e dare una spiegazione più dettagliata di quello che stai facendo potrei essere in grado di dare un aiuto più specifico.

Answer 5

Ok ho deciso di indagare su questo un po 'di più e che segue è la reslut e sembra agire come un JButton, ma appare come una JMenu su un jmenubar. Codice qui sotto. (Nota solo l'aggiunta di un ActionListener a un JMenu non ha funzionato destra che è la ragione per la MouseListener. Si aggiunge un ActionListener al MenuButton proprio come un normale pulsante e finché tu non aggiungere eventuali menuitems al MenuButton (che tecnicamente si poteva) apparirà come un JMenu sul JMenuBar ma comportarsi come un pulsante.

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;
    }
}
}