1 /*
2 * Copyright (c) 2010, 2014, 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.util;
27
28 import javafx.geometry.BoundingBox;
29 import javafx.geometry.Bounds;
30 import javafx.geometry.HPos;
31 import javafx.geometry.NodeOrientation;
32 import javafx.geometry.Point2D;
33 import javafx.geometry.Rectangle2D;
34 import javafx.geometry.VPos;
35 import javafx.scene.Node;
36 import javafx.scene.Scene;
37 import javafx.scene.paint.Color;
38 import javafx.scene.paint.Stop;
39 import javafx.stage.Screen;
40 import javafx.stage.Stage;
41 import javafx.stage.Window;
42 import java.util.List;
43 import com.sun.javafx.PlatformUtil;
44 import com.sun.javafx.stage.StageHelper;
45
46 /**
47 * Some basic utilities which need to be in java (for shifting operations or
48 * other reasons), which are not toolkit dependent.
49 *
50 */
51 public class Utils {
52
53 /***************************************************************************
54 * *
55 * Math-related utilities *
56 * *
57 **************************************************************************/
58
59 /**
60 * Simple utility function which clamps the given value to be strictly
61 * between the min and max values.
62 */
63 public static float clamp(float min, float value, float max) {
64 if (value < min) return min;
65 if (value > max) return max;
66 return value;
67 }
68
69 /**
70 * Simple utility function which clamps the given value to be strictly
71 * between the min and max values.
72 */
73 public static int clamp(int min, int value, int max) {
74 if (value < min) return min;
75 if (value > max) return max;
76 return value;
77 }
78
79 /**
80 * Simple utility function which clamps the given value to be strictly
81 * between the min and max values.
82 */
83 public static double clamp(double min, double value, double max) {
84 if (value < min) return min;
85 if (value > max) return max;
86 return value;
87 }
88
89 /**
90 * Simple utility function which clamps the given value to be strictly
91 * above the min value.
92 */
93 public static double clampMin(double value, double min) {
94 if (value < min) return min;
95 return value;
96 }
97
98 /**
99 * Simple utility function which clamps the given value to be strictly
100 * under the max value.
101 */
102 public static int clampMax(int value, int max) {
103 if (value > max) return max;
104 return value;
105 }
106
107 /**
108 * Utility function which returns either {@code less} or {@code more}
109 * depending on which {@code value} is closer to. If {@code value}
110 * is perfectly between them, then either may be returned.
111 */
112 public static double nearest(double less, double value, double more) {
113 double lessDiff = value - less;
114 double moreDiff = more - value;
115 if (lessDiff < moreDiff) return less;
116 return more;
117 }
118
119 /***************************************************************************
120 * *
121 * String-related utilities *
122 * *
123 **************************************************************************/
124
125 /**
126 * Helper to remove leading and trailing quotes from a string.
127 * Works with single or double quotes.
128 */
129 public static String stripQuotes(String str) {
130 if (str == null) return str;
131 if (str.length() == 0) return str;
132
133 int beginIndex = 0;
134 final char openQuote = str.charAt(beginIndex);
135 if ( openQuote == '\"' || openQuote=='\'' ) beginIndex += 1;
136
137 int endIndex = str.length();
138 final char closeQuote = str.charAt(endIndex - 1);
139 if ( closeQuote == '\"' || closeQuote=='\'' ) endIndex -= 1;
140
141 if ((endIndex - beginIndex) < 0) return str;
142
143 // note that String.substring returns "this" if beginIndex == 0 && endIndex == count
144 // or a new string that shares the character buffer with the original string.
145 return str.substring(beginIndex, endIndex);
146 }
147
148 /**
149 * Because mobile doesn't have string.split(s) function, this function
150 * was written.
151 */
152 public static String[] split(String str, String separator) {
153 if (str == null || str.length() == 0) return new String[] { };
154 if (separator == null || separator.length() == 0) return new String[] { };
155 if (separator.length() > str.length()) return new String[] { };
156
157 java.util.List<String> result = new java.util.ArrayList<String>();
158
159 int index = str.indexOf(separator);
160 while (index >= 0) {
161 String newStr = str.substring(0, index);
162 if (newStr != null && newStr.length() > 0) {
163 result.add(newStr);
164 }
165 str = str.substring(index + separator.length());
166 index = str.indexOf(separator);
167 }
168
169 if (str != null && str.length() > 0) {
170 result.add(str);
171 }
172
173 return result.toArray(new String[] { });
174 }
175
176 /**
177 * Because mobile doesn't have string.contains(s) function, this function
178 * was written.
179 */
180 public static boolean contains(String src, String s) {
181 if (src == null || src.length() == 0) return false;
182 if (s == null || s.length() == 0) return false;
183 if (s.length() > src.length()) return false;
184
185 return src.indexOf(s) > -1;
186 }
187
188 /***************************************************************************
189 * *
190 * Color-related utilities *
191 * *
192 **************************************************************************/
193
194 /**
195 * Calculates a perceptual brightness for a color between 0.0 black and 1.0 while
196 */
197 public static double calculateBrightness(Color color) {
198 return (0.3*color.getRed()) + (0.59*color.getGreen()) + (0.11*color.getBlue());
199 }
200
201 /**
202 * Derives a lighter or darker of a given color.
203 *
204 * @param c The color to derive from
205 * @param brightness The brightness difference for the new color -1.0 being 100% dark which is always black, 0.0 being
206 * no change and 1.0 being 100% lighter which is always white
207 */
208 public static Color deriveColor(Color c, double brightness) {
209 double baseBrightness = calculateBrightness(c);
210 double calcBrightness = brightness;
211 // Fine adjustments to colors in ranges of brightness to adjust the contrast for them
212 if (brightness > 0) {
213 if (baseBrightness > 0.85) {
214 calcBrightness = calcBrightness * 1.6;
215 } else if (baseBrightness > 0.6) {
216 // no change
217 } else if (baseBrightness > 0.5) {
218 calcBrightness = calcBrightness * 0.9;
219 } else if (baseBrightness > 0.4) {
220 calcBrightness = calcBrightness * 0.8;
221 } else if (baseBrightness > 0.3) {
222 calcBrightness = calcBrightness * 0.7;
223 } else {
224 calcBrightness = calcBrightness * 0.6;
225 }
226 } else {
227 if (baseBrightness < 0.2) {
228 calcBrightness = calcBrightness * 0.6;
229 }
230 }
231 // clamp brightness
232 if (calcBrightness < -1) { calcBrightness = -1; } else if (calcBrightness > 1) {calcBrightness = 1;}
233 // window two take the calculated brightness multiplyer and derive color based on source color
234 double[] hsb = RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue());
235 // change brightness
236 if (calcBrightness > 0) { // brighter
237 hsb[1] *= 1 - calcBrightness;
238 hsb[2] += (1 - hsb[2]) * calcBrightness;
239 } else { // darker
240 hsb[2] *= calcBrightness + 1;
241 }
242 // clip saturation and brightness
243 if (hsb[1] < 0) { hsb[1] = 0;} else if (hsb[1] > 1) {hsb[1] = 1;}
244 if (hsb[2] < 0) { hsb[2] = 0;} else if (hsb[2] > 1) {hsb[2] = 1;}
245 // convert back to color
246 Color c2 = Color.hsb((int)hsb[0], hsb[1], hsb[2],c.getOpacity());
247 return Color.hsb((int)hsb[0], hsb[1], hsb[2],c.getOpacity());
248
249 /* var hsb:Number[] = RGBtoHSB(c.red,c.green,c.blue);
250 // change brightness
251 if (brightness > 0) {
252 //var bright:Number = brightness * (1-calculateBrightness(c));
253 var bright:Number = if (calculateBrightness(c)<0.65 and brightness > 0.5) {
254 if (calculateBrightness(c)<0.2) then brightness * 0.55 else brightness * 0.7
255 } else brightness;
256 // brighter
257 hsb[1] *= 1 - bright;
258 hsb[2] += (1 - hsb[2]) * bright;
259 } else {
260 // darker
261 hsb[2] *= brightness+1;
262 }
263 // clip saturation and brightness
264 if (hsb[1] < 0) { hsb[1] = 0;} else if (hsb[1] > 1) {hsb[1] = 1}
265 if (hsb[2] < 0) { hsb[2] = 0;} else if (hsb[2] > 1) {hsb[2] = 1}
266 // convert back to color
267 return Color.hsb(hsb[0],hsb[1],hsb[2]) */
268 }
269
270 /**
271 * interpolate at a set {@code position} between two colors {@code color1} and {@code color2}.
272 * The interpolation is done is linear RGB color space not the default sRGB color space.
273 */
274 private static Color interpolateLinear(double position, Color color1, Color color2) {
275 Color c1Linear = convertSRGBtoLinearRGB(color1);
276 Color c2Linear = convertSRGBtoLinearRGB(color2);
277 return convertLinearRGBtoSRGB(Color.color(
278 c1Linear.getRed() + (c2Linear.getRed() - c1Linear.getRed()) * position,
279 c1Linear.getGreen() + (c2Linear.getGreen() - c1Linear.getGreen()) * position,
280 c1Linear.getBlue() + (c2Linear.getBlue() - c1Linear.getBlue()) * position,
281 c1Linear.getOpacity() + (c2Linear.getOpacity() - c1Linear.getOpacity()) * position
282 ));
283 }
284
285 /**
286 * Get the color at the give {@code position} in the ladder of color stops
287 */
288 private static Color ladder(final double position, final Stop[] stops) {
289 Stop prevStop = null;
290 for (int i=0; i<stops.length; i++) {
291 Stop stop = stops[i];
292 if(position <= stop.getOffset()){
293 if (prevStop == null) {
294 return stop.getColor();
295 } else {
296 return interpolateLinear((position-prevStop.getOffset())/(stop.getOffset()-prevStop.getOffset()), prevStop.getColor(), stop.getColor());
297 }
298 }
299 prevStop = stop;
300 }
301 // position is greater than biggest stop, so will we biggest stop's color
302 return prevStop.getColor();
303 }
304
305 /**
306 * Get the color at the give {@code position} in the ladder of color stops
307 */
308 public static Color ladder(final Color color, final Stop[] stops) {
309 return ladder(calculateBrightness(color), stops);
310 }
311
312 public static double[] HSBtoRGB(double hue, double saturation, double brightness) {
313 // normalize the hue
314 double normalizedHue = ((hue % 360) + 360) % 360;
315 hue = normalizedHue/360;
316
317 double r = 0, g = 0, b = 0;
318 if (saturation == 0) {
319 r = g = b = brightness;
320 } else {
321 double h = (hue - Math.floor(hue)) * 6.0;
322 double f = h - java.lang.Math.floor(h);
323 double p = brightness * (1.0 - saturation);
324 double q = brightness * (1.0 - saturation * f);
325 double t = brightness * (1.0 - (saturation * (1.0 - f)));
326 switch ((int) h) {
327 case 0:
328 r = brightness;
329 g = t;
330 b = p;
331 break;
332 case 1:
333 r = q;
334 g = brightness;
335 b = p;
336 break;
337 case 2:
338 r = p;
339 g = brightness;
340 b = t;
341 break;
342 case 3:
343 r = p;
344 g = q;
345 b = brightness;
346 break;
347 case 4:
348 r = t;
349 g = p;
350 b = brightness;
351 break;
352 case 5:
353 r = brightness;
354 g = p;
355 b = q;
356 break;
357 }
358 }
359 double[] f = new double[3];
360 f[0] = r;
361 f[1] = g;
362 f[2] = b;
363 return f;
364 }
365
366 public static double[] RGBtoHSB(double r, double g, double b) {
367 double hue, saturation, brightness;
368 double[] hsbvals = new double[3];
369 double cmax = (r > g) ? r : g;
370 if (b > cmax) cmax = b;
371 double cmin = (r < g) ? r : g;
372 if (b < cmin) cmin = b;
373
374 brightness = cmax;
375 if (cmax != 0)
376 saturation = (double) (cmax - cmin) / cmax;
377 else
378 saturation = 0;
379
380 if (saturation == 0) {
381 hue = 0;
382 } else {
383 double redc = (cmax - r) / (cmax - cmin);
384 double greenc = (cmax - g) / (cmax - cmin);
385 double bluec = (cmax - b) / (cmax - cmin);
386 if (r == cmax)
387 hue = bluec - greenc;
388 else if (g == cmax)
389 hue = 2.0 + redc - bluec;
390 else
391 hue = 4.0 + greenc - redc;
392 hue = hue / 6.0;
393 if (hue < 0)
394 hue = hue + 1.0;
395 }
396 hsbvals[0] = hue * 360;
397 hsbvals[1] = saturation;
398 hsbvals[2] = brightness;
399 return hsbvals;
400 }
401
402 /**
403 * Helper function to convert a color in sRGB space to linear RGB space.
404 */
405 public static Color convertSRGBtoLinearRGB(Color color) {
406 double[] colors = new double[] { color.getRed(), color.getGreen(), color.getBlue() };
407 for (int i=0; i<colors.length; i++) {
408 if (colors[i] <= 0.04045) {
409 colors[i] = colors[i] / 12.92;
410 } else {
411 colors[i] = Math.pow((colors[i] + 0.055) / 1.055, 2.4);
412 }
413 }
414 return Color.color(colors[0], colors[1], colors[2], color.getOpacity());
415 }
416
417 /**
418 * Helper function to convert a color in linear RGB space to SRGB space.
419 */
420 public static Color convertLinearRGBtoSRGB(Color color) {
421 double[] colors = new double[] { color.getRed(), color.getGreen(), color.getBlue() };
422 for (int i=0; i<colors.length; i++) {
423 if (colors[i] <= 0.0031308) {
424 colors[i] = colors[i] * 12.92;
425 } else {
426 colors[i] = (1.055 * Math.pow(colors[i], (1.0 / 2.4))) - 0.055;
427 }
428 }
429 return Color.color(colors[0], colors[1], colors[2], color.getOpacity());
430 }
431
432 /** helper function for calculating the sum of a series of numbers */
433 public static double sum(double[] values) {
434 double sum = 0;
435 for (double v : values) sum = sum+v;
436 return sum / values.length;
437 }
438
439 public static Point2D pointRelativeTo(Node parent, Node node, HPos hpos,
440 VPos vpos, double dx, double dy, boolean reposition)
441 {
442 final double nodeWidth = node.getLayoutBounds().getWidth();
443 final double nodeHeight = node.getLayoutBounds().getHeight();
444 return pointRelativeTo(parent, nodeWidth, nodeHeight, hpos, vpos, dx, dy, reposition);
445 }
446
447 public static Point2D pointRelativeTo(Node parent, double anchorWidth,
448 double anchorHeight, HPos hpos, VPos vpos, double dx, double dy,
449 boolean reposition)
450 {
451 final Bounds parentBounds = getBounds(parent);
452 Scene scene = parent.getScene();
453 NodeOrientation orientation = parent.getEffectiveNodeOrientation();
454
455 if (orientation == NodeOrientation.RIGHT_TO_LEFT) {
456 if (hpos == HPos.LEFT) {
457 hpos = HPos.RIGHT;
458 } else if (hpos == HPos.RIGHT) {
459 hpos = HPos.LEFT;
460 }
461 dx *= -1;
462 }
463
464 double layoutX = positionX(parentBounds, anchorWidth, hpos) + dx;
465 final double layoutY = positionY(parentBounds, anchorHeight, vpos) + dy;
466
467 if (orientation == NodeOrientation.RIGHT_TO_LEFT && hpos == HPos.CENTER) {
468 //TODO - testing for an instance of Stage seems wrong but works for menus
469 if (scene.getWindow() instanceof Stage) {
470 layoutX = layoutX + parentBounds.getWidth() - anchorWidth;
471 } else {
472 layoutX = layoutX - parentBounds.getWidth() - anchorWidth;
473 }
474 }
475
476 if (reposition) {
477 return pointRelativeTo(parent, anchorWidth, anchorHeight, layoutX, layoutY, hpos, vpos);
478 } else {
479 return new Point2D(layoutX, layoutY);
480 }
481 }
482
483 /**
484 * This is the fallthrough function that most other functions fall into. It takes
485 * care specifically of the repositioning of the item such that it remains onscreen
486 * as best it can, given it's unique qualities.
487 *
488 * As will all other functions, this one returns a Point2D that represents an x,y
489 * location that should safely position the item onscreen as best as possible.
490 *
491 * Note that <code>width</code> and <height> refer to the width and height of the
492 * node/popup that is needing to be repositioned, not of the parent.
493 *
494 * Don't use the BASELINE vpos, it doesn't make sense and would produce wrong result.
495 */
496 public static Point2D pointRelativeTo(Object parent, double width,
497 double height, double screenX, double screenY, HPos hpos, VPos vpos)
498 {
499 double finalScreenX = screenX;
500 double finalScreenY = screenY;
501 final Bounds parentBounds = getBounds(parent);
502
503 // ...and then we get the bounds of this screen
504 final Screen currentScreen = getScreen(parent);
505 final Rectangle2D screenBounds =
506 hasFullScreenStage(currentScreen)
507 ? currentScreen.getBounds()
508 : currentScreen.getVisualBounds();
509
510 // test if this layout will force the node to appear outside
511 // of the screens bounds. If so, we must reposition the item to a better position.
512 // We firstly try to do this intelligently, so as to not overlap the parent if
513 // at all possible.
514 if (hpos != null) {
515 // Firstly we consider going off the right hand side
516 if ((finalScreenX + width) > screenBounds.getMaxX()) {
517 finalScreenX = positionX(parentBounds, width, getHPosOpposite(hpos, vpos));
518 }
519
520 // don't let the node go off to the left of the current screen
521 if (finalScreenX < screenBounds.getMinX()) {
522 finalScreenX = positionX(parentBounds, width, getHPosOpposite(hpos, vpos));
523 }
524 }
525
526 if (vpos != null) {
527 // don't let the node go off the bottom of the current screen
528 if ((finalScreenY + height) > screenBounds.getMaxY()) {
529 finalScreenY = positionY(parentBounds, height, getVPosOpposite(hpos,vpos));
530 }
531
532 // don't let the node out of the top of the current screen
533 if (finalScreenY < screenBounds.getMinY()) {
534 finalScreenY = positionY(parentBounds, height, getVPosOpposite(hpos,vpos));
535 }
536 }
537
538 // --- after all the moving around, we do one last check / rearrange.
539 // Unlike the check above, this time we are just fully committed to keeping
540 // the item on screen at all costs, regardless of whether or not that results
541 /// in overlapping the parent object.
542 if ((finalScreenX + width) > screenBounds.getMaxX()) {
543 finalScreenX -= (finalScreenX + width - screenBounds.getMaxX());
544 }
545 if (finalScreenX < screenBounds.getMinX()) {
546 finalScreenX = screenBounds.getMinX();
547 }
548 if ((finalScreenY + height) > screenBounds.getMaxY()) {
549 finalScreenY -= (finalScreenY + height - screenBounds.getMaxY());
550 }
551 if (finalScreenY < screenBounds.getMinY()) {
552 finalScreenY = screenBounds.getMinY();
553 }
554
555 return new Point2D(finalScreenX, finalScreenY);
556 }
557
558 /**
559 * Utility function that returns the x-axis position that an object should be positioned at,
560 * given the parents screen bounds, the width of the object, and
561 * the required HPos.
562 */
563 private static double positionX(Bounds parentBounds, double width, HPos hpos) {
564 if (hpos == HPos.CENTER) {
565 // this isn't right, but it is needed for root menus to show properly
566 return parentBounds.getMinX();
567 } else if (hpos == HPos.RIGHT) {
568 return parentBounds.getMaxX();
569 } else if (hpos == HPos.LEFT) {
570 return parentBounds.getMinX() - width;
571 } else {
572 return 0;
573 }
574 }
575
576 /**
577 * Utility function that returns the y-axis position that an object should be positioned at,
578 * given the parents screen bounds, the height of the object, and
579 * the required VPos.
580 *
581 * The BASELINE vpos doesn't make sense here, 0 is returned for it.
582 */
583 private static double positionY(Bounds parentBounds, double height, VPos vpos) {
584 if (vpos == VPos.BOTTOM) {
585 return parentBounds.getMaxY();
586 } else if (vpos == VPos.CENTER) {
587 return parentBounds.getMinY();
588 } else if (vpos == VPos.TOP) {
589 return parentBounds.getMinY() - height;
590 } else {
591 return 0;
592 }
593 }
594
595 /**
596 * To facilitate multiple types of parent object, we unfortunately must allow for
597 * Objects to be passed in. This method handles determining the bounds of the
598 * given Object. If the Object type is not supported, a default Bounds will be returned.
599 */
600 private static Bounds getBounds(Object obj) {
601 if (obj instanceof Node) {
602 final Node n = (Node)obj;
603 return n.localToScreen(n.getLayoutBounds());
604 } else if (obj instanceof Window) {
605 final Window window = (Window)obj;
606 return new BoundingBox(window.getX(), window.getY(), window.getWidth(), window.getHeight());
607 } else {
608 return new BoundingBox(0, 0, 0, 0);
609 }
610 }
611
612 /*
613 * Simple utitilty function to return the 'opposite' value of a given HPos, taking
614 * into account the current VPos value. This is used to try and avoid overlapping.
615 */
616 private static HPos getHPosOpposite(HPos hpos, VPos vpos) {
617 if (vpos == VPos.CENTER) {
618 if (hpos == HPos.LEFT){
619 return HPos.RIGHT;
620 } else if (hpos == HPos.RIGHT){
621 return HPos.LEFT;
622 } else if (hpos == HPos.CENTER){
623 return HPos.CENTER;
624 } else {
625 // by default center for now
626 return HPos.CENTER;
627 }
628 } else {
629 return HPos.CENTER;
630 }
631 }
632
633 /*
634 * Simple utitilty function to return the 'opposite' value of a given VPos, taking
635 * into account the current HPos value. This is used to try and avoid overlapping.
636 */
637 private static VPos getVPosOpposite(HPos hpos, VPos vpos) {
638 if (hpos == HPos.CENTER) {
639 if (vpos == VPos.BASELINE){
640 return VPos.BASELINE;
641 } else if (vpos == VPos.BOTTOM){
642 return VPos.TOP;
643 } else if (vpos == VPos.CENTER){
644 return VPos.CENTER;
645 } else if (vpos == VPos.TOP){
646 return VPos.BOTTOM;
647 } else {
648 // by default center for now
649 return VPos.CENTER;
650 }
651 } else {
652 return VPos.CENTER;
653 }
654 }
655
656 public static boolean hasFullScreenStage(final Screen screen) {
657 final List<Stage> allStages = StageHelper.getStages();
658
659 for (final Stage stage: allStages) {
660 if (stage.isFullScreen() && (getScreen(stage) == screen)) {
661 return true;
662 }
663 }
664
665 return false;
666 }
667
668 /*
669 * Returns true if the primary Screen has QVGA dimensions, in landscape or portrait mode.
670 */
671 public static boolean isQVGAScreen() {
672 Rectangle2D bounds = Screen.getPrimary().getBounds();
673 return ((bounds.getWidth() == 320 && bounds.getHeight() == 240) ||
674 (bounds.getWidth() == 240 && bounds.getHeight() == 320));
675 }
676
677 /**
678 * This function attempts to determine the best screen given the parent object
679 * from which we are wanting to position another item relative to. This is particularly
680 * important when we want to keep items from going off screen, and for handling
681 * multiple monitor support.
682 */
683 public static Screen getScreen(Object obj) {
684 final Bounds parentBounds = getBounds(obj);
685
686 final Rectangle2D rect = new Rectangle2D(
687 parentBounds.getMinX(),
688 parentBounds.getMinY(),
689 parentBounds.getWidth(),
690 parentBounds.getHeight());
691
692 return getScreenForRectangle(rect);
693 }
694
695 public static Screen getScreenForRectangle(final Rectangle2D rect) {
696 final List<Screen> screens = Screen.getScreens();
697
698 final double rectX0 = rect.getMinX();
699 final double rectX1 = rect.getMaxX();
700 final double rectY0 = rect.getMinY();
701 final double rectY1 = rect.getMaxY();
702
703 Screen selectedScreen;
704
705 selectedScreen = null;
706 double maxIntersection = 0;
707 for (final Screen screen: screens) {
708 final Rectangle2D screenBounds = screen.getBounds();
709 final double intersection =
710 getIntersectionLength(rectX0, rectX1,
711 screenBounds.getMinX(),
712 screenBounds.getMaxX())
713 * getIntersectionLength(rectY0, rectY1,
714 screenBounds.getMinY(),
715 screenBounds.getMaxY());
716
717 if (maxIntersection < intersection) {
718 maxIntersection = intersection;
719 selectedScreen = screen;
720 }
721 }
722
723 if (selectedScreen != null) {
724 return selectedScreen;
725 }
726
727 selectedScreen = Screen.getPrimary();
728 double minDistance = Double.MAX_VALUE;
729 for (final Screen screen: screens) {
730 final Rectangle2D screenBounds = screen.getBounds();
731 final double dx = getOuterDistance(rectX0, rectX1,
732 screenBounds.getMinX(),
733 screenBounds.getMaxX());
734 final double dy = getOuterDistance(rectY0, rectY1,
735 screenBounds.getMinY(),
736 screenBounds.getMaxY());
737 final double distance = dx * dx + dy * dy;
738
739 if (minDistance > distance) {
740 minDistance = distance;
741 selectedScreen = screen;
742 }
743 }
744
745 return selectedScreen;
746 }
747
748 public static Screen getScreenForPoint(final double x, final double y) {
749 final List<Screen> screens = Screen.getScreens();
750
751 // first check whether the point is inside some screen
752 for (final Screen screen: screens) {
753 // can't use screen.bounds.contains, because it returns true for
754 // the min + width point
755 final Rectangle2D screenBounds = screen.getBounds();
756 if ((x >= screenBounds.getMinX())
757 && (x < screenBounds.getMaxX())
758 && (y >= screenBounds.getMinY())
759 && (y < screenBounds.getMaxY())) {
760 return screen;
761 }
762 }
763
764 // the point is not inside any screen, find the closest screen now
765 Screen selectedScreen = Screen.getPrimary();
766 double minDistance = Double.MAX_VALUE;
767 for (final Screen screen: screens) {
768 final Rectangle2D screenBounds = screen.getBounds();
769 final double dx = getOuterDistance(screenBounds.getMinX(),
770 screenBounds.getMaxX(),
771 x);
772 final double dy = getOuterDistance(screenBounds.getMinY(),
773 screenBounds.getMaxY(),
774 y);
775 final double distance = dx * dx + dy * dy;
776 if (minDistance >= distance) {
777 minDistance = distance;
778 selectedScreen = screen;
779 }
780 }
781
782 return selectedScreen;
783 }
784
785 private static double getIntersectionLength(
786 final double a0, final double a1,
787 final double b0, final double b1) {
788 // (a0 <= a1) && (b0 <= b1)
789 return (a0 <= b0) ? getIntersectionLengthImpl(b0, b1, a1)
790 : getIntersectionLengthImpl(a0, a1, b1);
791 }
792
793 private static double getIntersectionLengthImpl(
794 final double v0, final double v1, final double v) {
795 // (v0 <= v1)
796 if (v <= v0) {
797 return 0;
798 }
799
800 return (v <= v1) ? v - v0 : v1 - v0;
801 }
802
803 private static double getOuterDistance(
804 final double a0, final double a1,
805 final double b0, final double b1) {
806 // (a0 <= a1) && (b0 <= b1)
807 if (a1 <= b0) {
808 return b0 - a1;
809 }
810
811 if (b1 <= a0) {
812 return b1 - a0;
813 }
814
815 return 0;
816 }
817
818 private static double getOuterDistance(final double v0,
819 final double v1,
820 final double v) {
821 // (v0 <= v1)
822 if (v <= v0) {
823 return v0 - v;
824 }
825
826 if (v >= v1) {
827 return v - v1;
828 }
829
830 return 0;
831 }
832
833 /***************************************************************************
834 * *
835 * Miscellaneous utilities *
836 * *
837 **************************************************************************/
838
839 public static boolean assertionEnabled() {
840 boolean assertsEnabled = false;
841 assert assertsEnabled = true; // Intentional side-effect !!!
842
843 return assertsEnabled;
844 }
845
846 /**
847 * Returns true if the operating system is a form of Windows.
848 */
849 public static boolean isWindows(){
850 return PlatformUtil.isWindows();
851 }
852
853 /**
854 * Returns true if the operating system is a form of Mac OS.
855 */
856 public static boolean isMac(){
857 return PlatformUtil.isMac();
858 }
859
860 /**
861 * Returns true if the operating system is a form of Unix, including Linux.
862 */
863 public static boolean isUnix(){
864 return PlatformUtil.isUnix();
865 }
866
867 /***************************************************************************
868 * *
869 * Unicode-related utilities *
870 * *
871 **************************************************************************/
872
873 public static String convertUnicode(String src) {
874 /** The input buffer, index of next character to be read,
875 * index of one past last character in buffer.
876 */
877 char[] buf;
878 int bp;
879 int buflen;
880
881 /** The current character.
882 */
883 char ch;
884
885 /** The buffer index of the last converted unicode character
886 */
887 int unicodeConversionBp = -1;
888
889 buf = src.toCharArray();
890 buflen = buf.length;
891 bp = -1;
892
893 char[] dst = new char[buflen];
894 int dstIndex = 0;
895
896 while (bp < buflen - 1) {
897 ch = buf[++bp];
898 if (ch == '\\') {
899 if (unicodeConversionBp != bp) {
900 bp++; ch = buf[bp];
901 if (ch == 'u') {
902 do {
903 bp++; ch = buf[bp];
904 } while (ch == 'u');
905 int limit = bp + 3;
906 if (limit < buflen) {
907 char c = ch;
908 int result = Character.digit(c, 16);
909 if (result >= 0 && c > 0x7f) {
910 //lexError(pos+1, "illegal.nonascii.digit");
911 ch = "0123456789abcdef".charAt(result);
912 }
913 int d = result;
914 int code = d;
915 while (bp < limit && d >= 0) {
916 bp++; ch = buf[bp];
917 char c1 = ch;
918 int result1 = Character.digit(c1, 16);
919 if (result1 >= 0 && c1 > 0x7f) {
920 //lexError(pos+1, "illegal.nonascii.digit");
921 ch = "0123456789abcdef".charAt(result1);
922 }
923 d = result1;
924 code = (code << 4) + d;
925 }
926 if (d >= 0) {
927 ch = (char)code;
928 unicodeConversionBp = bp;
929 }
930 }
931 //lexError(bp, "illegal.unicode.esc");
932 } else {
933 bp--;
934 ch = '\\';
935 }
936 }
937 }
938 dst[dstIndex++] = ch;
939 }
940
941 return new String(dst, 0, dstIndex);
942 }
943 }