Merge branch 'subtree'
[nikiroo-utils.git] / src / be / nikiroo / utils / ui / ListModel.java
CommitLineData
a917f100
NR
1package be.nikiroo.utils.ui;
2
3import java.awt.Component;
4import java.awt.Point;
5import java.awt.event.MouseAdapter;
6import java.awt.event.MouseEvent;
7import java.util.ArrayList;
8import java.util.Collection;
9import java.util.List;
10
11import javax.swing.JList;
12import javax.swing.JPopupMenu;
13import javax.swing.ListCellRenderer;
14
15import be.nikiroo.utils.compat.DefaultListModel6;
16import be.nikiroo.utils.compat.JList6;
17import be.nikiroo.utils.compat.ListCellRenderer6;
18
19/**
20 * A {@link javax.swing.ListModel} that can maintain 2 lists; one with the
21 * actual data (the elements), and a second one with the items that are
22 * currently displayed (the items).
23 * <p>
24 * It also offers filter options, supports hovered changes and some more utility
25 * functions.
26 *
27 * @author niki
28 *
29 * @param <T>
30 * the type of elements and items (the same type)
31 */
32public class ListModel<T> extends DefaultListModel6<T> {
33 private static final long serialVersionUID = 1L;
34
35 /**
36 * A filter interface, to check for a condition (note that a Predicate class
37 * already exists in Java 1.8+, and is compatible with this one if you
38 * change the signatures -- but I support java 1.6+).
39 *
40 * @author niki
41 *
42 * @param <T>
43 * the type of elements and items (the same type)
44 */
45 public interface Predicate<T> {
46 /**
47 * Check if an item or an element pass a filter.
48 *
49 * @param item
50 * the item to test
51 *
52 * @return TRUE if the test passed, FALSE if not
53 */
54 public boolean test(T item);
55 }
56
57 /**
58 * A simple interface your elements must implement if you want to use
59 * {@link ListModel#generateRenderer(ListModel)}.
60 *
61 * @author niki
62 */
63 public interface Hoverable {
64 /**
65 * The element is currently selected.
66 *
67 * @param selected
68 * TRUE for selected, FALSE for unselected
69 */
70 public void setSelected(boolean selected);
71
72 /**
73 * The element is currently under the mouse cursor.
74 *
75 * @param hovered
76 * TRUE if it is, FALSE if not
77 */
78 public void setHovered(boolean hovered);
79 }
80
81 private int hoveredIndex;
82 private List<T> items = new ArrayList<T>();
f2573c37 83 private boolean keepSelection = true;
a917f100 84
b489d804
NR
85 @SuppressWarnings("rawtypes") // JList<?> not compatible Java 1.6
86 private JList list;
87
a917f100
NR
88 /**
89 * Create a new {@link ListModel}.
90 *
91 * @param list
b489d804 92 * the {@link JList6} we will handle the data of (cannot be NULL)
a917f100 93 */
b489d804
NR
94 @SuppressWarnings("rawtypes") // JList<?> not compatible Java 1.6
95 public ListModel(JList6<T> list) {
96 this((JList) list);
a917f100
NR
97 }
98
99 /**
100 * Create a new {@link ListModel}.
101 *
102 * @param list
b489d804 103 * the {@link JList6} we will handle the data of (cannot be NULL)
a917f100
NR
104 * @param popup
105 * the popup to use and keep track of (can be NULL)
106 */
b489d804
NR
107 @SuppressWarnings("rawtypes") // JList<?> not compatible Java 1.6
108 public ListModel(final JList6<T> list, final JPopupMenu popup) {
109 this((JList) list, popup);
a917f100
NR
110 }
111
112 /**
113 * Create a new {@link ListModel}.
b489d804
NR
114 * <p>
115 * Note that you must take care of passing a {@link JList} that only handles
116 * elements of the type of this {@link ListModel} -- you can also use
117 * {@link ListModel#ListModel(JList6)} instead.
a917f100
NR
118 *
119 * @param list
b489d804
NR
120 * the {@link JList} we will handle the data of (cannot be NULL,
121 * must only contain elements of the type of this
122 * {@link ListModel})
a917f100 123 */
b489d804
NR
124 @SuppressWarnings("rawtypes") // JList<?> not compatible Java 1.6
125 public ListModel(JList list) {
a917f100
NR
126 this(list, null);
127 }
128
129 /**
130 * Create a new {@link ListModel}.
b489d804
NR
131 * <p>
132 * Note that you must take care of passing a {@link JList} that only handles
133 * elements of the type of this {@link ListModel} -- you can also use
134 * {@link ListModel#ListModel(JList6, JPopupMenu)} instead.
a917f100
NR
135 *
136 * @param list
b489d804
NR
137 * the {@link JList} we will handle the data of (cannot be NULL,
138 * must only contain elements of the type of this
139 * {@link ListModel})
a917f100
NR
140 * @param popup
141 * the popup to use and keep track of (can be NULL)
142 */
b489d804
NR
143 @SuppressWarnings({ "unchecked", "rawtypes" }) // JList<?> not in Java 1.6
144 public ListModel(final JList list, final JPopupMenu popup) {
a917f100
NR
145 this.list = list;
146 list.setModel(this);
147
148 list.addMouseMotionListener(new MouseAdapter() {
149 @Override
150 public void mouseMoved(MouseEvent me) {
151 if (popup != null && popup.isShowing())
152 return;
153
154 Point p = new Point(me.getX(), me.getY());
155 int index = list.locationToIndex(p);
156 if (index != hoveredIndex) {
157 int oldIndex = hoveredIndex;
158 hoveredIndex = index;
159 fireElementChanged(oldIndex);
160 fireElementChanged(index);
161 }
162 }
163 });
164
165 list.addMouseListener(new MouseAdapter() {
166 @Override
167 public void mousePressed(MouseEvent e) {
168 check(e);
169 }
170
171 @Override
172 public void mouseReleased(MouseEvent e) {
173 check(e);
174 }
175
176 @Override
177 public void mouseExited(MouseEvent e) {
178 if (popup != null && popup.isShowing())
179 return;
180
181 if (hoveredIndex > -1) {
182 int oldIndex = hoveredIndex;
183 hoveredIndex = -1;
184 fireElementChanged(oldIndex);
185 }
186 }
187
188 private void check(MouseEvent e) {
189 if (popup == null) {
190 return;
191 }
192
193 if (e.isPopupTrigger()) {
194 if (list.getSelectedIndices().length <= 1) {
195 list.setSelectedIndex(
196 list.locationToIndex(e.getPoint()));
197 }
198
199 popup.show(list, e.getX(), e.getY());
200 }
201 }
202 });
203 }
204
f2573c37
NR
205 /**
206 * (Try and) keep the elements that were selected when filtering.
207 * <p>
208 * This will use toString on the elements to identify them, and can be a bit
209 * resource intensive.
210 *
211 * @return TRUE if we do
212 */
213 public boolean isKeepSelection() {
214 return keepSelection;
215 }
216
217 /**
218 * (Try and) keep the elements that were selected when filtering.
219 * <p>
220 * This will use toString on the elements to identify them, and can be a bit
221 * resource intensive.
222 *
223 * @param keepSelection
224 * TRUE to try and keep them selected
225 */
226 public void setKeepSelection(boolean keepSelection) {
227 this.keepSelection = keepSelection;
228 }
229
a917f100
NR
230 /**
231 * Check if this element is currently under the mouse.
232 *
233 * @param element
234 * the element to check
235 *
236 * @return TRUE if it is
237 */
238 public boolean isHovered(T element) {
239 return indexOf(element) == hoveredIndex;
240 }
241
242 /**
243 * Check if this element is currently under the mouse.
244 *
245 * @param index
246 * the index of the element to check
247 *
248 * @return TRUE if it is
249 */
250 public boolean isHovered(int index) {
251 return index == hoveredIndex;
252 }
253
254 /**
255 * Add an item to the model.
256 *
257 * @param item
258 * the new item to add
259 */
260 public void addItem(T item) {
261 items.add(item);
262 }
263
264 /**
265 * Add items to the model.
266 *
267 * @param items
268 * the new items to add
269 */
270 public void addAllItems(Collection<T> items) {
271 this.items.addAll(items);
272 }
273
274 /**
275 * Removes the first occurrence of the specified element from this list, if
276 * it is present (optional operation).
277 *
278 * @param item
279 * the item to remove if possible (can be NULL)
280 *
281 * @return TRUE if one element was removed, FALSE if not found
282 */
283 public boolean removeItem(T item) {
284 return items.remove(item);
285 }
286
287 /**
288 * Remove the items that pass the given filter (or all items if the filter
289 * is NULL).
290 *
291 * @param filter
292 * the filter (if the filter returns TRUE, the item will be
293 * removed)
294 *
295 * @return TRUE if at least one item was removed
296 */
297 public boolean removeItemIf(Predicate<T> filter) {
298 boolean changed = false;
299 if (filter == null) {
300 changed = !items.isEmpty();
301 clearItems();
302 } else {
303 for (int i = 0; i < items.size(); i++) {
304 if (filter.test(items.get(i))) {
305 items.remove(i--);
306 changed = true;
307 }
308 }
309 }
310
311 return changed;
312 }
313
314 /**
315 * Removes all the items from this model.
316 */
317 public void clearItems() {
318 items.clear();
319 }
320
321 /**
322 * Filter the current elements.
323 * <p>
324 * This method will clear all the elements then look into all the items:
325 * those that pass the given filter will be copied as elements.
326 *
327 * @param filter
328 * the filter to select which elements to keep; an item that pass
329 * the filter will be copied as an element (can be NULL, in that
330 * case all items will be copied as elements)
331 */
b489d804 332 @SuppressWarnings("unchecked") // JList<?> not compatible Java 1.6
a917f100 333 public void filter(Predicate<T> filter) {
f2573c37
NR
334 ListSnapshot snapshot = null;
335
336 if (keepSelection)
337 snapshot = new ListSnapshot(list);
338
a917f100
NR
339 clear();
340 for (T item : items) {
341 if (filter == null || filter.test(item)) {
342 addElement(item);
343 }
344 }
345
f2573c37
NR
346 if (keepSelection)
347 snapshot.apply();
348
a917f100
NR
349 list.repaint();
350 }
351
352 /**
353 * Return the currently selected elements.
354 *
355 * @return the selected elements
356 */
357 public List<T> getSelectedElements() {
358 List<T> selected = new ArrayList<T>();
359 for (int index : list.getSelectedIndices()) {
360 selected.add(get(index));
361 }
362
363 return selected;
364 }
365
366 /**
367 * Return the selected element if <b>one</b> and <b>only one</b> element is
368 * selected. I.E., if zero, two or more elements are selected, NULL will be
369 * returned.
370 *
371 * @return the element if it is the only selected element, NULL otherwise
372 */
373 public T getUniqueSelectedElement() {
374 List<T> selected = getSelectedElements();
375 if (selected.size() == 1) {
376 return selected.get(0);
377 }
378
379 return null;
380 }
381
382 /**
383 * Notify that this element has been changed.
384 *
385 * @param index
386 * the index of the element
387 */
388 public void fireElementChanged(int index) {
389 if (index >= 0) {
390 fireContentsChanged(this, index, index);
391 }
392 }
393
394 /**
395 * Notify that this element has been changed.
396 *
397 * @param element
398 * the element
399 */
400 public void fireElementChanged(T element) {
401 int index = indexOf(element);
402 if (index >= 0) {
403 fireContentsChanged(this, index, index);
404 }
405 }
406
b489d804 407 @SuppressWarnings("unchecked") // JList<?> not compatible Java 1.6
a917f100
NR
408 @Override
409 public T get(int index) {
410 return (T) super.get(index);
411 }
412
413 /**
414 * Generate a {@link ListCellRenderer} that supports {@link Hoverable}
415 * elements.
416 *
417 * @param <T>
418 * the type of elements and items (the same type), which should
419 * implement {@link Hoverable} (it will not cause issues if not,
420 * but then, it will be a default renderer)
421 * @param model
422 * the model to use
423 *
424 * @return a suitable, {@link Hoverable} compatible renderer
425 */
426 static public <T extends Component> ListCellRenderer6<T> generateRenderer(
427 final ListModel<T> model) {
428 return new ListCellRenderer6<T>() {
429 @Override
430 public Component getListCellRendererComponent(JList6<T> list,
431 T item, int index, boolean isSelected,
432 boolean cellHasFocus) {
433 if (item instanceof Hoverable) {
434 Hoverable hoverable = (Hoverable) item;
435 hoverable.setSelected(isSelected);
436 hoverable.setHovered(model.isHovered(index));
437 }
438
439 return item;
440 }
441 };
442 }
443}