Swing Actions direkt auf der JMenuBar

[KrokoDiehl]

Hallo zusammen.
In der Anwendung unserer Firma gibt es (ziemlich oft) Menüleisten mit Menüpunkten, die keine Submenüs haben, sprich wie Buttons (intern vom Typ Action) reagieren.
Da man auf eine JMenuBar nicht direkt Actions legen kann, ist meine Vorgehensweise bisher wie folgt:

- Es gibt "normale" Menüs, sprich ein JMenu welches als Submenüs einige Actions bekommt (völlig unproblematisch )-
- Die Actions, die keine Submenüs haben, sollen direkt auf die Menüleiste. Bisher werden diese als JButton drauf gesetzt.

Das funktioniert im Grunde ganz gut, wenn man dem JButton noch ein paar Eigenschaften verpasst, sodass er wie ein normales JMenu aussieht (wie

setBorderPainted(false);

).

ABER ... dann kommen die Look&Feels ins Spiel, die z.B. andere MouseOver-Effekte haben oder die Breiten anders berechnen.
Es wäre nun schön, wenn ich diese JButton auf der Menüleiste noch so hinbekommen würde, dass sie sich entspr. dem Look&Feel auch verhalten und aussehen wie JMenus.

Kann mir hier jemand einen Hinweis geben / Hilfe leisten? Ich habe folgende Ansätze schon ausprobiert mit den jeweils genannten Ergebnissen. Vielleicht hat dazu jmd einen Korrekturvorschlag?


Folgende Dinge wurden schon probiert:

1) Direkt JMenuItem auf die JMenuBar legen:

myMenuBar.add( new JMenuItem(currentAction) );

Das geht zwar, aber die MenuItems sehen da sehr schräg aus, viel zu breit und Borders werden teilweise seltsam gezeichnet.

2) ActionListener an JMenu setzen:
Es wird direkt ein JMenu (ohne Submenüs) auf die Leiste gelegt und diesem Menü ein ActionListener verpasst. Mit dem dem Effekt, dass beim Klick auf das Menü nur ein kleines Eckchen zu sehen ist (leeres Popupmenü) und der eigene ActionListener gar nicht anspringt.

3) Dem JButton die MenuUI verpassen:
Man kann ja via

setUI()

das entsprechende UI vom Look&Feel setzen. Dies schien mir der erfolgreichste Ansatz, aber leider fruchtete etwas wie

myMenuButton.setUI(  UIManager.getUI(new JMenu()) );
// myMenuButton vom Typ JButton

nur in einer ClassCastException
Mit den UIs habe ich bisher nichts gemacht und weiß daher auch nicht sicher, wie ich damit umgehen muss, sprich ob es überhaupt möglich ist, nem JButton die UI von einem JMenu zu geben (immerhin erben beide von AbstractButton).

Also soweit mein Problem. Danke schonmal fürs Lesen und Nachdenken

 

[eRaaaa]

huhu,

ich hab zwar keine direkte lösung, aber eine frage/anmerkung
eine menubar, ist doch dafür vorgesehen, menüs ranzuhängen, wärs in eurem fall nicht vllt sinnvoller, die "buttons" so wie du sie nennst, vllt in eine toolbar o.ä. auszulagern?
denn der user erwartet ja, wenn er in der menubar etwas anklickt, dass sich ein menü öffnet, bei euch würde dann direkt eine aktion ausgeführt werden, was manche, mich würde das zumindestens, etwas verwirren würde.


oder den umweg gehen und vllt dann lieber ein menü mit nur einem eintrag.

so, das wollt ich einfach mal in den raum werfen, vllt sagt ja ein GUI guru auch dazu was

 

[KrokoDiehl]

Ja da stimme ich dir zu: Unsere Menüleiste ist etwas unkonventionell, soll aber (leider!) so bleiben, da es bereits eine ältere Oberfläche gibt, die als Vorlage dient, und man keinem Benutzer zumuten will, dass er seine Gewohnheiten ändern muss.

 

