JList - Part 2

This example will show us how to select more than one thing on the list, and how the Event Listener deals with this.

There are three 'Selection Modes' the JList can be in.

SINGLE_SELECTION - This allows you to only select one item in the list at once.
SINGLE_INTERVAL_SELECTION - This allows you to select more than one item, as long as they are adjacent in the list. You cannot skip an item in the list.
MULTIPLE_INTERVAL_SELECTION - This lets you select any item you want. Go crazy!

In this example we will attempt the 'Big Kahuna' and go for the MULTIPLE_INTERVAL_SELECTION. Woo!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.Color;
import java.awt.event.*;

public class ListExample_Extended implements  ListSelectionListener{

    JList boxes;
    JPanel[] boxArray = new JPanel[10];
    
    public JPanel createContentPane (){
        
        JPanel totalGUI = new JPanel();
        
        // Array for the names to be in the list.
        String names[] = {"Red", "Blue", "Green", "Orange", "Yellow",
                          "Pink", "Cyan", "Gray", "Black", "Magenta"};
        
        // Creation of the list.
        // We set the cells in the list to be 20px x 140px.
        // And set the 'selection mode' to MULTIPLE! Woo, BigKahuna!
        // We finish by adding an event listener for the List.
        
        boxes = new JList(names);
        boxes.setVisibleRowCount(10);
        boxes.setFixedCellHeight(20);
        boxes.setFixedCellWidth(140);
        boxes.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
        boxes.addListSelectionListener(this);
        
        // We create a JPanel with the GridLayout.
        JPanel mainPanel = new JPanel(new GridLayout(3, 4, 10, 30));

        boxArray[0] = createSquareJPanel(Color.red, 50);
        boxArray[1] = createSquareJPanel(Color.blue, 50);
        boxArray[2] = createSquareJPanel(Color.green, 50);
        boxArray[3] = createSquareJPanel(Color.orange, 50);
        boxArray[4] = createSquareJPanel(Color.yellow, 50);
        boxArray[5] = createSquareJPanel(Color.pink, 50);
        boxArray[6] = createSquareJPanel(Color.cyan, 50);
        boxArray[7] = createSquareJPanel(Color.gray, 50);
        boxArray[8] = createSquareJPanel(Color.black, 50);
        boxArray[9] = createSquareJPanel(Color.magenta, 50);
        
        // This sets every JPanel in the array to be hidden,
        // and then adds it to the mainPanel JPanel.
        
        for(int i = 0; i < 10; i++)
        {
            boxArray[i].setVisible(false);
            mainPanel.add(boxArray[i]);
        }
        
        // This final bit of code uses a BoxLayout to space out the widgets
        // in the GUI.
        
        JPanel bottomPanel = new JPanel();
        bottomPanel.setLayout(new BoxLayout(bottomPanel, BoxLayout.LINE_AXIS));
        
        bottomPanel.add(Box.createRigidArea(new Dimension(10,0)));
        bottomPanel.add(boxes);
        bottomPanel.add(Box.createRigidArea(new Dimension(10,0)));
        bottomPanel.add(mainPanel);
        bottomPanel.add(Box.createRigidArea(new Dimension(10,0)));
        
        totalGUI.add(bottomPanel);
        totalGUI.setOpaque(true);
        return totalGUI;
    }

    // In this method, we create a square JPanel of a colour and set size
    // specified by the arguments.

    private JPanel createSquareJPanel(Color color, int size) {
        JPanel tempPanel = new JPanel();
        tempPanel.setBackground(color);
        tempPanel.setMinimumSize(new Dimension(size, size));
        tempPanel.setMaximumSize(new Dimension(size, size));
        tempPanel.setPreferredSize(new Dimension(size, size));
        return tempPanel;
    }

    // valueChanged is the method that deals with a ListSelectionEvent.
    // This simply changes the boxes that are selected to true.

    public void valueChanged(ListSelectionEvent e) {

        if (e.getValueIsAdjusting() == false) {
            if (e.getSource() == boxes) {
            
            int[] fromindex = itemList.getSelectedIndices();
            
                for(int i = 0; i < 10; i++)
                {
                    boxArray[i].setVisible(false);
                } 
                for(int i = 0; i < fromindex.length; i++)
                {
                    boxArray[fromindex[i]].setVisible(true);
                }
            }
        }
    }

    private static void createAndShowGUI() {

    JFrame.setDefaultLookAndFeelDecorated(true);
        JFrame frame = new JFrame("[=] JListExample [=]");

        ListExample_Extended demo = new ListExample_Extended();
        frame.setContentPane(demo.createContentPane());
        
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }
}

There are only two changes from the example in the last section, and they are very very small.

The selection mode has changed from SINGLE_SELECTION to MULTIPLE_INTERVAL_SELECTION.

29	boxes.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

The valueChanged method has changed to accept more than one selected index. Instead of just getting one index by using the command getSelectedIndex(), we need to get more than one, so we use the command getSelectedIndices() to get an array of indices (plural of index).

So we set all the boxes to be hidden, then set the boxes of the selections to be shown.

94
95
96
97
98
99
100
101

                for(int i = 0; i < 10; i++)
                {
                    boxArray[i].setVisible(false);
                } 
                for(int i = 0; i < fromindex.length; i++)
                {
                    boxArray[fromindex[i]].setVisible(true);
                }

Run this code, and see how it differs from the last program. (Hold Shift to select a group of cells, and Hold Ctrl to select a single cell)
GUI Picture

That's how we deal with more than one selection at once. Now we want to look at adding and removing items from a list.