Debian Codegraph @

src/java/org/astrogrid/samp/gui/IconBox.java

raw
1 package org.astrogrid.samp.gui;
2
3 import java.awt.Color;
4 import java.awt.Component;
5 import java.awt.Dimension;
6 import java.awt.Graphics;
7 import java.awt.Insets;
8 import java.awt.Point;
9 import java.awt.event.MouseEvent;
10 import java.util.ArrayList;
11 import java.util.Collections;
12 import java.util.Iterator;
13 import java.util.List;
14 import javax.swing.AbstractListModel;
15 import javax.swing.Icon;
16 import javax.swing.JComponent;
17 import javax.swing.ListModel;
18 import javax.swing.ToolTipManager;
19 import javax.swing.event.ListDataEvent;
20 import javax.swing.event.ListDataListener;
21
22 /**
23 * Component which displays the contents of a ListModel as icons.
24 * Custom icon and tooltip generation are supported by use of a separate
25 * renderer object.
26 *
27 * @author Mark Taylor
28 * @since 26 Nov 2008
29 */
30 class IconBox extends JComponent {
31
32 private final List entryList_;
33 private final ListDataListener modelListener_;
34 private final Color enabledBg_;
35 private final Color disabledBg_;
36 private boolean vertical_;
37 private boolean trailing_;
38 private boolean reversed_;
39 private int transSize_;
40 private int gap_;
41 private CellRenderer renderer_;
42 private ListModel model_;
43 private Dimension minSize_;
44 private Dimension maxSize_;
45 private Dimension prefSize_;
46 private static final ListModel EMPTY_LIST_MODEL = createEmptyListModel();
47
48 /**
49 * Constructor.
50 *
51 * @param transSize the transverse (horizontal/vertical) size
52 * available for icons in pixels
53 */
54 public IconBox( int transSize ) {
55 transSize_ = transSize;
56 setOpaque( true );
57 disabledBg_ = null;
58 enabledBg_ = Color.WHITE;
59 setBackground( enabledBg_ );
60 modelListener_ = new ListDataListener() {
61 public void contentsChanged( ListDataEvent evt ) {
62 int i0 = evt.getIndex0();
63 int i1 = evt.getIndex1();
64 if ( 0 <= i0 && i0 <= i1 && i1 <= entryList_.size() ) {
65 for ( int i = i0; i <= i1; i++ ) {
66 entryList_.set( i, createEntry( i ) );
67 }
68 repaint(); // could be more efficient
69 }
70 else {
71 refreshState();
72 }
73 }
74 public void intervalAdded( ListDataEvent evt ) {
75 int i0 = evt.getIndex0();
76 int i1 = evt.getIndex1();
77 if ( 0 <= i0 && i0 <= i1 && i1 <= model_.getSize() ) {
78 for ( int i = i0; i <= i1; i++ ) {
79 entryList_.add( i, createEntry( i ) );
80 }
81 repaint(); // could be more efficient
82 }
83 else {
84 refreshState();
85 }
86 }
87 public void intervalRemoved( ListDataEvent evt ) {
88 int i0 = evt.getIndex0();
89 int i1 = evt.getIndex1();
90 if ( 0 <= i0 && i0 <= i1 && i1 <= entryList_.size() ) {
91 for ( int i = i1; i >= i0; i-- ) {
92 entryList_.remove( i );
93 }
94 repaint(); // could be more efficient
95 }
96 else {
97 refreshState();
98 }
99 }
100 };
101 entryList_ = new ArrayList();
102 gap_ = 4;
103 ToolTipManager.sharedInstance().registerComponent( this );
104 setModel( EMPTY_LIST_MODEL );
105 setRenderer( new DefaultRenderer() );
106 }
107
108 /**
109 * Sets whether icons will be lined up in a horizontal or vertical line.
110 *
111 * @param vertical true for vertical run, false for horizontal
112 */
113 public void setVertical( boolean vertical ) {
114 vertical_ = vertical;
115 revalidate();
116 repaint();
117 }
118
119 /**
120 * Returns whether icons will be lined up horizontally or vertically.
121 *
122 * @return false for hormizontal run, true for vertical
123 */
124 public boolean getVertical() {
125 return vertical_;
126 }
127
128 /**
129 * Sets the alignment of the icons in this component.
130 *
131 * @param trailing false for left/top, true for right/bottom alignment
132 */
133 public void setTrailing( boolean trailing ) {
134 trailing_ = trailing;
135 repaint();
136 }
137
138 /**
139 * Returns the alignment of the icons in this component.
140 *
141 * @return false for left/top, true for right/bottom alignment
142 */
143 public boolean getTrailing() {
144 return trailing_;
145 }
146
147 /**
148 * Sets the first-to-last ordering of the icons in this component.
149 *
150 * @param reversed false for increasing to right/bottom,
151 * true for increasig to left/top
152 */
153 public void setReversed( boolean reversed ) {
154 reversed_ = reversed;
155 repaint();
156 }
157
158 /**
159 * Returns the first-to-last ordering of the icons in this component.
160 *
161 * @return false for increasing to right/bottom,
162 * true for increasig to left/top
163 */
164 public boolean getReversed() {
165 return reversed_;
166 }
167
168 public void setEnabled( boolean enabled ) {
169 super.setEnabled( enabled );
170 setBackground( enabled ? enabledBg_ : disabledBg_ );
171 }
172
173 /**
174 * Refreshes the list-related state from scratch.
175 */
176 private void refreshState() {
177 entryList_.clear();
178 int count = model_.getSize();
179 for ( int i = 0; i < count; i++ ) {
180 entryList_.add( createEntry( i ) );
181 }
182 repaint();
183 }
184
185 /**
186 * Constructs an Entry object from an object contained in the ListModel,
187 * using the currently installed renderer.
188 *
189 * @param index index of entry in list
190 * @return new entry
191 */
192 private Entry createEntry( int index ) {
193 Object value = model_.getElementAt( index );
194 return new Entry( renderer_.getIcon( this, value, index ),
195 renderer_.getToolTipText( this, value, index ) );
196 }
197
198 /**
199 * Sets the list model for use with this component.
200 * Objects will be rendered as icons by using the currently intalled
201 * renderer.
202 *
203 * @param model list model
204 */
205 public void setModel( ListModel model ) {
206 if ( model_ != null ) {
207 model_.removeListDataListener( modelListener_ );
208 }
209 model_ = model;
210 if ( model_ != null ) {
211 model_.addListDataListener( modelListener_ );
212 }
213 refreshState();
214 }
215
216 /**
217 * Returns the list model used by this component.
218 *
219 * @return list model
220 */
221 public ListModel getModel() {
222 return model_;
223 }
224
225 /**
226 * Sets the transverse dimension in pixels of this box.
227 *
228 * @param transSize pixel count across list run
229 */
230 public void setTransverseSize( int transSize ) {
231 transSize_ = transSize;
232 if ( transSize_ != transSize ) {
233 repaint();
234 }
235 }
236
237 /**
238 * Returns the transverse dimension in pixels of this box.
239 *
240 * @return pixel count across run
241 */
242 public int getTransverseSize() {
243 return transSize_;
244 }
245
246 /**
247 * Sets the object which is used to turn list model contents into the
248 * icons and tooltips displayed by this component.
249 *
250 * @param renderer new renderer
251 */
252 public void setRenderer( CellRenderer renderer ) {
253 renderer_ = renderer;
254 refreshState();
255 }
256
257 /**
258 * Returns the object which turns list model contents into display things.
259 * The default value tries to cast to Icon and uses toString for tooltip.
260 *
261 * @return current renderer
262 */
263 public CellRenderer getRenderer() {
264 return renderer_;
265 }
266
267 public void setPreferredSize( Dimension prefSize ) {
268 prefSize_ = prefSize;
269 }
270
271 public Dimension getPreferredSize() {
272 if ( prefSize_ == null ) {
273 int leng = 0;
274 for ( Iterator it = entryList_.iterator(); it.hasNext(); ) {
275 Entry entry = (Entry) it.next();
276 Icon icon = entry.icon_;
277 leng += vertical_ ? icon.getIconHeight() : icon.getIconWidth();
278 if ( it.hasNext() ) {
279 leng += gap_;
280 }
281 }
282 Dimension size = vertical_ ? new Dimension( transSize_, leng )
283 : new Dimension( leng, transSize_ );
284 Insets insets = getInsets();
285 size.width += insets.left + insets.right;
286 size.height += insets.top + insets.bottom;
287 return size;
288 }
289 else {
290 return prefSize_;
291 }
292 }
293
294 public void setMinimumSize( Dimension minSize ) {
295 minSize_ = minSize;
296 }
297
298 public Dimension getMinimumSize() {
299 if ( minSize_ == null ) {
300 Dimension size = vertical_ ? new Dimension( transSize_, 0 )
301 : new Dimension( 0, transSize_ );
302 Insets insets = getInsets();
303 size.width += insets.left + insets.right;
304 size.height += insets.top + insets.bottom;
305 return size;
306 }
307 else {
308 return minSize_;
309 }
310 }
311
312 public void setMaximumSize( Dimension maxSize ) {
313 maxSize_ = maxSize;
314 }
315
316 public Dimension getMaximumSize() {
317 if ( maxSize_ == null ) {
318 Dimension size = new Dimension( transSize_, transSize_ );
319 Insets insets = getInsets();
320 size.width += insets.left + insets.right;
321 size.height += insets.top + insets.bottom;
322 if ( vertical_ ) {
323 size.height = Integer.MAX_VALUE;
324 }
325 else {
326 size.width = Integer.MAX_VALUE;
327 }
328 return size;
329 }
330 else {
331 return maxSize_;
332 }
333 }
334
335 /**
336 * Returns the index of the list model element whose icon is displayed
337 * at a given point in this component.
338 *
339 * @param point point to interrogate
340 * @return list model index, or -1 if not found
341 */
342 public int getIndexAt( Point point ) {
343 Dimension size = getSize();
344 Insets insets = getInsets();
345
346 // The following should reject the request if it's outside this components
347 // bounds. However, it seems that sometimes (always??) getSize() reports
348 // zero size. I don't understand why, and I'm surprised the rest of the
349 // functionality here works under these circumstances; but it does.
350 // Leave it like this for now.
351 // if ( point.x < insets.left || point.x > size.width - insets.right ||
352 // point.y < insets.top || point.y > size.height - insets.bottom ) {
353 // return -1;
354 // }
355 List entryList = entryList_;
356 if ( reversed_ ) {
357 entryList = new ArrayList( entryList );
358 Collections.reverse( entryList );
359 }
360 int pLeng = trailing_
361 ? ( vertical_ ? size.height - insets.bottom - point.y
362 : size.width - insets.right - point.x )
363 : ( vertical_ ? point.y - insets.top
364 : point.x - insets.left );
365 int index = 0;
366 for ( Iterator it = entryList.iterator(); it.hasNext(); ) {
367 Icon icon = ((Entry) it.next()).icon_;
368 int leng = gap_ + ( vertical_ ? icon.getIconHeight()
369 : icon.getIconWidth() );
370 if ( pLeng < leng ) {
371 if ( index < entryList.size() ) {
372 return index;
373 }
374 else {
375 assert false;
376 return -1;
377 }
378 }
379 pLeng -= leng;
380 index++;
381 }
382 return -1;
383 }
384
385 protected void paintComponent( Graphics g ) {
386 super.paintComponent( g );
387 Dimension size = getSize();
388 if ( isOpaque() ) {
389 Color color = g.getColor();
390 g.setColor( getBackground() );
391 g.fillRect( 0, 0, size.width, size.height );
392 g.setColor( color );
393 }
394 Insets insets = getInsets();
395 List entryList = entryList_;
396 if ( reversed_ ) {
397 entryList = new ArrayList( entryList );
398 Collections.reverse( entryList );
399 }
400 if ( entryList.isEmpty() ) {
401 return;
402 }
403 int x = vertical_
404 ? insets.left
405 : ( trailing_ ? size.width - insets.right
406 - ((Entry) entryList.get( 0 ))
407 .icon_.getIconWidth()
408 : insets.left );
409 int y = vertical_
410 ? ( trailing_ ? size.height - insets.bottom
411 - ((Entry) entryList.get( 0 ))
412 .icon_.getIconHeight()
413 : insets.top )
414 : insets.top;
415 for ( Iterator it = entryList.iterator(); it.hasNext(); ) {
416 Icon icon = ((Entry) it.next()).icon_;
417 int width = icon.getIconWidth();
418 int height = icon.getIconHeight();
419 if ( g.hitClip( x, y, width, height ) ) {
420 icon.paintIcon( this, g, x, y );
421 }
422 if ( vertical_ ) {
423 y += ( trailing_ ? -1 : +1 ) * ( height + gap_ );
424 }
425 else {
426 x += ( trailing_ ? -1 : +1 ) * ( width + gap_ );
427 }
428 }
429 }
430
431 public String getToolTipText( MouseEvent evt ) {
432 int index = getIndexAt( evt.getPoint() );
433 return index >= 0 ? ((Entry) entryList_.get( index )).tooltip_
434 : null;
435 }
436
437 /**
438 * Defines how list model elements will be rendered as icons and tooltips.
439 */
440 interface CellRenderer {
441
442 /**
443 * Returns the icon to be displayed for a given list model element.
444 *
445 * @param iconBox component using this renderer
446 * @param value list model element
447 * @param index index in the entry list being rendered
448 * @return icon to paint
449 */
450 Icon getIcon( IconBox iconBox, Object value, int index );
451
452 /**
453 * Returns the tooltip text to be used for a given list model element.
454 * Null is OK.
455 *
456 * @param iconBox component using this renderer
457 * @param value list model element
458 * @param index index in the entry list being rendered
459 * @return tooltip for value
460 */
461 String getToolTipText( IconBox iconBox, Object value, int index );
462 }
463
464 /**
465 * Convenience struct-type class which aggregates an icon and a tooltip.
466 */
467 private static class Entry {
468 final Icon icon_;
469 final String tooltip_;
470
471 /**
472 * Constructor.
473 *
474 * @param icon icon
475 * @param tooltip tooltip
476 */
477 Entry( Icon icon, String tooltip ) {
478 icon_ = icon;
479 tooltip_ = tooltip;
480 }
481 }
482
483 /**
484 * Constructs an immutable list model with no content.
485 *
486 * @return dummy list model
487 */
488 private static ListModel createEmptyListModel() {
489 return new AbstractListModel() {
490 public int getSize() {
491 return 0;
492 }
493 public Object getElementAt( int index ) {
494 return null;
495 }
496 };
497 }
498
499 /**
500 * Default renderer.
501 */
502 private class DefaultRenderer implements CellRenderer, Icon {
503 public Icon getIcon( IconBox iconBox, Object value, int index ) {
504 return value instanceof Icon
505 ? (Icon) value
506 : (Icon) this;
507 }
508 public String getToolTipText( IconBox iconBox, Object value,
509 int index ) {
510 return value == null
511 ? null
512 : value.toString();
513 }
514 public int getIconWidth() {
515 return transSize_;
516 }
517 public int getIconHeight() {
518 return transSize_;
519 }
520 public void paintIcon( Component c, Graphics g, int x, int y ) {
521 g.drawOval( x, y, transSize_, transSize_ );
522 }
523 }
524 }