1 /*
2 * Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.javafx.scene.control.skin;
27
28 import javafx.geometry.Orientation;
29 import javafx.geometry.Point2D;
30 import javafx.scene.AccessibleAction;
31 import javafx.scene.AccessibleAttribute;
32 import javafx.scene.AccessibleRole;
33 import javafx.scene.control.ScrollBar;
34 import javafx.scene.input.MouseButton;
35 import javafx.scene.input.ScrollEvent;
36 import javafx.scene.layout.Region;
37 import javafx.scene.layout.StackPane;
38 import javafx.scene.Node;
39 import com.sun.javafx.util.Utils;
40 import com.sun.javafx.scene.control.behavior.ScrollBarBehavior;
41
42 public class ScrollBarSkin extends BehaviorSkinBase<ScrollBar, ScrollBarBehavior> {
43
44 /***************************************************************************
45 * *
46 * UI Subcomponents *
47 * *
48 **************************************************************************/
49
50 public final static int DEFAULT_LENGTH = 100;
51 public final static int DEFAULT_WIDTH = 20;
52
53 private StackPane thumb;
54 private StackPane trackBackground;
55 private StackPane track;
56 private EndButton incButton;
57 private EndButton decButton;
58
59 private double trackLength;
60 private double thumbLength;
61
62 private double preDragThumbPos;
63 private Point2D dragStart; // in the track's coord system
64
65 private double trackPos;
66
67 /***************************************************************************
68 * *
69 * Constructors *
70 * *
71 **************************************************************************/
72
73 public ScrollBarSkin(ScrollBar scrollbar) {
74 super(scrollbar, new ScrollBarBehavior(scrollbar));
75 initialize();
76 getSkinnable().requestLayout();
77 // Register listeners
78 registerChangeListener(scrollbar.minProperty(), "MIN");
79 registerChangeListener(scrollbar.maxProperty(), "MAX");
80 registerChangeListener(scrollbar.valueProperty(), "VALUE");
81 registerChangeListener(scrollbar.orientationProperty(), "ORIENTATION");
82 registerChangeListener(scrollbar.visibleAmountProperty(), "VISIBLE_AMOUNT");
83 }
84
85 /**
86 * Initializes the ScrollBarSkin. Creates the scene and sets up all the
87 * bindings for the group.
88 */
89 private void initialize() {
90
91 track = new StackPane();
92 track.getStyleClass().setAll("track");
93
94 trackBackground = new StackPane();
95 trackBackground.getStyleClass().setAll("track-background");
96
97 thumb = new StackPane() {
98 @Override
99 public Object queryAccessibleAttribute(AccessibleAttribute attribute, Object... parameters) {
100 switch (attribute) {
101 case VALUE: return getSkinnable().getValue();
102 default: return super.queryAccessibleAttribute(attribute, parameters);
103 }
104 }
105 };
106 thumb.getStyleClass().setAll("thumb");
107 thumb.setAccessibleRole(AccessibleRole.THUMB);
108
109
110 if (!IS_TOUCH_SUPPORTED) {
111
112 incButton = new EndButton("increment-button", "increment-arrow") {
113 @Override
114 public void executeAccessibleAction(AccessibleAction action, Object... parameters) {
115 switch (action) {
116 case FIRE:
117 getSkinnable().increment();
118 break;
119 default: super.executeAccessibleAction(action, parameters);
120 }
121 }
122 };
123 incButton.setAccessibleRole(AccessibleRole.INCREMENT_BUTTON);
124 incButton.setOnMousePressed(me -> {
125 /*
126 ** if the tracklenght isn't greater than do nothing....
127 */
128 if (!thumb.isVisible() || trackLength > thumbLength) {
129 getBehavior().incButtonPressed();
130 }
131 me.consume();
132 });
133 incButton.setOnMouseReleased(me -> {
134 /*
135 ** if the tracklenght isn't greater than do nothing....
136 */
137 if (!thumb.isVisible() || trackLength > thumbLength) {
138 getBehavior().incButtonReleased();
139 }
140 me.consume();
141 });
142
143 decButton = new EndButton("decrement-button", "decrement-arrow") {
144 @Override
145 public void executeAccessibleAction(AccessibleAction action, Object... parameters) {
146 switch (action) {
147 case FIRE:
148 getSkinnable().decrement();
149 break;
150 default: super.executeAccessibleAction(action, parameters);
151 }
152 }
153 };
154 decButton.setAccessibleRole(AccessibleRole.DECREMENT_BUTTON);
155 decButton.setOnMousePressed(me -> {
156 /*
157 ** if the tracklenght isn't greater than do nothing....
158 */
159 if (!thumb.isVisible() || trackLength > thumbLength) {
160 getBehavior().decButtonPressed();
161 }
162 me.consume();
163 });
164 decButton.setOnMouseReleased(me -> {
165 /*
166 ** if the tracklenght isn't greater than do nothing....
167 */
168 if (!thumb.isVisible() || trackLength > thumbLength) {
169 getBehavior().decButtonReleased();
170 }
171 me.consume();
172 });
173 }
174
175
176 track.setOnMousePressed(me -> {
177 if (!thumb.isPressed() && me.getButton() == MouseButton.PRIMARY) {
178 if (getSkinnable().getOrientation() == Orientation.VERTICAL) {
179 if (trackLength != 0) {
180 getBehavior().trackPress(me.getY() / trackLength);
181 me.consume();
182 }
183 } else {
184 if (trackLength != 0) {
185 getBehavior().trackPress(me.getX() / trackLength);
186 me.consume();
187 }
188 }
189 }
190 });
191
192 track.setOnMouseReleased(me -> {
193 getBehavior().trackRelease();
194 me.consume();
195 });
196
197 thumb.setOnMousePressed(me -> {
198 if (me.isSynthesized()) {
199 // touch-screen events handled by Scroll handler
200 me.consume();
201 return;
202 }
203 /*
204 ** if max isn't greater than min then there is nothing to do here
205 */
206 if (getSkinnable().getMax() > getSkinnable().getMin()) {
207 dragStart = thumb.localToParent(me.getX(), me.getY());
208 double clampedValue = Utils.clamp(getSkinnable().getMin(), getSkinnable().getValue(), getSkinnable().getMax());
209 preDragThumbPos = (clampedValue - getSkinnable().getMin()) / (getSkinnable().getMax() - getSkinnable().getMin());
210 me.consume();
211 }
212 });
213
214
215 thumb.setOnMouseDragged(me -> {
216 if (me.isSynthesized()) {
217 // touch-screen events handled by Scroll handler
218 me.consume();
219 return;
220 }
221 /*
222 ** if max isn't greater than min then there is nothing to do here
223 */
224 if (getSkinnable().getMax() > getSkinnable().getMin()) {
225 /*
226 ** if the tracklength isn't greater then do nothing....
227 */
228 if (trackLength > thumbLength) {
229 Point2D cur = thumb.localToParent(me.getX(), me.getY());
230 if (dragStart == null) {
231 // we're getting dragged without getting a mouse press
232 dragStart = thumb.localToParent(me.getX(), me.getY());
233 }
234 double dragPos = getSkinnable().getOrientation() == Orientation.VERTICAL ? cur.getY() - dragStart.getY(): cur.getX() - dragStart.getX();
235 getBehavior().thumbDragged(preDragThumbPos + dragPos / (trackLength - thumbLength));
236 }
237
238 me.consume();
239 }
240 });
241
242 thumb.setOnScrollStarted(se -> {
243 if (se.isDirect()) {
244 /*
245 ** if max isn't greater than min then there is nothing to do here
246 */
247 if (getSkinnable().getMax() > getSkinnable().getMin()) {
248 dragStart = thumb.localToParent(se.getX(), se.getY());
249 double clampedValue = Utils.clamp(getSkinnable().getMin(), getSkinnable().getValue(), getSkinnable().getMax());
250 preDragThumbPos = (clampedValue - getSkinnable().getMin()) / (getSkinnable().getMax() - getSkinnable().getMin());
251 se.consume();
252 }
253 }
254 });
255
256 thumb.setOnScroll(event -> {
257 if (event.isDirect()) {
258 /*
259 ** if max isn't greater than min then there is nothing to do here
260 */
261 if (getSkinnable().getMax() > getSkinnable().getMin()) {
262 /*
263 ** if the tracklength isn't greater then do nothing....
264 */
265 if (trackLength > thumbLength) {
266 Point2D cur = thumb.localToParent(event.getX(), event.getY());
267 if (dragStart == null) {
268 // we're getting dragged without getting a mouse press
269 dragStart = thumb.localToParent(event.getX(), event.getY());
270 }
271 double dragPos = getSkinnable().getOrientation() == Orientation.VERTICAL ? cur.getY() - dragStart.getY(): cur.getX() - dragStart.getX();
272 getBehavior().thumbDragged(/*todo*/ preDragThumbPos + dragPos / (trackLength - thumbLength));
273 }
274
275 event.consume();
276 return;
277 }
278 }
279 });
280
281
282 getSkinnable().addEventHandler(ScrollEvent.SCROLL, event -> {
283 /*
284 ** if the tracklength isn't greater then do nothing....
285 */
286 if (trackLength > thumbLength) {
287
288 double dx = event.getDeltaX();
289 double dy = event.getDeltaY();
290
291 /*
292 ** in 2.0 a horizontal scrollbar would scroll on a vertical
293 ** drag on a tracker-pad. We need to keep this behavior.
294 */
295 dx = (Math.abs(dx) < Math.abs(dy) ? dy : dx);
296
297 /*
298 ** we only consume an event that we've used.
299 */
300 ScrollBar sb = (ScrollBar) getSkinnable();
301
302 double delta = (getSkinnable().getOrientation() == Orientation.VERTICAL ? dy : dx);
303
304 /*
305 ** RT-22941 - If this is either a touch or inertia scroll
306 ** then we move to the position of the touch point.
307 *
308 * TODO: this fix causes RT-23406 ([ScrollBar, touch] Dragging scrollbar from the
309 * track on touchscreen causes flickering)
310 */
311 if (event.isDirect()) {
312 if (trackLength > thumbLength) {
313 getBehavior().thumbDragged((getSkinnable().getOrientation() == Orientation.VERTICAL ? event.getY(): event.getX()) / trackLength);
314 event.consume();
315 }
316 }
317 else {
318 if (delta > 0.0 && sb.getValue() > sb.getMin()) {
319 sb.decrement();
320 event.consume();
321 } else if (delta < 0.0 && sb.getValue() < sb.getMax()) {
322 sb.increment();
323 event.consume();
324 }
325 }
326 }
327 });
328
329 getChildren().clear();
330 if (!IS_TOUCH_SUPPORTED) {
331 getChildren().addAll(trackBackground, incButton, decButton, track, thumb);
332 }
333 else {
334 getChildren().addAll(track, thumb);
335 }
336 }
337
338
339
340 @Override protected void handleControlPropertyChanged(String p) {
341 super.handleControlPropertyChanged(p);
342 if ("ORIENTATION".equals(p)) {
343 getSkinnable().requestLayout();
344 } else if ("MIN".equals(p) || "MAX".equals(p) || "VISIBLE_AMOUNT".equals(p)) {
345 positionThumb();
346 getSkinnable().requestLayout();
347 } else if ("VALUE".equals(p)) {
348 positionThumb();
349 }
350 }
351
352 /***************************************************************************
353 * *
354 * Layout *
355 * *
356 **************************************************************************/
357
358 private static final double DEFAULT_EMBEDDED_SB_BREADTH = 8.0;
359
360 /*
361 * Gets the breadth of the scrollbar. The "breadth" is the distance
362 * across the scrollbar, i.e. if vertical the width, otherwise the height.
363 * On desktop this is determined by the greater of the breadths of the end-buttons.
364 * Embedded doesn't have end-buttons, so currently we use a default breadth.
365 * We should change this when we get width/height css properties.
366 */
367 double getBreadth() {
368 if (!IS_TOUCH_SUPPORTED) {
369 if (getSkinnable().getOrientation() == Orientation.VERTICAL) {
370 return Math.max(decButton.prefWidth(-1), incButton.prefWidth(-1)) +snappedLeftInset()+snappedRightInset();
371 } else {
372 return Math.max(decButton.prefHeight(-1), incButton.prefHeight(-1)) +snappedTopInset()+snappedBottomInset();
373 }
374 }
375 else {
376 if (getSkinnable().getOrientation() == Orientation.VERTICAL) {
377 return Math.max(DEFAULT_EMBEDDED_SB_BREADTH, DEFAULT_EMBEDDED_SB_BREADTH)+snappedLeftInset()+snappedRightInset();
378 } else {
379 return Math.max(DEFAULT_EMBEDDED_SB_BREADTH, DEFAULT_EMBEDDED_SB_BREADTH)+snappedTopInset()+snappedBottomInset();
380 }
381 }
382 }
383
384 double minThumbLength() {
385 return 1.5f * getBreadth();
386 }
387
388 double minTrackLength() {
389 return 2.0f * getBreadth();
390 }
391
392 /*
393 * Minimum length is the length of the end buttons plus twice the
394 * minimum thumb length, which should be enough for a reasonably-sized
395 * track. Minimum breadth is determined by the breadths of the
396 * end buttons.
397 */
398 @Override protected double computeMinWidth(double height, double topInset, double rightInset, double bottomInset, double leftInset) {
399 if (getSkinnable().getOrientation() == Orientation.VERTICAL) {
400 return getBreadth();
401 } else {
402 if (!IS_TOUCH_SUPPORTED) {
403 return decButton.minWidth(-1) + incButton.minWidth(-1) + minTrackLength()+leftInset+rightInset;
404 } else {
405 return minTrackLength()+leftInset+rightInset;
406 }
407 }
408 }
409
410 @Override protected double computeMinHeight(double width, double topInset, double rightInset, double bottomInset, double leftInset) {
411 if (getSkinnable().getOrientation() == Orientation.VERTICAL) {
412 if (!IS_TOUCH_SUPPORTED) {
413 return decButton.minHeight(-1) + incButton.minHeight(-1) + minTrackLength()+topInset+bottomInset;
414 } else {
415 return minTrackLength()+topInset+bottomInset;
416 }
417 } else {
418 return getBreadth();
419 }
420 }
421
422 /*
423 * Preferred size. The breadth is determined by the breadth of
424 * the end buttons. The length is a constant default length.
425 * Usually applications or other components will either set a
426 * specific length using LayoutInfo or will stretch the length
427 * of the scrollbar to fit a container.
428 */
429 @Override protected double computePrefWidth(double height, double topInset, double rightInset, double bottomInset, double leftInset) {
430 final ScrollBar s = getSkinnable();
431 return s.getOrientation() == Orientation.VERTICAL ? getBreadth() : DEFAULT_LENGTH+leftInset+rightInset;
432 }
433
434 @Override protected double computePrefHeight(double height, double topInset, double rightInset, double bottomInset, double leftInset) {
435 final ScrollBar s = getSkinnable();
436 return s.getOrientation() == Orientation.VERTICAL ? DEFAULT_LENGTH+topInset+bottomInset : getBreadth();
437 }
438
439 @Override protected double computeMaxWidth(double height, double topInset, double rightInset, double bottomInset, double leftInset) {
440 final ScrollBar s = getSkinnable();
441 return s.getOrientation() == Orientation.VERTICAL ? s.prefWidth(-1) : Double.MAX_VALUE;
442 }
443
444 @Override protected double computeMaxHeight(double width, double topInset, double rightInset, double bottomInset, double leftInset) {
445 final ScrollBar s = getSkinnable();
446 return s.getOrientation() == Orientation.VERTICAL ? Double.MAX_VALUE : s.prefHeight(-1);
447 }
448
449 /**
450 * Called when ever either min, max or value changes, so thumb's layoutX, Y is recomputed.
451 */
452 void positionThumb() {
453 ScrollBar s = getSkinnable();
454 double clampedValue = Utils.clamp(s.getMin(), s.getValue(), s.getMax());
455 trackPos = (s.getMax() - s.getMin() > 0) ? ((trackLength - thumbLength) * (clampedValue - s.getMin()) / (s.getMax() - s.getMin())) : (0.0F);
456
457 if (!IS_TOUCH_SUPPORTED) {
458 if (s.getOrientation() == Orientation.VERTICAL) {
459 trackPos += decButton.prefHeight(-1);
460 } else {
461 trackPos += decButton.prefWidth(-1);
462 }
463 }
464
465 thumb.setTranslateX( snapPosition(s.getOrientation() == Orientation.VERTICAL ? snappedLeftInset() : trackPos + snappedLeftInset()));
466 thumb.setTranslateY( snapPosition(s.getOrientation() == Orientation.VERTICAL ? trackPos + snappedTopInset() : snappedTopInset()));
467 }
468
469 @Override protected void layoutChildren(final double x, final double y,
470 final double w, final double h) {
471
472 final ScrollBar s = getSkinnable();
473
474 /**
475 * Compute the percentage length of thumb as (visibleAmount/range)
476 * if max isn't greater than min then there is nothing to do here
477 */
478 double visiblePortion;
479 if (s.getMax() > s.getMin()) {
480 visiblePortion = s.getVisibleAmount()/(s.getMax() - s.getMin());
481 }
482 else {
483 visiblePortion = 1.0;
484 }
485
486 if (s.getOrientation() == Orientation.VERTICAL) {
487 if (!IS_TOUCH_SUPPORTED) {
488 double decHeight = snapSize(decButton.prefHeight(-1));
489 double incHeight = snapSize(incButton.prefHeight(-1));
490
491 decButton.resize(w, decHeight);
492 incButton.resize(w, incHeight);
493
494 trackLength = snapSize(h - (decHeight + incHeight));
495 thumbLength = snapSize(Utils.clamp(minThumbLength(), (trackLength * visiblePortion), trackLength));
496
497 trackBackground.resizeRelocate(snapPosition(x), snapPosition(y), w, trackLength+decHeight+incHeight);
498 decButton.relocate(snapPosition(x), snapPosition(y));
499 incButton.relocate(snapPosition(x), snapPosition(y + h - incHeight));
500 track.resizeRelocate(snapPosition(x), snapPosition(y + decHeight), w, trackLength);
501 thumb.resize(snapSize(x >= 0 ? w : w + x), thumbLength); // Account for negative padding (see also RT-10719)
502 positionThumb();
503 }
504 else {
505 trackLength = snapSize(h);
506 thumbLength = snapSize(Utils.clamp(minThumbLength(), (trackLength * visiblePortion), trackLength));
507
508 track.resizeRelocate(snapPosition(x), snapPosition(y), w, trackLength);
509 thumb.resize(snapSize(x >= 0 ? w : w + x), thumbLength); // Account for negative padding (see also RT-10719)
510 positionThumb();
511 }
512 } else {
513 if (!IS_TOUCH_SUPPORTED) {
514 double decWidth = snapSize(decButton.prefWidth(-1));
515 double incWidth = snapSize(incButton.prefWidth(-1));
516
517 decButton.resize(decWidth, h);
518 incButton.resize(incWidth, h);
519
520 trackLength = snapSize(w - (decWidth + incWidth));
521 thumbLength = snapSize(Utils.clamp(minThumbLength(), (trackLength * visiblePortion), trackLength));
522
523 trackBackground.resizeRelocate(snapPosition(x), snapPosition(y), trackLength+decWidth+incWidth, h);
524 decButton.relocate(snapPosition(x), snapPosition(y));
525 incButton.relocate(snapPosition(x + w - incWidth), snapPosition(y));
526 track.resizeRelocate(snapPosition(x + decWidth), snapPosition(y), trackLength, h);
527 thumb.resize(thumbLength, snapSize(y >= 0 ? h : h + y)); // Account for negative padding (see also RT-10719)
528 positionThumb();
529 }
530 else {
531 trackLength = snapSize(w);
532 thumbLength = snapSize(Utils.clamp(minThumbLength(), (trackLength * visiblePortion), trackLength));
533
534 track.resizeRelocate(snapPosition(x), snapPosition(y), trackLength, h);
535 thumb.resize(thumbLength, snapSize(y >= 0 ? h : h + y)); // Account for negative padding (see also RT-10719)
536 positionThumb();
537 }
538
539 s.resize(snapSize(s.getWidth()), snapSize(s.getHeight()));
540 }
541
542 // things should be invisible only when well below minimum length
543 if (s.getOrientation() == Orientation.VERTICAL && h >= (computeMinHeight(-1, (int)y , snappedRightInset(), snappedBottomInset(), (int)x) - (y+snappedBottomInset())) ||
544 s.getOrientation() == Orientation.HORIZONTAL && w >= (computeMinWidth(-1, (int)y , snappedRightInset(), snappedBottomInset(), (int)x) - (x+snappedRightInset()))) {
545 trackBackground.setVisible(true);
546 track.setVisible(true);
547 thumb.setVisible(true);
548 if (!IS_TOUCH_SUPPORTED) {
549 incButton.setVisible(true);
550 decButton.setVisible(true);
551 }
552 }
553 else {
554 trackBackground.setVisible(false);
555 track.setVisible(false);
556 thumb.setVisible(false);
557
558 if (!IS_TOUCH_SUPPORTED) {
559 /*
560 ** once the space is big enough for one button we
561 ** can look at drawing
562 */
563 if (h >= decButton.computeMinWidth(-1)) {
564 decButton.setVisible(true);
565 }
566 else {
567 decButton.setVisible(false);
568 }
569 if (h >= incButton.computeMinWidth(-1)) {
570 incButton.setVisible(true);
571 }
572 else {
573 incButton.setVisible(false);
574 }
575 }
576 }
577 }
578
579
580 public Node getThumb() {
581 return thumb;
582 }
583
584 public Node getTrack() {
585 return track;
586 }
587
588 public Node getIncButton() {
589 return incButton;
590 }
591
592 public Node getDecButton() {
593 return decButton;
594 }
595
596 private static class EndButton extends Region {
597 private Region arrow;
598
599 private EndButton(String styleClass, String arrowStyleClass) {
600 getStyleClass().setAll(styleClass);
601 arrow = new Region();
602 arrow.getStyleClass().setAll(arrowStyleClass);
603 getChildren().setAll(arrow);
604 requestLayout();
605 }
606
607 @Override protected void layoutChildren() {
608 final double top = snappedTopInset();
609 final double left = snappedLeftInset();
610 final double bottom = snappedBottomInset();
611 final double right = snappedRightInset();
612 final double aw = snapSize(arrow.prefWidth(-1));
613 final double ah = snapSize(arrow.prefHeight(-1));
614 final double yPos = snapPosition((getHeight() - (top + bottom + ah)) / 2.0);
615 final double xPos = snapPosition((getWidth() - (left + right + aw)) / 2.0);
616 arrow.resizeRelocate(xPos + left, yPos + top, aw, ah);
617 }
618
619 @Override protected double computeMinHeight(double width) {
620 return prefHeight(-1);
621 }
622
623 @Override protected double computeMinWidth(double height) {
624 return prefWidth(-1);
625 }
626
627 @Override protected double computePrefWidth(double height) {
628 final double left = snappedLeftInset();
629 final double right = snappedRightInset();
630 final double aw = snapSize(arrow.prefWidth(-1));
631 return left + aw + right;
632 }
633
634 @Override protected double computePrefHeight(double width) {
635 final double top = snappedTopInset();
636 final double bottom = snappedBottomInset();
637 final double ah = snapSize(arrow.prefHeight(-1));
638 return top + ah + bottom;
639 }
640 }
641 }