JList + JCheckBox + desabilitar os checks

Java Ninja Membro desde: 21/12/2006 19:15:48 Mensagens: 256 Offline

Olá pessoal....

Estou com um problema na utilização de um JList que é o seguinte:

Tenho um JList com JCheckbox que vem de um banco de dados. Imaginem a sequinte situação:

Ao carregar a tela é mostrado 5 JCheckBox. Até aí tudo bem;
Ao clicar no 1° eu gostaria de desabilitar o 3° JCheckBox. "Aí está o problema"

Resumindo: ao clicar em um determinado check preciso validar quais dos demais checks poderão estar habilitados.

Como posso proceder? já procurei em vários lugares e não consigo encontrar nada que faça isto.

Obrigado

Não consegui entender muito bem a estrutura de seus componentes. Você tem um JList e dentro dele tem JCheckBox? É isso mesmo?

Java Ninja Membro desde: 21/12/2006 19:15:48 Mensagens: 256 Offline

Isso aí..... não estou com o exemplo em mão com o código aqui, mas este aí em baixo é parecido com o que fiz.
O problema é que ao clicar em um check preciso desabilitar outros.
obs.: peguei este na net.,...

import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;
import java.awt.event.*;
 
public class JCheckBoxList extends JList
{
    protected static Border noFocusBorder = new EmptyBorder(1, 1, 1, 1);
 
    public JCheckBoxList()
    {
        setCellRenderer(new CheckBoxCellRenderer());
 
        addMouseListener(new MouseAdapter()
        {
            public void mousePressed(MouseEvent e)
            {
                int index = locationToIndex(e.getPoint());
                if (index != -1)
                {
                    JCheckBox checkbox = (JCheckBox) getModel().getElementAt(index);
                    checkbox.setSelected(!checkbox.isSelected());
                    repaint();
                }
            }
        });
 
        addKeyListener(new KeyAdapter()
        {
            public void keyPressed(KeyEvent e)
            {
                if (e.getKeyCode() == KeyEvent.VK_SPACE)
                {
                    int index = getSelectedIndex();
                    if (index != -1)
                    {
                        JCheckBox checkbox = (JCheckBox) getModel().getElementAt(index);
                        checkbox.setSelected(!checkbox.isSelected());
                        repaint();
                    }
                }
            }
        });
 
        setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    }
 
    protected class CheckBoxCellRenderer implements ListCellRenderer
    {
        public Component getListCellRendererComponent(JList list, Object value, int index,
                                                      boolean isSelected, boolean cellHasFocus)
        {
            JCheckBox checkbox = (JCheckBox) value;
            checkbox.setBackground(isSelected ? getSelectionBackground() : getBackground());
            checkbox.setForeground(isSelected ? getSelectionForeground() : getForeground());
 
            checkbox.setEnabled(isEnabled());
			checkbox.setFont(getFont());
            checkbox.setFocusPainted(false);
 
            checkbox.setBorderPainted(true);
            checkbox.setBorder(isSelected ? UIManager.getBorder("List.focusCellHighlightBorder") : noFocusBorder);

return checkbox;
        }
    }
 
 
    public static void main(String args[])
    {
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().setLayout(new BorderLayout());
 
        JCheckBoxList cbList = new JCheckBoxList();
 
		JCheckBox check = new JCheckBox("one");
		Object[] cbArray = new Object[3];
        cbArray[0] = check;
        cbArray[1] = new JCheckBox("two");
        cbArray[2] = new JCheckBox("three");
		
        cbList.setListData(cbArray);
 
        frame.getContentPane().add(cbList);
        frame.pack();
        frame.setVisible(true);
    }
}

Com base nisso, colocando algumas modificações, criei um Model específico e nele há métodos para controle (você pode criar outros depois). No método main tem um exemplo:

import java.awt.Component;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.swing.AbstractListModel;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.ListCellRenderer;
import javax.swing.ListModel;
import javax.swing.ListSelectionModel;
import javax.swing.WindowConstants;

