1 /*
2 * Copyright (c) 2010, 2016, 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.application;
27
28 import static com.sun.javafx.FXPermissions.CREATE_TRANSPARENT_WINDOW_PERMISSION;
29 import com.sun.javafx.PlatformUtil;
30 import com.sun.javafx.css.StyleManager;
31 import com.sun.javafx.runtime.SystemProperties;
32 import com.sun.javafx.tk.TKListener;
33 import com.sun.javafx.tk.TKStage;
34 import com.sun.javafx.tk.Toolkit;
35 import com.sun.javafx.util.ModuleHelper;
36
37 import java.lang.reflect.InvocationTargetException;
38 import java.lang.reflect.Method;
39 import java.security.AccessControlContext;
40 import java.security.AccessController;
41 import java.security.PrivilegedAction;
42 import java.util.ArrayList;
43 import java.util.HashMap;
44 import java.util.List;
45 import java.util.Map;
46 import java.util.Optional;
47 import java.util.Set;
48 import java.util.concurrent.CopyOnWriteArraySet;
49 import java.util.concurrent.CountDownLatch;
50 import java.util.concurrent.atomic.AtomicBoolean;
51 import java.util.concurrent.atomic.AtomicInteger;
52 import java.util.function.Predicate;
53
54 import javafx.application.Application;
55 import javafx.application.ConditionalFeature;
56 import javafx.beans.property.BooleanProperty;
57 import javafx.beans.property.SimpleBooleanProperty;
58 import javafx.scene.Scene;
59 import javafx.util.FXPermission;
60
61 public class PlatformImpl {
62
63 private static AtomicBoolean initialized = new AtomicBoolean(false);
64 private static AtomicBoolean platformExit = new AtomicBoolean(false);
65 private static AtomicBoolean toolkitExit = new AtomicBoolean(false);
66 private static CountDownLatch startupLatch = new CountDownLatch(1);
67 private static AtomicBoolean listenersRegistered = new AtomicBoolean(false);
68 private static TKListener toolkitListener = null;
69 private static volatile boolean implicitExit = true;
70 private static boolean taskbarApplication = true;
71 private static boolean contextual2DNavigation;
72 private static AtomicInteger pendingRunnables = new AtomicInteger(0);
73 private static AtomicInteger numWindows = new AtomicInteger(0);
74 private static volatile boolean firstWindowShown = false;
75 private static volatile boolean lastWindowClosed = false;
76 private static AtomicBoolean reallyIdle = new AtomicBoolean(false);
77 private static Set<FinishListener> finishListeners =
78 new CopyOnWriteArraySet<FinishListener>();
79 private final static Object runLaterLock = new Object();
80 private static Boolean isGraphicsSupported;
81 private static Boolean isControlsSupported;
82 private static Boolean isMediaSupported;
83 private static Boolean isWebSupported;
84 private static Boolean isSWTSupported;
85 private static Boolean isSwingSupported;
86 private static Boolean isFXMLSupported;
87 private static Boolean hasTwoLevelFocus;
88 private static Boolean hasVirtualKeyboard;
89 private static Boolean hasTouch;
90 private static Boolean hasMultiTouch;
91 private static Boolean hasPointer;
92 private static boolean isThreadMerged = false;
93 private static String applicationType = "";
94 private static BooleanProperty accessibilityActive = new SimpleBooleanProperty();
95
96 // Internal permission used by FXCanvas (SWT interop)
97 private static final FXPermission FXCANVAS_PERMISSION =
98 new FXPermission("accessFXCanvasInternals");
99
100 /**
101 * Set a flag indicating whether this application should show up in the
102 * task bar. The default value is true.
103 *
104 * @param taskbarApplication the new value of this attribute
105 */
106 public static void setTaskbarApplication(boolean taskbarApplication) {
107 PlatformImpl.taskbarApplication = taskbarApplication;
108 }
109
110 /**
111 * Returns the current value of the taskBarApplication flag.
112 *
113 * @return the current state of the flag.
114 */
115 public static boolean isTaskbarApplication() {
116 return taskbarApplication;
117 }
118
119 /**
120 * Sets the name of the this application based on the Application class.
121 * This method is called by the launcher or by the deploy code, and is not
122 * called from the FX Application Thread, so we need to do it in a runLater.
123 * We do not need to wait for the result since it will complete before the
124 * Application start() method is called regardless.
125 *
126 * @param appClass the Application class.
127 */
128 public static void setApplicationName(final Class appClass) {
129 runLater(() -> com.sun.glass.ui.Application.GetApplication().setName(appClass.getName()));
130 }
131
132 /**
133 * Return whether or not focus navigation between controls is context-
134 * sensitive.
135 * @return true if the context-sensitive algorithm for focus navigation is
136 * used
137 */
138 public static boolean isContextual2DNavigation() {
139 return contextual2DNavigation;
140 }
141
142 /**
143 * This method is invoked typically on the main thread. At this point,
144 * the JavaFX Application Thread has not been started. Any attempt
145 * to call startup more than once results in all subsequent calls turning into
146 * nothing more than a runLater call with the provided Runnable being called.
147 * @param r
148 */
149 public static void startup(final Runnable r) {
150 startup(r, false);
151 }
152
153 /**
154 * This method is invoked typically on the main thread. At this point,
155 * the JavaFX Application Thread has not been started. If preventDuplicateCalls
156 * is true, calling this method multiple times will result in an
157 * IllegalStateException. If it is false, calling this method multiple times
158 * will result in all subsequent calls turning into
159 * nothing more than a runLater call with the provided Runnable being called.
160 * @param r
161 * @param preventDuplicateCalls
162 */
163 public static void startup(final Runnable r, boolean preventDuplicateCalls) {
164
165 // NOTE: if we ever support re-launching an application and/or
166 // launching a second application in the same VM/classloader
167 // this will need to be changed.
168 if (platformExit.get()) {
169 throw new IllegalStateException("Platform.exit has been called");
170 }
171
172 if (initialized.getAndSet(true)) {
173 if (preventDuplicateCalls) {
174 throw new IllegalStateException("Toolkit already initialized");
175 }
176
177 // If we've already initialized, just put the runnable on the queue.
178 runLater(r);
179 return;
180 }
181
182 AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
183 applicationType = System.getProperty("com.sun.javafx.application.type");
184 if (applicationType == null) applicationType = "";
185
186 contextual2DNavigation = Boolean.getBoolean(
187 "com.sun.javafx.isContextual2DNavigation");
188 String s = System.getProperty("com.sun.javafx.twoLevelFocus");
189 if (s != null) {
190 hasTwoLevelFocus = Boolean.valueOf(s);
191 }
192 s = System.getProperty("com.sun.javafx.virtualKeyboard");
193 if (s != null) {
194 if (s.equalsIgnoreCase("none")) {
195 hasVirtualKeyboard = false;
196 } else if (s.equalsIgnoreCase("javafx")) {
197 hasVirtualKeyboard = true;
198 } else if (s.equalsIgnoreCase("native")) {
199 hasVirtualKeyboard = true;
200 }
201 }
202 s = System.getProperty("com.sun.javafx.touch");
203 if (s != null) {
204 hasTouch = Boolean.valueOf(s);
205 }
206 s = System.getProperty("com.sun.javafx.multiTouch");
207 if (s != null) {
208 hasMultiTouch = Boolean.valueOf(s);
209 }
210 s = System.getProperty("com.sun.javafx.pointer");
211 if (s != null) {
212 hasPointer = Boolean.valueOf(s);
213 }
214 s = System.getProperty("javafx.embed.singleThread");
215 if (s != null) {
216 isThreadMerged = Boolean.valueOf(s);
217 }
218 return null;
219 });
220
221 System.err.println("PlatformImpl::startup : applicationType = " + applicationType);
222 if ("FXCanvas".equals(applicationType)) {
223 initFXCanvas();
224 }
225
226 if (!taskbarApplication) {
227 AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
228 System.setProperty("glass.taskbarApplication", "false");
229 return null;
230 });
231 }
232
233 // Create Toolkit listener and register it with the Toolkit.
234 // Call notifyFinishListeners when we get notified.
235 toolkitListener = new TKListener() {
236 @Override public void changedTopLevelWindows(List<TKStage> windows) {
237 numWindows.set(windows.size());
238 checkIdle();
239 }
240
241 @Override
242 public void exitedLastNestedLoop() {
243 checkIdle();
244 }
245 };
246 Toolkit.getToolkit().addTkListener(toolkitListener);
247
248 Toolkit.getToolkit().startup(() -> {
249 startupLatch.countDown();
250 r.run();
251 });
252
253 //Initialize the thread merging mechanism
254 if (isThreadMerged) {
255 installFwEventQueue();
256 }
257 }
258
259 // Pass certain system properties to glass via the device details Map
260 private static void initDeviceDetailsFXCanvas() {
261 // Read the javafx.embed.eventProc system property and store
262 // it in an entry in the glass Application device details map
263 final String eventProcProperty = "javafx.embed.eventProc";
264 final long eventProc = AccessController.doPrivileged((PrivilegedAction<Long>) () ->
265 Long.getLong(eventProcProperty, 0));
266 System.err.println("PlatformImpl.initSWT: "
267 + eventProcProperty + " = " + eventProc);
268 if (eventProc != 0L) {
269 // Set the value for the javafx.embed.eventProc
270 // key in the glass Application map
271 Map map = com.sun.glass.ui.Application.getDeviceDetails();
272 if (map == null) {
273 map = new HashMap();
274 com.sun.glass.ui.Application.setDeviceDetails(map);
275 }
276 if (map.get(eventProcProperty) == null) {
277 map.put(eventProcProperty, eventProc);
278 }
279 }
280 }
281
282 // Add the necessary qualified exports to the calling module
283 private static void addExportsToFXCanvas(Class<?> fxCanvasClass) {
284 final String[] swtNeededPackages = {
285 "com.sun.glass.ui",
286 "com.sun.javafx.cursor",
287 "com.sun.javafx.embed",
288 "com.sun.javafx.stage"
289 };
290
291 System.err.println("addExportsToFXCanvas: class = " + fxCanvasClass);
292 Object thisModule = ModuleHelper.getModule(PlatformImpl.class);
293 Object javafxSwtModule = ModuleHelper.getModule(fxCanvasClass);
294 for (String pkg : swtNeededPackages) {
295 System.err.println("add export of " + pkg + " from " + thisModule + " to " + javafxSwtModule);
296 ModuleHelper.addExports(thisModule, pkg, javafxSwtModule);
297 }
298 }
299
300 // FXCanvas-specific initialization
301 private static void initFXCanvas() {
302 // Verify that we have the appropriate permission
303 final SecurityManager sm = System.getSecurityManager();
304 if (sm != null) {
305 try {
306 sm.checkPermission(FXCANVAS_PERMISSION);
307 } catch (SecurityException ex) {
308 System.err.println("FXCanvas: no permission to access JavaFX internals");
309 ex.printStackTrace();
310 return;
311 }
312 }
313
314 // Find the calling class, ignoring any stack frames from FX application classes
315 Predicate<StackWalker.StackFrame> classFilter = f ->
316 !f.getClassName().startsWith("javafx.application.")
317 && !f.getClassName().startsWith("com.sun.javafx.application.");
318
319 final StackWalker walker = AccessController.doPrivileged((PrivilegedAction<StackWalker>) () ->
320 StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE));
321 Optional<StackWalker.StackFrame> frame = walker.walk(
322 s -> s.filter(classFilter).findFirst());
323 System.err.println("frame = " + frame);
324
325 if (frame.isPresent()) {
326 Class<?> caller = frame.get().getDeclaringClass();
327 System.err.println("callerClassName = " + caller);
328
329 // Verify that the caller is javafx.embed.swt.FXCanvas
330 if ("javafx.embed.swt.FXCanvas".equals(caller.getName())) {
331 initDeviceDetailsFXCanvas();
332 addExportsToFXCanvas(caller);
333 }
334 }
335 }
336
337 private static void installFwEventQueue() {
338 invokeSwingFXUtilsMethod("installFwEventQueue");
339 }
340
341 private static void removeFwEventQueue() {
342 invokeSwingFXUtilsMethod("removeFwEventQueue");
343 }
344
345 private static void invokeSwingFXUtilsMethod(final String methodName) {
346 //Use reflection in case we are running compact profile
347 try {
348 Class swingFXUtilsClass = Class.forName("javafx.embed.swing.SwingFXUtils");
349 Method installFwEventQueue = swingFXUtilsClass.getDeclaredMethod(methodName);
350 AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
351 installFwEventQueue.setAccessible(true);
352 return null;
353 });
354
355 waitForStart();
356 installFwEventQueue.invoke(null);
357
358 } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException e) {
359 throw new RuntimeException("Property javafx.embed.singleThread is not supported");
360 } catch (InvocationTargetException e) {
361 throw new RuntimeException(e);
362 }
363 }
364
365 private static void waitForStart() {
366 // If the startup runnable has not yet been called, then wait it.
367 // Note that we check the count before calling await() to avoid
368 // the try/catch which is unnecessary after startup.
369 if (startupLatch.getCount() > 0) {
370 try {
371 startupLatch.await();
372 } catch (InterruptedException ex) {
373 ex.printStackTrace();
374 }
375 }
376 }
377
378 public static boolean isFxApplicationThread() {
379 return Toolkit.getToolkit().isFxUserThread();
380 }
381
382 public static void runLater(final Runnable r) {
383 runLater(r, false);
384 }
385
386 private static void runLater(final Runnable r, boolean exiting) {
387 if (!initialized.get()) {
388 throw new IllegalStateException("Toolkit not initialized");
389 }
390
391 pendingRunnables.incrementAndGet();
392 waitForStart();
393
394 if (SystemProperties.isDebug()) {
395 Toolkit.getToolkit().pauseCurrentThread();
396 }
397
398 synchronized (runLaterLock) {
399 if (!exiting && toolkitExit.get()) {
400 // Don't schedule a runnable after we have exited the toolkit
401 pendingRunnables.decrementAndGet();
402 return;
403 }
404
405 final AccessControlContext acc = AccessController.getContext();
406 // Don't catch exceptions, they are handled by Toolkit.defer()
407 Toolkit.getToolkit().defer(() -> {
408 try {
409 AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
410 r.run();
411 return null;
412 }, acc);
413 } finally {
414 pendingRunnables.decrementAndGet();
415 checkIdle();
416 }
417 });
418 }
419 }
420
421 public static void runAndWait(final Runnable r) {
422 runAndWait(r, false);
423 }
424
425 private static void runAndWait(final Runnable r, boolean exiting) {
426 if (SystemProperties.isDebug()) {
427 Toolkit.getToolkit().pauseCurrentThread();
428 }
429
430 if (isFxApplicationThread()) {
431 try {
432 r.run();
433 } catch (Throwable t) {
434 System.err.println("Exception in runnable");
435 t.printStackTrace();
436 }
437 } else {
438 final CountDownLatch doneLatch = new CountDownLatch(1);
439 runLater(() -> {
440 try {
441 r.run();
442 } finally {
443 doneLatch.countDown();
444 }
445 }, exiting);
446
447 if (!exiting && toolkitExit.get()) {
448 throw new IllegalStateException("Toolkit has exited");
449 }
450
451 try {
452 doneLatch.await();
453 } catch (InterruptedException ex) {
454 ex.printStackTrace();
455 }
456 }
457 }
458
459 public static void setImplicitExit(boolean implicitExit) {
460 PlatformImpl.implicitExit = implicitExit;
461 checkIdle();
462 }
463
464 public static boolean isImplicitExit() {
465 return implicitExit;
466 }
467
468 public static void addListener(FinishListener l) {
469 listenersRegistered.set(true);
470 finishListeners.add(l);
471 }
472
473 public static void removeListener(FinishListener l) {
474 finishListeners.remove(l);
475 listenersRegistered.set(!finishListeners.isEmpty());
476 if (!listenersRegistered.get()) {
477 checkIdle();
478 }
479 }
480
481 private static void notifyFinishListeners(boolean exitCalled) {
482 // Notify listeners if any are registered, else exit directly
483 if (listenersRegistered.get()) {
484 for (FinishListener l : finishListeners) {
485 if (exitCalled) {
486 l.exitCalled();
487 } else {
488 l.idle(implicitExit);
489 }
490 }
491 } else if (implicitExit || platformExit.get()) {
492 tkExit();
493 }
494 }
495
496 // Check for idle, meaning the last top-level window has been closed and
497 // there are no pending Runnables waiting to be run.
498 private static void checkIdle() {
499 // If we aren't initialized yet, then this method is a no-op.
500 if (!initialized.get()) {
501 return;
502 }
503
504 if (!isFxApplicationThread()) {
505 // Add a dummy runnable to the runLater queue, which will then call
506 // checkIdle() on the FX application thread.
507 runLater(() -> {
508 });
509 return;
510 }
511
512 boolean doNotify = false;
513
514 synchronized (PlatformImpl.class) {
515 int numWin = numWindows.get();
516 if (numWin > 0) {
517 firstWindowShown = true;
518 lastWindowClosed = false;
519 reallyIdle.set(false);
520 } else if (numWin == 0 && firstWindowShown) {
521 lastWindowClosed = true;
522 }
523
524 // In case there is an event in process, allow for it to show
525 // another window. If no new window is shown before all pending
526 // runnables (including this one) are done and there is no running
527 // nested loops, then we will shutdown.
528 if (lastWindowClosed && pendingRunnables.get() == 0
529 && (toolkitExit.get() || !Toolkit.getToolkit().isNestedLoopRunning())) {
530 // System.err.println("Last window closed and no pending runnables");
531 if (reallyIdle.getAndSet(true)) {
532 // System.err.println("Really idle now");
533 doNotify = true;
534 lastWindowClosed = false;
535 } else {
536 // System.err.println("Queuing up a dummy idle check runnable");
537 runLater(() -> {
538 // System.err.println("Dummy runnable");
539 });
540 }
541 }
542 }
543
544 if (doNotify) {
545 notifyFinishListeners(false);
546 }
547 }
548
549 // package scope method for testing
550 private static final CountDownLatch platformExitLatch = new CountDownLatch(1);
551 static CountDownLatch test_getPlatformExitLatch() {
552 return platformExitLatch;
553 }
554
555 public static void tkExit() {
556 if (toolkitExit.getAndSet(true)) {
557 return;
558 }
559
560 if (initialized.get()) {
561 // Always call toolkit exit on FX app thread
562 // System.err.println("PlatformImpl.tkExit: scheduling Toolkit.exit");
563 PlatformImpl.runAndWait(() -> {
564 // System.err.println("PlatformImpl.tkExit: calling Toolkit.exit");
565 Toolkit.getToolkit().exit();
566 }, true);
567
568 if (isThreadMerged) {
569 removeFwEventQueue();
570 }
571
572 Toolkit.getToolkit().removeTkListener(toolkitListener);
573 toolkitListener = null;
574 platformExitLatch.countDown();
575 }
576 }
577
578 public static BooleanProperty accessibilityActiveProperty() {
579 return accessibilityActive;
580 }
581
582 public static void exit() {
583 platformExit.set(true);
584 notifyFinishListeners(true);
585 }
586
587 private static Boolean checkForClass(String classname) {
588 try {
589 Class.forName(classname, false, PlatformImpl.class.getClassLoader());
590 return Boolean.TRUE;
591 } catch (ClassNotFoundException cnfe) {
592 return Boolean.FALSE;
593 }
594 }
595
596 public static boolean isSupported(ConditionalFeature feature) {
597 final boolean supported = isSupportedImpl(feature);
598 if (supported && (feature == ConditionalFeature.TRANSPARENT_WINDOW)) {
599 // some features require the application to have the corresponding
600 // permissions, if the application doesn't have them, the platform
601 // will behave as if the feature wasn't supported
602 final SecurityManager securityManager =
603 System.getSecurityManager();
604 if (securityManager != null) {
605 try {
606 securityManager.checkPermission(CREATE_TRANSPARENT_WINDOW_PERMISSION);
607 } catch (final SecurityException e) {
608 return false;
609 }
610 }
611
612 return true;
613 }
614
615 return supported;
616 }
617
618 public static interface FinishListener {
619 public void idle(boolean implicitExit);
620 public void exitCalled();
621 }
622
623 /**
624 * Set the platform user agent stylesheet to the default.
625 */
626 public static void setDefaultPlatformUserAgentStylesheet() {
627 setPlatformUserAgentStylesheet(Application.STYLESHEET_MODENA);
628 }
629
630 private static boolean isModena = false;
631 private static boolean isCaspian = false;
632
633 /**
634 * Current Platform User Agent Stylesheet is Modena.
635 *
636 * Note: Please think hard before using this as we really want to avoid special cases in the platform for specific
637 * themes. This was added to allow tempory work arounds in the platform for bugs.
638 *
639 * @return true if using modena stylesheet
640 */
641 public static boolean isModena() {
642 return isModena;
643 }
644
645 /**
646 * Current Platform User Agent Stylesheet is Caspian.
647 *
648 * Note: Please think hard before using this as we really want to avoid special cases in the platform for specific
649 * themes. This was added to allow tempory work arounds in the platform for bugs.
650 *
651 * @return true if using caspian stylesheet
652 */
653 public static boolean isCaspian() {
654 return isCaspian;
655 }
656
657 /**
658 * Set the platform user agent stylesheet to the given URL. This method has special handling for platform theme
659 * name constants.
660 */
661 public static void setPlatformUserAgentStylesheet(final String stylesheetUrl) {
662 if (isFxApplicationThread()) {
663 _setPlatformUserAgentStylesheet(stylesheetUrl);
664 } else {
665 runLater(() -> _setPlatformUserAgentStylesheet(stylesheetUrl));
666 }
667 }
668
669 private static String accessibilityTheme;
670 public static boolean setAccessibilityTheme(String platformTheme) {
671
672 if (accessibilityTheme != null) {
673 StyleManager.getInstance().removeUserAgentStylesheet(accessibilityTheme);
674 accessibilityTheme = null;
675 }
676
677 _setAccessibilityTheme(platformTheme);
678
679 if (accessibilityTheme != null) {
680 StyleManager.getInstance().addUserAgentStylesheet(accessibilityTheme);
681 return true;
682 }
683 return false;
684
685 }
686
687 private static void _setAccessibilityTheme(String platformTheme) {
688
689 // check to see if there is an override to enable a high-contrast theme
690 final String userTheme = AccessController.doPrivileged(
691 (PrivilegedAction<String>) () -> System.getProperty("com.sun.javafx.highContrastTheme"));
692
693 if (isCaspian()) {
694 if (platformTheme != null || userTheme != null) {
695 // caspian has only one high contrast theme, use it regardless of the user or platform theme.
696 accessibilityTheme = "com/sun/javafx/scene/control/skin/caspian/highcontrast.css";
697 }
698 } else if (isModena()) {
699 // User-defined property takes precedence
700 if (userTheme != null) {
701 switch (userTheme.toUpperCase()) {
702 case "BLACKONWHITE":
703 accessibilityTheme = "com/sun/javafx/scene/control/skin/modena/blackOnWhite.css";
704 break;
705 case "WHITEONBLACK":
706 accessibilityTheme = "com/sun/javafx/scene/control/skin/modena/whiteOnBlack.css";
707 break;
708 case "YELLOWONBLACK":
709 accessibilityTheme = "com/sun/javafx/scene/control/skin/modena/yellowOnBlack.css";
710 break;
711 default:
712 }
713 } else {
714 if (platformTheme != null) {
715 // The following names are Platform specific (Windows 7 and 8)
716 switch (platformTheme) {
717 case "High Contrast White":
718 accessibilityTheme = "com/sun/javafx/scene/control/skin/modena/blackOnWhite.css";
719 break;
720 case "High Contrast Black":
721 accessibilityTheme = "com/sun/javafx/scene/control/skin/modena/whiteOnBlack.css";
722 break;
723 case "High Contrast #1":
724 case "High Contrast #2": //TODO #2 should be green on black
725 accessibilityTheme = "com/sun/javafx/scene/control/skin/modena/yellowOnBlack.css";
726 break;
727 default:
728 }
729 }
730 }
731 }
732 }
733
734 private static void _setPlatformUserAgentStylesheet(String stylesheetUrl) {
735 isModena = isCaspian = false;
736 // check for command line override
737 final String overrideStylesheetUrl = AccessController.doPrivileged(
738 (PrivilegedAction<String>) () -> System.getProperty("javafx.userAgentStylesheetUrl"));
739
740 if (overrideStylesheetUrl != null) {
741 stylesheetUrl = overrideStylesheetUrl;
742 }
743
744 final List<String> uaStylesheets = new ArrayList<>();
745
746 // check for named theme constants for modena and caspian
747 if (Application.STYLESHEET_CASPIAN.equalsIgnoreCase(stylesheetUrl)) {
748 isCaspian = true;
749
750 uaStylesheets.add("com/sun/javafx/scene/control/skin/caspian/caspian.css");
751
752 if (isSupported(ConditionalFeature.INPUT_TOUCH)) {
753 uaStylesheets.add("com/sun/javafx/scene/control/skin/caspian/embedded.css");
754 if (com.sun.javafx.util.Utils.isQVGAScreen()) {
755 uaStylesheets.add("com/sun/javafx/scene/control/skin/caspian/embedded-qvga.css");
756 }
757 if (PlatformUtil.isAndroid()) {
758 uaStylesheets.add("com/sun/javafx/scene/control/skin/caspian/android.css");
759 }
760 }
761
762 if (isSupported(ConditionalFeature.TWO_LEVEL_FOCUS)) {
763 uaStylesheets.add("com/sun/javafx/scene/control/skin/caspian/two-level-focus.css");
764 }
765
766 if (isSupported(ConditionalFeature.VIRTUAL_KEYBOARD)) {
767 uaStylesheets.add("com/sun/javafx/scene/control/skin/caspian/fxvk.css");
768 }
769
770 if (!isSupported(ConditionalFeature.TRANSPARENT_WINDOW)) {
771 uaStylesheets.add("com/sun/javafx/scene/control/skin/caspian/caspian-no-transparency.css");
772 }
773
774 } else if (Application.STYLESHEET_MODENA.equalsIgnoreCase(stylesheetUrl)) {
775 isModena = true;
776
777 uaStylesheets.add("com/sun/javafx/scene/control/skin/modena/modena.css");
778
779 if (isSupported(ConditionalFeature.INPUT_TOUCH)) {
780 uaStylesheets.add("com/sun/javafx/scene/control/skin/modena/touch.css");
781 }
782 // when running on embedded add a extra stylesheet to tune performance of modena theme
783 if (PlatformUtil.isEmbedded()) {
784 uaStylesheets.add("com/sun/javafx/scene/control/skin/modena/modena-embedded-performance.css");
785 }
786 if (PlatformUtil.isAndroid()) {
787 uaStylesheets.add("com/sun/javafx/scene/control/skin/modena/android.css");
788 }
789
790 if (isSupported(ConditionalFeature.TWO_LEVEL_FOCUS)) {
791 uaStylesheets.add("com/sun/javafx/scene/control/skin/modena/two-level-focus.css");
792 }
793
794 if (isSupported(ConditionalFeature.VIRTUAL_KEYBOARD)) {
795 uaStylesheets.add("com/sun/javafx/scene/control/skin/caspian/fxvk.css");
796 }
797
798 if (!isSupported(ConditionalFeature.TRANSPARENT_WINDOW)) {
799 uaStylesheets.add("com/sun/javafx/scene/control/skin/modena/modena-no-transparency.css");
800 }
801
802 } else {
803 uaStylesheets.add(stylesheetUrl);
804 }
805
806 // Ensure that accessibility starts right
807 _setAccessibilityTheme(Toolkit.getToolkit().getThemeName());
808 if (accessibilityTheme != null) {
809 uaStylesheets.add(accessibilityTheme);
810 }
811
812 AccessController.doPrivileged((PrivilegedAction) () -> {
813 StyleManager.getInstance().setUserAgentStylesheets(uaStylesheets);
814 return null;
815 });
816
817 }
818
819 public static void addNoTransparencyStylesheetToScene(final Scene scene) {
820 if (PlatformImpl.isCaspian()) {
821 AccessController.doPrivileged((PrivilegedAction) () -> {
822 StyleManager.getInstance().addUserAgentStylesheet(scene,
823 "com/sun/javafx/scene/control/skin/caspian/caspian-no-transparency.css");
824 return null;
825 });
826 } else if (PlatformImpl.isModena()) {
827 AccessController.doPrivileged((PrivilegedAction) () -> {
828 StyleManager.getInstance().addUserAgentStylesheet(scene,
829 "com/sun/javafx/scene/control/skin/modena/modena-no-transparency.css");
830 return null;
831 });
832 }
833 }
834
835 private static boolean isSupportedImpl(ConditionalFeature feature) {
836 switch (feature) {
837 case GRAPHICS:
838 if (isGraphicsSupported == null) {
839 isGraphicsSupported = checkForClass("javafx.stage.Stage");
840 }
841 return isGraphicsSupported;
842 case CONTROLS:
843 if (isControlsSupported == null) {
844 isControlsSupported = checkForClass(
845 "javafx.scene.control.Control");
846 }
847 return isControlsSupported;
848 case MEDIA:
849 if (isMediaSupported == null) {
850 isMediaSupported = checkForClass(
851 "javafx.scene.media.MediaView");
852 if (isMediaSupported && PlatformUtil.isEmbedded()) {
853 AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
854 String s = System.getProperty(
855 "com.sun.javafx.experimental.embedded.media",
856 "false");
857 isMediaSupported = Boolean.valueOf(s);
858 return null;
859
860 });
861 }
862 }
863 return isMediaSupported;
864 case WEB:
865 if (isWebSupported == null) {
866 isWebSupported = checkForClass("javafx.scene.web.WebView");
867 if (isWebSupported && PlatformUtil.isEmbedded()) {
868 AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
869 String s = System.getProperty(
870 "com.sun.javafx.experimental.embedded.web",
871 "false");
872 isWebSupported = Boolean.valueOf(s);
873 return null;
874
875 });
876 }
877 }
878 return isWebSupported;
879 case SWT:
880 if (isSWTSupported == null) {
881 isSWTSupported = checkForClass("javafx.embed.swt.FXCanvas");
882 }
883 return isSWTSupported;
884 case SWING:
885 if (isSwingSupported == null) {
886 isSwingSupported =
887 // check for JComponent first, it may not be present
888 checkForClass("javax.swing.JComponent") &&
889 checkForClass("javafx.embed.swing.JFXPanel");
890 }
891 return isSwingSupported;
892 case FXML:
893 if (isFXMLSupported == null) {
894 isFXMLSupported = checkForClass("javafx.fxml.FXMLLoader")
895 && checkForClass("javax.xml.stream.XMLInputFactory");
896 }
897 return isFXMLSupported;
898 case TWO_LEVEL_FOCUS:
899 if (hasTwoLevelFocus == null) {
900 return Toolkit.getToolkit().isSupported(feature);
901 }
902 return hasTwoLevelFocus;
903 case VIRTUAL_KEYBOARD:
904 if (hasVirtualKeyboard == null) {
905 return Toolkit.getToolkit().isSupported(feature);
906 }
907 return hasVirtualKeyboard;
908 case INPUT_TOUCH:
909 if (hasTouch == null) {
910 return Toolkit.getToolkit().isSupported(feature);
911 }
912 return hasTouch;
913 case INPUT_MULTITOUCH:
914 if (hasMultiTouch == null) {
915 return Toolkit.getToolkit().isSupported(feature);
916 }
917 return hasMultiTouch;
918 case INPUT_POINTER:
919 if (hasPointer == null) {
920 return Toolkit.getToolkit().isSupported(feature);
921 }
922 return hasPointer;
923 default:
924 return Toolkit.getToolkit().isSupported(feature);
925 }
926 }
927 }