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: {
175: if (getComponentOrientation()
176: == ComponentOrientation.LEFT_TO_RIGHT)
177: {
178: if (key == LOWER_LEADING_CORNER)
179: key = LOWER_LEFT_CORNER;
180: else if (key == LOWER_TRAILING_CORNER)
181: key = LOWER_RIGHT_CORNER;
182: else if (key == UPPER_LEADING_CORNER)
183: key = UPPER_LEFT_CORNER;
184: else if (key == UPPER_TRAILING_CORNER)
185: key = UPPER_RIGHT_CORNER;
186: }
187: else if (getComponentOrientation()
188: == ComponentOrientation.RIGHT_TO_LEFT)
189: {
190: if (key == LOWER_LEADING_CORNER)
191: key = LOWER_RIGHT_CORNER;
192: else if (key == LOWER_TRAILING_CORNER)
193: key = LOWER_LEFT_CORNER;
194: else if (key == UPPER_LEADING_CORNER)
195: key = UPPER_RIGHT_CORNER;
196: else if (key == UPPER_TRAILING_CORNER)
197: key = UPPER_LEFT_CORNER;
198: }
199:
200: if (key == LOWER_RIGHT_CORNER)
201: return lowerRight;
202: else if (key == UPPER_RIGHT_CORNER)
203: return upperRight;
204: else if (key == LOWER_LEFT_CORNER)
205: return lowerLeft;
206: else if (key == UPPER_LEFT_CORNER)
207: return upperLeft;
208: return null;
209: }
210:
211: public JScrollBar getHorizontalScrollBar()
212: {
213: return horizontalScrollBar;
214: }
215:
216: public int getHorizontalScrollBarPolicy()
217: {
218: return horizontalScrollBarPolicy;
219: }
220:
221: public JViewport getRowHeader()
222: {
223: return rowHeader;
224: }
225:
226: public JScrollBar getVerticalScrollBar()
227: {
228: return verticalScrollBar;
229: }
230:
231: public int getVerticalScrollBarPolicy()
232: {
233: return verticalScrollBarPolicy;
234: }
235:
236: public JViewport getViewport()
237: {
238: return viewport;
239: }
240:
241: public Border getViewportBorder()
242: {
243: return viewportBorder;
244: }
245:
246: public Rectangle getViewportBorderBounds()
247: {
248: if (viewportBorder == null)
249: {
250: if (getViewport() == null)
251: return new Rectangle(0, 0, 0, 0);
252: else
253: return getViewport().getBounds();
254: }
255: else
256: {
257: Insets i = viewportBorder.getBorderInsets(getViewport());
258: if (getViewport() == null)
259: return new Rectangle(0, 0, 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: setUI((ScrollPaneUI) UIManager.getUI(this));
635: }
636:
637:
642: public ScrollPaneUI getUI()
643: {
644: return (ScrollPaneUI) ui;
645: }
646:
647:
652: public void setUI(ScrollPaneUI ui)
653: {
654: super.setUI(ui);
655: }
656:
657: protected class ScrollBar
658: extends JScrollBar
659: implements UIResource
660: {
661: private static final long serialVersionUID = -42032395320987283L;
662:
663: public ScrollBar(int orientation)
664: {
665: super(orientation);
666: }
667:
668: public int getBlockIncrement(int direction)
669: {
670: Component view = JScrollPane.this.getViewport().getView();
671: if (view == null || (! (view instanceof Scrollable)))
672: return super.getBlockIncrement(direction);
673: else
674: {
675: Scrollable s = (Scrollable) view;
676: return s.getScrollableBlockIncrement(JScrollPane.this.getViewport().getViewRect(),
677: this.getOrientation(),
678: direction);
679: }
680: }
681:
682: public int getUnitIncrement(int direction)
683: {
684: Component view = JScrollPane.this.getViewport().getView();
685: if (view == null || (! (view instanceof Scrollable)))
686: return super.getUnitIncrement(direction);
687: else
688: {
689: Scrollable s = (Scrollable) view;
690: return s.getScrollableUnitIncrement(JScrollPane.this.getViewport().getViewRect(),
691: this.getOrientation(),
692: direction);
693: }
694: }
695: }
696:
697:
704: public AccessibleContext getAccessibleContext()
705: {
706: if (accessibleContext == null)
707: accessibleContext = new AccessibleJScrollPane();
708: return accessibleContext;
709: }
710: }