[Michael...]

Ich würde den Button lassen, denn wenn ich auf einen Menüeintrag in der MenüBar klicke erwarte ich, dass sich ein Untermenü öffnet. Und beim Button kann ich wenigstens erkennen, dass das mein Click eine direkte Konsequenz hat.

Ansonsten könnte man vielleicht mit einen MenuListener rumspielen, ob man da das Verhalten immitieren kann.

 

[Ebenius]

Ich stimme auch zu, dass das nicht hübsch ist. Wenn Du aber an der Anforderung nicht vorbei kommst, sollte dies eine ganz hübsche Arbeitsgrundlage sein:

/* (@)JMenuBarButton.java */

/* Copyright 2009 Sebastian Haufe

 * Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       [url]http://www.apache.org/licenses/LICENSE-2.0[/url]

 * Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License. */

package com.ebenius.swing;

import java.awt.*;

import javax.swing.*;
import javax.swing.border.Border;

/**
 * A JButton looking like a JMenu.
 * 
 * @version $Revision$ as of $Date$
 * @author Sebastian Haufe
 * @since Playground-3.8
 */
public class JMenuBarButton extends JButton {

  /** Serial version UID */
  private static final long serialVersionUID = 1L;
  // -------------------------------------------------------------------------
  // Instance fields
  // -------------------------------------------------------------------------

  private JMenu menu;
  private CellRendererPane rendererPane;

  // -------------------------------------------------------------------------
  // Constructors
  // -------------------------------------------------------------------------

  /** Creates a new {@code JMenuBarButton}. */
  public JMenuBarButton() {
    menu = new JMenu() {

      /** Serial version UID */
      private static final long serialVersionUID = 1L;

      @Override
      public boolean isTopLevelMenu() {
        return true;
      }

      @Override
      public void menuSelectionChanged(boolean isIncluded) {}

      @Override
      public void setPopupMenuVisible(boolean b) {}

      @Override
      public void setBorder(Border border) {
        super.setBorder(border);
      }

      @Override
      public void addNotify() {
        super.addNotify();
      }

      @Override
      public Container getParent() {
        Container p = super.getParent();
        if (p instanceof CellRendererPane) {
          p = p.getParent();
          if (p instanceof JMenuBarButton) {
            return p.getParent();
          }
        }
        return p;
      }
    };
    menu.setModel(new DefaultButtonModel());
    menu.setAction(getAction());
    menu.setText(getText());
    menu.setIcon(getIcon());
    menu.setMnemonic(getMnemonic());
    menu.setToolTipText(getToolTipText());
    menu.setBounds(0, 0, 0, 0);

    setOpaque(menu.isOpaque());
    setBorder(BorderFactory.createEmptyBorder());
    setLayout(new BorderLayout());
    setBorderPainted(false);

    add(rendererPane = new CellRendererPane(), BorderLayout.CENTER);
    rendererPane.add(menu);
  }

  // -------------------------------------------------------------------------
  // Tweak painting
  // -------------------------------------------------------------------------

  /**
   * Creates a new <code>JMenuBarButton</code> with an action.
   * 
   * @param a the action
   */
  public JMenuBarButton(Action a) {
    this();
    setAction(a);
  }

  /**
   * Creates a new <code>JMenuBarButton</code> with an icon.
   * 
   * @param icon the icon
   */
  public JMenuBarButton(Icon icon) {
    this();
    setIcon(icon);
  }

  /**
   * Creates a new <code>JMenuBarButton</code> with text and icon.
   * 
   * @param text the text
   * @param icon the icon
   */
  public JMenuBarButton(String text, Icon icon) {
    this();
    setText(text);
    setIcon(icon);
  }

  /**
   * Creates a new <code>JMenuBarButton</code> with a text.
   * 
   * @param text the text
   */
  public JMenuBarButton(String text) {
    this();
    setText(text);
  }

  // -------------------------------------------------------------------------
  // Custom painting
  // -------------------------------------------------------------------------

