1 /*

     2  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package sun.awt;

    27 

    28 import java.awt.*;

    29 import static java.awt.RenderingHints.*;

    30 import java.awt.dnd.*;

    31 import java.awt.dnd.peer.DragSourceContextPeer;

    32 import java.awt.peer.*;

    33 import java.awt.event.WindowEvent;

    34 import java.awt.event.KeyEvent;

    35 import java.awt.image.*;

    36 import java.awt.TrayIcon;

    37 import java.awt.SystemTray;

    38 import java.awt.event.InputEvent;

    39 import java.io.File;

    40 import java.io.IOException;

    41 import java.io.InputStream;

    42 import java.net.URL;

    43 import java.security.PrivilegedAction;

    44 import java.util.*;

    45 import java.util.concurrent.TimeUnit;

    46 import java.util.concurrent.locks.Condition;

    47 import java.util.concurrent.locks.Lock;

    48 import java.util.concurrent.locks.ReentrantLock;

    49 

    50 import sun.awt.datatransfer.DataTransferer;

    51 import sun.util.logging.PlatformLogger;

    52 import sun.misc.SoftCache;

    53 import sun.font.FontDesignMetrics;

    54 import sun.awt.im.InputContext;

    55 import sun.awt.image.*;

    56 import sun.security.action.GetPropertyAction;

    57 import sun.security.action.GetBooleanAction;

    58 import java.lang.reflect.InvocationTargetException;

    59 import java.security.AccessController;

    60 

    61 public abstract class SunToolkit extends Toolkit

    62     implements ComponentFactory, InputMethodSupport, KeyboardFocusManagerPeerProvider {

    63 

    64     // 8014718: logging has been removed from SunToolkit

    65 

    66     /* Load debug settings for native code */

    67     static {

    68         if (AccessController.doPrivileged(new GetBooleanAction("sun.awt.nativedebug"))) {

    69             DebugSettings.init();

    70         }

    71     };

    72 

    73     /**

    74      * Special mask for the UngrabEvent events, in addition to the

    75      * public masks defined in AWTEvent.  Should be used as the mask

    76      * value for Toolkit.addAWTEventListener.

    77      */

    78     public static final int GRAB_EVENT_MASK = 0x80000000;

    79 

    80     /* The key to put()/get() the PostEventQueue into/from the AppContext.

    81      */

    82     private static final String POST_EVENT_QUEUE_KEY = "PostEventQueue";

    83 

    84     /**

    85      * Number of buttons.

    86      * By default it's taken from the system. If system value does not

    87      * fit into int type range, use our own MAX_BUTTONS_SUPPORT value.

    88      */

    89     protected static int numberOfButtons = 0;

    90 

    91 

    92     /* XFree standard mention 24 buttons as maximum:

    93      * http://www.xfree86.org/current/mouse.4.html

    94      * We workaround systems supporting more than 24 buttons.

    95      * Otherwise, we have to use long type values as masks

    96      * which leads to API change.

    97      * InputEvent.BUTTON_DOWN_MASK may contain only 21 masks due to

    98      * the 4-bytes limit for the int type. (CR 6799099)

    99      * One more bit is reserved for FIRST_HIGH_BIT.

   100      */

   101     public final static int MAX_BUTTONS_SUPPORTED = 20;

   102 

   103     /**

   104      * Creates and initializes EventQueue instance for the specified

   105      * AppContext.

   106      * Note that event queue must be created from createNewAppContext()

   107      * only in order to ensure that EventQueue constructor obtains

   108      * the correct AppContext.

   109      * @param appContext AppContext to associate with the event queue

   110      */

   111     private static void initEQ(AppContext appContext) {

   112         EventQueue eventQueue;

   113 

   114         String eqName = System.getProperty("AWT.EventQueueClass",

   115                 "java.awt.EventQueue");

   116 

   117         try {

   118             eventQueue = (EventQueue)Class.forName(eqName).newInstance();

   119         } catch (Exception e) {

   120             e.printStackTrace();

   121             System.err.println("Failed loading " + eqName + ": " + e);

   122             eventQueue = new EventQueue();

   123         }

   124         appContext.put(AppContext.EVENT_QUEUE_KEY, eventQueue);

   125 

   126         PostEventQueue postEventQueue = new PostEventQueue(eventQueue);

   127         appContext.put(POST_EVENT_QUEUE_KEY, postEventQueue);

   128     }

   129 

   130     public SunToolkit() {

   131     }

   132 

   133     public boolean useBufferPerWindow() {

   134         return false;

   135     }

   136 

   137     public abstract WindowPeer createWindow(Window target)

   138         throws HeadlessException;

   139 

   140     public abstract FramePeer createFrame(Frame target)

   141         throws HeadlessException;

   142 

   143     public abstract FramePeer createLightweightFrame(LightweightFrame target)

   144         throws HeadlessException;

   145 

   146     public abstract DialogPeer createDialog(Dialog target)

   147         throws HeadlessException;

   148 

   149     public abstract ButtonPeer createButton(Button target)

   150         throws HeadlessException;

   151 

   152     public abstract TextFieldPeer createTextField(TextField target)

   153         throws HeadlessException;

   154 

   155     public abstract ChoicePeer createChoice(Choice target)

   156         throws HeadlessException;

   157 

   158     public abstract LabelPeer createLabel(Label target)

   159         throws HeadlessException;

   160 

   161     public abstract ListPeer createList(java.awt.List target)

   162         throws HeadlessException;

   163 

   164     public abstract CheckboxPeer createCheckbox(Checkbox target)

   165         throws HeadlessException;

   166 

   167     public abstract ScrollbarPeer createScrollbar(Scrollbar target)

   168         throws HeadlessException;

   169 

   170     public abstract ScrollPanePeer createScrollPane(ScrollPane target)

   171         throws HeadlessException;

   172 

   173     public abstract TextAreaPeer createTextArea(TextArea target)

   174         throws HeadlessException;

   175 

   176     public abstract FileDialogPeer createFileDialog(FileDialog target)

   177         throws HeadlessException;

   178 

   179     public abstract MenuBarPeer createMenuBar(MenuBar target)

   180         throws HeadlessException;

   181 

   182     public abstract MenuPeer createMenu(Menu target)

   183         throws HeadlessException;

   184 

   185     public abstract PopupMenuPeer createPopupMenu(PopupMenu target)

   186         throws HeadlessException;

   187 

   188     public abstract MenuItemPeer createMenuItem(MenuItem target)

   189         throws HeadlessException;

   190 

   191     public abstract CheckboxMenuItemPeer createCheckboxMenuItem(

   192         CheckboxMenuItem target)

   193         throws HeadlessException;

   194 

   195     public abstract DragSourceContextPeer createDragSourceContextPeer(

   196         DragGestureEvent dge)

   197         throws InvalidDnDOperationException;

   198 

   199     public abstract TrayIconPeer createTrayIcon(TrayIcon target)

   200         throws HeadlessException, AWTException;

   201 

   202     public abstract SystemTrayPeer createSystemTray(SystemTray target);

   203 

   204     public abstract boolean isTraySupported();

   205 

   206     @SuppressWarnings("deprecation")

   207     public abstract FontPeer getFontPeer(String name, int style);

   208 

   209     public abstract RobotPeer createRobot(Robot target, GraphicsDevice screen)

   210         throws AWTException;

   211 

   212     public abstract KeyboardFocusManagerPeer getKeyboardFocusManagerPeer()

   213         throws HeadlessException;

   214 

   215     /**

   216      * The AWT lock is typically only used on Unix platforms to synchronize

   217      * access to Xlib, OpenGL, etc.  However, these methods are implemented

   218      * in SunToolkit so that they can be called from shared code (e.g.

   219      * from the OGL pipeline) or from the X11 pipeline regardless of whether

   220      * XToolkit or MToolkit is currently in use.  There are native macros

   221      * (such as AWT_LOCK) defined in awt.h, so if the implementation of these

   222      * methods is changed, make sure it is compatible with the native macros.

   223      *

   224      * Note: The following methods (awtLock(), awtUnlock(), etc) should be

   225      * used in place of:

   226      *     synchronized (getAWTLock()) {

   227      *         ...

   228      *     }

   229      *

   230      * By factoring these methods out specially, we are able to change the

   231      * implementation of these methods (e.g. use more advanced locking

   232      * mechanisms) without impacting calling code.

   233      *

   234      * Sample usage:

   235      *     private void doStuffWithXlib() {

   236      *         assert !SunToolkit.isAWTLockHeldByCurrentThread();

   237      *         SunToolkit.awtLock();

   238      *         try {

   239      *             ...

   240      *             XlibWrapper.XDoStuff();

   241      *         } finally {

   242      *             SunToolkit.awtUnlock();

   243      *         }

   244      *     }

   245      */

   246 

   247     private static final ReentrantLock AWT_LOCK = new ReentrantLock();

   248     private static final Condition AWT_LOCK_COND = AWT_LOCK.newCondition();

   249 

   250     public static final void awtLock() {

   251         AWT_LOCK.lock();

   252     }

   253 

   254     public static final boolean awtTryLock() {

   255         return AWT_LOCK.tryLock();

   256     }

   257 

   258     public static final void awtUnlock() {

   259         AWT_LOCK.unlock();

   260     }

   261 

   262     public static final void awtLockWait()

   263         throws InterruptedException

   264     {

   265         AWT_LOCK_COND.await();

   266     }

   267 

   268     public static final void awtLockWait(long timeout)

   269         throws InterruptedException

   270     {

   271         AWT_LOCK_COND.await(timeout, TimeUnit.MILLISECONDS);

   272     }

   273 

   274     public static final void awtLockNotify() {

   275         AWT_LOCK_COND.signal();

   276     }

   277 

   278     public static final void awtLockNotifyAll() {

   279         AWT_LOCK_COND.signalAll();

   280     }

   281 

   282     public static final boolean isAWTLockHeldByCurrentThread() {

   283         return AWT_LOCK.isHeldByCurrentThread();

   284     }

   285 

   286     /*

   287      * Create a new AppContext, along with its EventQueue, for a

   288      * new ThreadGroup.  Browser code, for example, would use this

   289      * method to create an AppContext & EventQueue for an Applet.

   290      */

   291     public static AppContext createNewAppContext() {

   292         ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();

   293         return createNewAppContext(threadGroup);

   294     }

   295 

   296     static final AppContext createNewAppContext(ThreadGroup threadGroup) {

   297         // Create appContext before initialization of EventQueue, so all

   298         // the calls to AppContext.getAppContext() from EventQueue ctor

   299         // return correct values

   300         AppContext appContext = new AppContext(threadGroup);

   301         initEQ(appContext);

   302 

   303         return appContext;

   304     }

   305 

   306     static void wakeupEventQueue(EventQueue q, boolean isShutdown){

   307         AWTAccessor.getEventQueueAccessor().wakeup(q, isShutdown);

   308     }

   309 

   310     /*

   311      * Fetch the peer associated with the given target (as specified

   312      * in the peer creation method).  This can be used to determine

   313      * things like what the parent peer is.  If the target is null

   314      * or the target can't be found (either because the a peer was

   315      * never created for it or the peer was disposed), a null will

   316      * be returned.

   317      */

   318     protected static Object targetToPeer(Object target) {

   319         if (target != null && !GraphicsEnvironment.isHeadless()) {

   320             return AWTAutoShutdown.getInstance().getPeer(target);

   321         }

   322         return null;

   323     }

   324 

   325     protected static void targetCreatedPeer(Object target, Object peer) {

   326         if (target != null && peer != null &&

   327             !GraphicsEnvironment.isHeadless())

   328         {

   329             AWTAutoShutdown.getInstance().registerPeer(target, peer);

   330         }

   331     }

   332 

   333     protected static void targetDisposedPeer(Object target, Object peer) {

   334         if (target != null && peer != null &&

   335             !GraphicsEnvironment.isHeadless())

   336         {

   337             AWTAutoShutdown.getInstance().unregisterPeer(target, peer);

   338         }

   339     }

   340 

   341     // Maps from non-Component/MenuComponent to AppContext.

   342     // WeakHashMap<Component,AppContext>

   343     private static final Map<Object, AppContext> appContextMap =

   344         Collections.synchronizedMap(new WeakHashMap<Object, AppContext>());

   345 

   346     /**

   347      * Sets the appContext field of target. If target is not a Component or

   348      * MenuComponent, this returns false.

   349      */

   350     private static boolean setAppContext(Object target,

   351                                          AppContext context) {

   352         if (target instanceof Component) {

   353             AWTAccessor.getComponentAccessor().

   354                 setAppContext((Component)target, context);

   355         } else if (target instanceof MenuComponent) {

   356             AWTAccessor.getMenuComponentAccessor().

   357                 setAppContext((MenuComponent)target, context);

   358         } else {

   359             return false;

   360         }

   361         return true;

   362     }

   363 

   364     /**

   365      * Returns the appContext field for target. If target is not a

   366      * Component or MenuComponent this returns null.

   367      */

   368     private static AppContext getAppContext(Object target) {

   369         if (target instanceof Component) {

   370             return AWTAccessor.getComponentAccessor().

   371                        getAppContext((Component)target);

   372         } else if (target instanceof MenuComponent) {

   373             return AWTAccessor.getMenuComponentAccessor().

   374                        getAppContext((MenuComponent)target);

   375         } else {

   376             return null;

   377         }

   378     }

   379 

   380     /*

   381      * Fetch the AppContext associated with the given target.

   382      * This can be used to determine things like which EventQueue

   383      * to use for posting events to a Component.  If the target is

   384      * null or the target can't be found, a null with be returned.

   385      */

   386     public static AppContext targetToAppContext(Object target) {

   387         if (target == null) {

   388             return null;

   389         }

   390         AppContext context = getAppContext(target);

   391         if (context == null) {

   392             // target is not a Component/MenuComponent, try the

   393             // appContextMap.

   394             context = appContextMap.get(target);

   395         }

   396         return context;

   397     }

   398 

   399      /**

   400       * Sets the synchronous status of focus requests on lightweight

   401       * components in the specified window to the specified value.

   402       * If the boolean parameter is <code>true</code> then the focus

   403       * requests on lightweight components will be performed

   404       * synchronously, if it is <code>false</code>, then asynchronously.

   405       * By default, all windows have their lightweight request status

   406       * set to asynchronous.

   407       * <p>

   408       * The application can only set the status of lightweight focus

   409       * requests to synchronous for any of its windows if it doesn't

   410       * perform focus transfers between different heavyweight containers.

   411       * In this case the observable focus behaviour is the same as with

   412       * asynchronous status.

   413       * <p>

   414       * If the application performs focus transfer between different

   415       * heavyweight containers and sets the lightweight focus request

   416       * status to synchronous for any of its windows, then further focus

   417       * behaviour is unspecified.

   418       * <p>

   419       * @param    w window for which the lightweight focus request status

   420       *             should be set

   421       * @param    status the value of lightweight focus request status

   422       */

   423 

   424     public static void setLWRequestStatus(Window changed,boolean status){

   425         AWTAccessor.getWindowAccessor().setLWRequestStatus(changed, status);

   426     };

   427 

   428     public static void checkAndSetPolicy(Container cont) {

   429         FocusTraversalPolicy defaultPolicy = KeyboardFocusManager.

   430             getCurrentKeyboardFocusManager().

   431                 getDefaultFocusTraversalPolicy();

   432 

   433         cont.setFocusTraversalPolicy(defaultPolicy);

   434     }

   435 

   436     private static FocusTraversalPolicy createLayoutPolicy() {

   437         FocusTraversalPolicy policy = null;

   438         try {

   439             Class<?> layoutPolicyClass =

   440                 Class.forName("javax.swing.LayoutFocusTraversalPolicy");

   441             policy = (FocusTraversalPolicy)layoutPolicyClass.newInstance();

   442         }

   443         catch (ClassNotFoundException e) {

   444             assert false;

   445         }

   446         catch (InstantiationException e) {

   447             assert false;

   448         }

   449         catch (IllegalAccessException e) {

   450             assert false;

   451         }

   452 

   453         return policy;

   454     }

   455 

   456     /*

   457      * Insert a mapping from target to AppContext, for later retrieval

   458      * via targetToAppContext() above.

   459      */

   460     public static void insertTargetMapping(Object target, AppContext appContext) {

   461         if (!setAppContext(target, appContext)) {

   462             // Target is not a Component/MenuComponent, use the private Map

   463             // instead.

   464             appContextMap.put(target, appContext);

   465         }

   466     }

   467 

   468     /*

   469      * Post an AWTEvent to the Java EventQueue, using the PostEventQueue

   470      * to avoid possibly calling client code (EventQueueSubclass.postEvent())

   471      * on the toolkit (AWT-Windows/AWT-Motif) thread.  This function should

   472      * not be called under another lock since it locks the EventQueue.

   473      * See bugids 4632918, 4526597.

   474      */

   475     public static void postEvent(AppContext appContext, AWTEvent event) {

   476         if (event == null) {

   477             throw new NullPointerException();

   478         }

   479 

   480         AWTAccessor.SequencedEventAccessor sea = AWTAccessor.getSequencedEventAccessor();

   481         if (sea != null && sea.isSequencedEvent(event)) {

   482             AWTEvent nested = sea.getNested(event);

   483             if (nested.getID() == WindowEvent.WINDOW_LOST_FOCUS &&

   484                 nested instanceof TimedWindowEvent)

   485             {

   486                 TimedWindowEvent twe = (TimedWindowEvent)nested;

   487                 ((SunToolkit)Toolkit.getDefaultToolkit()).

   488                     setWindowDeactivationTime((Window)twe.getSource(), twe.getWhen());

   489             }

   490         }

   491 

   492         // All events posted via this method are system-generated.

   493         // Placing the following call here reduces considerably the

   494         // number of places throughout the toolkit that would

   495         // otherwise have to be modified to precisely identify

   496         // system-generated events.

   497         setSystemGenerated(event);

   498         AppContext eventContext = targetToAppContext(event.getSource());

   499         if (eventContext != null && !eventContext.equals(appContext)) {

   500             throw new RuntimeException("Event posted on wrong app context : " + event);

   501         }

   502         PostEventQueue postEventQueue =

   503             (PostEventQueue)appContext.get(POST_EVENT_QUEUE_KEY);

   504         if (postEventQueue != null) {

   505             postEventQueue.postEvent(event);

   506         }

   507     }

   508 

   509     /*

   510      * Post AWTEvent of high priority.

   511      */

   512     public static void postPriorityEvent(final AWTEvent e) {

   513         PeerEvent pe = new PeerEvent(Toolkit.getDefaultToolkit(), new Runnable() {

   514                 public void run() {

   515                     AWTAccessor.getAWTEventAccessor().setPosted(e);

   516                     ((Component)e.getSource()).dispatchEvent(e);

   517                 }

   518             }, PeerEvent.ULTIMATE_PRIORITY_EVENT);

   519         postEvent(targetToAppContext(e.getSource()), pe);

   520     }

   521 

   522     /*

   523      * Flush any pending events which haven't been posted to the AWT

   524      * EventQueue yet.

   525      */

   526     public static void flushPendingEvents()  {

   527         AppContext appContext = AppContext.getAppContext();

   528         flushPendingEvents(appContext);

   529     }

   530 

   531     /*

   532      * Flush the PostEventQueue for the right AppContext.

   533      * The default flushPendingEvents only flushes the thread-local context,

   534      * which is not always correct, c.f. 3746956

   535      */

   536     public static void flushPendingEvents(AppContext appContext) {

   537         PostEventQueue postEventQueue =

   538                 (PostEventQueue)appContext.get(POST_EVENT_QUEUE_KEY);

   539         if (postEventQueue != null) {

   540             postEventQueue.flush();

   541         }

   542     }

   543 

   544     /*

   545      * Execute a chunk of code on the Java event handler thread for the

   546      * given target.  Does not wait for the execution to occur before

   547      * returning to the caller.

   548      */

   549     public static void executeOnEventHandlerThread(Object target,

   550                                                    Runnable runnable) {

   551         executeOnEventHandlerThread(new PeerEvent(target, runnable, PeerEvent.PRIORITY_EVENT));

   552     }

   553 

   554     /*

   555      * Fixed 5064013: the InvocationEvent time should be equals

   556      * the time of the ActionEvent

   557      */

   558     @SuppressWarnings("serial")

   559     public static void executeOnEventHandlerThread(Object target,

   560                                                    Runnable runnable,

   561                                                    final long when) {

   562         executeOnEventHandlerThread(

   563             new PeerEvent(target, runnable, PeerEvent.PRIORITY_EVENT) {

   564                 public long getWhen() {

   565                     return when;

   566                 }

   567             });

   568     }

   569 

   570     /*

   571      * Execute a chunk of code on the Java event handler thread for the

   572      * given target.  Does not wait for the execution to occur before

   573      * returning to the caller.

   574      */

   575     public static void executeOnEventHandlerThread(PeerEvent peerEvent) {

   576         postEvent(targetToAppContext(peerEvent.getSource()), peerEvent);

   577     }

   578 

   579     /*

   580      * Execute a chunk of code on the Java event handler thread. The

   581      * method takes into account provided AppContext and sets

   582      * <code>SunToolkit.getDefaultToolkit()</code> as a target of the

   583      * event. See 6451487 for detailes.

   584      * Does not wait for the execution to occur before returning to

   585      * the caller.

   586      */

   587      public static void invokeLaterOnAppContext(

   588         AppContext appContext, Runnable dispatcher)

   589      {

   590         postEvent(appContext,

   591             new PeerEvent(Toolkit.getDefaultToolkit(), dispatcher,

   592                 PeerEvent.PRIORITY_EVENT));

   593      }

   594 

   595     /*

   596      * Execute a chunk of code on the Java event handler thread for the

   597      * given target.  Waits for the execution to occur before returning

   598      * to the caller.

   599      */

   600     public static void executeOnEDTAndWait(Object target, Runnable runnable)

   601         throws InterruptedException, InvocationTargetException

   602     {

   603         if (EventQueue.isDispatchThread()) {

   604             throw new Error("Cannot call executeOnEDTAndWait from any event dispatcher thread");

   605         }

   606 

   607         class AWTInvocationLock {}

   608         Object lock = new AWTInvocationLock();

   609 

   610         PeerEvent event = new PeerEvent(target, runnable, lock, true, PeerEvent.PRIORITY_EVENT);

   611 

   612         synchronized (lock) {

   613             executeOnEventHandlerThread(event);

   614             while(!event.isDispatched()) {

   615                 lock.wait();

   616             }

   617         }

   618 

   619         Throwable eventThrowable = event.getThrowable();

   620         if (eventThrowable != null) {

   621             throw new InvocationTargetException(eventThrowable);

   622         }

   623     }

   624 

   625     /*

   626      * Returns true if the calling thread is the event dispatch thread

   627      * contained within AppContext which associated with the given target.

   628      * Use this call to ensure that a given task is being executed

   629      * (or not being) on the event dispatch thread for the given target.

   630      */

   631     public static boolean isDispatchThreadForAppContext(Object target) {

   632         AppContext appContext = targetToAppContext(target);

   633         EventQueue eq = (EventQueue)appContext.get(AppContext.EVENT_QUEUE_KEY);

   634 

   635         AWTAccessor.EventQueueAccessor accessor = AWTAccessor.getEventQueueAccessor();

   636         return accessor.isDispatchThreadImpl(eq);

   637     }

   638 

   639     public Dimension getScreenSize() {

   640         return new Dimension(getScreenWidth(), getScreenHeight());

   641     }

   642     protected abstract int getScreenWidth();

   643     protected abstract int getScreenHeight();

   644 

   645     @SuppressWarnings("deprecation")

   646     public FontMetrics getFontMetrics(Font font) {

   647         return FontDesignMetrics.getMetrics(font);

   648     }

   649 

   650     @SuppressWarnings("deprecation")

   651     public String[] getFontList() {

   652         String[] hardwiredFontList = {

   653             Font.DIALOG, Font.SANS_SERIF, Font.SERIF, Font.MONOSPACED,

   654             Font.DIALOG_INPUT

   655 

   656             // -- Obsolete font names from 1.0.2.  It was decided that

   657             // -- getFontList should not return these old names:

   658             //    "Helvetica", "TimesRoman", "Courier", "ZapfDingbats"

   659         };

   660         return hardwiredFontList;

   661     }

   662 

   663     public PanelPeer createPanel(Panel target) {

   664         return (PanelPeer)createComponent(target);

   665     }

   666 

   667     public CanvasPeer createCanvas(Canvas target) {

   668         return (CanvasPeer)createComponent(target);

   669     }

   670 

   671     /**

   672      * Disables erasing of background on the canvas before painting if

   673      * this is supported by the current toolkit. It is recommended to

   674      * call this method early, before the Canvas becomes displayable,

   675      * because some Toolkit implementations do not support changing

   676      * this property once the Canvas becomes displayable.

   677      */

   678     public void disableBackgroundErase(Canvas canvas) {

   679         disableBackgroundEraseImpl(canvas);

   680     }

   681 

   682     /**

   683      * Disables the native erasing of the background on the given

   684      * component before painting if this is supported by the current

   685      * toolkit. This only has an effect for certain components such as

   686      * Canvas, Panel and Window. It is recommended to call this method

   687      * early, before the Component becomes displayable, because some

   688      * Toolkit implementations do not support changing this property

   689      * once the Component becomes displayable.

   690      */

   691     public void disableBackgroundErase(Component component) {

   692         disableBackgroundEraseImpl(component);

   693     }

   694 

   695     private void disableBackgroundEraseImpl(Component component) {

   696         AWTAccessor.getComponentAccessor().setBackgroundEraseDisabled(component, true);

   697     }

   698 

   699     /**

   700      * Returns the value of "sun.awt.noerasebackground" property. Default

   701      * value is {@code false}.

   702      */

   703     public static boolean getSunAwtNoerasebackground() {

   704         return AccessController.doPrivileged(new GetBooleanAction("sun.awt.noerasebackground"));

   705     }

   706 

   707     /**

   708      * Returns the value of "sun.awt.erasebackgroundonresize" property. Default

   709      * value is {@code false}.

   710      */

   711     public static boolean getSunAwtErasebackgroundonresize() {

   712         return AccessController.doPrivileged(new GetBooleanAction("sun.awt.erasebackgroundonresize"));

   713     }

   714 

   715 

   716     static final SoftCache imgCache = new SoftCache();

   717 

   718     static Image getImageFromHash(Toolkit tk, URL url) {

   719         checkPermissions(url);

   720         synchronized (imgCache) {

   721             Image img = (Image)imgCache.get(url);

   722             if (img == null) {

   723                 try {

   724                     img = tk.createImage(new URLImageSource(url));

   725                     imgCache.put(url, img);

   726                 } catch (Exception e) {

   727                 }

   728             }

   729             return img;

   730         }

   731     }

   732 

   733     static Image getImageFromHash(Toolkit tk,

   734                                                String filename) {

   735         checkPermissions(filename);

   736         synchronized (imgCache) {

   737             Image img = (Image)imgCache.get(filename);

   738             if (img == null) {

   739                 try {

   740                     img = tk.createImage(new FileImageSource(filename));

   741                     imgCache.put(filename, img);

   742                 } catch (Exception e) {

   743                 }

   744             }

   745             return img;

   746         }

   747     }

   748 

   749     public Image getImage(String filename) {

   750         return getImageFromHash(this, filename);

   751     }

   752 

   753     public Image getImage(URL url) {

   754         return getImageFromHash(this, url);

   755     }

   756 

   757     protected Image getImageWithResolutionVariant(String fileName,

   758             String resolutionVariantName) {

   759         synchronized (imgCache) {

   760             Image image = getImageFromHash(this, fileName);

   761             if (image instanceof MultiResolutionImage) {

   762                 return image;

   763             }

   764             Image resolutionVariant = getImageFromHash(this, resolutionVariantName);

   765             image = createImageWithResolutionVariant(image, resolutionVariant);

   766             imgCache.put(fileName, image);

   767             return image;

   768         }

   769     }

   770 

   771     protected Image getImageWithResolutionVariant(URL url,

   772             URL resolutionVariantURL) {

   773         synchronized (imgCache) {

   774             Image image = getImageFromHash(this, url);

   775             if (image instanceof MultiResolutionImage) {

   776                 return image;

   777             }

   778             Image resolutionVariant = getImageFromHash(this, resolutionVariantURL);

   779             image = createImageWithResolutionVariant(image, resolutionVariant);

   780             imgCache.put(url, image);

   781             return image;

   782         }

   783     }

   784 

   785 

   786     public Image createImage(String filename) {

   787         checkPermissions(filename);

   788         return createImage(new FileImageSource(filename));

   789     }

   790 

   791     public Image createImage(URL url) {

   792         checkPermissions(url);

   793         return createImage(new URLImageSource(url));

   794     }

   795 

   796     public Image createImage(byte[] data, int offset, int length) {

   797         return createImage(new ByteArrayImageSource(data, offset, length));

   798     }

   799 

   800     public Image createImage(ImageProducer producer) {

   801         return new ToolkitImage(producer);

   802     }

   803 

   804     public static Image createImageWithResolutionVariant(Image image,

   805             Image resolutionVariant) {

   806         return new MultiResolutionToolkitImage(image, resolutionVariant);

   807     }

   808 

   809     public int checkImage(Image img, int w, int h, ImageObserver o) {

   810         if (!(img instanceof ToolkitImage)) {

   811             return ImageObserver.ALLBITS;

   812         }

   813 

   814         ToolkitImage tkimg = (ToolkitImage)img;

   815         int repbits;

   816         if (w == 0 || h == 0) {

   817             repbits = ImageObserver.ALLBITS;

   818         } else {

   819             repbits = tkimg.getImageRep().check(o);

   820         }

   821         return (tkimg.check(o) | repbits) & checkResolutionVariant(img, w, h, o);

   822     }

   823 

   824     public boolean prepareImage(Image img, int w, int h, ImageObserver o) {

   825         if (w == 0 || h == 0) {

   826             return true;

   827         }

   828 

   829         // Must be a ToolkitImage

   830         if (!(img instanceof ToolkitImage)) {

   831             return true;

   832         }

   833 

   834         ToolkitImage tkimg = (ToolkitImage)img;

   835         if (tkimg.hasError()) {

   836             if (o != null) {

   837                 o.imageUpdate(img, ImageObserver.ERROR|ImageObserver.ABORT,

   838                               -1, -1, -1, -1);

   839             }

   840             return false;

   841         }

   842         ImageRepresentation ir = tkimg.getImageRep();

   843         return ir.prepare(o) & prepareResolutionVariant(img, w, h, o);

   844     }

   845 

   846     private int checkResolutionVariant(Image img, int w, int h, ImageObserver o) {

   847         ToolkitImage rvImage = getResolutionVariant(img);

   848         int rvw = getRVSize(w);

   849         int rvh = getRVSize(h);

   850         // Ignore the resolution variant in case of error

   851         return (rvImage == null || rvImage.hasError()) ? 0xFFFF :

   852                 checkImage(rvImage, rvw, rvh, MultiResolutionToolkitImage.

   853                                 getResolutionVariantObserver(

   854                                         img, o, w, h, rvw, rvh, true));

   855     }

   856 

   857     private boolean prepareResolutionVariant(Image img, int w, int h,

   858             ImageObserver o) {

   859 

   860         ToolkitImage rvImage = getResolutionVariant(img);

   861         int rvw = getRVSize(w);

   862         int rvh = getRVSize(h);

   863         // Ignore the resolution variant in case of error

   864         return rvImage == null || rvImage.hasError() || prepareImage(

   865                 rvImage, rvw, rvh,

   866                 MultiResolutionToolkitImage.getResolutionVariantObserver(

   867                         img, o, w, h, rvw, rvh, true));

   868     }

   869 

   870     private static int getRVSize(int size){

   871         return size == -1 ? -1 : 2 * size;

   872     }

   873 

   874     private static ToolkitImage getResolutionVariant(Image image) {

   875         if (image instanceof MultiResolutionToolkitImage) {

   876             Image resolutionVariant = ((MultiResolutionToolkitImage) image).

   877                     getResolutionVariant();

   878             if (resolutionVariant instanceof ToolkitImage) {

   879                 return (ToolkitImage) resolutionVariant;

   880             }

   881         }

   882         return null;

   883     }

   884 

   885     protected static boolean imageCached(Object key) {

   886         return imgCache.containsKey(key);

   887     }

   888 

   889     protected static boolean imageExists(String filename) {

   890         checkPermissions(filename);

   891         return filename != null && new File(filename).exists();

   892     }

   893 

   894     @SuppressWarnings("try")

   895     protected static boolean imageExists(URL url) {

   896         checkPermissions(url);

   897         if (url != null) {

   898             try (InputStream is = url.openStream()) {

   899                 return true;

   900             }catch(IOException e){

   901                 return false;

   902             }

   903         }

   904         return false;

   905     }

   906 

   907     private static void checkPermissions(String filename) {

   908         SecurityManager security = System.getSecurityManager();

   909         if (security != null) {

   910             security.checkRead(filename);

   911         }

   912     }

   913 

   914     private static void checkPermissions(URL url) {

   915         SecurityManager sm = System.getSecurityManager();

   916         if (sm != null) {

   917             try {

   918                 java.security.Permission perm =

   919                     url.openConnection().getPermission();

   920                 if (perm != null) {

   921                     try {

   922                         sm.checkPermission(perm);

   923                     } catch (SecurityException se) {

   924                         // fallback to checkRead/checkConnect for pre 1.2

   925                         // security managers

   926                         if ((perm instanceof java.io.FilePermission) &&

   927                             perm.getActions().indexOf("read") != -1) {

   928                             sm.checkRead(perm.getName());

   929                         } else if ((perm instanceof

   930                             java.net.SocketPermission) &&

   931                             perm.getActions().indexOf("connect") != -1) {

   932                             sm.checkConnect(url.getHost(), url.getPort());

   933                         } else {

   934                             throw se;

   935                         }

   936                     }

   937                 }

   938             } catch (java.io.IOException ioe) {

   939                     sm.checkConnect(url.getHost(), url.getPort());

   940             }

   941         }

   942     }

   943 

   944     /**

   945      * Scans {@code imageList} for best-looking image of specified dimensions.

   946      * Image can be scaled and/or padded with transparency.

   947      */

   948     public static BufferedImage getScaledIconImage(java.util.List<Image> imageList, int width, int height) {

   949         if (width == 0 || height == 0) {

   950             return null;

   951         }

   952         Image bestImage = null;

   953         int bestWidth = 0;

   954         int bestHeight = 0;

   955         double bestSimilarity = 3; //Impossibly high value

   956         double bestScaleFactor = 0;

   957         for (Iterator<Image> i = imageList.iterator();i.hasNext();) {

   958             //Iterate imageList looking for best matching image.

   959             //'Similarity' measure is defined as good scale factor and small insets.

   960             //best possible similarity is 0 (no scale, no insets).

   961             //It's found while the experiments that good-looking result is achieved

   962             //with scale factors x1, x3/4, x2/3, xN, x1/N.

   963             Image im = i.next();

   964             if (im == null) {

   965                 continue;

   966             }

   967             if (im instanceof ToolkitImage) {

   968                 ImageRepresentation ir = ((ToolkitImage)im).getImageRep();

   969                 ir.reconstruct(ImageObserver.ALLBITS);

   970             }

   971             int iw;

   972             int ih;

   973             try {

   974                 iw = im.getWidth(null);

   975                 ih = im.getHeight(null);

   976             } catch (Exception e){

   977                 continue;

   978             }

   979             if (iw > 0 && ih > 0) {

   980                 //Calc scale factor

   981                 double scaleFactor = Math.min((double)width / (double)iw,

   982                                               (double)height / (double)ih);

   983                 //Calculate scaled image dimensions

   984                 //adjusting scale factor to nearest "good" value

   985                 int adjw = 0;

   986                 int adjh = 0;

   987                 double scaleMeasure = 1; //0 - best (no) scale, 1 - impossibly bad

   988                 if (scaleFactor >= 2) {

   989                     //Need to enlarge image more than twice

   990                     //Round down scale factor to multiply by integer value

   991                     scaleFactor = Math.floor(scaleFactor);

   992                     adjw = iw * (int)scaleFactor;

   993                     adjh = ih * (int)scaleFactor;

   994                     scaleMeasure = 1.0 - 0.5 / scaleFactor;

   995                 } else if (scaleFactor >= 1) {

   996                     //Don't scale

   997                     scaleFactor = 1.0;

   998                     adjw = iw;

   999                     adjh = ih;

  1000                     scaleMeasure = 0;

  1001                 } else if (scaleFactor >= 0.75) {

  1002                     //Multiply by 3/4

  1003                     scaleFactor = 0.75;

  1004                     adjw = iw * 3 / 4;

  1005                     adjh = ih * 3 / 4;

  1006                     scaleMeasure = 0.3;

  1007                 } else if (scaleFactor >= 0.6666) {

  1008                     //Multiply by 2/3

  1009                     scaleFactor = 0.6666;

  1010                     adjw = iw * 2 / 3;

  1011                     adjh = ih * 2 / 3;

  1012                     scaleMeasure = 0.33;

  1013                 } else {

  1014                     //Multiply size by 1/scaleDivider

  1015                     //where scaleDivider is minimum possible integer

  1016                     //larger than 1/scaleFactor

  1017                     double scaleDivider = Math.ceil(1.0 / scaleFactor);

  1018                     scaleFactor = 1.0 / scaleDivider;

  1019                     adjw = (int)Math.round((double)iw / scaleDivider);

  1020                     adjh = (int)Math.round((double)ih / scaleDivider);

  1021                     scaleMeasure = 1.0 - 1.0 / scaleDivider;

  1022                 }

  1023                 double similarity = ((double)width - (double)adjw) / (double)width +

  1024                     ((double)height - (double)adjh) / (double)height + //Large padding is bad

  1025                     scaleMeasure; //Large rescale is bad

  1026                 if (similarity < bestSimilarity) {

  1027                     bestSimilarity = similarity;

  1028                     bestScaleFactor = scaleFactor;

  1029                     bestImage = im;

  1030                     bestWidth = adjw;

  1031                     bestHeight = adjh;

  1032                 }

  1033                 if (similarity == 0) break;

  1034             }

  1035         }

  1036         if (bestImage == null) {

  1037             //No images were found, possibly all are broken

  1038             return null;

  1039         }

  1040         BufferedImage bimage =

  1041             new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

  1042         Graphics2D g = bimage.createGraphics();

  1043         g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,

  1044                            RenderingHints.VALUE_INTERPOLATION_BILINEAR);

  1045         try {

  1046             int x = (width - bestWidth) / 2;

  1047             int y = (height - bestHeight) / 2;

  1048             g.drawImage(bestImage, x, y, bestWidth, bestHeight, null);

  1049         } finally {

  1050             g.dispose();

  1051         }

  1052         return bimage;

  1053     }

  1054 

  1055     public static DataBufferInt getScaledIconData(java.util.List<Image> imageList, int width, int height) {

  1056         BufferedImage bimage = getScaledIconImage(imageList, width, height);

  1057         if (bimage == null) {

  1058             return null;

  1059         }

  1060         Raster raster = bimage.getRaster();

  1061         DataBuffer buffer = raster.getDataBuffer();

  1062         return (DataBufferInt)buffer;

  1063     }

  1064 

  1065     protected EventQueue getSystemEventQueueImpl() {

  1066         return getSystemEventQueueImplPP();

  1067     }

  1068 

  1069     // Package private implementation

  1070     static EventQueue getSystemEventQueueImplPP() {

  1071         return getSystemEventQueueImplPP(AppContext.getAppContext());

  1072     }

  1073 

  1074     public static EventQueue getSystemEventQueueImplPP(AppContext appContext) {

  1075         EventQueue theEventQueue =

  1076             (EventQueue)appContext.get(AppContext.EVENT_QUEUE_KEY);

  1077         return theEventQueue;

  1078     }

  1079 

  1080     /**

  1081      * Give native peers the ability to query the native container

  1082      * given a native component (eg the direct parent may be lightweight).

  1083      */

  1084     public static Container getNativeContainer(Component c) {

  1085         return Toolkit.getNativeContainer(c);

  1086     }

  1087 

  1088     /**

  1089      * Gives native peers the ability to query the closest HW component.

  1090      * If the given component is heavyweight, then it returns this. Otherwise,

  1091      * it goes one level up in the hierarchy and tests next component.

  1092      */

  1093     public static Component getHeavyweightComponent(Component c) {

  1094         while (c != null && AWTAccessor.getComponentAccessor().isLightweight(c)) {

  1095             c = AWTAccessor.getComponentAccessor().getParent(c);

  1096         }

  1097         return c;

  1098     }

  1099 

  1100     /**

  1101      * Returns key modifiers used by Swing to set up a focus accelerator key stroke.

  1102      */

  1103     public int getFocusAcceleratorKeyMask() {

  1104         return InputEvent.ALT_MASK;

  1105     }

  1106 

  1107     /**

  1108      * Tests whether specified key modifiers mask can be used to enter a printable

  1109      * character. This is a default implementation of this method, which reflects

  1110      * the way things work on Windows: here, pressing ctrl + alt allows user to enter

  1111      * characters from the extended character set (like euro sign or math symbols)

  1112      */

  1113     public boolean isPrintableCharacterModifiersMask(int mods) {

  1114         return ((mods & InputEvent.ALT_MASK) == (mods & InputEvent.CTRL_MASK));

  1115     }

  1116 

  1117     /**

  1118      * Returns whether popup is allowed to be shown above the task bar.

  1119      * This is a default implementation of this method, which checks

  1120      * corresponding security permission.

  1121      */

  1122     public boolean canPopupOverlapTaskBar() {

  1123         boolean result = true;

  1124         try {

  1125             SecurityManager sm = System.getSecurityManager();

  1126             if (sm != null) {

  1127                 sm.checkPermission(AWTPermissions.SET_WINDOW_ALWAYS_ON_TOP_PERMISSION);

  1128             }

  1129         } catch (SecurityException se) {

  1130             // There is no permission to show popups over the task bar

  1131             result = false;

  1132         }

  1133         return result;

  1134     }