1:
37:
38:
39: package ;
40:
41: import ;
42: import ;
43: import ;
44: import ;
45: import ;
46: import ;
47: import ;
48:
49: import ;
50: import ;
51: import ;
52: import ;
53: import ;
54: import ;
55: import ;
56:
57:
81: public class JScrollPane extends JComponent
82: implements Accessible, ScrollPaneConstants
83: {
84:
89: protected class AccessibleJScrollPane extends AccessibleJComponent
90: implements ChangeListener, PropertyChangeListener
91: {
92:
93:
96: protected JViewport viewPort;
97:
98:
104: public AccessibleJScrollPane()
105: {
106: viewPort = getViewport();
107: viewPort.addChangeListener(this);
108: viewPort.addPropertyChangeListener(this);
109: }
110:
111:
116: public void stateChanged(ChangeEvent event)
117: {
118:
119: }
120:
121:
126: public void propertyChange(PropertyChangeEvent e)
127: {
128:
129: }
130:
131:
138: public void resetViewPort()
139: {
140: viewPort.removeChangeListener(this);
141: viewPort.removePropertyChangeListener(this);
142: viewPort = getViewport();
143: viewPort.addChangeListener(this);
144: viewPort.addPropertyChangeListener(this);
145: }
146: }
147:
148: private static final long serialVersionUID = 5203525440012340014L;
149:
150: protected JViewport columnHeader;
151: protected JViewport rowHeader;
152:
153: protected Component lowerLeft;
154: protected Component lowerRight;
155: protected Component upperLeft;
156: protected Component upperRight;
157:
158: protected JScrollBar horizontalScrollBar;
159: protected int horizontalScrollBarPolicy;
160: protected JScrollBar verticalScrollBar;
161: protected int verticalScrollBarPolicy;
162:
163: protected JViewport viewport;
164:
165: Border viewportBorder;
166: boolean wheelScrollingEnabled;
167:
168: public JViewport getColumnHeader()
169: {
170: return columnHeader;
171: }
172:
173: public Component getCorner(String key) {
174: if (getComponentOrientation()
175: == ComponentOrientation.LEFT_TO_RIGHT)
176: {
177: if (key == LOWER_LEADING_CORNER)
178: key = LOWER_LEFT_CORNER;
179: else if (key == LOWER_TRAILING_CORNER)
180: key = LOWER_RIGHT_CORNER;
181: else if (key == UPPER_LEADING_CORNER)
182: key = UPPER_LEFT_CORNER;
183: else if (key == UPPER_TRAILING_CORNER)
184: key = UPPER_RIGHT_CORNER;
185: }
186: else if (getComponentOrientation()
187: == ComponentOrientation.RIGHT_TO_LEFT)
188: {
189: if (key == LOWER_LEADING_CORNER)
190: key = LOWER_RIGHT_CORNER;
191: else if (key == LOWER_TRAILING_CORNER)
192: key = LOWER_LEFT_CORNER;
193: else if (key == UPPER_LEADING_CORNER)
194: key = UPPER_RIGHT_CORNER;
195: else if (key == UPPER_TRAILING_CORNER)
196: key = UPPER_LEFT_CORNER;
197: }
198:
199: if (key == LOWER_RIGHT_CORNER)
200: return lowerRight;
201: else if (key == UPPER_RIGHT_CORNER)
202: return upperRight;
203: else if (key == LOWER_LEFT_CORNER)
204: return lowerLeft;
205: else if (key == UPPER_LEFT_CORNER)
206: return upperLeft;
207: return null;
208: }
209:
210: public JScrollBar getHorizontalScrollBar()
211: {
212: return horizontalScrollBar;
213: }
214:
215: public int getHorizontalScrollBarPolicy()
216: {
217: return horizontalScrollBarPolicy;
218: }
219:
220: public JViewport getRowHeader()
221: {
222: return rowHeader;
223: }
224:
225: public JScrollBar getVerticalScrollBar()
226: {
227: return verticalScrollBar;
228: }
229:
230: public int getVerticalScrollBarPolicy()
231: {
232: return verticalScrollBarPolicy;
233: }
234:
235: public JViewport getViewport()
236: {
237: return viewport;
238: }
239:
240: public Border getViewportBorder()
241: {
242: return viewportBorder;
243: }
244:
245: public Rectangle getViewportBorderBounds()
246: {
247: if (viewportBorder == null)
248: {
249: if (getViewport() == null)
250: return new Rectangle(0,0,0,0);
251: else
252: return getViewport().getBounds();
253: }
254: else
255: {
256: Insets i = viewportBorder.getBorderInsets(getViewport());
257: if (getViewport() == null)
258: return new Rectangle(0,0,
259: i.left+i.right, i.top+i.bottom);
260: else
261: {
262: Rectangle b = getViewport().getBounds();
263: return new Rectangle(b.x - i.left,
264: b.y - i.top,
265: b.width + i.left + i.right,
266: b.height + i.top + i.bottom);
267: }
268: }
269: }
270:
271: public boolean isWheelScrollingEnabled()
272: {
273: return wheelScrollingEnabled;
274: }
275:
276:
277:
278: private void sync()
279: {
280: LayoutManager m = super.getLayout();
281: if (m != null && m instanceof ScrollPaneLayout)
282: {
283: ScrollPaneLayout sl = (ScrollPaneLayout) m;
284: sl.syncWithScrollPane(this);
285: }
286: }
287:
288: private void removeNonNull(Component c)
289: {
290: if (c != null)
291: remove(c);
292: }
293:
294: private void addNonNull(Component c, Object constraints)
295: {
296: if (c != null)
297: add(c, constraints);
298: }
299:
300: public void setComponentOrientation(ComponentOrientation co)
301: {
302: ComponentOrientation old = super.getComponentOrientation();
303: super.setComponentOrientation(co);
304: firePropertyChange("componentOrientation", old, co);
305: sync();
306: }
307:
308: public void setColumnHeader(JViewport h)
309: {
310: if (columnHeader == h)
311: return;
312:
313: JViewport old = columnHeader;
314: removeNonNull(old);
315: columnHeader = h;
316: addNonNull(h, JScrollPane.COLUMN_HEADER);
317: firePropertyChange("columnHeader", old, h);
318: sync();
319: }
320:
321: public void setColumnHeaderView(Component c)
322: {
323: if (columnHeader == null)
324: setColumnHeader(createViewport());
325: columnHeader.setView(c);
326: sync();
327: }
328:
329: public void setCorner(String key, Component c)
330: {
331: if (getComponentOrientation()
332: == ComponentOrientation.LEFT_TO_RIGHT)
333: {
334: if (key == LOWER_LEADING_CORNER)
335: key = LOWER_LEFT_CORNER;
336: else if (key == LOWER_TRAILING_CORNER)
337: key = LOWER_RIGHT_CORNER;
338: else if (key == UPPER_LEADING_CORNER)
339: key = UPPER_LEFT_CORNER;
340: else if (key == UPPER_TRAILING_CORNER)
341: key = UPPER_RIGHT_CORNER;
342: }
343: else if (getComponentOrientation()
344: == ComponentOrientation.RIGHT_TO_LEFT)
345: {
346: if (key == LOWER_LEADING_CORNER)
347: key = LOWER_RIGHT_CORNER;
348: else if (key == LOWER_TRAILING_CORNER)
349: key = LOWER_LEFT_CORNER;
350: else if (key == UPPER_LEADING_CORNER)
351: key = UPPER_RIGHT_CORNER;
352: else if (key == UPPER_TRAILING_CORNER)
353: key = UPPER_LEFT_CORNER;
354: }
355:
356: if (key == LOWER_RIGHT_CORNER)
357: {
358: removeNonNull(lowerRight);
359: lowerRight = c;
360: addNonNull(c, JScrollPane.LOWER_RIGHT_CORNER);
361: }
362: else if (key == UPPER_RIGHT_CORNER)
363: {
364: removeNonNull(upperRight);
365: upperRight = c;
366: addNonNull(c, JScrollPane.UPPER_RIGHT_CORNER);
367: }
368: else if (key == LOWER_LEFT_CORNER)
369: {
370: removeNonNull(lowerLeft);
371: lowerLeft = c;
372: addNonNull(c, JScrollPane.LOWER_LEFT_CORNER);
373: }
374: else if (key == UPPER_LEFT_CORNER)
375: {
376: removeNonNull(upperLeft);
377: upperLeft = c;
378: addNonNull(c, JScrollPane.UPPER_LEFT_CORNER);
379: }
380: else
381: throw new IllegalArgumentException("unknown corner " + key);
382: sync();
383: }
384:
385: public void setHorizontalScrollBar(JScrollBar h)
386: {
387: if (horizontalScrollBar == h)
388: return;
389:
390: JScrollBar old = horizontalScrollBar;
391: removeNonNull(old);
392: horizontalScrollBar = h;
393: addNonNull(h, JScrollPane.HORIZONTAL_SCROLLBAR);
394: firePropertyChange("horizontalScrollBar", old, h);
395: sync();
396:
397: }
398:
399: public void setHorizontalScrollBarPolicy(int h)
400: {
401: if (horizontalScrollBarPolicy == h)
402: return;
403:
404: if (h != HORIZONTAL_SCROLLBAR_AS_NEEDED
405: && h != HORIZONTAL_SCROLLBAR_NEVER
406: && h != HORIZONTAL_SCROLLBAR_ALWAYS)
407: throw new IllegalArgumentException("unknown horizontal scrollbar policy");
408:
409: int old = horizontalScrollBarPolicy;
410: horizontalScrollBarPolicy = h;
411: firePropertyChange("horizontalScrollBarPolicy", old, h);
412: sync();
413: revalidate();
414: }
415:
416: public void setLayout(LayoutManager l)
417: {
418: LayoutManager old = super.getLayout();
419: ScrollPaneLayout tmp = (ScrollPaneLayout) l;
420: super.setLayout(l);
421: tmp.syncWithScrollPane(this);
422: firePropertyChange("layout", old, l);
423: sync();
424: }
425:
426: public void setRowHeader(JViewport v)
427: {
428: if (rowHeader == v)
429: return;
430:
431: JViewport old = rowHeader;
432: removeNonNull(old);
433: rowHeader = v;
434: addNonNull(v, JScrollPane.ROW_HEADER);
435: firePropertyChange("rowHeader", old, v);
436: sync();
437: }
438:
439: public void setRowHeaderView(Component c)
440: {
441: if (rowHeader == null)
442: setRowHeader(createViewport());
443: rowHeader.setView(c);
444: sync();
445: }
446:
447: public void setVerticalScrollBar(JScrollBar v)
448: {
449: if (verticalScrollBar == v)
450: return;
451:
452: JScrollBar old = verticalScrollBar;
453: removeNonNull(old);
454: verticalScrollBar = v;
455: addNonNull(v, JScrollPane.VERTICAL_SCROLLBAR);
456: firePropertyChange("verticalScrollBar", old, v);
457: sync();
458: }
459:
460: public void setVerticalScrollBarPolicy(int v)
461: {
462: if (verticalScrollBarPolicy == v)
463: return;
464:
465: if (v != VERTICAL_SCROLLBAR_AS_NEEDED
466: && v != VERTICAL_SCROLLBAR_NEVER
467: && v != VERTICAL_SCROLLBAR_ALWAYS)
468: throw new IllegalArgumentException("unknown vertical scrollbar policy");
469:
470: int old = verticalScrollBarPolicy;
471: verticalScrollBarPolicy = v;
472: firePropertyChange("verticalScrollBarPolicy", old, v);
473: sync();
474: revalidate();
475: }
476:
477: public void setWheelScrollingEnabled(boolean b)
478: {
479: if (wheelScrollingEnabled == b)
480: return;
481:
482: boolean old = wheelScrollingEnabled;
483: wheelScrollingEnabled = b;
484: firePropertyChange("wheelScrollingEnabled", old, b);
485: sync();
486: }
487:
488: public void setViewport(JViewport v)
489: {
490: if (viewport == v)
491: return;
492:
493: JViewport old = viewport;
494: removeNonNull(old);
495: viewport = v;
496: addNonNull(v, JScrollPane.VIEWPORT);
497: revalidate();
498: repaint();
499: firePropertyChange("viewport", old, v);
500: sync();
501: if (accessibleContext != null)
502: {
503: AccessibleJScrollPane asp = (AccessibleJScrollPane) accessibleContext;
504: asp.resetViewPort();
505: }
506: }
507:
508: public void setViewportBorder(Border b)
509: {
510: if (viewportBorder == b)
511: return;
512:
513: Border old = viewportBorder;
514: viewportBorder = b;
515: firePropertyChange("viewportBorder", old, b);
516: sync();
517: }
518:
519: public void setViewportView(Component view)
520: {
521: if (getViewport() == null)
522: {
523: setViewport(createViewport());
524: }
525:
526: if (view != null)
527: {
528: getViewport().setView(view);
529: }
530: sync();
531: }
532:
533: public boolean isValidateRoot()
534: {
535: return true;
536: }
537:
538:
543: public JScrollPane()
544: {
545: this(null);
546: }
547:
548:
555: public JScrollPane(Component view)
556: {
557: this(view,
558: VERTICAL_SCROLLBAR_AS_NEEDED,
559: HORIZONTAL_SCROLLBAR_AS_NEEDED);
560: }
561:
562:
576: public JScrollPane(int vsbPolicy, int hsbPolicy)
577: {
578: this(null, vsbPolicy, hsbPolicy);
579: }
580:
581:
596: public JScrollPane(Component view, int vsbPolicy, int hsbPolicy)
597: {
598: setVerticalScrollBarPolicy(vsbPolicy);
599: setVerticalScrollBar(createVerticalScrollBar());
600: setHorizontalScrollBarPolicy(hsbPolicy);
601: setHorizontalScrollBar(createHorizontalScrollBar());
602: viewport = createViewport();
603: if (view != null)
604: getViewport().setView(view);
605: add(viewport,0);
606: setLayout(new ScrollPaneLayout());
607: setOpaque(false);
608: updateUI();
609: }
610:
611:
612: public JScrollBar createHorizontalScrollBar()
613: {
614: return new ScrollBar(SwingConstants.HORIZONTAL);
615: }
616:
617: public JScrollBar createVerticalScrollBar()
618: {
619: return new ScrollBar(SwingConstants.VERTICAL);
620: }
621:
622: protected JViewport createViewport()
623: {
624: return new JViewport();
625: }
626:
627: public String getUIClassID()
628: {
629: return "ScrollPaneUI";
630: }
631:
632: public void updateUI()
633: {
634: ScrollPaneUI b = (ScrollPaneUI)UIManager.getUI(this);
635: setUI(b);
636: }
637:
638:
643: public ScrollPaneUI getUI()
644: {
645: return (ScrollPaneUI) ui;
646: }
647:
648:
653: public void setUI(ScrollPaneUI ui)
654: {
655: super.setUI(ui);
656: }
657:
658: protected class ScrollBar
659: extends JScrollBar
660: implements UIResource
661: {
662: private static final long serialVersionUID = -42032395320987283L;
663:
664: public ScrollBar(int orientation)
665: {
666: super(orientation);
667: }
668:
669: public int getBlockIncrement(int direction)
670: {
671: Component view = JScrollPane.this.getViewport().getView();
672: if (view == null || (! (view instanceof Scrollable)))
673: return super.getBlockIncrement(direction);
674: else
675: {
676: Scrollable s = (Scrollable) view;
677: return s.getScrollableBlockIncrement(JScrollPane.this.getViewport().getViewRect(),
678: this.getOrientation(),
679: direction);
680: }
681: }
682:
683: public int getUnitIncrement(int direction)
684: {
685: Component view = JScrollPane.this.getViewport().getView();
686: if (view == null || (! (view instanceof Scrollable)))
687: return super.getUnitIncrement(direction);
688: else
689: {
690: Scrollable s = (Scrollable) view;
691: return s.getScrollableUnitIncrement(JScrollPane.this.getViewport().getViewRect(),
692: this.getOrientation(),
693: direction);
694: }
695: }
696: }
697:
698:
705: public AccessibleContext getAccessibleContext()
706: {
707: if (accessibleContext == null)
708: accessibleContext = new AccessibleJScrollPane();
709: return accessibleContext;
710: }
711: }