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?
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);
}
}
Blz…
Valew marcobiscaro2112.