1 /*
   2  * Copyright (c) 2011, 2012, 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 sun.lwawt.macosx;
  27 
  28 import java.awt.*;
  29 import java.awt.datatransfer.Clipboard;
  30 import java.awt.dnd.*;
  31 import java.awt.dnd.peer.DragSourceContextPeer;
  32 import java.awt.event.InputEvent;
  33 import java.awt.event.InvocationEvent;
  34 import java.awt.event.KeyEvent;
  35 import java.awt.im.InputMethodHighlight;
  36 import java.awt.peer.*;
  37 import java.lang.reflect.*;
  38 import java.security.*;
  39 import java.util.*;
  40 import java.util.concurrent.Callable;
  41 
  42 import sun.awt.*;
  43 import sun.lwawt.*;
  44 import sun.lwawt.LWWindowPeer.PeerType;
  45 
  46 
  47 class NamedCursor extends Cursor {
  48     NamedCursor(String name) {
  49         super(name);
  50     }
  51 }
  52 
  53 /**
  54  * Mac OS X Cocoa-based AWT Toolkit.
  55  */
  56 public class LWCToolkit extends LWToolkit {
  57     // While it is possible to enumerate all mouse devices
  58     // and query them for the number of buttons, the code
  59     // that does it is rather complex. Instead, we opt for
  60     // the easy way and just support up to 5 mouse buttons,
  61     // like Windows.
  62     private static final int BUTTONS = 5;
  63 
  64     private static native void initIDs();
  65 
  66     static native void startNativeNestedEventLoop();
  67 
  68     static native void stopNativeNestedEventLoop();
  69 
  70     private static CInputMethodDescriptor sInputMethodDescriptor;
  71 
  72     static {
  73         System.err.flush();
  74         java.security.AccessController.doPrivileged(new java.security.PrivilegedAction<Object>() {
  75             public Object run() {
  76                 System.loadLibrary("awt");
  77                 System.loadLibrary("fontmanager");
  78                 return null;
  79             }
  80         });
  81         if (!GraphicsEnvironment.isHeadless()) {
  82             initIDs();
  83         }
  84     }
  85 
  86     static String getSystemProperty(final String name, final String deflt) {
  87         return AccessController.doPrivileged (new PrivilegedAction<String>() {
  88             public String run() {
  89                 return System.getProperty(name, deflt);
  90             }
  91         });
  92     }
  93 
  94     public LWCToolkit() {
  95         SunToolkit.setDataTransfererClassName("sun.lwawt.macosx.CDataTransferer");
  96 
  97         areExtraMouseButtonsEnabled = Boolean.parseBoolean(System.getProperty("sun.awt.enableExtraMouseButtons", "true"));
  98         //set system property if not yet assigned
  99         System.setProperty("sun.awt.enableExtraMouseButtons", ""+areExtraMouseButtonsEnabled);
 100     }
 101 
 102     /*
 103      * System colors with default initial values, overwritten by toolkit if system values differ and are available.
 104      */
 105     private final static int NUM_APPLE_COLORS = 3;
 106     public final static int KEYBOARD_FOCUS_COLOR = 0;
 107     public final static int INACTIVE_SELECTION_BACKGROUND_COLOR = 1;
 108     public final static int INACTIVE_SELECTION_FOREGROUND_COLOR = 2;
 109     private static int[] appleColors = {
 110         0xFF808080, // keyboardFocusColor = Color.gray;
 111         0xFFC0C0C0, // secondarySelectedControlColor
 112         0xFF303030, // controlDarkShadowColor
 113     };
 114 
 115     private native void loadNativeColors(final int[] systemColors, final int[] appleColors);
 116 
 117     protected void loadSystemColors(final int[] systemColors) {
 118         if (systemColors == null) return;
 119         loadNativeColors(systemColors, appleColors);
 120     }
 121 
 122     private static class AppleSpecificColor extends Color {
 123         int index;
 124         public AppleSpecificColor(int index) {
 125             super(appleColors[index]);
 126             this.index = index;
 127         }
 128 
 129         public int getRGB() {
 130             return appleColors[index];
 131         }
 132     }
 133 
 134     /**
 135      * Returns Apple specific colors that we may expose going forward.
 136      *
 137      */
 138     public static Color getAppleColor(int color) {
 139         return new AppleSpecificColor(color);
 140     }
 141 
 142     static void systemColorsChanged() {
 143         // This is only called from native code.
 144         EventQueue.invokeLater(new Runnable() {
 145             public void run() {
 146                 AccessController.doPrivileged (new PrivilegedAction<Object>() {
 147                     public Object run() {
 148                         try {
 149                             final Method updateColorsMethod = SystemColor.class.getDeclaredMethod("updateSystemColors", new Class[0]);
 150                             updateColorsMethod.setAccessible(true);
 151                             updateColorsMethod.invoke(null, new Object[0]);
 152                         } catch (final Throwable e) {
 153                             e.printStackTrace();
 154                             // swallow this if something goes horribly wrong
 155                         }
 156                         return null;
 157                     }
 158                 });
 159             }
 160            });
 161     }
 162 
 163     @Override
 164     protected PlatformWindow createPlatformWindow(PeerType peerType) {
 165         if (peerType == PeerType.EMBEDDEDFRAME) {
 166             return new CPlatformEmbeddedFrame();
 167         } else {
 168             return new CPlatformWindow(peerType);
 169         }
 170     }
 171 
 172     @Override
 173     protected PlatformComponent createPlatformComponent() {
 174         return new CPlatformComponent();
 175     }
 176 
 177     @Override
 178     protected FileDialogPeer createFileDialogPeer(FileDialog target) {
 179         return new CFileDialog(target);
 180     }
 181 
 182     @Override
 183     public MenuPeer createMenu(Menu target) {
 184         MenuPeer peer = new CMenu(target);
 185         targetCreatedPeer(target, peer);
 186         return peer;
 187     }
 188 
 189     @Override
 190     public MenuBarPeer createMenuBar(MenuBar target) {
 191          MenuBarPeer peer = new CMenuBar(target);
 192          targetCreatedPeer(target, peer);
 193              return peer;
 194     }
 195 
 196     @Override
 197     public MenuItemPeer createMenuItem(MenuItem target) {
 198         MenuItemPeer peer = new CMenuItem(target);
 199         targetCreatedPeer(target, peer);
 200         return peer;
 201     }
 202 
 203     @Override
 204     public CheckboxMenuItemPeer createCheckboxMenuItem(CheckboxMenuItem target) {
 205         CheckboxMenuItemPeer peer = new CCheckboxMenuItem(target);
 206         targetCreatedPeer(target, peer);
 207         return peer;
 208     }
 209 
 210     @Override
 211     public PopupMenuPeer createPopupMenu(PopupMenu target) {
 212         PopupMenuPeer peer = new CPopupMenu(target);
 213         targetCreatedPeer(target, peer);
 214         return peer;
 215 
 216     }
 217 
 218     @Override
 219     public SystemTrayPeer createSystemTray(SystemTray target) {
 220         SystemTrayPeer peer = new CSystemTray();
 221         targetCreatedPeer(target, peer);
 222         return peer;
 223     }
 224 
 225     @Override
 226     public TrayIconPeer createTrayIcon(TrayIcon target) {
 227         TrayIconPeer peer = new CTrayIcon(target);
 228         targetCreatedPeer(target, peer);
 229         return peer;
 230     }
 231 
 232     @Override
 233     public LWCursorManager getCursorManager() {
 234         return CCursorManager.getInstance();
 235     }
 236 
 237     @Override
 238     public Cursor createCustomCursor(final Image cursor, final Point hotSpot, final String name) throws IndexOutOfBoundsException, HeadlessException {
 239         return new CCustomCursor(cursor, hotSpot, name);
 240     }
 241 
 242     @Override
 243     public Dimension getBestCursorSize(final int preferredWidth, final int preferredHeight) throws HeadlessException {
 244         return CCustomCursor.getBestCursorSize(preferredWidth, preferredHeight);
 245     }
 246 
 247     @Override
 248     protected void platformCleanup() {
 249         // TODO Auto-generated method stub
 250 
 251     }
 252 
 253     @Override
 254     protected void platformInit() {
 255         // TODO Auto-generated method stub
 256 
 257     }
 258 
 259     @Override
 260     protected void platformRunMessage() {
 261         // TODO Auto-generated method stub
 262 
 263     }
 264 
 265     @Override
 266     protected void platformShutdown() {
 267         // TODO Auto-generated method stub
 268 
 269     }
 270 
 271     class OSXPlatformFont extends sun.awt.PlatformFont
 272     {
 273         public OSXPlatformFont(String name, int style)
 274         {
 275             super(name, style);
 276         }
 277         protected char getMissingGlyphCharacter()
 278         {
 279             // Follow up for real implementation
 280             return (char)0xfff8; // see http://developer.apple.com/fonts/LastResortFont/
 281         }
 282     }
 283     public FontPeer getFontPeer(String name, int style) {
 284         return new OSXPlatformFont(name, style);
 285     }
 286 
 287     @Override
 288     protected MouseInfoPeer createMouseInfoPeerImpl() {
 289         return new CMouseInfoPeer();
 290     }
 291 
 292 
 293     @Override
 294     protected int getScreenHeight() {
 295         return GraphicsEnvironment.getLocalGraphicsEnvironment()
 296                 .getDefaultScreenDevice().getDefaultConfiguration().getBounds().height;
 297     }
 298 
 299     @Override
 300     protected int getScreenWidth() {
 301         return GraphicsEnvironment.getLocalGraphicsEnvironment()
 302                 .getDefaultScreenDevice().getDefaultConfiguration().getBounds().width;
 303     }
 304 
 305     @Override
 306     protected void initializeDesktopProperties() {
 307         super.initializeDesktopProperties();
 308         Map <Object, Object> fontHints = new HashMap<Object, Object>();
 309         fontHints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 310         fontHints.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 311         desktopProperties.put(SunToolkit.DESKTOPFONTHINTS, fontHints);
 312         desktopProperties.put("awt.mouse.numButtons", BUTTONS);
 313 
 314         // These DnD properties must be set, otherwise Swing ends up spewing NPEs
 315         // all over the place. The values came straight off of MToolkit.
 316         desktopProperties.put("DnD.Autoscroll.initialDelay", new Integer(50));
 317         desktopProperties.put("DnD.Autoscroll.interval", new Integer(50));
 318         desktopProperties.put("DnD.Autoscroll.cursorHysteresis", new Integer(5));
 319 
 320         desktopProperties.put("DnD.isDragImageSupported", new Boolean(true));
 321 
 322         // Register DnD cursors
 323         desktopProperties.put("DnD.Cursor.CopyDrop", new NamedCursor("DnD.Cursor.CopyDrop"));
 324         desktopProperties.put("DnD.Cursor.MoveDrop", new NamedCursor("DnD.Cursor.MoveDrop"));
 325         desktopProperties.put("DnD.Cursor.LinkDrop", new NamedCursor("DnD.Cursor.LinkDrop"));
 326         desktopProperties.put("DnD.Cursor.CopyNoDrop", new NamedCursor("DnD.Cursor.CopyNoDrop"));
 327         desktopProperties.put("DnD.Cursor.MoveNoDrop", new NamedCursor("DnD.Cursor.MoveNoDrop"));
 328         desktopProperties.put("DnD.Cursor.LinkNoDrop", new NamedCursor("DnD.Cursor.LinkNoDrop"));
 329 
 330     }
 331 
 332 
 333 /*
 334  * The method returns true if some events were processed during that timeout.
 335  * @see sun.awt.SunToolkit#syncNativeQueue(long)
 336  */
 337     @Override
 338     protected boolean syncNativeQueue(long timeout) {
 339         return nativeSyncQueue(timeout);
 340     }
 341 
 342     @Override
 343     public native void beep();
 344 
 345     @Override
 346     public int getScreenResolution() throws HeadlessException {
 347         return ((CGraphicsDevice) GraphicsEnvironment
 348                 .getLocalGraphicsEnvironment().getDefaultScreenDevice()).getScreenResolution();
 349     }
 350 
 351     @Override
 352     public Insets getScreenInsets(final GraphicsConfiguration gc) {
 353         final CGraphicsConfig cgc = (CGraphicsConfig) gc;
 354         final int displayId = cgc.getDevice().getCoreGraphicsScreen();
 355         Rectangle fullScreen, workArea;
 356         final long screen = CWrapper.NSScreen.screenByDisplayId(displayId);
 357         try {
 358             fullScreen = CWrapper.NSScreen.frame(screen).getBounds();
 359             workArea = CWrapper.NSScreen.visibleFrame(screen).getBounds();
 360         } finally {
 361             CWrapper.NSObject.release(screen);
 362         }
 363         // Convert between Cocoa's coordinate system and Java.
 364         return new Insets(fullScreen.height - workArea.height - workArea.y,
 365                           workArea.x, workArea.y,
 366                           fullScreen.width - workArea.width - workArea.x);
 367     }
 368 
 369     @Override
 370     public void sync() {
 371         // TODO Auto-generated method stub
 372 
 373     }
 374 
 375     @Override
 376     public RobotPeer createRobot(Robot target, GraphicsDevice screen) {
 377         return new CRobot(target, (CGraphicsDevice)screen);
 378     }
 379 
 380     private native boolean isCapsLockOn();
 381 
 382     /*
 383      * NOTE: Among the keys this method is supposed to check,
 384      * only Caps Lock works as a true locking key with OS X.
 385      * There is no Scroll Lock key on modern Apple keyboards,
 386      * and with a PC keyboard plugged in Scroll Lock is simply
 387      * ignored: no LED lights up if you press it.
 388      * The key located at the same position on Apple keyboards
 389      * as Num Lock on PC keyboards is called Clear, doesn't lock
 390      * anything and is used for entirely different purpose.
 391      */
 392     public boolean getLockingKeyState(int keyCode) throws UnsupportedOperationException {
 393         switch (keyCode) {
 394             case KeyEvent.VK_NUM_LOCK:
 395             case KeyEvent.VK_SCROLL_LOCK:
 396             case KeyEvent.VK_KANA_LOCK:
 397                 throw new UnsupportedOperationException("Toolkit.getLockingKeyState");
 398 
 399             case KeyEvent.VK_CAPS_LOCK:
 400                 return isCapsLockOn();
 401 
 402             default:
 403                 throw new IllegalArgumentException("invalid key for Toolkit.getLockingKeyState");
 404         }
 405     }
 406 
 407     //Is it allowed to generate events assigned to extra mouse buttons.
 408     //Set to true by default.
 409     private static boolean areExtraMouseButtonsEnabled = true;
 410 
 411     public boolean areExtraMouseButtonsEnabled() throws HeadlessException {
 412         return areExtraMouseButtonsEnabled;
 413     }
 414 
 415     public int getNumberOfButtons(){
 416         return BUTTONS;
 417     }
 418 
 419 
 420     @Override
 421     public boolean isTraySupported() {
 422         return true;
 423     }
 424 
 425     @Override
 426     public boolean isAlwaysOnTopSupported() {
 427         return true;
 428     }
 429 
 430     // Intended to be called from the LWCToolkit.m only.
 431     private static void installToolkitThreadNameInJava() {
 432         Thread.currentThread().setName(CThreading.APPKIT_THREAD_NAME);
 433     }
 434 
 435     @Override
 436     public boolean isWindowOpacitySupported() {
 437         return true;
 438     }
 439 
 440     @Override
 441     public boolean isFrameStateSupported(int state) throws HeadlessException {
 442         switch (state) {
 443             case Frame.NORMAL:
 444             case Frame.ICONIFIED:
 445             case Frame.MAXIMIZED_BOTH:
 446                 return true;
 447             default:
 448                 return false;
 449         }
 450     }
 451 
 452     /**
 453      * Determines which modifier key is the appropriate accelerator
 454      * key for menu shortcuts.
 455      * <p>
 456      * Menu shortcuts, which are embodied in the
 457      * <code>MenuShortcut</code> class, are handled by the
 458      * <code>MenuBar</code> class.
 459      * <p>
 460      * By default, this method returns <code>Event.CTRL_MASK</code>.
 461      * Toolkit implementations should override this method if the
 462      * <b>Control</b> key isn't the correct key for accelerators.
 463      * @return    the modifier mask on the <code>Event</code> class
 464      *                 that is used for menu shortcuts on this toolkit.
 465      * @see       java.awt.MenuBar
 466      * @see       java.awt.MenuShortcut
 467      * @since     JDK1.1
 468      */
 469     public int getMenuShortcutKeyMask() {
 470         return Event.META_MASK;
 471     }
 472 
 473     @Override
 474     public Image getImage(final String filename) {
 475         final Image nsImage = checkForNSImage(filename);
 476         if (nsImage != null) return nsImage;
 477 
 478         return super.getImage(filename);
 479     }
 480 
 481     static final String nsImagePrefix = "NSImage://";
 482     protected Image checkForNSImage(final String imageName) {
 483         if (imageName == null) return null;
 484         if (!imageName.startsWith(nsImagePrefix)) return null;
 485         return CImage.getCreator().createImageFromName(imageName.substring(nsImagePrefix.length()));
 486     }
 487 
 488     // Thread-safe Object.equals() called from native
 489     public static boolean doEquals(final Object a, final Object b, Component c) {
 490         if (a == b) return true;
 491 
 492         final boolean[] ret = new boolean[1];
 493 
 494         try {  invokeAndWait(new Runnable() { public void run() { synchronized(ret) {
 495             ret[0] = a.equals(b);
 496         }}}, c); } catch (Exception e) { e.printStackTrace(); }
 497 
 498         synchronized(ret) { return ret[0]; }
 499     }
 500 
 501     // Kicks an event over to the appropriate eventqueue and waits for it to finish
 502     // To avoid deadlocking, we manually run the NSRunLoop while waiting
 503     // Any selector invoked using ThreadUtilities performOnMainThread will be processed in doAWTRunLoop
 504     // The CInvocationEvent will call LWCToolkit.stopAWTRunLoop() when finished, which will stop our manual runloop
 505     public static void invokeAndWait(Runnable event, Component component) throws InterruptedException, InvocationTargetException {
 506         invokeAndWait(event, component, true);
 507     }
 508 
 509     public static <T> T invokeAndWait(final Callable<T> callable, Component component) throws Exception {
 510         final CallableWrapper<T> wrapper = new CallableWrapper<T>(callable);
 511         invokeAndWait(wrapper, component);
 512         return wrapper.getResult();
 513     }
 514 
 515     static final class CallableWrapper<T> implements Runnable {
 516         final Callable<T> callable;
 517         T object;
 518         Exception e;
 519 
 520         public CallableWrapper(final Callable<T> callable) {
 521             this.callable = callable;
 522         }
 523 
 524         public void run() {
 525             try {
 526                 object = callable.call();
 527             } catch (final Exception e) {
 528                 this.e = e;
 529             }
 530         }
 531 
 532         public T getResult() throws Exception {
 533             if (e != null) throw e;
 534             return object;
 535         }
 536     }
 537 
 538     public static void invokeAndWait(Runnable event, Component component, boolean detectDeadlocks) throws InterruptedException, InvocationTargetException {
 539         long mediator = createAWTRunLoopMediator();
 540 
 541         InvocationEvent invocationEvent = new CPeerEvent(event, mediator);
 542 
 543         if (component != null) {
 544             AppContext appContext = SunToolkit.targetToAppContext(component);
 545             SunToolkit.postEvent(appContext, invocationEvent);
 546 
 547             // 3746956 - flush events from PostEventQueue to prevent them from getting stuck and causing a deadlock
 548             sun.awt.SunToolkitSubclass.flushPendingEvents(appContext);
 549         } else {
 550             // This should be the equivalent to EventQueue.invokeAndWait
 551             ((LWCToolkit)Toolkit.getDefaultToolkit()).getSystemEventQueueForInvokeAndWait().postEvent(invocationEvent);
 552         }
 553 
 554         doAWTRunLoop(mediator, true, detectDeadlocks);
 555 
 556         Throwable eventException = invocationEvent.getException();
 557         if (eventException != null) {
 558             if (eventException instanceof UndeclaredThrowableException) {
 559                 eventException = ((UndeclaredThrowableException)eventException).getUndeclaredThrowable();
 560             }
 561             throw new InvocationTargetException(eventException);
 562         }
 563     }
 564 
 565     public static void invokeLater(Runnable event, Component component) throws InvocationTargetException {
 566         final InvocationEvent invocationEvent = new CPeerEvent(event, 0);
 567 
 568         if (component != null) {
 569             final AppContext appContext = SunToolkit.targetToAppContext(component);
 570             SunToolkit.postEvent(appContext, invocationEvent);
 571 
 572             // 3746956 - flush events from PostEventQueue to prevent them from getting stuck and causing a deadlock
 573             sun.awt.SunToolkitSubclass.flushPendingEvents(appContext);
 574         } else {
 575             // This should be the equivalent to EventQueue.invokeAndWait
 576             ((LWCToolkit)Toolkit.getDefaultToolkit()).getSystemEventQueueForInvokeAndWait().postEvent(invocationEvent);
 577         }
 578 
 579         final Throwable eventException = invocationEvent.getException();
 580         if (eventException == null) return;
 581 
 582         if (eventException instanceof UndeclaredThrowableException) {
 583             throw new InvocationTargetException(((UndeclaredThrowableException)eventException).getUndeclaredThrowable());
 584         }
 585         throw new InvocationTargetException(eventException);
 586     }
 587 
 588     // This exists purely to get around permissions issues with getSystemEventQueueImpl
 589     EventQueue getSystemEventQueueForInvokeAndWait() {
 590         return getSystemEventQueueImpl();
 591     }
 592 
 593 
 594 // DnD support
 595 
 596     public DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge) throws InvalidDnDOperationException {
 597         DragSourceContextPeer dscp = CDragSourceContextPeer.createDragSourceContextPeer(dge);
 598 
 599         return dscp;
 600     }
 601 
 602     public <T extends DragGestureRecognizer> T createDragGestureRecognizer(Class<T> abstractRecognizerClass, DragSource ds, Component c, int srcActions, DragGestureListener dgl) {
 603         DragGestureRecognizer dgr = null;
 604 
 605         // Create a new mouse drag gesture recognizer if we have a class match:
 606         if (MouseDragGestureRecognizer.class.equals(abstractRecognizerClass))
 607             dgr = new CMouseDragGestureRecognizer(ds, c, srcActions, dgl);
 608 
 609         return (T)dgr;
 610     }
 611 
 612 // InputMethodSupport Method
 613     /**
 614      * Returns the default keyboard locale of the underlying operating system
 615      */
 616     public Locale getDefaultKeyboardLocale() {
 617         Locale locale = CInputMethod.getNativeLocale();
 618 
 619         if (locale == null) {
 620             return super.getDefaultKeyboardLocale();
 621         }
 622 
 623         return locale;
 624     }
 625 
 626     public java.awt.im.spi.InputMethodDescriptor getInputMethodAdapterDescriptor() {
 627         if (sInputMethodDescriptor == null)
 628             sInputMethodDescriptor = new CInputMethodDescriptor();
 629 
 630         return sInputMethodDescriptor;
 631     }
 632 
 633     /**
 634      * Returns a map of visual attributes for thelevel description
 635      * of the given input method highlight, or null if no mapping is found.
 636      * The style field of the input method highlight is ignored. The map
 637      * returned is unmodifiable.
 638      * @param highlight input method highlight
 639      * @return style attribute map, or null
 640      * @since 1.3
 641      */
 642     public Map mapInputMethodHighlight(InputMethodHighlight highlight) {
 643         return CInputMethod.mapInputMethodHighlight(highlight);
 644     }
 645 
 646     /**
 647      * Returns key modifiers used by Swing to set up a focus accelerator key stroke.
 648      */
 649     @Override
 650     public int getFocusAcceleratorKeyMask() {
 651         return InputEvent.CTRL_MASK | InputEvent.ALT_MASK;
 652     }
 653 
 654     /**
 655      * Tests whether specified key modifiers mask can be used to enter a printable
 656      * character.
 657      */
 658     @Override
 659     public boolean isPrintableCharacterModifiersMask(int mods) {
 660         return ((mods & (InputEvent.META_MASK | InputEvent.CTRL_MASK)) == 0);
 661     }
 662 
 663     /**
 664      * Returns whether popup is allowed to be shown above the task bar.
 665      */
 666     @Override
 667     public boolean canPopupOverlapTaskBar() {
 668         return false;
 669     }
 670 
 671     // Extends PeerEvent because we want to pass long an ObjC mediator object and because we want these events to be posted early
 672     // Typically, rather than relying on the notifier to call notifyAll(), we use the mediator to stop the runloop
 673     public static class CPeerEvent extends PeerEvent {
 674         private long _mediator = 0;
 675 
 676         public CPeerEvent(Runnable runnable, long mediator) {
 677             super(Toolkit.getDefaultToolkit(), runnable, null, true, 0);
 678             _mediator = mediator;
 679         }
 680 
 681         public void dispatch() {
 682             try {
 683                 super.dispatch();
 684             } finally {
 685                 if (_mediator != 0) {
 686                     LWCToolkit.stopAWTRunLoop(_mediator);
 687                 }
 688             }
 689         }
 690     }
 691 
 692     // Call through to native methods
 693     public static void doAWTRunLoop(long mediator, boolean awtMode) { doAWTRunLoop(mediator, awtMode, true); }
 694     public static void doAWTRunLoop(long mediator) { doAWTRunLoop(mediator, true); }
 695 
 696     private static Boolean sunAwtDisableCALayers = null;
 697 
 698     /**
 699      * Returns the value of "sun.awt.disableCALayers" property. Default
 700      * value is {@code false}.
 701      */
 702     public synchronized static boolean getSunAwtDisableCALayers() {
 703         if (sunAwtDisableCALayers == null) {
 704             sunAwtDisableCALayers =
 705             getBooleanSystemProperty("sun.awt.disableCALayers");
 706         }
 707         return sunAwtDisableCALayers.booleanValue();
 708     }
 709 
 710 
 711     /*
 712      * Returns true if the application (one of its windows) owns keyboard focus.
 713      */
 714     public native boolean isApplicationActive();
 715 
 716     /************************
 717      * Native methods section
 718      ************************/
 719 
 720     // These are public because they are accessed from WebKitPluginObject in JavaDeploy
 721     // Basic usage:
 722     // createAWTRunLoopMediator. Start client code on another thread. doAWTRunLoop. When client code is finished, stopAWTRunLoop.
 723     public static native long createAWTRunLoopMediator();
 724     public static native void doAWTRunLoop(long mediator, boolean awtMode, boolean detectDeadlocks);
 725     public static native void stopAWTRunLoop(long mediator);
 726 
 727     private native boolean nativeSyncQueue(long timeout);
 728 
 729     @Override
 730     public Clipboard createPlatformClipboard() {
 731         return new CClipboard("System");
 732     }
 733 
 734     @Override
 735     public boolean isModalExclusionTypeSupported(Dialog.ModalExclusionType exclusionType) {
 736         return (exclusionType == null) ||
 737             (exclusionType == Dialog.ModalExclusionType.NO_EXCLUDE) ||
 738             (exclusionType == Dialog.ModalExclusionType.APPLICATION_EXCLUDE) ||
 739             (exclusionType == Dialog.ModalExclusionType.TOOLKIT_EXCLUDE);
 740     }
 741 
 742     @Override
 743     public boolean isModalityTypeSupported(Dialog.ModalityType modalityType) {
 744         //TODO: FileDialog blocks excluded windows...
 745         //TODO: Test: 2 file dialogs, separate AppContexts: a) Dialog 1 blocked, shouldn't be. Frame 4 blocked (shouldn't be).
 746         return (modalityType == null) ||
 747             (modalityType == Dialog.ModalityType.MODELESS) ||
 748             (modalityType == Dialog.ModalityType.DOCUMENT_MODAL) ||
 749             (modalityType == Dialog.ModalityType.APPLICATION_MODAL) ||
 750             (modalityType == Dialog.ModalityType.TOOLKIT_MODAL);
 751     }
 752 
 753     @Override
 754     public boolean isWindowTranslucencySupported() {
 755         return true;
 756     }
 757 
 758     @Override
 759     public boolean isTranslucencyCapable(GraphicsConfiguration gc) {
 760         return true;
 761     }
 762 
 763     @Override
 764     public boolean enableInputMethodsForTextComponent() {
 765         return true;
 766     }
 767 }