public class JCheckBoxList extends JList {

/**
	 * Classe que renderizará os componentes (nesse caso, JCheckBox).
	 */
	protected class CheckBoxCellRenderer implements ListCellRenderer {

public Component getListCellRendererComponent(JList list, Object value,
				int index, boolean isSelected, boolean cellHasFocus) {
			JCheckBox checkbox = (JCheckBox) value;
			checkbox.setBackground(isSelected ? list.getSelectionBackground()
					: list.getBackground());
			checkbox.setForeground(isSelected ? list.getSelectionForeground()
					: list.getForeground());
			checkbox.setFont(list.getFont());
			if (!list.isEnabled()) {
				checkbox.setEnabled(false);
			}
			return checkbox;
		}

}

/**
	 * Nosso modelo. Ele tratará os JCheckBox'es.
	 */
	public class CheckBoxListModel extends AbstractListModel {

private static final long serialVersionUID = 1L;
		// os checkBoxes que teremos
		private List<JCheckBox> checkBoxes;

/**
		 * Cria um modelo a partir do List de JCheckBox passado.
		 * 
		 * @param checks
		 *            o List de JCheckBox que o modelo conterá
		 */
		public CheckBoxListModel(List<JCheckBox> checks) {
			checkBoxes = new ArrayList<JCheckBox>(checks);
		}

/**
		 * Adiciona um novo JCheckBox.
		 * 
		 * @param checkBox
		 *            o JCheckBox a ser adicionado
		 */
		public void add(JCheckBox checkBox) {
			checkBoxes.add(checkBox);
			fireIntervalAdded(this, checkBoxes.size() - 1,
					checkBoxes.size() - 1);
		}

/**
		 * Altera o valor de seleção do JCheckBox do índice passado.
		 * 
		 * @param index
		 *            o índice jo JCheckBox que será alternado
		 */
		public void changeCheckBoxSelecionAt(int index) {
			if (index == -1) {
				return;
			}
			JCheckBox checkBox = checkBoxes.get(index);
			checkBox.doClick();
			fireContentsChanged(this, index, index);
		}

public void setCheckBoxSelectionAt(int index, boolean selected) {
			if (index == -1) {
				return;
			}
			JCheckBox checkBox = checkBoxes.get(index);
			checkBox.setSelected(selected);
			fireContentsChanged(this, index, index);
		}

/**
		 * Remove todos os JCheckBox.
		 */
		public void clear() {
			int size = getSize();
			checkBoxes.clear();
			fireIntervalRemoved(this, 0, size - 1);
		}

public JCheckBox get(int index) {
			return checkBoxes.get(index);
		}

/**
		 * @return uma cópia do List de JCheckBox que está sendo usado.
		 */
		public List<JCheckBox> getCheckBoxes() {
			return new ArrayList<JCheckBox>(checkBoxes);
		}

@Override
		public Object getElementAt(int index) {
			return checkBoxes.get(index);
		}

@Override
		public int getSize() {
			return checkBoxes.size();
		}

/**
		 * Verifica o índice de determinado JCheckBox.
		 * 
		 * @param checkBox
		 *            o JCheckBox a ser verificado
		 * @return o índice dele no Model
		 */
		public int indexOf(JCheckBox checkBox) {
			return checkBoxes.indexOf(checkBox);
		}

/**
		 * Remove o JCheckBox do índice específico.
		 * 
		 * @param index
		 *            o índice do JCheckBox a ser removido
		 */
		public void remove(int index) {
			checkBoxes.remove(index);
			fireIntervalRemoved(this, index, index);
		}

/**
		 * Ativa ou desativa o JCheckBox no índice especificado.
		 * 
		 * @param index
		 * @param enabled
		 */
		public void setCheckBoxAtEnabled(int index, boolean enabled) {
			checkBoxes.get(index).setEnabled(enabled);
			fireContentsChanged(this, index, index);
		}

}

private static final long serialVersionUID = 1L;
	private CheckBoxListModel checkBoxListModel;

/**
	 * Construtor alternativo para facilitar a chamada.
	 * 
	 * @param checkBoxes
	 *            os JCheckBox que serão usados
	 */
	public JCheckBoxList(JCheckBox... checkBoxes) {
		this(Arrays.asList(checkBoxes));
	}

/**
	 * Construtor padrão. Cria um JCheckBoxList que conterá todos os JCheckBox
	 * que estão na List.
	 * 
	 * @param checks
	 *            os JCheckBox que serão usados.
	 */
	public JCheckBoxList(List<JCheckBox> checks) {
		// cria nosso modelo próprio
		checkBoxListModel = new CheckBoxListModel(checks);
		// e usa o CellRenderer e o ListModel que criamos
		setCellRenderer(new CheckBoxCellRenderer());
		setModel(checkBoxListModel);
		// adiciona os Listeners que mudam a seleção do JCheckBox
		addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(MouseEvent e) {
				int index = locationToIndex(e.getPoint());
				checkBoxListModel.changeCheckBoxSelecionAt(index);
			}
		});
		addKeyListener(new KeyAdapter() {
			@Override
			public void keyPressed(KeyEvent e) {
				if (e.getKeyCode() == KeyEvent.VK_SPACE) {
					int index = getSelectedIndex();
					checkBoxListModel.changeCheckBoxSelecionAt(index);
				}
			}
		});
		// e permite seleção única
		setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
	}

@Override
	public CheckBoxListModel getModel() {
		return checkBoxListModel;
	}

/**
	 * Sobreescrita de setModel, permitindo apenas instâncias de
	 * CheckBoxListModel para nosso JList.
	 * 
	 * @throws IllegalArgumentException
	 *             se o model passado não for instância de CheckBoxListModel
	 */
	@Override
	public void setModel(ListModel model) throws IllegalArgumentException {
		if (!(model instanceof CheckBoxListModel)) {
			throw new IllegalArgumentException(
					"The model must be a CheckBoxCellRender instance.");
		}
		checkBoxListModel = (CheckBoxListModel) model;
		super.setModel(model);
	}

/**
	 * Somente para testes.
	 */
	public static void main(String args[]) {
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);

JCheckBox one = new JCheckBox("one");
		final JCheckBoxList cbList = new JCheckBoxList(one,
				new JCheckBox("two"), new JCheckBox("three"));
		// para alterar valores, adicionamos um Listener que escuta quanto o
		// JCheckBox é pressionado e faz as ações abaixo:
		one.addItemListener(new ItemListener() {

@Override
			public void itemStateChanged(ItemEvent e) {
				// alterna a seleção do check box do índice 1
				cbList.getModel().setCheckBoxAtEnabled(1,
						!cbList.getModel().get(1).isEnabled());
				// altera o enabled do check box do índice 2
				cbList.getModel().changeCheckBoxSelecionAt(2);
			}

});
		frame.add(cbList);
		frame.pack();
		frame.setVisible(true);
	}

}

Java Ninja Membro desde: 21/12/2006 19:15:48 Mensagens: 256 Offline

Blz.....
Valew marcobiscaro2112.

Notícias, artigos e o maior fórum brasileiro sobre Java