Как отключить все компоненты в JPanel

Question

В моем JPanel у меня есть много компонентов, включая другие JPanels, JLabels, JTextAreas и JButtons. Becuase Я хочу реализовать режим учебника, в котором появляется другое окно, и все в моем основном JPanel отключено, так как новое окно объясняет каждую функцию «один за другим». Я хочу знать, как отключить все компоненты, находящиеся внутри моего origininal JPanel. Я знаю, что вы можете использовать:

component.setEnabled(false); 

Но я не хочу писать его для каждого компонента в моем JPanel. Я хотел бы знать, можно ли отключить ВСЕ компоненты в моей JPanel с циклом for или что-то еще?

Примечание: Есть также компонент в вложенном JPanel,, как заказ будет

Главной JPanel ---> Вложенные JPanel ---> Компонент

Я также хочу, чтобы Итоговые компоненты также будут отключены ...

Спасибо! Вся помощь приветствуется!

Answer 1

Отъезд Disabled Panel для нескольких решений.

Используется отключенный тип подхода GlassPane, а другой рекурсивно отключает компоненты, отслеживая состояние текущего компонента, чтобы его можно было включить позже.

Answer 2

JPanel - это контейнер. Контейнер имеет метод getComponents(). Вы должны проходить в дереве компонентов рекурсивно.
Если текущий ребенок также является контейнером (instanceof), вы можете сделать другой рекурсивный вызов, иначе вы просто вызываете setEnabled (false).

Answer 3

Некоторое время назад я реализовал решение с использованием JXLayer, которое использует его возможности эффекта блокировки для обеспечения «блокирующего» слоя над контейнером.

Он основан на JXLayer 3.x и использует фильтры из JHLabs генерировать это «серая шкала» эффект

import com.jhlabs.image.GrayscaleFilter; 
import java.awt.BorderLayout; 
import java.awt.Component; 
import java.awt.LayoutManager; 
import java.awt.RenderingHints; 
import java.util.ArrayList; 
import java.util.List; 
import java.util.Map; 
import javax.swing.JComponent; 
import javax.swing.JPanel; 
import org.jdesktop.jxlayer.JXLayer; 
import org.jdesktop.jxlayer.QualityHints; 
import org.jdesktop.jxlayer.plaf.BetterBufferedImageOpEffect; 
import org.jdesktop.jxlayer.plaf.LayerUI; 
import org.jdesktop.jxlayer.plaf.ext.LockableUI; 

public class CoreXPane extends JPanel { 

    private JXLayer<JPanel> layer; 
    private FadedLockUI fadedLockUI; 
    private JPanel pnlBody; 

    public CoreXPane(LayoutManager layout) { 

     super.setLayout(new BorderLayout()); 
     super.addImpl(getLayer(), BorderLayout.CENTER, 0); 

     setLayout(layout); 

    } 

    public CoreXPane() { 

     this(new BorderLayout()); 

    } 

    @Override 
    public void setEnabled(boolean enabled) { 

     getLockUI().setLocked(!enabled); 
     getBodyPane().setEnabled(enabled); 
     super.setEnabled(enabled); 

    } 

    @Override 
    protected void addImpl(Component comp, Object constraints, int index) { 

     getBodyPane().add(comp, constraints, index); 

    } 

    @Override 
    public void remove(int index) { 

     getBodyPane().remove(index); 

    } 

    @Override 
    public void removeAll() { 

     getBodyPane().removeAll(); 

    } 

    protected FadedLockUI getLockUI() { 

     if (fadedLockUI == null) { 

      fadedLockUI = new FadedLockUI(); 

     } 

     return fadedLockUI; 

    } 

    @Override 
    public void invalidate() { 

     getLockUI().invalidate(); 

     super.invalidate(); 

    } 

    @Override 
    public void revalidate() { 

     getLockUI().revalidate(); 
     super.revalidate(); 

    } 

    @Override 
    public void repaint() { 

     getLockUI().repaint(); 

     super.repaint(); 

    } 

    protected void getLayers(List<LayerUI> layers) { 

     layers.add(getLockUI()); 

    } 

    protected JXLayer<JPanel> getLayer() { 

     if (layer == null) { 

      List<LayerUI> layers = new ArrayList<LayerUI>(4); 
      getLayers(layers); 

      JComponent wrapper = getBodyPane(); 
      for (LayerUI ui : layers) { 

       wrapper = new JXLayer(wrapper, ui); 

      } 

      layer = (JXLayer<JPanel>) wrapper; 

     } 

     return layer; 

    } 

    @Override 
    public void setLayout(LayoutManager mgr) { 

     getBodyPane().setLayout(mgr); 

    } 

    @Override 
    public LayoutManager getLayout() { 

     return getBodyPane().getLayout(); 

    } 

    public JPanel getBodyPane() { 

     if (pnlBody == null) { 

      pnlBody = new JPanel(); 
      pnlBody.setLayout(new BorderLayout()); 

     } 

     return pnlBody; 

    } 

    @Override 
    public void setOpaque(boolean isOpaque) { 

     super.setOpaque(isOpaque); 
     getBodyPane().setOpaque(isOpaque); 

    } 

    public static class FadedLockUI extends LockableUI { 

     public static Map<RenderingHints.Key, Object> mapRenderHints = new QualityHints(); 

