JToolBar ein/ausblenden

[cr3m4]

Hallo Leute,

doofe Frage, wie aktiviere, bzw deaktiviere ich ne JToolBar?

ich habe ein Menü mit CheckboxMenuItems für die Abfrage welche JToolBar angezeigt werden soll.
Also wie z.b. in Office unter "Ansicht-Symbolleisten".

Bei der Abfrage passiert jedoch leider nichts.

Hier mein bishheriger Lösungsansatz:

public void getToolBarState(char t, boolean b)
		{
			switch(t)
			{
			case 'f':
                                {
				jToolBar1.setVisible(b); 
                                jToolBar1.setEnabled(b);
			        }
			}
			
		}

wenn ich eine Ausgabe von 'b' im case-zweig mache, wird mir true/false auch angezeigt, also an der wertübergabe liegts nicht.

Gibts ne spezielle Methode für Toolbars?

danke

 

[L-ectron-X]

Die setVisible()-Methode ist dafür schon richtig. Damit kannst du die JToolBar sichtbar oder unsichtbar machen.

 

[Gast]

Und vielleicht noch das ganze (re)validieren... mit validate() bzw revalidate()

 

[cr3m4]

also ich habe setenabled, setvisible auf false gesetzt, validated, revalidated, repainted, komponente removed, alles ohne erfolg. selbst wenn ich das komplette Panel mit den Toolbars entfernen will, funzt dat nit.

hier mal etwas code, vielleicht habt ihr so nen besseren überblick:

Frame zur Darstellung:

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;

import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;
import javax.swing.border.BevelBorder;

public class Fenster extends javax.swing.JFrame {
   private static final long   serialVersionUID   = 1L;
   
   private StdMenu std_jMenuBar=new StdMenu();
   private JPanel jPanel2;
   private JPanel jPanel1;
   private ButtonPanel buttonPanel1;
   private JPanel center_jPanel;
   private JPanel top_jPanel;

   /***Main-Methode***/
   public static void main(String[] args) {
      SwingUtilities.invokeLater(new Runnable() {
         public void run() {
        		 Fenster inst = new Fenster();
            inst.setLocationRelativeTo(null);
            inst.setVisible(true);
         }
      });
   }
   /***Ende Main-Methode***/
   
   public Fenster() {
      super();
      initGUI();
   }
   
