rev 6142 : RT-35355 [Monocle] Software rendering ports of Monocle need notification of pixel upload end

   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     /**
 368      * Gets a Runnable object to be called on the application thread to
 369      * notify that rendering has completed. Systems that require notification
 370      * of rendering completion should override this method.
 371      *
 372      * @return a Runnable to be called on the application thread when rendering
 373      * has completed, or null if no notification is needed.
 374      */
 375     public Runnable getRenderEndNotifier() {
 376         return null;
 377     }
 378 
 379     public void terminate() {
 380         checkEventThread();
 381         try {
 382                 final List<Window> windows = new LinkedList<>(Window.getWindows());
 383                 for (Window window : windows) {
 384                     // first make windows invisible
 385                     window.setVisible(false);
 386                 }
 387                 for (Window window : windows) {
 388                     // now we can close windows
 389                     window.close();
 390                 }
 391         } catch (Throwable t) {
 392             t.printStackTrace();
 393         } finally {
 394             finishTerminating();
 395         }
 396     }
 397 
 398     // May be called on any thread
 399     static public Application GetApplication() {
 400         return Application.application;
 401     }
 402 
 403     // May be called on any thread
 404     protected static void setEventThread(Thread thread) {
 405         Application.eventThread = thread;
 406     }
 407 
 408     // May be called on any thread
 409     protected static Thread getEventThread() {
 410         return Application.eventThread;
 411     }
 412 
 413     /**
 414      * Returns {@code true} if the current thread is the event thread.
 415      */
 416     public static boolean isEventThread() {
 417         return Thread.currentThread() == Application.eventThread;
 418     }
 419 
 420     /**
 421      * Verifies that the current thread is the event thread, and throws
 422      * an exception if this is not so.
 423      * 
 424      * The check can be disabled by setting the "glass.disableThreadChecks"
 425      * system property. It is preferred, however, to fix the application code
 426      * instead.
 427      *
 428      * @throws IllegalStateException if the current thread is not the event thread
 429      */
 430     public static void checkEventThread() {
 431         //TODO: we do NOT advertise the "glass.disableThreadChecks".
 432         //      If we never get a complaint about this check, we can consider
 433         //      dropping the system property and perform the check unconditionally
 434         if (!disableThreadChecks &&
 435                 Thread.currentThread() != Application.eventThread)
 436         {
 437             throw new IllegalStateException(
 438                     "This operation is permitted on the event thread only; currentThread = "
 439                     + Thread.currentThread().getName());
 440 
 441         }
 442     }
 443 
 444     // Called from native, when a JNI exception has occurred
 445     public static void reportException(Throwable t) {
 446         Thread currentThread = Thread.currentThread();
 447         Thread.UncaughtExceptionHandler handler =
 448                 currentThread.getUncaughtExceptionHandler();
 449         handler.uncaughtException(currentThread, t);
 450     }
 451 
 452     abstract protected void _invokeAndWait(java.lang.Runnable runnable);
 453     /**
 454      * Block the current thread and wait until the given  runnable finishes
 455      * running on the native event loop thread.
 456      */
 457     public static void invokeAndWait(java.lang.Runnable runnable) {
 458         if (runnable == null) {
 459             return;
 460         }
 461         if (isEventThread()) {
 462             runnable.run();
 463         } else {
 464             GetApplication()._invokeAndWait(runnable);
 465         }
 466     }
 467 
 468     abstract protected void _invokeLater(java.lang.Runnable runnable);
 469     /**
 470      * Schedule the given runnable to run on the native event loop thread
 471      * some time in the future, and return immediately.
 472      */
 473     public static void invokeLater(java.lang.Runnable runnable) {
 474         if (runnable == null) {
 475             return;
 476         }
 477         GetApplication()._invokeLater(runnable);
 478     }
 479 
 480     protected abstract Object _enterNestedEventLoop();
 481     protected abstract void _leaveNestedEventLoop(Object retValue);
 482 
 483     private static int nestedEventLoopCounter = 0;
 484 
 485     /**
 486      * Starts a nested event loop.
 487      *
 488      * Calling this method temporarily blocks processing of the current event,
 489      * and starts a nested event loop to handle other native events.  To
 490      * proceed with the blocked execution path, the application should call the
 491      * {@link #leaveNestedEventLoop(Object)} method.
 492      *
 493      * Note that this method may only be invoked on the main (event handling)
 494      * thread.
 495      *
 496      * An application may enter several nested loops recursively. There's no
 497      * limit of recursion other than that imposed by the native stack size.
 498      *
 499      * @return an object passed to the leaveNestedEventLoop() method
 500      * @throws RuntimeException if the current thread is not the main thread
 501      */
 502     static Object enterNestedEventLoop() {
 503         checkEventThread();
 504 
 505         nestedEventLoopCounter++;
 506         try {
 507             return GetApplication()._enterNestedEventLoop();
 508         } finally {
 509             nestedEventLoopCounter--;
 510         }
 511     }
 512 
 513     /**
 514      * Terminates the current nested event loop.
 515      *
 516      * After calling this method and returning from the current event handler,
 517      * the execusion returns to the point where the {@link #enterNestedEventLoop}
 518      * was called previously. You may specify a return value for the
 519      * enterNestedEventLoop() method by passing the argument {@code retValue} to
 520      * the leaveNestedEventLoop().
 521      *
 522      * Note that this method may only be invoked on the main (event handling)
 523      * thread.
 524      *
 525      * @throws RuntimeException if the current thread is not the main thread
 526      * @throws IllegalStateException if the application hasn't started a nested
 527      *                               event loop
 528      */
 529     static void leaveNestedEventLoop(Object retValue) {
 530         checkEventThread();
 531 
 532         if (nestedEventLoopCounter == 0) {
 533             throw new IllegalStateException("Not in a nested event loop");
 534         }
 535 
 536         GetApplication()._leaveNestedEventLoop(retValue);
 537     }
 538 
 539     public static boolean isNestedLoopRunning() {
 540         checkEventThread();
 541         return nestedEventLoopCounter > 0;
 542     }
 543 
 544     //TODO: move to the EventHandler
 545     public void menuAboutAction() {
 546         System.err.println("about");
 547     }
 548 
 549 
 550     // FACTORY METHODS
 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 abstract Window createWindow(Window owner, Screen screen, int styleMask);
 563 
 564     /**
 565      * Create a window.
 566      *
 567      * The styleMask argument is a bitmask of window styles as defined in the
 568      * Window class.  Note, however, that visual kinds (UNTITLED, TITLED,
 569      * or TRANSPARENT) can't be combined together.  Also, functional types
 570      * (NORMAL, POPUP, or UTILITY) can't be combined together.  A window is
 571      * allowed to be of exactly one visual kind, and exactly one functional
 572      * type.
 573      */
 574     public final Window createWindow(Screen screen, int styleMask) {
 575         return createWindow(null, screen, styleMask);
 576     }
 577 
 578     public abstract Window createWindow(long parent);
 579 
 580     public abstract View createView();
 581 
 582     public abstract Cursor createCursor(int type);
 583     public abstract Cursor createCursor(int x, int y, Pixels pixels);
 584 
 585     protected abstract void staticCursor_setVisible(boolean visible);
 586     protected abstract Size staticCursor_getBestSize(int width, int height);
 587 
 588     public final Menu createMenu(String title) {
 589         return new Menu(title);
 590     }
 591 
 592     public final Menu createMenu(String title, boolean enabled) {
 593         return new Menu(title, enabled);
 594     }
 595 
 596     public final MenuBar createMenuBar() {
 597         return new MenuBar();
 598     }
 599 
 600     public final MenuItem createMenuItem(String title) {
 601         return createMenuItem(title, null);
 602     }
 603 
 604     public final MenuItem createMenuItem(String title, MenuItem.Callback callback) {
 605         return createMenuItem(title, callback, KeyEvent.VK_UNDEFINED, KeyEvent.MODIFIER_NONE);
 606     }
 607 
 608     public final MenuItem createMenuItem(String title, MenuItem.Callback callback,
 609             int shortcutKey, int shortcutModifiers) {
 610         return createMenuItem(title, callback, shortcutKey, shortcutModifiers, null);
 611     }
 612 
 613     public final MenuItem createMenuItem(String title, MenuItem.Callback callback,
 614             int shortcutKey, int shortcutModifiers, Pixels pixels) {
 615         return new MenuItem(title, callback, shortcutKey, shortcutModifiers, pixels);
 616     }
 617 
 618     public abstract Pixels createPixels(int width, int height, ByteBuffer data);
 619     public abstract Pixels createPixels(int width, int height, IntBuffer data);
 620     public abstract Pixels createPixels(int width, int height, IntBuffer data, float scale);
 621     protected abstract int staticPixels_getNativeFormat();
 622 
 623     /* utility method called from native code */
 624     static Pixels createPixels(int width, int height, int[] data, float scale) {
 625         return Application.GetApplication().createPixels(width, height, IntBuffer.wrap(data), scale);
 626     }
 627 
 628     /* utility method called from native code */
 629     static float getScaleFactor(final int x, final int y, final int w, final int h) {
 630         float scale = 0.0f;
 631         // Find the maximum scale for screens this area overlaps
 632         for (Screen s : Screen.getScreens()) {
 633             final int sx = s.getX(), sy = s.getY(), sw = s.getWidth(), sh = s.getHeight();
 634             if (x < (sx + sw) && (x + w) > sx && y < (sy + sh) && (y + h) > sy) {
 635                 if (scale < s.getScale()) {
 636                     scale = s.getScale();
 637                 }
 638             }
 639         }
 640         return scale == 0.0f ? 1.0f : scale;
 641     }
 642 
 643 
 644     public abstract Robot createRobot();
 645 
 646     protected abstract double staticScreen_getVideoRefreshPeriod();
 647     protected abstract Screen[] staticScreen_getScreens();
 648 
 649     public abstract Timer createTimer(Runnable runnable);
 650     protected abstract int staticTimer_getMinPeriod();
 651     protected abstract int staticTimer_getMaxPeriod();
 652 
 653     public final EventLoop createEventLoop() {
 654         return new EventLoop();
 655     }
 656 
 657     protected abstract FileChooserResult staticCommonDialogs_showFileChooser(Window owner, String folder, String filename, String title, int type,
 658                                                      boolean multipleMode, ExtensionFilter[] extensionFilters, int defaultFilterIndex);
 659 
 660     protected abstract File staticCommonDialogs_showFolderChooser(Window owner, String folder, String title);
 661 
 662     protected abstract long staticView_getMultiClickTime();
 663     protected abstract int staticView_getMultiClickMaxX();
 664     protected abstract int staticView_getMultiClickMaxY();
 665 
 666     protected boolean _supportsInputMethods() {
 667         // Overridden in subclasses
 668         return false;
 669     }
 670     public final boolean supportsInputMethods() {
 671         checkEventThread();
 672         return _supportsInputMethods();
 673     }
 674 
 675     protected abstract boolean _supportsTransparentWindows();
 676     public final boolean supportsTransparentWindows() {
 677         checkEventThread();
 678         return _supportsTransparentWindows();
 679     }
 680 
 681     public boolean hasTwoLevelFocus() {
 682         return false;
 683     }
 684 
 685     public boolean hasVirtualKeyboard() {
 686         return false;
 687     }
 688 
 689     public boolean hasTouch() {
 690         return false;
 691     }
 692 
 693     public boolean hasMultiTouch() {
 694         return false;
 695     }
 696 
 697     public boolean hasPointer() {
 698         return true;
 699     }
 700 
 701     protected abstract boolean _supportsUnifiedWindows();
 702     public final boolean supportsUnifiedWindows() {
 703         checkEventThread();
 704         return _supportsUnifiedWindows();
 705     }
 706 
 707     protected boolean _supportsSystemMenu() {
 708         // Overridden in subclasses
 709         return false;
 710     }
 711     public final boolean supportsSystemMenu() {
 712         checkEventThread();
 713         return _supportsSystemMenu();
 714     }
 715 }
--- EOF ---