     public FadedLockUI() { 

      setLockedEffects(new BufferedImageOpEffect(new GrayscaleFilter())); 

      mapRenderHints.put(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY); // okay 
      mapRenderHints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); // bad 
      mapRenderHints.put(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY); // okay 
      mapRenderHints.put(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE); 
      mapRenderHints.put(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON); 
      mapRenderHints.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); 
      mapRenderHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY); 

     } 

     @Override 
     protected Map<RenderingHints.Key, Object> getRenderingHints(JXLayer<? extends JComponent> l) { 
      return mapRenderHints; 
     } 

     public void repaint() { 
      setDirty(true); 
     } 

     public void invalidate() { 
      setDirty(true); 
     } 

     public void revalidate() { 
      setDirty(true); 
     } 
    } 
} 

Посмотрите на LockableUI для получения более подробной информации

Answer 4

я использовал следующую функцию:

void setPanelEnabled(JPanel panel, Boolean isEnabled) { 
    panel.setEnabled(isEnabled); 

    Component[] components = panel.getComponents(); 

    for(int i = 0; i < components.length; i++) { 
     if(components[i].getClass().getName() == "javax.swing.JPanel") { 
      setPanelEnabled((JPanel) components[i], isEnabled); 
     } 

     components[i].setEnabled(isEnabled); 
    } 
} 

Answer 5

Легкий быстрый способ:

for (Component cp : yourPanle.getComponents()){ 
     cp.setEnabled(false); 
} 

Answer 6

Я просто сделал небольшой класс, который рекурсивно отключает все внутри данного Контейнера, а затем снова включает каждый компонент, который был отключен раньше (в обратном порядке). Он также позволяет исключить произвольные компоненты из режима отключения, добавленную функцию, потому что JLabels выглядят излишне уродливыми при отключении.

Работает как очарование. Поскольку проблема появляется достаточно часто, и я случайно увидел этот пост ранее сегодня, вот класс:

import java.awt.*; 
import java.util.ArrayList; 
import java.util.List; 

/** 
* Purpose: To recursively disable (and later re-enable) all components of a container, e.g. if you want to clearly show 
* that a program is busy or if you want to prevent clicks and other inputs that piled up meanwhile to affect a window 
* once the program becomes responsive again. Though the solution for that would be simpler: Just disable the window and 
* then, in a SwingUtilities.invokeLater(), re-enable it. This makes sure that before this happens, all input events are 
* eaten. 
*/ 
final public class EverythingDisablerAndReenabler { // v[1, 2016-12-05 14!30 UTC] by dreamspace-president.com 

    final private Container rootContainerForWhatShouldBeDisabled; 
    final private Class<?>[] componentClassesToBeIgnored; 
    final private List<Component> componentsToReenable = new ArrayList<>(); 

    private boolean disableHasBeenCalled = false; // Order is strictly upheld via IllegalStateException! 

    /** 
    * @param rootContainerForWhatShouldBeDisabled NOT NULL! The Container whose components are to be recursively 
    *            disabled. The container itself will not be disabled. 
    * @param componentClassesToBeIgnored   null or an array of classes (e.g. containing JLabel.class) that 
    *            should be excluded from disabling. Adding a Container here does not 
    *            affect the recursive process. 
    * @throws IllegalArgumentException if the container argument is null. In case someone wonders why I don't use 
    *         {@link NullPointerException} here: Null can be a perfectly legal argument in 
    *         other places, but here, it is not. If an argument does not check out, the choice 
    *         of Exception, of course, is IllegalArgument, not NullPointer. 
    */ 
    public EverythingDisablerAndReenabler(final Container rootContainerForWhatShouldBeDisabled, final Class<?>[] componentClassesToBeIgnored) { 

     if (rootContainerForWhatShouldBeDisabled == null) { 
      throw new IllegalArgumentException(); 
     } 
     this.rootContainerForWhatShouldBeDisabled = rootContainerForWhatShouldBeDisabled; 
     this.componentClassesToBeIgnored = componentClassesToBeIgnored; 
    } 

    /** 
    * Disables everything recursively, except the excluded types. 
    * 
    * @throws IllegalStateException if called twice in a row. 
    */ 
    public void disable() { 

     if (disableHasBeenCalled) { 
      throw new IllegalStateException(); 
     } 
     disableHasBeenCalled = true; 
     componentsToReenable.clear(); 
     disableEverythingInsideThisHierarchically(rootContainerForWhatShouldBeDisabled); 
    } 

    /** 
    * @throws IllegalStateException if called twice in a row or if disable() had not been called yet. 
    */ 
    public void reenable() { 

     if (!disableHasBeenCalled) { 
      throw new IllegalStateException(); 
     } 
     disableHasBeenCalled = false; 

     for (int i = componentsToReenable.size() - 1; i >= 0; i--) { 
      componentsToReenable.get(i).setEnabled(true); 
     } 
     componentsToReenable.clear(); 
    } 

    private void disableEverythingInsideThisHierarchically(final Container container) { 

     final Component[] components = container.getComponents(); 
     for (Component component : components) { 

      if (component != null) { 

       // RECURSION FIRST 
       if (component instanceof Container) { 
        disableEverythingInsideThisHierarchically((Container) component); 
       } 

       // AND THEN DEAL WITH THE ELEMENTS 
       if (component.isEnabled()) { 
        boolean found = false; 
        if (componentClassesToBeIgnored != null) { 
         for (Class<?> cls : componentClassesToBeIgnored) { 
          if (component.getClass() == cls) { 
           found = true; 
           break; 
          } 
         } 
        } 
        if (!found) { 
         component.setEnabled(false); 
         componentsToReenable.add(component); 
        } 
       } 
      } 
     } 
    } 


}