   private void initGUI() {
      try {
         setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
         this.setPreferredSize(new java.awt.Dimension(800, 600));

            {
               top_jPanel = new JPanel();
               BorderLayout top_jPanelLayout = new BorderLayout();
               top_jPanel.setLayout(top_jPanelLayout);
               getContentPane().add(top_jPanel, BorderLayout.NORTH);
               top_jPanel.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
               top_jPanel.setPreferredSize(new java.awt.Dimension(10, 42));
               top_jPanel.add(getButtonPanel1(), BorderLayout.CENTER);
               top_jPanel.add(getJPanel1(), BorderLayout.NORTH);
               top_jPanel.add(getJPanel2(), BorderLayout.SOUTH);
            }
               {
                  center_jPanel = new JPanel();
                  getContentPane().add(center_jPanel, BorderLayout.CENTER);
               }
            {   
               setJMenuBar(std_jMenuBar.getStd_jMenuBar("bafdlespvwh"));
   
            }
         pack();
         this.setSize(800, 600);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
   
   private ButtonPanel getButtonPanel1() {
         
         buttonPanel1 = new ButtonPanel();
         BoxLayout buttonPanel1Layout = new BoxLayout(buttonPanel1, javax.swing.BoxLayout.X_AXIS);
         
         buttonPanel1.setLayout(buttonPanel1Layout);
         buttonPanel1.setButtonGroupEnabled("h");
         
         return buttonPanel1;
   }
   
   private JPanel getJPanel1() {
         if(jPanel1 == null) {
            jPanel1 = new JPanel();
            jPanel1.setPreferredSize(new java.awt.Dimension(10, 2));
         }
         return jPanel1;
   }
   
   private JPanel getJPanel2() {
         if(jPanel2 == null) {
            jPanel2 = new JPanel();
            jPanel2.setPreferredSize(new java.awt.Dimension(10, 2));
         }
         return jPanel2;
   }
   /**!***/ 
   private ButtonPanel removeButtonPanel1() {
         
         remove(buttonPanel1);
         
         buttonPanel1.setButtonGroupEnabled("");
         
         buttonPanel1.setEnabled(false);
         buttonPanel1.setVisible(false);
         
         buttonPanel1.revalidate();
         
         return buttonPanel1;
   }
   /**!***/ 
   public void setToolBarStatus(boolean b)
      {
         
         if(!b)
         removeButtonPanel1();
         
         System.out.println("deleted");  //der text wird ausgegeben, also der Methodenaufruf funktioniert.
      }
         
}

Das Toolbar:

class ButtonPanel extends javax.swing.JPanel {
 
 /**
	 * 
	 */
	private static final long	serialVersionUID	= 1L;
private JToolBar      haupt_JToolBar;
 private JButton         ersterButton;
 private JButton       zweiterButton;
 private JPanel 		jPanel1;

/** Da ich die Klassen in unterschiedlichen Fenstern verwende, lege ich somit fest welche Panels dargestellt werden **/
public void setButtonGroupEnabled(String tb)   //h für hauptToolbar,
    {         
       char menuAdd[]=new char[tb.length()];
       for(int i=0;i<tb.length();i++)
       {
       menuAdd[i]=tb.charAt(i);
       
       if(menuAdd[i]=='h')
          jPanel1.add(getHaupt_JToolBar());

       jPanel1.revalidate(); repaint();
       }
    }

public ButtonPanel()
    {
       BorderLayout thisLayout = new BorderLayout();

       this.setLayout(thisLayout);
       this.setPreferredSize(new java.awt.Dimension(535, 37));
       this.setSize(535, 30);
       this.add(getJPanel1(), BorderLayout.CENTER);

       return;
    }

private JToolBar getHaupt_JToolBar()
    {
       haupt_JToolBar = new JToolBar();
       GridLayout haupt_JPanelLayout = new GridLayout(1, 1);
       haupt_JPanelLayout.setVgap(0);
       haupt_JPanelLayout.setColumns(1);
       haupt_JPanelLayout.setHgap(5);
       haupt_JToolBar.setLayout(haupt_JPanelLayout);
       haupt_JToolBar.setPreferredSize(new java.awt.Dimension(198, 30));
       haupt_JToolBar.add(getErsterButton());
       haupt_JToolBar.add(getZweiterButton());

       return haupt_JToolBar;
    }

private JButton getErsterButton()
    {
       ersterButton = new JButton();
       ersterButton.setToolTipText("nr1");
       ersterButton.setPreferredSize(new java.awt.Dimension(25, 25));
       return ersterButton;
    }

private JButton getZweiterButton()
    {
       zweiterButton = new JButton();
       zweiterButton .setToolTipText("nr2");
       zweiterButton .setPreferredSize(new java.awt.Dimension(25, 25));
       return zweiterButton ;
    }




private JPanel getJPanel1() {
       if(jPanel1 == null) {
          jPanel1 = new JPanel();
          FlowLayout jPanel1Layout = new FlowLayout();
          jPanel1Layout.setAlignment(FlowLayout.LEFT);
          jPanel1Layout.setVgap(2);
          jPanel1Layout.setHgap(10);
          jPanel1.setLayout(jPanel1Layout);
          jPanel1.setPreferredSize(new java.awt.Dimension(455, 24));
                              //siehe SetButtonGroupEnabled
       }
       return jPanel1;
 } 
    }

Menüleiste:

Klasse Standardmenü

class StdMenu extends JMenuBar
{
 private static final long   serialVersionUID   = 1L;
 
 private JMenuBar std_jMenuBar;
 private JMenu ansicht_Menu;
 private JMenu toolbar_Menu;
 private AbstractAction popupMenu_abstractAction;

      private JCheckBoxMenuItem hauptToolbarMenuItem;

public JMenuBar getStd_jMenuBar(String getmenu)
    {
       std_jMenuBar= new JMenuBar();

       std_jMenuBar.add(getAnsicht_Menu());
          
       return std_jMenuBar;
    }

private JMenu getAnsicht_Menu()
    {
       ansicht_Menu=new JMenu();
       ansicht_Menu.setText("Ansicht");
       
       ansicht_Menu.add(getToolbar_Menu());

       return ansicht_Menu;
       
    }

private JMenu getToolbar_Menu()
    {
       toolbar_Menu=new JMenu();
       toolbar_Menu.setText("Symbolleisten");
       toolbar_Menu.add(getHauptToolbarMenuItem());
       
       return toolbar_Menu;
    }

private JCheckBoxMenuItem getHauptToolbarMenuItem()
    {
       hauptToolbarMenuItem=new JCheckBoxMenuItem();
       hauptToolbarMenuItem.setText("HauptLeiste");
       hauptToolbarMenuItem.addActionListener(getPopupMenu_abstractAction());
       
       return hauptToolbarMenuItem;
    }

/***********************************************************/
private AbstractAction getPopupMenu_abstractAction() {
       if(popupMenu_abstractAction == null) {
          popupMenu_abstractAction = new AbstractAction("", null) {

                private static final long   serialVersionUID   = 1L;

                public void actionPerformed(ActionEvent evt) {

                                       /**Hier wird die Methode zum Panel-Deaktivieren aufgerufen.**/
                                              if(evt.getSource()==hauptToolbarMenuItem)
                      {
        /**!***/                       new Fenster().setToolBarStatus(hauptToolbarMenuItem.isSelected());

                      }
                }
          };
       }
       return popupMenu_abstractAction;
 }
}

 

[thE_29]

Dir ist schon klar das du immer ein komplett neues Fenster/JFrame Objekt erzeugst wenn du new Fenster() sagst?
Und somist du eine falsche Referenz wegblendest?

 

[cr3m4]

hmm, stimmt. aber wie ruf ich ne Methode die in der Hauptklasse angesiedelt ist in na Nebenklasse auf, ohne dass sich die Hauptklasse immerwieder selber aufruft? Da hab ich glaub ich grad nen Denkfehler

 

[thE_29]

Entweder via dem Singleton Pattern oder du übergibst deiner Toolbar Klasse die Referenz zu dem Fenster!

Eventuell würde mach auch via getTopLevelAncestor() drankommen!