1 /*
2 * Copyright (c) 2010, 2013, 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 package com.sun.glass.ui;
26
27 import com.sun.glass.events.KeyEvent;
28 import com.sun.glass.ui.CommonDialogs.ExtensionFilter;
29 import com.sun.glass.ui.CommonDialogs.FileChooserResult;
30
31 import java.io.File;
32 import java.nio.ByteBuffer;
33 import java.nio.IntBuffer;
34 import java.security.AccessController;
35 import java.security.PrivilegedAction;
36 import java.util.ArrayList;
37 import java.util.Iterator;
38 import java.util.List;
39 import java.util.Map;
40 import java.util.LinkedList;
41
42 public abstract class Application {
43
44 private final static String DEFAULT_NAME = "java";
45 protected String name = DEFAULT_NAME;
46
47 public static class EventHandler {
48 // currently used only on Mac OS X
49 public void handleWillFinishLaunchingAction(Application app, long time) {
50 }
51 // currently used only on Mac OS X
52 public void handleDidFinishLaunchingAction(Application app, long time) {
53 }
54 // currently used only on Mac OS X
55 public void handleWillBecomeActiveAction(Application app, long time) {
56 }
57 // currently used only on Mac OS X
58 public void handleDidBecomeActiveAction(Application app, long time) {
59 }
60 // currently used only on Mac OS X
61 public void handleWillResignActiveAction(Application app, long time) {
62 }
63 // currently used only on Mac OS X
64 public void handleDidResignActiveAction(Application app, long time) {
65 }
66 // currently used only on iOS
67 public void handleDidReceiveMemoryWarning(Application app, long time) {
68 }
69 // currently used only on Mac OS X
70 public void handleWillHideAction(Application app, long time) {
71 }
72 // currently used only on Mac OS X
73 public void handleDidHideAction(Application app, long time) {
74 }
75 // currently used only on Mac OS X
76 public void handleWillUnhideAction(Application app, long time) {
77 }
78 // currently used only on Mac OS X
79 public void handleDidUnhideAction(Application app, long time) {
80 }
81 // currently used only on Mac OS X
82 // the open files which started up the app will arrive before app becomes active
83 public void handleOpenFilesAction(Application app, long time, String files[]) {
84 }
85 // currently used only on Mac OS X
86 public void handleQuitAction(Application app, long time) {
87 }
88 }
89
90 private EventHandler eventHandler;
91 private boolean initialActiveEventReceived = false;
92 private String initialOpenedFiles[] = null;
93
94 private static boolean loaded = false;
95 private static Application application;
96 private static Thread eventThread;
97 private static final boolean disableThreadChecks =
98 AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
99 public Boolean run() {
100 final String str =
101 System.getProperty("glass.disableThreadChecks", "false");
102 return "true".equalsIgnoreCase(str);
103 }
104 });
105
106 // May be called on any thread.
107 protected static synchronized void loadNativeLibrary(final String libname) {
108 // load the native library of the specified libname.
109 // the platform default by convention is "glass", all others should have a suffix, ie glass-x11
110 if (!loaded) {
111 com.sun.glass.utils.NativeLibLoader.loadLibrary(libname);
112 loaded = true;
113 }
114 }
115
116 // May be called on any thread.
117 protected static synchronized void loadNativeLibrary() {
118 // use the "platform default" name of "glass"
119 loadNativeLibrary("glass");
120 }
121
122 private static volatile Map deviceDetails = null;
123
124 // provides a means for the user to pass platorm specific details
125 // to the native glass impl. Can be null.
126 // May need be called before Run.
127 // May be called on any thread.
128 public static void setDeviceDetails(Map details) {
129 deviceDetails = details;
130 }
131
132 // May be called on any thread.
133 public static Map getDeviceDetails() {
134 return deviceDetails;
135 }
136
137 protected Application() {
138 }
139
140 // May be called on any thread.
141 public static void run(final Runnable launchable) {
142 if (application != null) {
143 throw new IllegalStateException("Application is already running");
144 }
145 application = PlatformFactory.getPlatformFactory().createApplication();
146 // each concrete Application should set the app name using its own platform mechanism:
147 // on Mac OS X - use NSBundle info, which can be overriden by -Xdock:name
148 // on Windows - TODO
149 // on Linux - TODO
150 //application.name = DEFAULT_NAME; // default
151 try {
152 application.runLoop(new Runnable() {
153 @Override public void run() {
154 Screen.initScreens();
155 launchable.run();
156 }
157 });
158 } catch (Throwable t) {
159 t.printStackTrace();
160 }
161 }
162
163 // runLoop never exits until app terminates
164 protected abstract void runLoop(Runnable launchable);
165
166 // should return after loop termination completion
167 protected void finishTerminating() {
168 // To make sure application object is not used outside of the run loop
169 application = null;
170 // The eventThread is null at this point, no need to check it
171 }
172
173 /**
174 * Gets the name for the application. The application name may
175 * be used to identify the application in the user interface or
176 * as part of the platform specific path used to store application
177 * data.
178 *
179 * This is a hint and may not be used on some platforms.
180 *
181 * @return the application name
182 */
183 public String getName() {
184 checkEventThread();
185 return name;
186 }
187
188 /**
189 * Sets the name for the application. The application name may
190 * be used to identify the application in the user interface or
191 * as part of the platform specific path used to store application
192 * data.
193 *
194 * The name could be set only once. All subsequent calls are ignored.
195 *
196 * This is a hint and may not be used on some platforms.
197 *
198 * @param name the new application name
199 */
200 public void setName(String name) {
201 checkEventThread();
202 if (name != null && DEFAULT_NAME.equals(this.name)) {
203 this.name = name;
204 }
205 }
206
207 /**
208 * Gets a platform specific path that can be used to store
209 * application data. The application name typically appears
210 * as part of the path.
211 *
212 * On some platforms, the path may not yet exist and the caller
213 * will need to create it.
214 *
215 * @return the platform specific path for the application data
216 */
217 public String getDataDirectory() {
218 checkEventThread();
219 return System.getProperty("user.home") + File.separator + "." + name + File.separator;
220 }
221
222 private void notifyWillFinishLaunching() {
223 EventHandler handler = getEventHandler();
224 if (handler != null) {
225 handler.handleWillFinishLaunchingAction(this, System.nanoTime());
226 }
227 }
228
229 private void notifyDidFinishLaunching() {
230 EventHandler handler = getEventHandler();
231 if (handler != null) {
232 handler.handleDidFinishLaunchingAction(this, System.nanoTime());
233 }
234 }
235
236 private void notifyWillBecomeActive() {
237 EventHandler handler = getEventHandler();
238 if (handler != null) {
239 handler.handleWillBecomeActiveAction(this, System.nanoTime());
240 }
241 }
242
243 private void notifyDidBecomeActive() {
244 this.initialActiveEventReceived = true;
245 EventHandler handler = getEventHandler();
246 if (handler != null) {
247 handler.handleDidBecomeActiveAction(this, System.nanoTime());
248 }
249 }
250
251 private void notifyWillResignActive() {
252 EventHandler handler = getEventHandler();
253 if (handler != null) {
254 handler.handleWillResignActiveAction(this, System.nanoTime());
255 }
256 }
257
258 private void notifyDidResignActive() {
259 EventHandler handler = getEventHandler();
260 if (handler != null) {
261 handler.handleDidResignActiveAction(this, System.nanoTime());
262 }
263 }
264
265 private void notifyDidReceiveMemoryWarning() {
266 EventHandler handler = getEventHandler();
267 if (handler != null) {
268 handler.handleDidReceiveMemoryWarning(this, System.nanoTime());
269 }
270 }
271
272 private void notifyWillHide() {
273 EventHandler handler = getEventHandler();
274 if (handler != null) {
275 handler.handleWillHideAction(this, System.nanoTime());
276 }
277 }
278
279 private void notifyDidHide() {
280 EventHandler handler = getEventHandler();
281 if (handler != null) {
282 handler.handleDidHideAction(this, System.nanoTime());
283 }
284 }
285
286 private void notifyWillUnhide() {
287 EventHandler handler = getEventHandler();
288 if (handler != null) {
289 handler.handleWillUnhideAction(this, System.nanoTime());
290 }
291 }
292
293 private void notifyDidUnhide() {
294 EventHandler handler = getEventHandler();
295 if (handler != null) {
296 handler.handleDidUnhideAction(this, System.nanoTime());
297 }
298 }
299
300 // notificiation when user drag and drops files onto app icon
301 private void notifyOpenFiles(String files[]) {
302 if ((this.initialActiveEventReceived == false) && (this.initialOpenedFiles == null)) {
303 // rememeber the initial opened files
304 this.initialOpenedFiles = files;
305 }
306 EventHandler handler = getEventHandler();
307 if ((handler != null) && (files != null)) {
308 handler.handleOpenFilesAction(this, System.nanoTime(), files);
309 }
310 }
311
312 private void notifyWillQuit() {
313 EventHandler handler = getEventHandler();
314 if (handler != null) {
315 handler.handleQuitAction(this, System.nanoTime());
316 }
317 }
318
319 /**
320 * Install app's default native menus:
321 * on Mac OS X - Apple menu (showing the app name) with a single Quit menu item
322 * on Windows - NOP
323 * on Linux - NOP
324 */
325 public void installDefaultMenus(MenuBar menubar) {
326 checkEventThread();
327 // To override in subclasses
328 }
329
330 public EventHandler getEventHandler() {
331 //checkEventThread(); // Glass (Mac)
332 // When an app is closing, Mac calls notify- Will/DidHide, Will/DidResignActive
333 // on a thread other than the Main thread
334 return eventHandler;
335 }
336
337 public void setEventHandler(EventHandler eventHandler) {
338 checkEventThread();
339 boolean resendOpenFiles = ((this.eventHandler != null) && (this.initialOpenedFiles != null));
340 this.eventHandler = eventHandler;
341 if (resendOpenFiles == true) {
342 // notify the new event handler with initial opened files
343 notifyOpenFiles(this.initialOpenedFiles);
344 }
345 }
346
347 private boolean terminateWhenLastWindowClosed = true;
348 public final boolean shouldTerminateWhenLastWindowClosed() {
349 checkEventThread();
350 return terminateWhenLastWindowClosed;
351 }
352 public final void setTerminateWhenLastWindowClosed(boolean b) {
353 checkEventThread();
354 terminateWhenLastWindowClosed = b;
355 }
356
357 public boolean shouldUpdateWindow() {
358 checkEventThread();
359 return false; // overridden in platform application class
360 }
361
362 public boolean hasWindowManager() {
363 //checkEventThread(); // Prism (Mac)
364 return true; // overridden in platform application class
365 }
366
367 public void terminate() {
368 checkEventThread();
369 try {
370 final List<Window> windows = new LinkedList<>(Window.getWindows());
371 for (Window window : windows) {
372 // first make windows invisible
373 window.setVisible(false);
374 }
375 for (Window window : windows) {
376 // now we can close windows
377 window.close();
378 }
379 } catch (Throwable t) {
380 t.printStackTrace();
381 } finally {
382 finishTerminating();
383 }
384 }
385
386 // May be called on any thread
387 static public Application GetApplication() {
388 return Application.application;
389 }
390
391 // May be called on any thread
392 protected static void setEventThread(Thread thread) {
393 Application.eventThread = thread;
394 }
395
396 // May be called on any thread
397 protected static Thread getEventThread() {
398 return Application.eventThread;
399 }
400
401 /**
402 * Returns {@code true} if the current thread is the event thread.
403 */
404 public static boolean isEventThread() {
405 return Thread.currentThread() == Application.eventThread;
406 }
407
408 /**
409 * Verifies that the current thread is the event thread, and throws
410 * an exception if this is not so.
411 *
412 * The check can be disabled by setting the "glass.disableThreadChecks"
413 * system property. It is preferred, however, to fix the application code
414 * instead.
415 *
416 * @throws IllegalStateException if the current thread is not the event thread
417 */
418 public static void checkEventThread() {
419 //TODO: we do NOT advertise the "glass.disableThreadChecks".
420 // If we never get a complaint about this check, we can consider
421 // dropping the system property and perform the check unconditionally
422 if (!disableThreadChecks &&
423 Thread.currentThread() != Application.eventThread)
424 {
425 throw new IllegalStateException(
426 "This operation is permitted on the event thread only; currentThread = "
427 + Thread.currentThread().getName());
428
429 }
430 }
431
432 // Called from native, when a JNI exception has occurred
433 public static void reportException(Throwable t) {
434 Thread currentThread = Thread.currentThread();
435 Thread.UncaughtExceptionHandler handler =
436 currentThread.getUncaughtExceptionHandler();
437 handler.uncaughtException(currentThread, t);
438 }
439
440 abstract protected void _invokeAndWait(java.lang.Runnable runnable);
441 /**
442 * Block the current thread and wait until the given runnable finishes
443 * running on the native event loop thread.
444 */
445 public static void invokeAndWait(java.lang.Runnable runnable) {
446 if (runnable == null) {
447 return;
448 }
449 if (isEventThread()) {
450 runnable.run();
451 } else {
452 GetApplication()._invokeAndWait(runnable);
453 }
454 }
455
456 abstract protected void _invokeLater(java.lang.Runnable runnable);
457 /**
458 * Schedule the given runnable to run on the native event loop thread
459 * some time in the future, and return immediately.
460 */
461 public static void invokeLater(java.lang.Runnable runnable) {
462 if (runnable == null) {
463 return;
464 }
465 GetApplication()._invokeLater(runnable);
466 }
467
468 protected abstract Object _enterNestedEventLoop();
469 protected abstract void _leaveNestedEventLoop(Object retValue);
470
471 private static int nestedEventLoopCounter = 0;
472
473 /**
474 * Starts a nested event loop.
475 *
476 * Calling this method temporarily blocks processing of the current event,
477 * and starts a nested event loop to handle other native events. To
478 * proceed with the blocked execution path, the application should call the
479 * {@link #leaveNestedEventLoop(Object)} method.
480 *
481 * Note that this method may only be invoked on the main (event handling)
482 * thread.
483 *
484 * An application may enter several nested loops recursively. There's no
485 * limit of recursion other than that imposed by the native stack size.
486 *
487 * @return an object passed to the leaveNestedEventLoop() method
488 * @throws RuntimeException if the current thread is not the main thread
489 */
490 static Object enterNestedEventLoop() {
491 checkEventThread();
492
493 nestedEventLoopCounter++;
494 try {
495 return GetApplication()._enterNestedEventLoop();
496 } finally {
497 nestedEventLoopCounter--;
498 }
499 }
500
501 /**
502 * Terminates the current nested event loop.
503 *
504 * After calling this method and returning from the current event handler,
505 * the execusion returns to the point where the {@link #enterNestedEventLoop}
506 * was called previously. You may specify a return value for the
507 * enterNestedEventLoop() method by passing the argument {@code retValue} to
508 * the leaveNestedEventLoop().
509 *
510 * Note that this method may only be invoked on the main (event handling)
511 * thread.
512 *
513 * @throws RuntimeException if the current thread is not the main thread
514 * @throws IllegalStateException if the application hasn't started a nested
515 * event loop
516 */
517 static void leaveNestedEventLoop(Object retValue) {
518 checkEventThread();
519
520 if (nestedEventLoopCounter == 0) {
521 throw new IllegalStateException("Not in a nested event loop");
522 }
523
524 GetApplication()._leaveNestedEventLoop(retValue);
525 }
526
527 public static boolean isNestedLoopRunning() {
528 checkEventThread();
529 return nestedEventLoopCounter > 0;
530 }
531
532 //TODO: move to the EventHandler
533 public void menuAboutAction() {
534 System.err.println("about");
535 }
536
537
538 // FACTORY METHODS
539
540 /**
541 * Create a window.
542 *
543 * The styleMask argument is a bitmask of window styles as defined in the
544 * Window class. Note, however, that visual kinds (UNTITLED, TITLED,
545 * or TRANSPARENT) can't be combined together. Also, functional types
546 * (NORMAL, POPUP, or UTILITY) can't be combined together. A window is
547 * allowed to be of exactly one visual kind, and exactly one functional
548 * type.
549 */
550 public abstract Window createWindow(Window owner, Screen screen, int styleMask);
551
552 /**
553 * Create a window.
554 *
555 * The styleMask argument is a bitmask of window styles as defined in the
556 * Window class. Note, however, that visual kinds (UNTITLED, TITLED,
557 * or TRANSPARENT) can't be combined together. Also, functional types
558 * (NORMAL, POPUP, or UTILITY) can't be combined together. A window is
559 * allowed to be of exactly one visual kind, and exactly one functional
560 * type.
561 */
562 public final Window createWindow(Screen screen, int styleMask) {
563 return createWindow(null, screen, styleMask);
564 }
565
566 public abstract Window createWindow(long parent);
567
568 public abstract View createView();
569
570 public abstract Cursor createCursor(int type);
571 public abstract Cursor createCursor(int x, int y, Pixels pixels);
572
573 protected abstract void staticCursor_setVisible(boolean visible);
574 protected abstract Size staticCursor_getBestSize(int width, int height);
575
576 public final Menu createMenu(String title) {
577 return new Menu(title);
578 }
579
580 public final Menu createMenu(String title, boolean enabled) {
581 return new Menu(title, enabled);
582 }
583
584 public final MenuBar createMenuBar() {
585 return new MenuBar();
586 }
587
588 public final MenuItem createMenuItem(String title) {
589 return createMenuItem(title, null);
590 }
591
592 public final MenuItem createMenuItem(String title, MenuItem.Callback callback) {
593 return createMenuItem(title, callback, KeyEvent.VK_UNDEFINED, KeyEvent.MODIFIER_NONE);
594 }
595
596 public final MenuItem createMenuItem(String title, MenuItem.Callback callback,
597 int shortcutKey, int shortcutModifiers) {
598 return createMenuItem(title, callback, shortcutKey, shortcutModifiers, null);
599 }
600
601 public final MenuItem createMenuItem(String title, MenuItem.Callback callback,
602 int shortcutKey, int shortcutModifiers, Pixels pixels) {
603 return new MenuItem(title, callback, shortcutKey, shortcutModifiers, pixels);
604 }
605
606 public abstract Pixels createPixels(int width, int height, ByteBuffer data);
607 public abstract Pixels createPixels(int width, int height, IntBuffer data);
608 public abstract Pixels createPixels(int width, int height, IntBuffer data, float scale);
609 protected abstract int staticPixels_getNativeFormat();
610
611 /* utility method called from native code */
612 static Pixels createPixels(int width, int height, int[] data, float scale) {
613 return Application.GetApplication().createPixels(width, height, IntBuffer.wrap(data), scale);
614 }
615
616 /* utility method called from native code */
617 static float getScaleFactor(final int x, final int y, final int w, final int h) {
618 float scale = 0.0f;
619 // Find the maximum scale for screens this area overlaps
620 for (Screen s : Screen.getScreens()) {
621 final int sx = s.getX(), sy = s.getY(), sw = s.getWidth(), sh = s.getHeight();
622 if (x < (sx + sw) && (x + w) > sx && y < (sy + sh) && (y + h) > sy) {
623 if (scale < s.getScale()) {
624 scale = s.getScale();
625 }
626 }
627 }
628 return scale == 0.0f ? 1.0f : scale;
629 }
630
631
632 public abstract Robot createRobot();
633
634 protected abstract double staticScreen_getVideoRefreshPeriod();
635 protected abstract Screen[] staticScreen_getScreens();
636
637 public abstract Timer createTimer(Runnable runnable);
638 protected abstract int staticTimer_getMinPeriod();
639 protected abstract int staticTimer_getMaxPeriod();
640
641 public final EventLoop createEventLoop() {
642 return new EventLoop();
643 }
644
645 protected abstract FileChooserResult staticCommonDialogs_showFileChooser(Window owner, String folder, String filename, String title, int type,
646 boolean multipleMode, ExtensionFilter[] extensionFilters, int defaultFilterIndex);
647
648 protected abstract File staticCommonDialogs_showFolderChooser(Window owner, String folder, String title);
649
650 protected abstract long staticView_getMultiClickTime();
651 protected abstract int staticView_getMultiClickMaxX();
652 protected abstract int staticView_getMultiClickMaxY();
653
654 protected boolean _supportsInputMethods() {
655 // Overridden in subclasses
656 return false;
657 }
658 public final boolean supportsInputMethods() {
659 checkEventThread();
660 return _supportsInputMethods();
661 }
662
663 protected abstract boolean _supportsTransparentWindows();
664 public final boolean supportsTransparentWindows() {
665 checkEventThread();
666 return _supportsTransparentWindows();
667 }
668
669 public boolean hasTwoLevelFocus() {
670 return false;
671 }
672
673 public boolean hasVirtualKeyboard() {
674 return false;
675 }
676
677 public boolean hasTouch() {
678 return false;
679 }
680
681 public boolean hasMultiTouch() {
682 return false;
683 }
684
685 public boolean hasPointer() {
686 return true;
687 }
688
689 protected abstract boolean _supportsUnifiedWindows();
690 public final boolean supportsUnifiedWindows() {
691 checkEventThread();
692 return _supportsUnifiedWindows();
693 }
694
695 protected boolean _supportsSystemMenu() {
696 // Overridden in subclasses
697 return false;
698 }
699 public final boolean supportsSystemMenu() {
700 checkEventThread();
701 return _supportsSystemMenu();
702 }
703 }