  @Override
  protected void paintBorder(Graphics g) {}

  @Override
  protected void paintChildren(Graphics g) {}

  @Override
  protected void paintComponent(Graphics g) {
// super.paintComponent(g);
    if (menu != null) {
      rendererPane.paintComponent(g, configureRendererComponent(), this, 0,
            0, getWidth(), getHeight(), true);
    }
  }

  private JMenu configureRendererComponent() {
    final ButtonModel menuModel = menu.getModel();
    final ButtonModel myModel = getModel();
    menuModel.setEnabled(myModel.isEnabled());
    menuModel.setPressed(myModel.isPressed());
    // Menu is selected if button is pressed
    menuModel.setSelected(myModel.isPressed());
    // Don't arm the model; SynthLFs don't like that
    // menuModel.setArmed(myModel.isArmed());
    menuModel.setRollover(myModel.isRollover());

    menu.setIcon(getIcon());
    menu.setDisabledIcon(getDisabledIcon());
    menu.setDisabledSelectedIcon(getDisabledSelectedIcon());
    menu.setSelectedIcon(getSelectedIcon());

    menu.setIconTextGap(getIconTextGap());
    menu.setText(getText());
    menu.setMnemonic(getMnemonic());
    menu.setDisplayedMnemonicIndex(getDisplayedMnemonicIndex());
    menu.setEnabled(isEnabled());
    menu.setComponentOrientation(getComponentOrientation());
    menu.setOpaque(isOpaque());
    return menu;
  }

  // -------------------------------------------------------------------------
  // Delegate Size getters to the menu
  // -------------------------------------------------------------------------

  @Override
  public Dimension getPreferredSize() {
    return menu != null
          ? configureRendererComponent().getPreferredSize()
          : super.getPreferredSize();
  }

  @Override
  public Dimension getMinimumSize() {
    return menu != null
          ? configureRendererComponent().getMinimumSize()
          : super.getMinimumSize();
  }

  @Override
  public Dimension getMaximumSize() {
    return menu != null
          ? configureRendererComponent().getMaximumSize()
          : super.getMaximumSize();
  }

  // -------------------------------------------------------------------------
  // Update the menu UI as well
  // -------------------------------------------------------------------------

  @Override
  public void updateUI() {
    super.updateUI();
    if (menu != null) {
      menu.updateUI();
    }
  }
}

Funktioniert augenscheinlich mit Metal-LAF, Nimbus-LAF (Snyth), CDE/Motif-LAF und GTK+-LAF. Hab kein Windows und keinen Mac zum Testen.

Happy Hacking!
Ebenius

 

[KrokoDiehl]

Sehr genial Ebenius!
Ich habe es mit noch einigen weiteren L&Fs getestet und die Nebeneffekte meiner Lösung sind damit behoben:
- keine unterschiedlichen Menübreiten mehr
- kein L&F-eigenes Aussehen für diese JButtons im Unterschied zu den JMenus
- Windows & Linux sind hier gleich

Einzig beim com.birosoft.liquid.LiquidLookAndFeel haben die JMenus noch einen MouseOver-Effekt. An dieser Stelle werde ich noch etwas probieren, aber das ist vernachlässigbar (wir wissen ja selbst noch nicht, welche L&Fs überhaupt benutzt werden sollen).

Also vielen Dank für die Lösung. Muss ich dir nun einen Teil meines Gehalts überweisen?

 

[Ebenius]

Einzig beim com.birosoft.liquid.LiquidLookAndFeel haben die JMenus noch einen MouseOver-Effekt. An dieser Stelle werde ich noch etwas probieren, aber das ist vernachlässigbar (wir wissen ja selbst noch nicht, welche L&Fs überhaupt benutzt werden sollen).

Eventuell musst Du noch dem Button sagen, er soll RollOverEnabled vom menu-Feld übernehmen.

Also vielen Dank für die Lösung. Muss ich dir nun einen Teil meines Gehalts überweisen?

Wie jetzt, einen Teil? ;-)

Ebenius