1:
37:
38:
39: package ;
40:
41: import ;
42: import ;
43: import ;
44: import ;
45: import ;
46: import ;
47: import ;
48: import ;
49: import ;
50: import ;
51: import ;
52: import ;
53: import ;
54: import ;
55: import ;
56:
57: import ;
58: import ;
59: import ;
60: import ;
61: import ;
62: import ;
63: import ;
64: import ;
65: import ;
66: import ;
67: import ;
68: import ;
69: import ;
70: import ;
71: import ;
72: import ;
73: import ;
74: import ;
75:
76:
79: public class BasicScrollBarUI extends ScrollBarUI implements LayoutManager,
80: SwingConstants
81: {
82:
86: protected class ArrowButtonListener extends MouseAdapter
87: {
88:
89:
95: public void mousePressed(MouseEvent e)
96: {
97: scrollTimer.stop();
98: scrollListener.setScrollByBlock(false);
99: if (e.getSource() == incrButton)
100: scrollListener.setDirection(POSITIVE_SCROLL);
101: else if (e.getSource() == decrButton)
102: scrollListener.setDirection(NEGATIVE_SCROLL);
103: scrollTimer.setDelay(100);
104: scrollTimer.start();
105: }
106:
107:
112: public void mouseReleased(MouseEvent e)
113: {
114: scrollTimer.stop();
115: scrollTimer.setDelay(300);
116: if (e.getSource() == incrButton)
117: scrollByUnit(POSITIVE_SCROLL);
118: else if (e.getSource() == decrButton)
119: scrollByUnit(NEGATIVE_SCROLL);
120: }
121: }
122:
123:
126: protected class ModelListener implements ChangeListener
127: {
128:
133: public void stateChanged(ChangeEvent e)
134: {
135: calculatePreferredSize();
136: updateThumbRect();
137: scrollbar.repaint();
138: }
139: }
140:
141:
144: public class PropertyChangeHandler implements PropertyChangeListener
145: {
146:
151: public void propertyChange(PropertyChangeEvent e)
152: {
153: if (e.getPropertyName().equals("model"))
154: {
155: ((BoundedRangeModel) e.getOldValue()).removeChangeListener(modelListener);
156: scrollbar.getModel().addChangeListener(modelListener);
157: updateThumbRect();
158: }
159: else if (e.getPropertyName().equals("orientation"))
160: {
161: uninstallListeners();
162: uninstallComponents();
163: uninstallDefaults();
164: installDefaults();
165: installComponents();
166: installListeners();
167: }
168: else if (e.getPropertyName().equals("enabled"))
169: {
170: Boolean b = (Boolean) e.getNewValue();
171: if (incrButton != null)
172: incrButton.setEnabled(b.booleanValue());
173: if (decrButton != null)
174: decrButton.setEnabled(b.booleanValue());
175: }
176: }
177: }
178:
179:
183: protected class ScrollListener implements ActionListener
184: {
185:
186: private transient int direction;
187:
188:
189: private transient boolean block;
190:
191:
195: public ScrollListener()
196: {
197: direction = POSITIVE_SCROLL;
198: block = true;
199: }
200:
201:
208: public ScrollListener(int dir, boolean block)
209: {
210: direction = dir;
211: this.block = block;
212: }
213:
214:
219: public void setDirection(int direction)
220: {
221: this.direction = direction;
222: }
223:
224:
229: public void setScrollByBlock(boolean block)
230: {
231: this.block = block;
232: }
233:
234:
239: public void actionPerformed(ActionEvent e)
240: {
241: if (block)
242: {
243:
244:
245:
246: if (!trackListener.shouldScroll(direction))
247: {
248: trackHighlight = NO_HIGHLIGHT;
249: scrollbar.repaint();
250: return;
251: }
252: scrollByBlock(direction);
253: }
254: else
255: scrollByUnit(direction);
256: }
257: }
258:
259:
262: protected class TrackListener extends MouseAdapter
263: implements MouseMotionListener
264: {
265:
266: protected int currentMouseX;
267:
268:
269: protected int currentMouseY;
270:
271:
275: protected int offset;
276:
277:
282: public void mouseDragged(MouseEvent e)
283: {
284: currentMouseX = e.getX();
285: currentMouseY = e.getY();
286: if (scrollbar.getValueIsAdjusting())
287: {
288: int value;
289: if (scrollbar.getOrientation() == SwingConstants.HORIZONTAL)
290: value = valueForXPosition(currentMouseX) - offset;
291: else
292: value = valueForYPosition(currentMouseY) - offset;
293:
294: scrollbar.setValue(value);
295: }
296: }
297:
298:
303: public void mouseMoved(MouseEvent e)
304: {
305: if (thumbRect.contains(e.getPoint()))
306: thumbRollover = true;
307: else
308: thumbRollover = false;
309: }
310:
311:
317: public void mousePressed(MouseEvent e)
318: {
319: currentMouseX = e.getX();
320: currentMouseY = e.getY();
321:
322: int value;
323: if (scrollbar.getOrientation() == SwingConstants.HORIZONTAL)
324: value = valueForXPosition(currentMouseX);
325: else
326: value = valueForYPosition(currentMouseY);
327:
328: if (! thumbRect.contains(e.getPoint()))
329: {
330: scrollTimer.stop();
331: scrollListener.setScrollByBlock(true);
332: if (value > scrollbar.getValue())
333: {
334: trackHighlight = INCREASE_HIGHLIGHT;
335: scrollListener.setDirection(POSITIVE_SCROLL);
336: }
337: else
338: {
339: trackHighlight = DECREASE_HIGHLIGHT;
340: scrollListener.setDirection(NEGATIVE_SCROLL);
341: }
342: scrollTimer.setDelay(100);
343: scrollTimer.start();
344: }
345: else
346: {
347:
348:
349:
350:
351:
352:
353:
354: scrollListener.setScrollByBlock(false);
355: scrollbar.setValueIsAdjusting(true);
356: offset = value - scrollbar.getValue();
357: }
358: scrollbar.repaint();
359: }
360:
361:
367: public void mouseReleased(MouseEvent e)
368: {
369: scrollTimer.stop();
370: scrollTimer.setDelay(300);
371: currentMouseX = e.getX();
372: currentMouseY = e.getY();
373:
374: if (shouldScroll(POSITIVE_SCROLL))
375: scrollByBlock(POSITIVE_SCROLL);
376: else if (shouldScroll(NEGATIVE_SCROLL))
377: scrollByBlock(NEGATIVE_SCROLL);
378:
379: trackHighlight = NO_HIGHLIGHT;
380: scrollListener.setScrollByBlock(false);
381: scrollbar.setValueIsAdjusting(true);
382: scrollbar.repaint();
383: }
384:
385:
393: boolean shouldScroll(int direction)
394: {
395: int value;
396: if (scrollbar.getOrientation() == HORIZONTAL)
397: value = valueForXPosition(currentMouseX);
398: else
399: value = valueForYPosition(currentMouseY);
400:
401: if (thumbRect.contains(currentMouseX, currentMouseY))
402: return false;
403:
404: if (direction == POSITIVE_SCROLL)
405: return value > scrollbar.getValue();
406: else
407: return value < scrollbar.getValue();
408: }
409: }
410:
411:
412: protected ArrowButtonListener buttonListener;
413:
414:
415: protected ModelListener modelListener;
416:
417:
418: protected PropertyChangeListener propertyChangeListener;
419:
420:
421: protected ScrollListener scrollListener;
422:
423:
424: protected TrackListener trackListener;
425:
426:
427: protected JButton decrButton;
428:
429:
430: protected JButton incrButton;
431:
432:
433: protected Dimension maximumThumbSize;
434:
435:
436: protected Dimension minimumThumbSize;
437:
438:
439: protected Color thumbColor;
440:
441:
442: protected Color thumbDarkShadowColor;
443:
444:
445: protected Color thumbHighlightColor;
446:
447:
448: protected Color thumbLightShadowColor;
449:
450:
451: protected Color trackHighlightColor;
452:
453:
454: protected Color trackColor;
455:
456:
457: protected Rectangle trackRect;
458:
459:
460: protected Rectangle thumbRect;
461:
462:
463: protected static final int DECREASE_HIGHLIGHT = 1;
464:
465:
466: protected static final int INCREASE_HIGHLIGHT = 2;
467:
468:
469: protected static final int NO_HIGHLIGHT = 0;
470:
471:
472: private static final int POSITIVE_SCROLL = 1;
473:
474:
475: private static final int NEGATIVE_SCROLL = -1;
476:
477:
478: private transient Dimension preferredSize;
479:
480:
481: protected int trackHighlight;
482:
483:
484: protected boolean isDragging;
485:
486:
487: protected Timer scrollTimer;
488:
489:
490: protected JScrollBar scrollbar;
491:
492:
493: boolean thumbRollover;
494:
495:
501: public void addLayoutComponent(String name, Component child)
502: {
503:
504:
505: }
506:
507:
511: protected void configureScrollBarColors()
512: {
513: trackColor = UIManager.getColor("ScrollBar.track");
514: trackHighlightColor = UIManager.getColor("ScrollBar.trackHighlight");
515: thumbColor = UIManager.getColor("ScrollBar.thumb");
516: thumbHighlightColor = UIManager.getColor("ScrollBar.thumbHighlight");
517: thumbDarkShadowColor = UIManager.getColor("ScrollBar.thumbDarkShadow");
518: thumbLightShadowColor = UIManager.getColor("ScrollBar.thumbShadow");
519: }
520:
521:
526: protected ArrowButtonListener createArrowButtonListener()
527: {
528: return new ArrowButtonListener();
529: }
530:
531:
539: protected JButton createIncreaseButton(int orientation)
540: {
541: return new BasicArrowButton(orientation);
542: }
543:
544:
552: protected JButton createDecreaseButton(int orientation)
553: {
554: return new BasicArrowButton(orientation);
555: }
556:
557:
562: protected ModelListener createModelListener()
563: {
564: return new ModelListener();
565: }
566:
567:
572: protected PropertyChangeListener createPropertyChangeListener()
573: {
574: return new PropertyChangeHandler();
575: }
576:
577:
582: protected ScrollListener createScrollListener()
583: {
584: return new ScrollListener();
585: }
586:
587:
592: protected TrackListener createTrackListener()
593: {
594: return new TrackListener();
595: }
596:
597:
604: public static ComponentUI createUI(JComponent c)
605: {
606: return new BasicScrollBarUI();
607: }
608:
609:
616: public Dimension getMaximumSize(JComponent c)
617: {
618: return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
619: }
620:
621:
626: protected Dimension getMaximumThumbSize()
627: {
628: return maximumThumbSize;
629: }
630:
631:
638: public Dimension getMinimumSize(JComponent c)
639: {
640: return getPreferredSize(c);
641: }
642:
643:
648: protected Dimension getMinimumThumbSize()
649: {
650: return minimumThumbSize;
651: }
652:
653:
658: void calculatePreferredSize()
659: {
660: int height;
661: int width;
662: height = width = 0;
663:
664: if (scrollbar.getOrientation() == SwingConstants.HORIZONTAL)
665: {
666: width += incrButton.getPreferredSize().getWidth();
667: width += decrButton.getPreferredSize().getWidth();
668: width += 16;
669: height = UIManager.getInt("ScrollBar.width");
670: }
671: else
672: {
673: height += incrButton.getPreferredSize().getHeight();
674: height += decrButton.getPreferredSize().getHeight();
675: height += 16;
676: width = UIManager.getInt("ScrollBar.width");
677: }
678:
679: Insets insets = scrollbar.getInsets();
680:
681: height += insets.top + insets.bottom;
682: width += insets.left + insets.right;
683:
684: preferredSize = new Dimension(width, height);
685: }
686:
687:
698: public Dimension getPreferredSize(JComponent c)
699: {
700: calculatePreferredSize();
701: return preferredSize;
702: }
703:
704:
710: protected Rectangle getThumbBounds()
711: {
712: return thumbRect;
713: }
714:
715:
721: protected Rectangle getTrackBounds()
722: {
723: return trackRect;
724: }
725:
726:
730: protected void installComponents()
731: {
732: int orientation = scrollbar.getOrientation();
733: switch (orientation)
734: {
735: case JScrollBar.HORIZONTAL:
736: incrButton = createIncreaseButton(EAST);
737: decrButton = createDecreaseButton(WEST);
738: break;
739: default:
740: incrButton = createIncreaseButton(SOUTH);
741: decrButton = createDecreaseButton(NORTH);
742: break;
743: }
744:
745: if (incrButton != null)
746: scrollbar.add(incrButton);
747: if (decrButton != null)
748: scrollbar.add(decrButton);
749: }
750:
751:
755: protected void installDefaults()
756: {
757: LookAndFeel.installColors(scrollbar, "ScrollBar.background",
758: "ScrollBar.foreground");
759: LookAndFeel.installBorder(scrollbar, "ScrollBar.border");
760: scrollbar.setOpaque(true);
761: scrollbar.setLayout(this);
762:
763: thumbColor = UIManager.getColor("ScrollBar.thumb");
764: thumbDarkShadowColor = UIManager.getColor("ScrollBar.thumbDarkShadow");
765: thumbHighlightColor = UIManager.getColor("ScrollBar.thumbHighlight");
766: thumbLightShadowColor = UIManager.getColor("ScrollBar.thumbShadow");
767:
768: maximumThumbSize = UIManager.getDimension("ScrollBar.maximumThumbSize");
769: minimumThumbSize = UIManager.getDimension("ScrollBar.minimumThumbSize");
770: }
771:
772:
777: protected void installKeyboardActions()
778: {
779: InputMap keyMap = getInputMap(
780: JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
781: SwingUtilities.replaceUIInputMap(scrollbar,
782: JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, keyMap);
783: ActionMap map = getActionMap();
784: SwingUtilities.replaceUIActionMap(scrollbar, map);
785: }
786:
787:
791: protected void uninstallKeyboardActions()
792: {
793: SwingUtilities.replaceUIActionMap(scrollbar, null);
794: SwingUtilities.replaceUIInputMap(scrollbar,
795: JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);
796: }
797:
798: InputMap getInputMap(int condition)
799: {
800: if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
801: return (InputMap) UIManager.get("ScrollBar.focusInputMap");
802: return null;
803: }
804:
805:
812: ActionMap getActionMap()
813: {
814: ActionMap map = (ActionMap) UIManager.get("ScrollBar.actionMap");
815:
816: if (map == null)
817: {
818: map = createActionMap();
819: if (map != null)
820: UIManager.put("ScrollBar.actionMap", map);
821: }
822: return map;
823: }
824:
825:
835: ActionMap createActionMap()
836: {
837: ActionMap map = new ActionMapUIResource();
838: map.put("positiveUnitIncrement",
839: new AbstractAction("positiveUnitIncrement") {
840: public void actionPerformed(ActionEvent event)
841: {
842: JScrollBar sb = (JScrollBar) event.getSource();
843: if (sb.isVisible())
844: {
845: int delta = sb.getUnitIncrement(1);
846: sb.setValue(sb.getValue() + delta);
847: }
848: }
849: }
850: );
851: map.put("positiveBlockIncrement",
852: new AbstractAction("positiveBlockIncrement") {
853: public void actionPerformed(ActionEvent event)
854: {
855: JScrollBar sb = (JScrollBar) event.getSource();
856: if (sb.isVisible())
857: {
858: int delta = sb.getBlockIncrement(1);
859: sb.setValue(sb.getValue() + delta);
860: }
861: }
862: }
863: );
864: map.put("negativeUnitIncrement",
865: new AbstractAction("negativeUnitIncrement") {
866: public void actionPerformed(ActionEvent event)
867: {
868: JScrollBar sb = (JScrollBar) event.getSource();
869: if (sb.isVisible())
870: {
871: int delta = sb.getUnitIncrement(-1);
872: sb.setValue(sb.getValue() + delta);
873: }
874: }
875: }
876: );
877: map.put("negativeBlockIncrement",
878: new AbstractAction("negativeBlockIncrement") {
879: public void actionPerformed(ActionEvent event)
880: {
881: JScrollBar sb = (JScrollBar) event.getSource();
882: if (sb.isVisible())
883: {
884: int delta = sb.getBlockIncrement(-1);
885: sb.setValue(sb.getValue() + delta);
886: }
887: }
888: }
889: );
890: map.put("minScroll",
891: new AbstractAction("minScroll") {
892: public void actionPerformed(ActionEvent event)
893: {
894: JScrollBar sb = (JScrollBar) event.getSource();
895: if (sb.isVisible())
896: {
897: sb.setValue(sb.getMinimum());
898: }
899: }
900: }
901: );
902: map.put("maxScroll",
903: new AbstractAction("maxScroll") {
904: public void actionPerformed(ActionEvent event)
905: {
906: JScrollBar sb = (JScrollBar) event.getSource();
907: if (sb.isVisible())
908: {
909: sb.setValue(sb.getMaximum());
910: }
911: }
912: }
913: );
914: return map;
915: }
916:
917:
921: protected void installListeners()
922: {
923: scrollListener = createScrollListener();
924: trackListener = createTrackListener();
925: buttonListener = createArrowButtonListener();
926: modelListener = createModelListener();
927: propertyChangeListener = createPropertyChangeListener();
928:
929: scrollbar.addMouseMotionListener(trackListener);
930: scrollbar.addMouseListener(trackListener);
931:
932: incrButton.addMouseListener(buttonListener);
933: decrButton.addMouseListener(buttonListener);
934:
935: scrollbar.addPropertyChangeListener(propertyChangeListener);
936: scrollbar.getModel().addChangeListener(modelListener);
937:
938: scrollTimer.addActionListener(scrollListener);
939: }
940:
941:
948: public void installUI(JComponent c)
949: {
950: super.installUI(c);
951: if (c instanceof JScrollBar)
952: {
953: scrollbar = (JScrollBar) c;
954:
955: trackRect = new Rectangle();
956: thumbRect = new Rectangle();
957:
958: scrollTimer = new Timer(300, null);
959:
960: installDefaults();
961: installComponents();
962: configureScrollBarColors();
963: installListeners();
964: installKeyboardActions();
965:
966: calculatePreferredSize();
967: }
968: }
969:
970:
975: public void layoutContainer(Container scrollbarContainer)
976: {
977: if (scrollbarContainer instanceof JScrollBar)
978: {
979: if (scrollbar.getOrientation() == SwingConstants.HORIZONTAL)
980: layoutHScrollbar((JScrollBar) scrollbarContainer);
981: else
982: layoutVScrollbar((JScrollBar) scrollbarContainer);
983: }
984: }
985:
986:
991: protected void layoutHScrollbar(JScrollBar sb)
992: {
993: Rectangle vr = new Rectangle();
994: SwingUtilities.calculateInnerArea(scrollbar, vr);
995:
996: Dimension incrDims = incrButton.getPreferredSize();
997: Dimension decrDims = decrButton.getPreferredSize();
998:
999:
1000: SwingUtilities.calculateInnerArea(scrollbar, trackRect);
1001: trackRect.width -= incrDims.getWidth();
1002: trackRect.width -= decrDims.getWidth();
1003: trackRect.x += decrDims.getWidth();
1004:
1005: updateThumbRect();
1006:
1007: decrButton.setBounds(vr.x, vr.y, decrDims.width, trackRect.height);
1008: incrButton.setBounds(trackRect.x + trackRect.width, vr.y, incrDims.width,
1009: trackRect.height);
1010: }
1011:
1012:
1017: protected void layoutVScrollbar(JScrollBar sb)
1018: {
1019: Rectangle vr = new Rectangle();
1020: SwingUtilities.calculateInnerArea(scrollbar, vr);
1021:
1022: Dimension incrDims = incrButton.getPreferredSize();
1023: Dimension decrDims = decrButton.getPreferredSize();
1024:
1025:
1026: SwingUtilities.calculateInnerArea(scrollbar, trackRect);
1027: trackRect.height -= incrDims.getHeight();
1028: trackRect.height -= decrDims.getHeight();
1029: trackRect.y += decrDims.getHeight();
1030:
1031: updateThumbRect();
1032:
1033: decrButton.setBounds(vr.x, vr.y, trackRect.width, decrDims.height);
1034: incrButton.setBounds(vr.x, trackRect.y + trackRect.height,
1035: trackRect.width, incrDims.height);
1036: }
1037:
1038:
1041: void updateThumbRect()
1042: {
1043: int max = scrollbar.getMaximum();
1044: int min = scrollbar.getMinimum();
1045: int value = scrollbar.getValue();
1046: int extent = scrollbar.getVisibleAmount();
1047: if (max - extent <= min)
1048: {
1049: if (scrollbar.getOrientation() == JScrollBar.HORIZONTAL)
1050: {
1051: thumbRect.x = trackRect.x;
1052: thumbRect.y = trackRect.y;
1053: thumbRect.width = getMinimumThumbSize().width;
1054: thumbRect.height = trackRect.height;
1055: }
1056: else
1057: {
1058: thumbRect.x = trackRect.x;
1059: thumbRect.y = trackRect.y;
1060: thumbRect.width = trackRect.width;
1061: thumbRect.height = getMinimumThumbSize().height;
1062: }
1063: }
1064: else
1065: {
1066: if (scrollbar.getOrientation() == JScrollBar.HORIZONTAL)
1067: {
1068: thumbRect.x = trackRect.x;
1069: thumbRect.width = Math.max(extent * trackRect.width / (max - min),
1070: getMinimumThumbSize().width);
1071: int availableWidth = trackRect.width - thumbRect.width;
1072: thumbRect.x += (value - min) * availableWidth / (max - min - extent);
1073: thumbRect.y = trackRect.y;
1074: thumbRect.height = trackRect.height;
1075: }
1076: else
1077: {
1078: thumbRect.x = trackRect.x;
1079: thumbRect.height = Math.max(extent * trackRect.height / (max - min),
1080: getMinimumThumbSize().height);
1081: int availableHeight = trackRect.height - thumbRect.height;
1082: thumbRect.y = trackRect.y
1083: + (value - min) * availableHeight / (max - min - extent);
1084: thumbRect.width = trackRect.width;
1085: }
1086: }
1087:
1088: }
1089:
1090:
1097: public Dimension minimumLayoutSize(Container scrollbarContainer)
1098: {
1099: return preferredLayoutSize(scrollbarContainer);
1100: }
1101:
1102:
1108: public void paint(Graphics g, JComponent c)
1109: {
1110: paintTrack(g, c, getTrackBounds());
1111: paintThumb(g, c, getThumbBounds());
1112:
1113: if (trackHighlight == INCREASE_HIGHLIGHT)
1114: paintIncreaseHighlight(g);
1115: else if (trackHighlight == DECREASE_HIGHLIGHT)
1116: paintDecreaseHighlight(g);
1117: }
1118:
1119:
1126: protected void paintDecreaseHighlight(Graphics g)
1127: {
1128: Color saved = g.getColor();
1129:
1130: g.setColor(trackHighlightColor);
1131: if (scrollbar.getOrientation() == HORIZONTAL)
1132: g.fillRect(trackRect.x, trackRect.y, thumbRect.x - trackRect.x,
1133: trackRect.height);
1134: else
1135: g.fillRect(trackRect.x, trackRect.y, trackRect.width,
1136: thumbRect.y - trackRect.y);
1137: g.setColor(saved);
1138: }
1139:
1140:
1147: protected void paintIncreaseHighlight(Graphics g)
1148: {
1149: Color saved = g.getColor();
1150:
1151: g.setColor(trackHighlightColor);
1152: if (scrollbar.getOrientation() == HORIZONTAL)
1153: g.fillRect(thumbRect.x + thumbRect.width, trackRect.y,
1154: trackRect.x + trackRect.width - thumbRect.x - thumbRect.width,
1155: trackRect.height);
1156: else
1157: g.fillRect(trackRect.x, thumbRect.y + thumbRect.height, trackRect.width,
1158: trackRect.y + trackRect.height - thumbRect.y
1159: - thumbRect.height);
1160: g.setColor(saved);
1161: }
1162:
1163:
1170: protected void paintThumb(Graphics g, JComponent c, Rectangle thumbBounds)
1171: {
1172: g.setColor(thumbColor);
1173: g.fillRect(thumbBounds.x, thumbBounds.y, thumbBounds.width,
1174: thumbBounds.height);
1175:
1176: BasicGraphicsUtils.drawBezel(g, thumbBounds.x, thumbBounds.y,
1177: thumbBounds.width, thumbBounds.height,
1178: false, false, thumbDarkShadowColor,
1179: thumbDarkShadowColor, thumbHighlightColor,
1180: thumbHighlightColor);
1181: }
1182:
1183:
1190: protected void paintTrack(Graphics g, JComponent c, Rectangle trackBounds)
1191: {
1192: Color saved = g.getColor();
1193: g.setColor(trackColor);
1194: g.fill3DRect(trackBounds.x, trackBounds.y, trackBounds.width,
1195: trackBounds.height, false);
1196: g.setColor(saved);
1197: }
1198:
1199:
1206: public Dimension preferredLayoutSize(Container scrollbarContainer)
1207: {
1208: if (scrollbarContainer instanceof JComponent)
1209: return getPreferredSize((JComponent) scrollbarContainer);
1210: else
1211: return null;
1212: }
1213:
1214:
1219: public void removeLayoutComponent(Component child)
1220: {
1221:
1222: }
1223:
1224:
1229: protected void scrollByBlock(int direction)
1230: {
1231: scrollbar.setValue(scrollbar.getValue()
1232: + scrollbar.getBlockIncrement(direction));
1233: }
1234:
1235:
1240: protected void scrollByUnit(int direction)
1241: {
1242: scrollbar.setValue(scrollbar.getValue()
1243: + scrollbar.getUnitIncrement(direction));
1244: }
1245:
1246:
1254: protected void setThumbBounds(int x, int y, int width, int height)
1255: {
1256: thumbRect.x = x;
1257: thumbRect.y = y;
1258: thumbRect.width = width;
1259: thumbRect.height = height;
1260: }
1261:
1262:
1266: protected void uninstallComponents()
1267: {
1268: if (incrButton != null)
1269: scrollbar.remove(incrButton);
1270: if (decrButton != null)
1271: scrollbar.remove(decrButton);
1272: }
1273:
1274:
1278: protected void uninstallDefaults()
1279: {
1280: scrollbar.setForeground(null);
1281: scrollbar.setBackground(null);
1282: LookAndFeel.uninstallBorder(scrollbar);
1283: incrButton = null;
1284: decrButton = null;
1285: }
1286:
1287:
1290: protected void uninstallListeners()
1291: {
1292: if (scrollTimer != null)
1293: scrollTimer.removeActionListener(scrollListener);
1294:
1295: if (scrollbar != null)
1296: {
1297: scrollbar.getModel().removeChangeListener(modelListener);
1298: scrollbar.removePropertyChangeListener(propertyChangeListener);
1299: scrollbar.removeMouseListener(trackListener);
1300: scrollbar.removeMouseMotionListener(trackListener);
1301: }
1302:
1303: if (decrButton != null)
1304: decrButton.removeMouseListener(buttonListener);
1305: if (incrButton != null)
1306: incrButton.removeMouseListener(buttonListener);
1307:
1308: propertyChangeListener = null;
1309: modelListener = null;
1310: buttonListener = null;
1311: trackListener = null;
1312: scrollListener = null;
1313: }
1314:
1315:
1322: public void uninstallUI(JComponent c)
1323: {
1324: uninstallKeyboardActions();
1325: uninstallListeners();
1326: uninstallDefaults();
1327: uninstallComponents();
1328:
1329: scrollTimer = null;
1330:
1331: thumbRect = null;
1332: trackRect = null;
1333:
1334: trackColor = null;
1335: trackHighlightColor = null;
1336: thumbColor = null;
1337: thumbHighlightColor = null;
1338: thumbDarkShadowColor = null;
1339: thumbLightShadowColor = null;
1340:
1341: scrollbar = null;
1342: }
1343:
1344:
1354: int valueForYPosition(int yPos)
1355: {
1356: int min = scrollbar.getMinimum();
1357: int max = scrollbar.getMaximum();
1358: int len = trackRect.height;
1359:
1360: int value;
1361:
1362:
1363:
1364: if (len == 0)
1365: return (max - min) / 2;
1366:
1367: value = (yPos - trackRect.y) * (max - min) / len + min;
1368:
1369:
1370: if (value > max)
1371: value = max;
1372: else if (value < min)
1373: value = min;
1374: return value;
1375: }
1376:
1377:
1387: int valueForXPosition(int xPos)
1388: {
1389: int min = scrollbar.getMinimum();
1390: int max = scrollbar.getMaximum();
1391: int len = trackRect.width;
1392:
1393: int value;
1394:
1395:
1396:
1397: if (len == 0)
1398: return (max - min) / 2;
1399:
1400: value = (xPos - trackRect.x) * (max - min) / len + min;
1401:
1402:
1403: if (value > max)
1404: value = max;
1405: else if (value < min)
1406: value = min;
1407: return value;
1408: }
1409:
1410:
1417: public boolean isThumbRollover()
1418: {
1419: return thumbRollover;
1420: }
1421:
1422:
1430: protected void setThumbRollover(boolean active)
1431: {
1432: thumbRollover = active;
1433: }
1434:
1435:
1444: public boolean getSupportsAbsolutePositioning()
1445: {
1446:
1447:
1448: return false;
1449: }
1450: }