jdk/src/share/classes/sun/awt/SunToolkit.java
author dav
Fri, 22 May 2009 16:09:45 +0400
changeset 2810 fa49c6a06baf
parent 2648 aa45a227fce3
child 3084 67ca55732362
permissions -rw-r--r--
6799099: All automatic regression tests that create Robot fail on X11 Reviewed-by: art, ant
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
     2
 * Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
90ce3da70b43 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.  Sun designates this
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
90ce3da70b43 Initial load
duke
parents:
diff changeset
     9
 * by Sun in the LICENSE file that accompanied this code.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    21
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    22
 * CA 95054 USA or visit www.sun.com if you need additional information or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    23
 * have any questions.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package sun.awt;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
import java.awt.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
import static java.awt.RenderingHints.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
import java.awt.dnd.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
import java.awt.dnd.peer.DragSourceContextPeer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
import java.awt.peer.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
import java.awt.event.WindowEvent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
import java.awt.event.KeyEvent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
import java.awt.image.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
import java.awt.TrayIcon;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
import java.awt.SystemTray;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
import java.net.URL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
import java.util.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
import java.util.concurrent.TimeUnit;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
import java.util.concurrent.locks.Condition;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
import java.util.concurrent.locks.ReentrantLock;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
import java.util.logging.Level;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
import java.util.logging.Logger;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
import sun.misc.SoftCache;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
import sun.font.FontDesignMetrics;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
import sun.awt.im.InputContext;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
import sun.awt.image.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
import sun.security.action.GetPropertyAction;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
import sun.security.action.GetBooleanAction;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
import java.lang.reflect.Field;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
import java.lang.reflect.Method;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
import java.lang.reflect.Constructor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
import java.lang.reflect.InvocationTargetException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
import java.security.AccessController;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
import java.security.PrivilegedAction;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
import java.security.PrivilegedActionException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
import java.security.PrivilegedExceptionAction;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
public abstract class SunToolkit extends Toolkit
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
    implements WindowClosingSupport, WindowClosingListener,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
    ComponentFactory, InputMethodSupport, KeyboardFocusManagerPeerProvider {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
    private static final Logger log = Logger.getLogger("sun.awt.SunToolkit");
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
    /* Load debug settings for native code */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
    static {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
        if (AccessController.doPrivileged(new GetBooleanAction("sun.awt.nativedebug"))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
            DebugSettings.init();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
    };
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
     * Special mask for the UngrabEvent events, in addition to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
     * public masks defined in AWTEvent.  Should be used as the mask
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
     * value for Toolkit.addAWTEventListener.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
    public static final int GRAB_EVENT_MASK = 0x80000000;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
    private static Field syncLWRequestsField;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
    private static Method  wakeupMethod;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
    private static Field componentKeyField;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
    private static Field menuComponentKeyField;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
    private static Field trayIconKeyField;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
    private static Field componentAppContextField;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
    private static Field menuComponentAppContextField;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
    private static Field isPostedField;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
    /* The key to put()/get() the PostEventQueue into/from the AppContext.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
    private static final String POST_EVENT_QUEUE_KEY = "PostEventQueue";
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
2810
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
    92
    /**
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
    93
     * Number of buttons.
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
    94
     * By default it's taken from the system. If system value does not
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
    95
     * fit into int type range, use our own MAX_BUTTONS_SUPPORT value.
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
    96
     */
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
    97
    protected static int numberOfButtons = 0;
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
    98
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
    99
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   100
    /* XFree standard mention 24 buttons as maximum:
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   101
     * http://www.xfree86.org/current/mouse.4.html
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   102
     * We workaround systems supporting more than 24 buttons.
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   103
     * Otherwise, we have to use long type values as masks
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   104
     * which leads to API change.
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   105
     * InputEvent.BUTTON_DOWN_MASK may contain only 21 masks due to
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   106
     * the 4-bytes limit for the int type. (CR 6799099)
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   107
     * One more bit is reserved for FIRST_HIGH_BIT.
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   108
     */
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   109
    public final static int MAX_BUTTONS_SUPPORTED = 20;
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
   110
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
    public SunToolkit() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
        /* If awt.threadgroup is set to class name the instance of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
         * this class is created (should be subclass of ThreadGroup)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
         * and EventDispatchThread is created inside of it
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
         *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
         * If loaded class overrides uncaughtException instance
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
         * handles all uncaught exception on EventDispatchThread
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
        ThreadGroup threadGroup = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
        String tgName = System.getProperty("awt.threadgroup", "");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
        if (tgName.length() != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
                Constructor ctor = Class.forName(tgName).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
                    getConstructor(new Class[] {String.class});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
                threadGroup = (ThreadGroup)ctor.newInstance(new Object[] {"AWT-ThreadGroup"});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
            } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
                System.err.println("Failed loading " + tgName + ": " + e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
        Runnable initEQ = new Runnable() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
            public void run () {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
                EventQueue eventQueue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
                String eqName = System.getProperty("AWT.EventQueueClass",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
                                                   "java.awt.EventQueue");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
                try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
                    eventQueue = (EventQueue)Class.forName(eqName).newInstance();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
                } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
                    e.printStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
                    System.err.println("Failed loading " + eqName + ": " + e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
                    eventQueue = new EventQueue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
                AppContext appContext = AppContext.getAppContext();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
                appContext.put(AppContext.EVENT_QUEUE_KEY, eventQueue);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
                PostEventQueue postEventQueue = new PostEventQueue(eventQueue);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
                appContext.put(POST_EVENT_QUEUE_KEY, postEventQueue);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
        };
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
        if (threadGroup != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
            Thread eqInitThread = new Thread(threadGroup, initEQ, "EventQueue-Init");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
            eqInitThread.start();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
                eqInitThread.join();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
            } catch (InterruptedException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
                e.printStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
            initEQ.run();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
    public boolean useBufferPerWindow() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
90ce3da70b43 Initial load
duke
parents:
diff changeset
   171
    public abstract WindowPeer createWindow(Window target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
    public abstract FramePeer createFrame(Frame target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
    public abstract DialogPeer createDialog(Dialog target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
    public abstract ButtonPeer createButton(Button target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
    public abstract TextFieldPeer createTextField(TextField target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
    public abstract ChoicePeer createChoice(Choice target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
    public abstract LabelPeer createLabel(Label target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
    public abstract ListPeer createList(java.awt.List target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
    public abstract CheckboxPeer createCheckbox(Checkbox target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
    public abstract ScrollbarPeer createScrollbar(Scrollbar target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
    public abstract ScrollPanePeer createScrollPane(ScrollPane target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
    public abstract TextAreaPeer createTextArea(TextArea target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
    public abstract FileDialogPeer createFileDialog(FileDialog target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
    public abstract MenuBarPeer createMenuBar(MenuBar target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
    public abstract MenuPeer createMenu(Menu target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
    public abstract PopupMenuPeer createPopupMenu(PopupMenu target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
    public abstract MenuItemPeer createMenuItem(MenuItem target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
    public abstract CheckboxMenuItemPeer createCheckboxMenuItem(
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
        CheckboxMenuItem target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
        throws HeadlessException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
    public abstract DragSourceContextPeer createDragSourceContextPeer(
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
        DragGestureEvent dge)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
        throws InvalidDnDOperationException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
    public abstract TrayIconPeer createTrayIcon(TrayIcon target)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
        throws HeadlessException, AWTException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
    public abstract SystemTrayPeer createSystemTray(SystemTray target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
    public abstract boolean isTraySupported();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
    public abstract FontPeer getFontPeer(String name, int style);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
    public abstract RobotPeer createRobot(Robot target, GraphicsDevice screen)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
        throws AWTException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
2464
3c6755bdc55f 6806217: implement synthetic focus model for MS Windows
ant
parents: 2451
diff changeset
   242
    public abstract KeyboardFocusManagerPeer createKeyboardFocusManagerPeer(KeyboardFocusManager manager)
3c6755bdc55f 6806217: implement synthetic focus model for MS Windows
ant
parents: 2451
diff changeset
   243
        throws HeadlessException;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
     * The AWT lock is typically only used on Unix platforms to synchronize
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
     * access to Xlib, OpenGL, etc.  However, these methods are implemented
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
     * in SunToolkit so that they can be called from shared code (e.g.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
     * from the OGL pipeline) or from the X11 pipeline regardless of whether
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
     * XToolkit or MToolkit is currently in use.  There are native macros
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
     * (such as AWT_LOCK) defined in awt.h, so if the implementation of these
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
     * methods is changed, make sure it is compatible with the native macros.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
     * Note: The following methods (awtLock(), awtUnlock(), etc) should be
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
     * used in place of:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
     *     synchronized (getAWTLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
     *         ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
     *     }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
     * By factoring these methods out specially, we are able to change the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
     * implementation of these methods (e.g. use more advanced locking
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
     * mechanisms) without impacting calling code.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
     * Sample usage:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
     *     private void doStuffWithXlib() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
     *         assert !SunToolkit.isAWTLockHeldByCurrentThread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
     *         SunToolkit.awtLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
     *         try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
     *             ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
     *             XlibWrapper.XDoStuff();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
     *         } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
     *             SunToolkit.awtUnlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
     *         }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
     *     }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
    private static final ReentrantLock AWT_LOCK = new ReentrantLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
    private static final Condition AWT_LOCK_COND = AWT_LOCK.newCondition();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
    public static final void awtLock() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
        AWT_LOCK.lock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
    public static final boolean awtTryLock() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
        return AWT_LOCK.tryLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
    public static final void awtUnlock() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
        AWT_LOCK.unlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
    public static final void awtLockWait()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
        throws InterruptedException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
        AWT_LOCK_COND.await();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
    public static final void awtLockWait(long timeout)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
        throws InterruptedException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
        AWT_LOCK_COND.await(timeout, TimeUnit.MILLISECONDS);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
    public static final void awtLockNotify() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
        AWT_LOCK_COND.signal();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
    public static final void awtLockNotifyAll() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
        AWT_LOCK_COND.signalAll();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
    public static final boolean isAWTLockHeldByCurrentThread() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
        return AWT_LOCK.isHeldByCurrentThread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
     * Create a new AppContext, along with its EventQueue, for a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
     * new ThreadGroup.  Browser code, for example, would use this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
     * method to create an AppContext & EventQueue for an Applet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
    public static AppContext createNewAppContext() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
        ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
        EventQueue eventQueue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
        String eqName = System.getProperty("AWT.EventQueueClass",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
                                           "java.awt.EventQueue");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
            eventQueue = (EventQueue)Class.forName(eqName).newInstance();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
        } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
            System.err.println("Failed loading " + eqName + ": " + e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
            eventQueue = new EventQueue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
        AppContext appContext = new AppContext(threadGroup);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
        appContext.put(AppContext.EVENT_QUEUE_KEY, eventQueue);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
        PostEventQueue postEventQueue = new PostEventQueue(eventQueue);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
        appContext.put(POST_EVENT_QUEUE_KEY, postEventQueue);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
        return appContext;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
    public static Field getField(final Class klass, final String fieldName) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
        return AccessController.doPrivileged(new PrivilegedAction<Field>() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
            public Field run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
                try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
                    Field field = klass.getDeclaredField(fieldName);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
                    assert (field != null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
                    field.setAccessible(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
                    return field;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
                } catch (SecurityException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
                    assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
                } catch (NoSuchFieldException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
                    assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
                return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
            }//run
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
        });
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
    static void wakeupEventQueue(EventQueue q, boolean isShutdown){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
        if (wakeupMethod == null){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
            wakeupMethod = (Method)AccessController.doPrivileged(new PrivilegedAction(){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
                    public Object run(){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
                        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
                            Method method  = EventQueue.class.getDeclaredMethod("wakeup",new Class [] {Boolean.TYPE} );
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
                            if (method != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
                                method.setAccessible(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
                            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
                            return method;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
                        } catch (NoSuchMethodException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
                            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
                        } catch (SecurityException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
                            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
                        return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
                    }//run
90ce3da70b43 Initial load
duke
parents:
diff changeset
   376
                });
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   378
        try{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
            if (wakeupMethod != null){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
                wakeupMethod.invoke(q, new Object[]{Boolean.valueOf(isShutdown)});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
        } catch (InvocationTargetException e){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
        } catch (IllegalAccessException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
     * Fetch the peer associated with the given target (as specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
     * in the peer creation method).  This can be used to determine
90ce3da70b43 Initial load
duke
parents:
diff changeset
   392
     * things like what the parent peer is.  If the target is null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   393
     * or the target can't be found (either because the a peer was
90ce3da70b43 Initial load
duke
parents:
diff changeset
   394
     * never created for it or the peer was disposed), a null will
90ce3da70b43 Initial load
duke
parents:
diff changeset
   395
     * be returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   396
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
    protected static Object targetToPeer(Object target) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
        if (target != null && !GraphicsEnvironment.isHeadless()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
            return AWTAutoShutdown.getInstance().getPeer(target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
        return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
    protected static void targetCreatedPeer(Object target, Object peer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
        if (target != null && peer != null &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   406
            !GraphicsEnvironment.isHeadless())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
        {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
            AWTAutoShutdown.getInstance().registerPeer(target, peer);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
    protected static void targetDisposedPeer(Object target, Object peer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   413
        if (target != null && peer != null &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
            !GraphicsEnvironment.isHeadless())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
        {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   416
            AWTAutoShutdown.getInstance().unregisterPeer(target, peer);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   417
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   418
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
90ce3da70b43 Initial load
duke
parents:
diff changeset
   420
    // Maps from non-Component/MenuComponent to AppContext.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
    // WeakHashMap<Component,AppContext>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
    private static final Map appContextMap =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
        Collections.synchronizedMap(new WeakHashMap());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   427
     * Sets the appContext field of target. If target is not a Component or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   428
     * MenuComponent, this returns false.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   429
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   430
    private static boolean setAppContext(Object target, AppContext context)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   432
        if (!(target instanceof Component) && !(target instanceof MenuComponent)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   435
        try{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
            if (target instanceof Component){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   437
                if (componentAppContextField == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   438
                    componentAppContextField = getField(Component.class, "appContext");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   439
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   440
                componentAppContextField.set(target, context);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   441
            } else if (target instanceof MenuComponent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
                if (menuComponentAppContextField == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   443
                    menuComponentAppContextField = getField(MenuComponent.class, "appContext");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   444
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   445
                menuComponentAppContextField.set(target, context);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   446
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   447
        } catch( IllegalAccessException e){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   448
            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   455
     * Returns the appContext field for target. If target is not a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   456
     * Component or MenuComponent this returns null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   457
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   458
    private static AppContext getAppContext(Object target) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
        AppContext retObj = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   460
        try{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
            if (target instanceof Component){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
                if (componentAppContextField == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
                    componentAppContextField = getField(Component.class, "appContext");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
                retObj = (AppContext) componentAppContextField.get(target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
            } else if (target instanceof MenuComponent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
                if (menuComponentAppContextField == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   468
                    menuComponentAppContextField = getField(MenuComponent.class, "appContext");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   469
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
                retObj = (AppContext) menuComponentAppContextField.get(target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   472
        } catch( IllegalAccessException e){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   473
            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   474
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   475
        return retObj;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   476
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
     * Fetch the AppContext associated with the given target.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
     * This can be used to determine things like which EventQueue
90ce3da70b43 Initial load
duke
parents:
diff changeset
   481
     * to use for posting events to a Component.  If the target is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
     * null or the target can't be found, a null with be returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   483
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   484
    public static AppContext targetToAppContext(Object target) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   485
        if (target == null || GraphicsEnvironment.isHeadless()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   488
        AppContext context = getAppContext(target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
        if (context == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
            // target is not a Component/MenuComponent, try the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   491
            // appContextMap.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   492
            context = (AppContext)appContextMap.get(target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   493
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   494
        return context;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   495
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   496
90ce3da70b43 Initial load
duke
parents:
diff changeset
   497
     /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
      * Sets the synchronous status of focus requests on lightweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
      * components in the specified window to the specified value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
      * If the boolean parameter is <code>true</code> then the focus
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
      * requests on lightweight components will be performed
90ce3da70b43 Initial load
duke
parents:
diff changeset
   502
      * synchronously, if it is <code>false</code>, then asynchronously.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
      * By default, all windows have their lightweight request status
90ce3da70b43 Initial load
duke
parents:
diff changeset
   504
      * set to asynchronous.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   505
      * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
      * The application can only set the status of lightweight focus
90ce3da70b43 Initial load
duke
parents:
diff changeset
   507
      * requests to synchronous for any of its windows if it doesn't
90ce3da70b43 Initial load
duke
parents:
diff changeset
   508
      * perform focus transfers between different heavyweight containers.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   509
      * In this case the observable focus behaviour is the same as with
90ce3da70b43 Initial load
duke
parents:
diff changeset
   510
      * asynchronous status.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   511
      * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   512
      * If the application performs focus transfer between different
90ce3da70b43 Initial load
duke
parents:
diff changeset
   513
      * heavyweight containers and sets the lightweight focus request
90ce3da70b43 Initial load
duke
parents:
diff changeset
   514
      * status to synchronous for any of its windows, then further focus
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
      * behaviour is unspecified.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
      * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
      * @param    w window for which the lightweight focus request status
90ce3da70b43 Initial load
duke
parents:
diff changeset
   518
      *             should be set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   519
      * @param    status the value of lightweight focus request status
90ce3da70b43 Initial load
duke
parents:
diff changeset
   520
      */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
    public static void setLWRequestStatus(Window changed,boolean status){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
        if (syncLWRequestsField == null){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
            syncLWRequestsField = getField(Window.class, "syncLWRequests");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
        try{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
            if (syncLWRequestsField != null){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
                syncLWRequestsField.setBoolean(changed, status);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   530
        } catch( IllegalAccessException e){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
    };
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
    public static void checkAndSetPolicy(Container cont, boolean isSwingCont)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
        FocusTraversalPolicy defaultPolicy = KeyboardFocusManager
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
            .getCurrentKeyboardFocusManager().getDefaultFocusTraversalPolicy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
        String toolkitName = Toolkit.getDefaultToolkit().getClass().getName();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   541
        // if this is not XAWT then use default policy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   542
        // because Swing change it
90ce3da70b43 Initial load
duke
parents:
diff changeset
   543
        if (!"sun.awt.X11.XToolkit".equals(toolkitName)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
            cont.setFocusTraversalPolicy(defaultPolicy);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
        String policyName = defaultPolicy.getClass().getName();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
        if (DefaultFocusTraversalPolicy.class != defaultPolicy.getClass()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
            // Policy was changed
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
            // Check if it is awt policy or swing policy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
            // If it is Swing policy we shouldn't use it in AWT frames
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
            // If it is AWT policy  we shouldn't use it in Swing frames
90ce3da70b43 Initial load
duke
parents:
diff changeset
   555
            // Otherwise we should use this policy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
            if (policyName.startsWith("java.awt.")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
                // AWT
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
                if (isSwingCont) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
                    // Can't use AWT policy in Swing windows - should use Swing's one.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
                    defaultPolicy = createLayoutPolicy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
                    // New awt policy.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
            } else if (policyName.startsWith("javax.swing.")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
                if (isSwingCont) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
                    // New Swing's policy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   567
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   568
                    defaultPolicy = new DefaultFocusTraversalPolicy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   569
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
            // Policy is default, use different default policy for swing
90ce3da70b43 Initial load
duke
parents:
diff changeset
   573
            if (isSwingCont) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   574
                defaultPolicy = createLayoutPolicy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   575
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   576
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   577
        cont.setFocusTraversalPolicy(defaultPolicy);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   578
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
    private static FocusTraversalPolicy createLayoutPolicy() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
        FocusTraversalPolicy policy = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
            Class layoutPolicyClass =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   584
                Class.forName("javax.swing.LayoutFocusTraversalPolicy");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
            policy = (FocusTraversalPolicy) layoutPolicyClass.newInstance();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   586
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   587
        catch (ClassNotFoundException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   590
        catch (InstantiationException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   591
            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   592
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   593
        catch (IllegalAccessException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   594
            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   595
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   596
90ce3da70b43 Initial load
duke
parents:
diff changeset
   597
        return policy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   598
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   599
90ce3da70b43 Initial load
duke
parents:
diff changeset
   600
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   601
     * Insert a mapping from target to AppContext, for later retrieval
90ce3da70b43 Initial load
duke
parents:
diff changeset
   602
     * via targetToAppContext() above.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   603
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   604
    public static void insertTargetMapping(Object target, AppContext appContext) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   605
        if (!GraphicsEnvironment.isHeadless()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   606
            if (!setAppContext(target, appContext)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   607
                // Target is not a Component/MenuComponent, use the private Map
90ce3da70b43 Initial load
duke
parents:
diff changeset
   608
                // instead.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   609
                appContextMap.put(target, appContext);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   610
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   611
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   612
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   613
90ce3da70b43 Initial load
duke
parents:
diff changeset
   614
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   615
     * Post an AWTEvent to the Java EventQueue, using the PostEventQueue
90ce3da70b43 Initial load
duke
parents:
diff changeset
   616
     * to avoid possibly calling client code (EventQueueSubclass.postEvent())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   617
     * on the toolkit (AWT-Windows/AWT-Motif) thread.  This function should
90ce3da70b43 Initial load
duke
parents:
diff changeset
   618
     * not be called under another lock since it locks the EventQueue.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   619
     * See bugids 4632918, 4526597.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   620
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   621
    public static void postEvent(AppContext appContext, AWTEvent event) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   622
        if (event == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   623
            throw new NullPointerException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   624
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   625
        AppContext eventContext = targetToAppContext(event.getSource());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   626
        if (eventContext != null && !eventContext.equals(appContext)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   627
            log.fine("Event posted on wrong app context : " + event);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   628
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   629
        PostEventQueue postEventQueue =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   630
            (PostEventQueue)appContext.get(POST_EVENT_QUEUE_KEY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   631
        if(postEventQueue != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   632
            postEventQueue.postEvent(event);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   633
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   634
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   635
90ce3da70b43 Initial load
duke
parents:
diff changeset
   636
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   637
     * Post AWTEvent of high priority.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   638
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   639
    public static void postPriorityEvent(final AWTEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   640
        if (isPostedField == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   641
            isPostedField = getField(AWTEvent.class, "isPosted");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   642
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   643
        PeerEvent pe = new PeerEvent(Toolkit.getDefaultToolkit(), new Runnable() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   644
                public void run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   645
                    try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   646
                        isPostedField.setBoolean(e, true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   647
                    } catch (IllegalArgumentException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   648
                        assert(false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   649
                    } catch (IllegalAccessException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   650
                        assert(false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   651
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   652
                    ((Component)e.getSource()).dispatchEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   653
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   654
            }, PeerEvent.ULTIMATE_PRIORITY_EVENT);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   655
        postEvent(targetToAppContext(e.getSource()), pe);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   656
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   657
90ce3da70b43 Initial load
duke
parents:
diff changeset
   658
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   659
     * Flush any pending events which haven't been posted to the AWT
90ce3da70b43 Initial load
duke
parents:
diff changeset
   660
     * EventQueue yet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   661
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   662
    public static void flushPendingEvents()  {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   663
        AppContext appContext = AppContext.getAppContext();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   664
        PostEventQueue postEventQueue =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   665
            (PostEventQueue)appContext.get(POST_EVENT_QUEUE_KEY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   666
        if(postEventQueue != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   667
            postEventQueue.flush();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   668
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   669
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   670
90ce3da70b43 Initial load
duke
parents:
diff changeset
   671
    public static boolean isPostEventQueueEmpty()  {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   672
        AppContext appContext = AppContext.getAppContext();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   673
        PostEventQueue postEventQueue =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   674
            (PostEventQueue)appContext.get(POST_EVENT_QUEUE_KEY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   675
        if (postEventQueue != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   676
            return postEventQueue.noEvents();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   677
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   678
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   679
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   680
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   681
90ce3da70b43 Initial load
duke
parents:
diff changeset
   682
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   683
     * Execute a chunk of code on the Java event handler thread for the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   684
     * given target.  Does not wait for the execution to occur before
90ce3da70b43 Initial load
duke
parents:
diff changeset
   685
     * returning to the caller.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   686
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   687
    public static void executeOnEventHandlerThread(Object target,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   688
                                                   Runnable runnable) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   689
        executeOnEventHandlerThread(new PeerEvent(target, runnable, PeerEvent.PRIORITY_EVENT));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   690
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   691
90ce3da70b43 Initial load
duke
parents:
diff changeset
   692
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   693
     * Fixed 5064013: the InvocationEvent time should be equals
90ce3da70b43 Initial load
duke
parents:
diff changeset
   694
     * the time of the ActionEvent
90ce3da70b43 Initial load
duke
parents:
diff changeset
   695
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   696
    public static void executeOnEventHandlerThread(Object target,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   697
                                                   Runnable runnable,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   698
                                                   final long when) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   699
        executeOnEventHandlerThread(new PeerEvent(target, runnable, PeerEvent.PRIORITY_EVENT){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   700
                public long getWhen(){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   701
                    return when;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   702
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   703
            });
90ce3da70b43 Initial load
duke
parents:
diff changeset
   704
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   705
90ce3da70b43 Initial load
duke
parents:
diff changeset
   706
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   707
     * Execute a chunk of code on the Java event handler thread for the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   708
     * given target.  Does not wait for the execution to occur before
90ce3da70b43 Initial load
duke
parents:
diff changeset
   709
     * returning to the caller.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   710
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   711
    public static void executeOnEventHandlerThread(PeerEvent peerEvent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   712
        postEvent(targetToAppContext(peerEvent.getSource()), peerEvent);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   713
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   714
90ce3da70b43 Initial load
duke
parents:
diff changeset
   715
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   716
     * Execute a chunk of code on the Java event handler thread. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
   717
     * method takes into account provided AppContext and sets
90ce3da70b43 Initial load
duke
parents:
diff changeset
   718
     * <code>SunToolkit.getDefaultToolkit()</code> as a target of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   719
     * event. See 6451487 for detailes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   720
     * Does not wait for the execution to occur before returning to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   721
     * the caller.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   722
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   723
     public static void invokeLaterOnAppContext(
90ce3da70b43 Initial load
duke
parents:
diff changeset
   724
        AppContext appContext, Runnable dispatcher)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   725
     {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   726
        postEvent(appContext,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   727
            new PeerEvent(Toolkit.getDefaultToolkit(), dispatcher,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   728
                PeerEvent.PRIORITY_EVENT));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   729
     }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   730
90ce3da70b43 Initial load
duke
parents:
diff changeset
   731
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   732
     * Execute a chunk of code on the Java event handler thread for the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   733
     * given target.  Waits for the execution to occur before returning
90ce3da70b43 Initial load
duke
parents:
diff changeset
   734
     * to the caller.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   735
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   736
    public static void executeOnEDTAndWait(Object target, Runnable runnable)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   737
        throws InterruptedException, InvocationTargetException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   738
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   739
        if (EventQueue.isDispatchThread()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   740
            throw new Error("Cannot call executeOnEDTAndWait from any event dispatcher thread");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   741
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   742
90ce3da70b43 Initial load
duke
parents:
diff changeset
   743
        class AWTInvocationLock {}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   744
        Object lock = new AWTInvocationLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   745
90ce3da70b43 Initial load
duke
parents:
diff changeset
   746
        PeerEvent event = new PeerEvent(target, runnable, lock, true, PeerEvent.PRIORITY_EVENT);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   747
90ce3da70b43 Initial load
duke
parents:
diff changeset
   748
        synchronized (lock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   749
            executeOnEventHandlerThread(event);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   750
            lock.wait();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   751
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   752
90ce3da70b43 Initial load
duke
parents:
diff changeset
   753
        Throwable eventThrowable = event.getThrowable();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   754
        if (eventThrowable != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   755
            throw new InvocationTargetException(eventThrowable);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   756
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   757
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   758
90ce3da70b43 Initial load
duke
parents:
diff changeset
   759
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   760
     * Returns next queue for the given EventQueue which has private access
90ce3da70b43 Initial load
duke
parents:
diff changeset
   761
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   762
    private static EventQueue getNextQueue(final Object o) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   763
        EventQueue result = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   764
        try{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   765
            Field nextQueueField = getField(EventQueue.class,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   766
                                            "nextQueue");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   767
            result = (EventQueue)nextQueueField.get(o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   768
        } catch( IllegalAccessException e){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   769
            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   770
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   771
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   772
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   773
90ce3da70b43 Initial load
duke
parents:
diff changeset
   774
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   775
     * Returns dispatch thread for the given EventQueue which has private access
90ce3da70b43 Initial load
duke
parents:
diff changeset
   776
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   777
    private static Thread getDispatchThread(final Object o) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   778
        Thread result = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   779
        try{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   780
            Field dispatchThreadField = getField(EventQueue.class,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   781
                                                 "dispatchThread");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   782
            result = (Thread)dispatchThreadField.get(o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   783
        } catch( IllegalAccessException e){
90ce3da70b43 Initial load
duke
parents:
diff changeset
   784
            assert false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   785
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   786
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   787
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   788
90ce3da70b43 Initial load
duke
parents:
diff changeset
   789
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   790
     * Returns true if the calling thread is the event dispatch thread
90ce3da70b43 Initial load
duke
parents:
diff changeset
   791
     * contained within AppContext which associated with the given target.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   792
     * Use this call to ensure that a given task is being executed
90ce3da70b43 Initial load
duke
parents:
diff changeset
   793
     * (or not being) on the event dispatch thread for the given target.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   794
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   795
    public static boolean isDispatchThreadForAppContext(Object target) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   796
        AppContext appContext = targetToAppContext(target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   797
        EventQueue eq = (EventQueue)appContext.get(AppContext.EVENT_QUEUE_KEY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   798
90ce3da70b43 Initial load
duke
parents:
diff changeset
   799
        EventQueue next = getNextQueue(eq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   800
        while (next != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   801
            eq = next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   802
            next = getNextQueue(eq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   803
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   804
90ce3da70b43 Initial load
duke
parents:
diff changeset
   805
        return (Thread.currentThread() == getDispatchThread(eq));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   806
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   807
90ce3da70b43 Initial load
duke
parents:
diff changeset
   808
    public Dimension getScreenSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   809
        return new Dimension(getScreenWidth(), getScreenHeight());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   810
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   811
    protected abstract int getScreenWidth();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   812
    protected abstract int getScreenHeight();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   813
90ce3da70b43 Initial load
duke
parents:
diff changeset
   814
    public FontMetrics getFontMetrics(Font font) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   815
        return FontDesignMetrics.getMetrics(font);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   816
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   817
90ce3da70b43 Initial load
duke
parents:
diff changeset
   818
    public String[] getFontList() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   819
        String[] hardwiredFontList = {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   820
            Font.DIALOG, Font.SANS_SERIF, Font.SERIF, Font.MONOSPACED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   821
            Font.DIALOG_INPUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
   822
90ce3da70b43 Initial load
duke
parents:
diff changeset
   823
            // -- Obsolete font names from 1.0.2.  It was decided that
90ce3da70b43 Initial load
duke
parents:
diff changeset
   824
            // -- getFontList should not return these old names:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   825
            //    "Helvetica", "TimesRoman", "Courier", "ZapfDingbats"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   826
        };
90ce3da70b43 Initial load
duke
parents:
diff changeset
   827
        return hardwiredFontList;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   828
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   829
90ce3da70b43 Initial load
duke
parents:
diff changeset
   830
    public PanelPeer createPanel(Panel target) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   831
        return (PanelPeer)createComponent(target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   832
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   833
90ce3da70b43 Initial load
duke
parents:
diff changeset
   834
    public CanvasPeer createCanvas(Canvas target) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   835
        return (CanvasPeer)createComponent(target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   836
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   837
90ce3da70b43 Initial load
duke
parents:
diff changeset
   838
    /**
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   839
     * Disables erasing of background on the canvas before painting if
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   840
     * this is supported by the current toolkit. It is recommended to
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   841
     * call this method early, before the Canvas becomes displayable,
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   842
     * because some Toolkit implementations do not support changing
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   843
     * this property once the Canvas becomes displayable.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   844
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   845
    public void disableBackgroundErase(Canvas canvas) {
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   846
        disableBackgroundEraseImpl(canvas);
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   847
    }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   848
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   849
    /**
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   850
     * Disables the native erasing of the background on the given
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   851
     * component before painting if this is supported by the current
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   852
     * toolkit. This only has an effect for certain components such as
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   853
     * Canvas, Panel and Window. It is recommended to call this method
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   854
     * early, before the Component becomes displayable, because some
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   855
     * Toolkit implementations do not support changing this property
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   856
     * once the Component becomes displayable.
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   857
     */
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   858
    public void disableBackgroundErase(Component component) {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   859
        disableBackgroundEraseImpl(component);
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   860
    }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   861
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   862
    private void disableBackgroundEraseImpl(Component component) {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   863
        AWTAccessor.getComponentAccessor().setBackgroundEraseDisabled(component, true);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   864
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   865
90ce3da70b43 Initial load
duke
parents:
diff changeset
   866
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   867
     * Returns the value of "sun.awt.noerasebackground" property. Default
90ce3da70b43 Initial load
duke
parents:
diff changeset
   868
     * value is {@code false}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   869
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   870
    public static boolean getSunAwtNoerasebackground() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   871
        return AccessController.doPrivileged(new GetBooleanAction("sun.awt.noerasebackground"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   872
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   873
90ce3da70b43 Initial load
duke
parents:
diff changeset
   874
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   875
     * Returns the value of "sun.awt.erasebackgroundonresize" property. Default
90ce3da70b43 Initial load
duke
parents:
diff changeset
   876
     * value is {@code false}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   877
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   878
    public static boolean getSunAwtErasebackgroundonresize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   879
        return AccessController.doPrivileged(new GetBooleanAction("sun.awt.erasebackgroundonresize"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   880
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   881
1190
f27065d0d9f0 6708392: Provide internal API to create OverrideRedirect windows, XToolkit
art
parents: 1181
diff changeset
   882
f27065d0d9f0 6708392: Provide internal API to create OverrideRedirect windows, XToolkit
art
parents: 1181
diff changeset
   883
    /**
f27065d0d9f0 6708392: Provide internal API to create OverrideRedirect windows, XToolkit
art
parents: 1181
diff changeset
   884
     * Makes the window OverrideRedirect, on X11 platforms. See
f27065d0d9f0 6708392: Provide internal API to create OverrideRedirect windows, XToolkit
art
parents: 1181
diff changeset
   885
     * ICCCM specification for more details about OverrideRedirect
f27065d0d9f0 6708392: Provide internal API to create OverrideRedirect windows, XToolkit
art
parents: 1181
diff changeset
   886
     * windows. Implemented in XToolkit, no-op in WToolkit.
f27065d0d9f0 6708392: Provide internal API to create OverrideRedirect windows, XToolkit
art
parents: 1181
diff changeset
   887
     */
f27065d0d9f0 6708392: Provide internal API to create OverrideRedirect windows, XToolkit
art
parents: 1181
diff changeset
   888
    public void setOverrideRedirect(Window target) {
f27065d0d9f0 6708392: Provide internal API to create OverrideRedirect windows, XToolkit
art
parents: 1181
diff changeset
   889
    }
f27065d0d9f0 6708392: Provide internal API to create OverrideRedirect windows, XToolkit
art
parents: 1181
diff changeset
   890
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   891
    static SoftCache imgCache = new SoftCache();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   892
90ce3da70b43 Initial load
duke
parents:
diff changeset
   893
    static synchronized Image getImageFromHash(Toolkit tk, URL url) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   894
        SecurityManager sm = System.getSecurityManager();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   895
        if (sm != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   896
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   897
                java.security.Permission perm =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   898
                    url.openConnection().getPermission();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   899
                if (perm != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   900
                    try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   901
                        sm.checkPermission(perm);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   902
                    } catch (SecurityException se) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   903
                        // fallback to checkRead/checkConnect for pre 1.2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   904
                        // security managers
90ce3da70b43 Initial load
duke
parents:
diff changeset
   905
                        if ((perm instanceof java.io.FilePermission) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   906
                            perm.getActions().indexOf("read") != -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   907
                            sm.checkRead(perm.getName());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   908
                        } else if ((perm instanceof
90ce3da70b43 Initial load
duke
parents:
diff changeset
   909
                            java.net.SocketPermission) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   910
                            perm.getActions().indexOf("connect") != -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   911
                            sm.checkConnect(url.getHost(), url.getPort());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   912
                        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   913
                            throw se;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   914
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   915
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   916
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   917
            } catch (java.io.IOException ioe) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   918
                    sm.checkConnect(url.getHost(), url.getPort());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   919
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   920
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   921
        Image img = (Image)imgCache.get(url);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   922
        if (img == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   923
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   924
                img = tk.createImage(new URLImageSource(url));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   925
                imgCache.put(url, img);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   926
            } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   927
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   928
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   929
        return img;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   930
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   931
90ce3da70b43 Initial load
duke
parents:
diff changeset
   932
    static synchronized Image getImageFromHash(Toolkit tk,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   933
                                               String filename) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   934
        SecurityManager security = System.getSecurityManager();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   935
        if (security != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   936
            security.checkRead(filename);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   937
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   938
        Image img = (Image)imgCache.get(filename);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   939
        if (img == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   940
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   941
                img = tk.createImage(new FileImageSource(filename));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   942
                imgCache.put(filename, img);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   943
            } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   944
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   945
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   946
        return img;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   947
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   948
90ce3da70b43 Initial load
duke
parents:
diff changeset
   949
    public Image getImage(String filename) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   950
        return getImageFromHash(this, filename);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   951
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   952
90ce3da70b43 Initial load
duke
parents:
diff changeset
   953
    public Image getImage(URL url) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   954
        return getImageFromHash(this, url);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   955
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   956
90ce3da70b43 Initial load
duke
parents:
diff changeset
   957
    public Image createImage(String filename) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   958
        SecurityManager security = System.getSecurityManager();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   959
        if (security != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   960
            security.checkRead(filename);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   961
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   962
        return createImage(new FileImageSource(filename));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   963
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   964
90ce3da70b43 Initial load
duke
parents:
diff changeset
   965
    public Image createImage(URL url) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   966
        SecurityManager sm = System.getSecurityManager();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   967
        if (sm != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   968
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   969
                java.security.Permission perm =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   970
                    url.openConnection().getPermission();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   971
                if (perm != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   972
                    try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   973
                        sm.checkPermission(perm);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   974
                    } catch (SecurityException se) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   975
                        // fallback to checkRead/checkConnect for pre 1.2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   976
                        // security managers
90ce3da70b43 Initial load
duke
parents:
diff changeset
   977
                        if ((perm instanceof java.io.FilePermission) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   978
                            perm.getActions().indexOf("read") != -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   979
                            sm.checkRead(perm.getName());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   980
                        } else if ((perm instanceof
90ce3da70b43 Initial load
duke
parents:
diff changeset
   981
                            java.net.SocketPermission) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   982
                            perm.getActions().indexOf("connect") != -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   983
                            sm.checkConnect(url.getHost(), url.getPort());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   984
                        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   985
                            throw se;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   986
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   987
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   988
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   989
            } catch (java.io.IOException ioe) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   990
                    sm.checkConnect(url.getHost(), url.getPort());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   991
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   992
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   993
        return createImage(new URLImageSource(url));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   994
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   995
90ce3da70b43 Initial load
duke
parents:
diff changeset
   996
    public Image createImage(byte[] data, int offset, int length) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   997
        return createImage(new ByteArrayImageSource(data, offset, length));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   998
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   999
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1000
    public Image createImage(ImageProducer producer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1001
        return new ToolkitImage(producer);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1002
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1003
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1004
    public int checkImage(Image img, int w, int h, ImageObserver o) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1005
        if (!(img instanceof ToolkitImage)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1006
            return ImageObserver.ALLBITS;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1007
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1008
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1009
        ToolkitImage tkimg = (ToolkitImage)img;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1010
        int repbits;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1011
        if (w == 0 || h == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1012
            repbits = ImageObserver.ALLBITS;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1013
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1014
            repbits = tkimg.getImageRep().check(o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1015
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1016
        return tkimg.check(o) | repbits;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1017
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1018
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1019
    public boolean prepareImage(Image img, int w, int h, ImageObserver o) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1020
        if (w == 0 || h == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1021
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1022
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1023
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1024
        // Must be a ToolkitImage
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1025
        if (!(img instanceof ToolkitImage)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1026
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1027
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1028
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1029
        ToolkitImage tkimg = (ToolkitImage)img;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1030
        if (tkimg.hasError()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1031
            if (o != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1032
                o.imageUpdate(img, ImageObserver.ERROR|ImageObserver.ABORT,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1033
                              -1, -1, -1, -1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1034
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1035
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1036
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1037
        ImageRepresentation ir = tkimg.getImageRep();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1038
        return ir.prepare(o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1039
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1040
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1041
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1042
     * Scans {@code imageList} for best-looking image of specified dimensions.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1043
     * Image can be scaled and/or padded with transparency.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1044
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1045
    public static BufferedImage getScaledIconImage(java.util.List<Image> imageList, int width, int height) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1046
        if (width == 0 || height == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1047
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1048
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1049
        Image bestImage = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1050
        int bestWidth = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1051
        int bestHeight = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1052
        double bestSimilarity = 3; //Impossibly high value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1053
        double bestScaleFactor = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1054
        for (Iterator<Image> i = imageList.iterator();i.hasNext();) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1055
            //Iterate imageList looking for best matching image.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1056
            //'Similarity' measure is defined as good scale factor and small insets.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1057
            //best possible similarity is 0 (no scale, no insets).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1058
            //It's found while the experiments that good-looking result is achieved
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1059
            //with scale factors x1, x3/4, x2/3, xN, x1/N.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1060
            Image im = i.next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1061
            if (im == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1062
                if (log.isLoggable(Level.FINER)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1063
                    log.log(Level.FINER, "SunToolkit.getScaledIconImage: " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1064
                            "Skipping the image passed into Java because it's null.");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1065
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1066
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1067
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1068
            if (im instanceof ToolkitImage) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1069
                ImageRepresentation ir = ((ToolkitImage)im).getImageRep();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1070
                ir.reconstruct(ImageObserver.ALLBITS);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1071
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1072
            int iw;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1073
            int ih;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1074
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1075
                iw = im.getWidth(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1076
                ih = im.getHeight(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1077
            } catch (Exception e){
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1078
                if (log.isLoggable(Level.FINER)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1079
                    log.log(Level.FINER, "SunToolkit.getScaledIconImage: " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1080
                            "Perhaps the image passed into Java is broken. Skipping this icon.");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1081
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1082
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1083
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1084
            if (iw > 0 && ih > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1085
                //Calc scale factor
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1086
                double scaleFactor = Math.min((double)width / (double)iw,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1087
                                              (double)height / (double)ih);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1088
                //Calculate scaled image dimensions
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1089
                //adjusting scale factor to nearest "good" value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1090
                int adjw = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1091
                int adjh = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1092
                double scaleMeasure = 1; //0 - best (no) scale, 1 - impossibly bad
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1093
                if (scaleFactor >= 2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1094
                    //Need to enlarge image more than twice
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1095
                    //Round down scale factor to multiply by integer value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1096
                    scaleFactor = Math.floor(scaleFactor);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1097
                    adjw = iw * (int)scaleFactor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1098
                    adjh = ih * (int)scaleFactor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1099
                    scaleMeasure = 1.0 - 0.5 / scaleFactor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1100
                } else if (scaleFactor >= 1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1101
                    //Don't scale
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1102
                    scaleFactor = 1.0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1103
                    adjw = iw;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1104
                    adjh = ih;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1105
                    scaleMeasure = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1106
                } else if (scaleFactor >= 0.75) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1107
                    //Multiply by 3/4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1108
                    scaleFactor = 0.75;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1109
                    adjw = iw * 3 / 4;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1110
                    adjh = ih * 3 / 4;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1111
                    scaleMeasure = 0.3;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1112
                } else if (scaleFactor >= 0.6666) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1113
                    //Multiply by 2/3
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1114
                    scaleFactor = 0.6666;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1115
                    adjw = iw * 2 / 3;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1116
                    adjh = ih * 2 / 3;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1117
                    scaleMeasure = 0.33;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1118
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1119
                    //Multiply size by 1/scaleDivider
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1120
                    //where scaleDivider is minimum possible integer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1121
                    //larger than 1/scaleFactor
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1122
                    double scaleDivider = Math.ceil(1.0 / scaleFactor);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1123
                    scaleFactor = 1.0 / scaleDivider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1124
                    adjw = (int)Math.round((double)iw / scaleDivider);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1125
                    adjh = (int)Math.round((double)ih / scaleDivider);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1126
                    scaleMeasure = 1.0 - 1.0 / scaleDivider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1127
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1128
                double similarity = ((double)width - (double)adjw) / (double)width +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1129
                    ((double)height - (double)adjh) / (double)height + //Large padding is bad
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1130
                    scaleMeasure; //Large rescale is bad
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1131
                if (similarity < bestSimilarity) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1132
                    bestSimilarity = similarity;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1133
                    bestScaleFactor = scaleFactor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1134
                    bestImage = im;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1135
                    bestWidth = adjw;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1136
                    bestHeight = adjh;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1137
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1138
                if (similarity == 0) break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1139
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1140
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1141
        if (bestImage == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1142
            //No images were found, possibly all are broken
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1143
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1144
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1145
        BufferedImage bimage =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1146
            new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1147
        Graphics2D g = bimage.createGraphics();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1148
        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1149
                           RenderingHints.VALUE_INTERPOLATION_BILINEAR);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1150
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1151
            int x = (width - bestWidth) / 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1152
            int y = (height - bestHeight) / 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1153
            if (log.isLoggable(Level.FINER)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1154
                log.log(Level.FINER, "WWindowPeer.getScaledIconData() result : " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1155
                        "w : " + width + " h : " + height +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1156
                        " iW : " + bestImage.getWidth(null) + " iH : " + bestImage.getHeight(null) +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1157
                        " sim : " + bestSimilarity + " sf : " + bestScaleFactor +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1158
                        " adjW : " + bestWidth + " adjH : " + bestHeight +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1159
                        " x : " + x + " y : " + y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1160
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1161
            g.drawImage(bestImage, x, y, bestWidth, bestHeight, null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1162
        } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1163
            g.dispose();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1164
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1165
        return bimage;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1166
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1167
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1168
    public static DataBufferInt getScaledIconData(java.util.List<Image> imageList, int width, int height) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1169
        BufferedImage bimage = getScaledIconImage(imageList, width, height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1170
        if (bimage == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1171
             if (log.isLoggable(Level.FINER)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1172
                 log.log(Level.FINER, "SunToolkit.getScaledIconData: " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1173
                         "Perhaps the image passed into Java is broken. Skipping this icon.");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1174
             }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1175
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1176
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1177
        Raster raster = bimage.getRaster();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1178
        DataBuffer buffer = raster.getDataBuffer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1179
        return (DataBufferInt)buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1180
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1181
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1182
    protected EventQueue getSystemEventQueueImpl() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1183
        return getSystemEventQueueImplPP();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1184
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1185
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1186
    // Package private implementation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1187
    static EventQueue getSystemEventQueueImplPP() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1188
        return getSystemEventQueueImplPP(AppContext.getAppContext());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1189
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1190
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1191
    public static EventQueue getSystemEventQueueImplPP(AppContext appContext) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1192
        EventQueue theEventQueue =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1193
            (EventQueue)appContext.get(AppContext.EVENT_QUEUE_KEY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1194
        return theEventQueue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1195
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1196
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1197
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1198
     * Give native peers the ability to query the native container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1199
     * given a native component (eg the direct parent may be lightweight).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1200
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1201
    public static Container getNativeContainer(Component c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1202
        return Toolkit.getNativeContainer(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1203
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1204
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1205
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1206
     * Returns a new input method window, with behavior as specified in
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1207
     * {@link java.awt.im.spi.InputMethodContext#createInputMethodWindow}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1208
     * If the inputContext is not null, the window should return it from its
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1209
     * getInputContext() method. The window needs to implement
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1210
     * sun.awt.im.InputMethodWindow.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1211
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1212
     * SunToolkit subclasses can override this method to return better input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1213
     * method windows.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1214
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1215
    public Window createInputMethodWindow(String title, InputContext context) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1216
        return new sun.awt.im.SimpleInputMethodWindow(title, context);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1217
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1218
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1219
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1220
     * Returns whether enableInputMethods should be set to true for peered
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1221
     * TextComponent instances on this platform. False by default.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1222
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1223
    public boolean enableInputMethodsForTextComponent() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1224
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1225
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1226
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1227
    private static Locale startupLocale = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1228
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1229
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1230
     * Returns the locale in which the runtime was started.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1231
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1232
    public static Locale getStartupLocale() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1233
        if (startupLocale == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1234
            String language, region, country, variant;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1235
            language = (String) AccessController.doPrivileged(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1236
                            new GetPropertyAction("user.language", "en"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1237
            // for compatibility, check for old user.region property
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1238
            region = (String) AccessController.doPrivileged(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1239
                            new GetPropertyAction("user.region"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1240
            if (region != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1241
                // region can be of form country, country_variant, or _variant
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1242
                int i = region.indexOf('_');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1243
                if (i >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1244
                    country = region.substring(0, i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1245
                    variant = region.substring(i + 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1246
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1247
                    country = region;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1248
                    variant = "";
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1249
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1250
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1251
                country = (String) AccessController.doPrivileged(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1252
                                new GetPropertyAction("user.country", ""));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1253
                variant = (String) AccessController.doPrivileged(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1254
                                new GetPropertyAction("user.variant", ""));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1255
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1256
            startupLocale = new Locale(language, country, variant);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1257
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1258
        return startupLocale;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1259
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1260
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1261
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1262
     * Returns the default keyboard locale of the underlying operating system
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1263
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1264
    public Locale getDefaultKeyboardLocale() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1265
        return getStartupLocale();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1266
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1267
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1268
    private static String dataTransfererClassName = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1269
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1270
    protected static void setDataTransfererClassName(String className) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1271
        dataTransfererClassName = className;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1272
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1273
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1274
    public static String getDataTransfererClassName() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1275
        if (dataTransfererClassName == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1276
            Toolkit.getDefaultToolkit(); // transferer set during toolkit init
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1277
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1278
        return dataTransfererClassName;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1279
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1280
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1281
    // Support for window closing event notifications
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1282
    private transient WindowClosingListener windowClosingListener = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1283
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1284
     * @see sun.awt.WindowClosingSupport#getWindowClosingListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1285
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1286
    public WindowClosingListener getWindowClosingListener() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1287
        return windowClosingListener;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1288
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1289
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1290
     * @see sun.awt.WindowClosingSupport#setWindowClosingListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1291
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1292
    public void setWindowClosingListener(WindowClosingListener wcl) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1293
        windowClosingListener = wcl;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1294
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1295
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1296
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1297
     * @see sun.awt.WindowClosingListener#windowClosingNotify
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1298
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1299
    public RuntimeException windowClosingNotify(WindowEvent event) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1300
        if (windowClosingListener != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1301
            return windowClosingListener.windowClosingNotify(event);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1302
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1303
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1304
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1305
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1306
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1307
     * @see sun.awt.WindowClosingListener#windowClosingDelivered
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1308
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1309
    public RuntimeException windowClosingDelivered(WindowEvent event) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1310
        if (windowClosingListener != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1311
            return windowClosingListener.windowClosingDelivered(event);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1312
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1313
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1314
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1315
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1316
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1317
    private static DefaultMouseInfoPeer mPeer = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1318
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1319
    protected synchronized MouseInfoPeer getMouseInfoPeer() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1320
        if (mPeer == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1321
            mPeer = new DefaultMouseInfoPeer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1322
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1323
        return mPeer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1324
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1325
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1326
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1327
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1328
     * Returns whether default toolkit needs the support of the xembed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1329
     * from embedding host(if any).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1330
     * @return <code>true</code>, if XEmbed is needed, <code>false</code> otherwise
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1331
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1332
    public static boolean needsXEmbed() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1333
        String noxembed = (String) AccessController.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1334
            doPrivileged(new GetPropertyAction("sun.awt.noxembed", "false"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1335
        if ("true".equals(noxembed)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1336
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1337
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1338
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1339
        Toolkit tk = Toolkit.getDefaultToolkit();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1340
        if (tk instanceof SunToolkit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1341
            // SunToolkit descendants should override this method to specify
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1342
            // concrete behavior
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1343
            return ((SunToolkit)tk).needsXEmbedImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1344
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1345
            // Non-SunToolkit doubtly might support XEmbed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1346
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1347
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1348
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1349
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1350
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1351
     * Returns whether this toolkit needs the support of the xembed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1352
     * from embedding host(if any).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1353
     * @return <code>true</code>, if XEmbed is needed, <code>false</code> otherwise
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1354
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1355
    protected boolean needsXEmbedImpl() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1356
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1357
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1358
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1359
    private static Dialog.ModalExclusionType DEFAULT_MODAL_EXCLUSION_TYPE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1360
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1361
    static {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1362
        DEFAULT_MODAL_EXCLUSION_TYPE = (Dialog.ModalExclusionType)AccessController.doPrivileged(new PrivilegedAction() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1363
            public Object run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1364
                Dialog.ModalExclusionType defaultType = Dialog.ModalExclusionType.NO_EXCLUDE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1365
                try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1366
                    java.lang.reflect.Field f = Dialog.class.getDeclaredField("DEFAULT_MODAL_EXCLUSION_TYPE");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1367
                    f.setAccessible(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1368
                    defaultType = (Dialog.ModalExclusionType)f.get(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1369
                } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1370
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1371
                return defaultType;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1372
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1373
        });
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1374
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1375
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1376
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1377
     * Returns whether the XEmbed server feature is requested by
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1378
     * developer.  If true, Toolkit should return an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1379
     * XEmbed-server-enabled CanvasPeer instead of the ordinary CanvasPeer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1380
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1381
    protected final boolean isXEmbedServerRequested() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1382
        return AccessController.doPrivileged(new GetBooleanAction("sun.awt.xembedserver"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1383
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1384
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1385
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1386
     * Returns whether the modal exclusion API is supported by the current toolkit.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1387
     * When it isn't supported, calling <code>setModalExcluded</code> has no
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1388
     * effect, and <code>isModalExcluded</code> returns false for all windows.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1389
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1390
     * @return true if modal exclusion is supported by the toolkit, false otherwise
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1391
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1392
     * @see sun.awt.SunToolkit#setModalExcluded(java.awt.Window)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1393
     * @see sun.awt.SunToolkit#isModalExcluded(java.awt.Window)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1394
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1395
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1396
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1397
    public static boolean isModalExcludedSupported()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1398
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1399
        Toolkit tk = Toolkit.getDefaultToolkit();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1400
        return tk.isModalExclusionTypeSupported(DEFAULT_MODAL_EXCLUSION_TYPE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1401
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1402
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1403
     * Default implementation for isModalExcludedSupportedImpl(), returns false.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1404
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1405
     * @see sun.awt.windows.WToolkit#isModalExcludeSupportedImpl
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1406
     * @see sun.awt.X11.XToolkit#isModalExcludeSupportedImpl
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1407
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1408
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1409
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1410
    protected boolean isModalExcludedSupportedImpl()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1411
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1412
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1413
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1414
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1415
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1416
     * Sets this window to be excluded from being modally blocked. When the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1417
     * toolkit supports modal exclusion and this method is called, input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1418
     * events, focus transfer and z-order will continue to work for the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1419
     * window, it's owned windows and child components, even in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1420
     * presence of a modal dialog.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1421
     * For details on which <code>Window</code>s are normally blocked
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1422
     * by modal dialog, see {@link java.awt.Dialog}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1423
     * Invoking this method when the modal exclusion API is not supported by
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1424
     * the current toolkit has no effect.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1425
     * @param window Window to be marked as not modally blocked
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1426
     * @see java.awt.Dialog
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1427
     * @see java.awt.Dialog#setModal(boolean)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1428
     * @see sun.awt.SunToolkit#isModalExcludedSupported
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1429
     * @see sun.awt.SunToolkit#isModalExcluded(java.awt.Window)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1430
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1431
    public static void setModalExcluded(Window window)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1432
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1433
        window.setModalExclusionType(DEFAULT_MODAL_EXCLUSION_TYPE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1434
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1435
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1436
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1437
     * Returns whether the specified window is blocked by modal dialogs.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1438
     * If the modal exclusion API isn't supported by the current toolkit,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1439
     * it returns false for all windows.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1440
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1441
     * @param window Window to test for modal exclusion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1442
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1443
     * @return true if the window is modal excluded, false otherwise. If
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1444
     * the modal exclusion isn't supported by the current Toolkit, false
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1445
     * is returned
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1446
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1447
     * @see sun.awt.SunToolkit#isModalExcludedSupported
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1448
     * @see sun.awt.SunToolkit#setModalExcluded(java.awt.Window)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1449
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1450
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1451
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1452
    public static boolean isModalExcluded(Window window)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1453
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1454
        return window.getModalExclusionType().compareTo(DEFAULT_MODAL_EXCLUSION_TYPE) >= 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1455
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1456
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1457
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1458
     * Overridden in XToolkit and WToolkit
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1459
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1460
    public boolean isModalityTypeSupported(Dialog.ModalityType modalityType) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1461
        return (modalityType == Dialog.ModalityType.MODELESS) ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1462
               (modalityType == Dialog.ModalityType.APPLICATION_MODAL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1463
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1464
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1465
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1466
     * Overridden in XToolkit and WToolkit
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1467
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1468
    public boolean isModalExclusionTypeSupported(Dialog.ModalExclusionType exclusionType) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1469
        return (exclusionType == Dialog.ModalExclusionType.NO_EXCLUDE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1470
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1471
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1472
    ///////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1473
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1474
    // The following is used by the Java Plug-in to coordinate dialog modality
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1475
    // between containing applications (browsers, ActiveX containers etc) and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1476
    // the AWT.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1477
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1478
    ///////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1479
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1480
    private ModalityListenerList modalityListeners = new ModalityListenerList();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1481
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1482
    public void addModalityListener(ModalityListener listener) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1483
        modalityListeners.add(listener);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1484
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1485
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1486
    public void removeModalityListener(ModalityListener listener) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1487
        modalityListeners.remove(listener);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1488
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1489
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1490
    public void notifyModalityPushed(Dialog dialog) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1491
        notifyModalityChange(ModalityEvent.MODALITY_PUSHED, dialog);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1492
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1493
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1494
    public void notifyModalityPopped(Dialog dialog) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1495
        notifyModalityChange(ModalityEvent.MODALITY_POPPED, dialog);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1496
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1497
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1498
    final void notifyModalityChange(int id, Dialog source) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1499
        ModalityEvent ev = new ModalityEvent(source, modalityListeners, id);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1500
        ev.dispatch();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1501
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1502
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1503
    static class ModalityListenerList implements ModalityListener {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1504
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1505
        Vector<ModalityListener> listeners = new Vector<ModalityListener>();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1506
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1507
        void add(ModalityListener listener) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1508
            listeners.addElement(listener);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1509
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1510
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1511
        void remove(ModalityListener listener) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1512
            listeners.removeElement(listener);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1513
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1514
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1515
        public void modalityPushed(ModalityEvent ev) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1516
            Iterator<ModalityListener> it = listeners.iterator();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1517
            while (it.hasNext()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1518
                it.next().modalityPushed(ev);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1519
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1520
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1521
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1522
        public void modalityPopped(ModalityEvent ev) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1523
            Iterator<ModalityListener> it = listeners.iterator();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1524
            while (it.hasNext()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1525
                it.next().modalityPopped(ev);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1526
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1527
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1528
    } // end of class ModalityListenerList
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1529
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1530
    ///////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1531
    // End Plug-in code
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1532
    ///////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1533
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1534
    public static boolean isLightweightOrUnknown(Component comp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1535
        if (comp.isLightweight()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1536
            || !(getDefaultToolkit() instanceof SunToolkit))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1537
        {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1538
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1539
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1540
        return !(comp instanceof Button
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1541
            || comp instanceof Canvas
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1542
            || comp instanceof Checkbox
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1543
            || comp instanceof Choice
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1544
            || comp instanceof Label
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1545
            || comp instanceof java.awt.List
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1546
            || comp instanceof Panel
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1547
            || comp instanceof Scrollbar
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1548
            || comp instanceof ScrollPane
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1549
            || comp instanceof TextArea
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1550
            || comp instanceof TextField
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1551
            || comp instanceof Window);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1552
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1553
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1554
    public static Method getMethod(final Class clz, final String methodName, final Class[] params) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1555
        Method res = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1556
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1557
            res = AccessController.doPrivileged(new PrivilegedExceptionAction<Method>() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1558
                    public Method run() throws Exception {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1559
                        Method m = clz.getDeclaredMethod(methodName, params);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1560
                        m.setAccessible(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1561
                        return m;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1562
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1563
                });
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1564
        } catch (PrivilegedActionException ex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1565
            ex.printStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1566
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1567
        return res;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1568
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1569
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1570
    public static class OperationTimedOut extends RuntimeException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1571
        public OperationTimedOut(String msg) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1572
            super(msg);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1573
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1574
        public OperationTimedOut() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1575
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1576
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1577
    public static class InfiniteLoop extends RuntimeException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1578
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1579
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1580
    public static class IllegalThreadException extends RuntimeException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1581
        public IllegalThreadException(String msg) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1582
            super(msg);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1583
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1584
        public IllegalThreadException() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1585
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1586
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1587
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1588
    public static final int DEFAULT_WAIT_TIME = 10000;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1589
    private static final int MAX_ITERS = 20;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1590
    private static final int MIN_ITERS = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1591
    private static final int MINIMAL_EDELAY = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1592
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1593
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1594
     * Parameterless version of realsync which uses default timout (see DEFAUL_WAIT_TIME).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1595
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1596
    public void realSync() throws OperationTimedOut, InfiniteLoop {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1597
        realSync(DEFAULT_WAIT_TIME);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1598
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1599
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1600
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1601
     * Forces toolkit to synchronize with the native windowing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1602
     * sub-system, flushing all pending work and waiting for all the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1603
     * events to be processed.  This method guarantees that after
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1604
     * return no additional Java events will be generated, unless
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1605
     * cause by user. Obviously, the method cannot be used on the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1606
     * event dispatch thread (EDT). In case it nevertheless gets
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1607
     * invoked on this thread, the method throws the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1608
     * IllegalThreadException runtime exception.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1609
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1610
     * <p> This method allows to write tests without explicit timeouts
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1611
     * or wait for some event.  Example:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1612
     * <code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1613
     * Frame f = ...;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1614
     * f.setVisible(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1615
     * ((SunToolkit)Toolkit.getDefaultToolkit()).realSync();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1616
     * </code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1617
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1618
     * <p> After realSync, <code>f</code> will be completely visible
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1619
     * on the screen, its getLocationOnScreen will be returning the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1620
     * right result and it will be the focus owner.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1621
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1622
     * <p> Another example:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1623
     * <code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1624
     * b.requestFocus();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1625
     * ((SunToolkit)Toolkit.getDefaultToolkit()).realSync();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1626
     * </code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1627
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1628
     * <p> After realSync, <code>b</code> will be focus owner.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1629
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1630
     * <p> Notice that realSync isn't guaranteed to work if recurring
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1631
     * actions occur, such as if during processing of some event
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1632
     * another request which may generate some events occurs.  By
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1633
     * default, sync tries to perform as much as {@value MAX_ITERS}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1634
     * cycles of event processing, allowing for roughly {@value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1635
     * MAX_ITERS} additional requests.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1636
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1637
     * <p> For example, requestFocus() generates native request, which
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1638
     * generates one or two Java focus events, which then generate a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1639
     * serie of paint events, a serie of Java focus events, which then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1640
     * generate a serie of paint events which then are processed -
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1641
     * three cycles, minimum.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1642
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1643
     * @param timeout the maximum time to wait in milliseconds, negative means "forever".
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1644
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1645
    public void realSync(final long timeout) throws OperationTimedOut, InfiniteLoop
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1646
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1647
        if (EventQueue.isDispatchThread()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1648
            throw new IllegalThreadException("The SunToolkit.realSync() method cannot be used on the event dispatch thread (EDT).");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1649
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1650
        int bigLoop = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1651
        do {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1652
            // Let's do sync first
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1653
            sync();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1654
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1655
            // During the wait process, when we were processing incoming
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1656
            // events, we could have made some new request, which can
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1657
            // generate new events.  Example: MapNotify/XSetInputFocus.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1658
            // Therefore, we dispatch them as long as there is something
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1659
            // to dispatch.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1660
            int iters = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1661
            while (iters < MIN_ITERS) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1662
                syncNativeQueue(timeout);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1663
                iters++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1664
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1665
            while (syncNativeQueue(timeout) && iters < MAX_ITERS) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1666
                iters++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1667
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1668
            if (iters >= MAX_ITERS) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1669
                throw new InfiniteLoop();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1670
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1671
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1672
            // native requests were dispatched by X/Window Manager or Windows
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1673
            // Moreover, we processed them all on Toolkit thread
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1674
            // Now wait while EDT processes them.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1675
            //
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1676
            // During processing of some events (focus, for example),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1677
            // some other events could have been generated.  So, after
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1678
            // waitForIdle, we may end up with full EventQueue
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1679
            iters = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1680
            while (iters < MIN_ITERS) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1681
                waitForIdle(timeout);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1682
                iters++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1683
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1684
            while (waitForIdle(timeout) && iters < MAX_ITERS) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1685
                iters++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1686
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1687
            if (iters >= MAX_ITERS) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1688
                throw new InfiniteLoop();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1689
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1690
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1691
            bigLoop++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1692
            // Again, for Java events, it was simple to check for new Java
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1693
            // events by checking event queue, but what if Java events
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1694
            // resulted in native requests?  Therefor, check native events again.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1695
        } while ((syncNativeQueue(timeout) || waitForIdle(timeout)) && bigLoop < MAX_ITERS);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1696
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1697
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1698
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1699
     * Platform toolkits need to implement this method to perform the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1700
     * sync of the native queue.  The method should wait until native
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1701
     * requests are processed, all native events are processed and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1702
     * corresponding Java events are generated.  Should return
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1703
     * <code>true</code> if some events were processed,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1704
     * <code>false</code> otherwise.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1705
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1706
    protected abstract boolean syncNativeQueue(final long timeout);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1707
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1708
    private boolean eventDispatched = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1709
    private boolean queueEmpty = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1710
    private final Object waitLock = "Wait Lock";
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1711
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1712
    static Method eqNoEvents;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1713
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1714
    private boolean isEQEmpty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1715
        EventQueue queue = getSystemEventQueueImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1716
        synchronized(SunToolkit.class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1717
            if (eqNoEvents == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1718
                eqNoEvents = getMethod(java.awt.EventQueue.class, "noEvents", null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1719
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1720
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1721
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1722
            return (Boolean)eqNoEvents.invoke(queue);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1723
        } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1724
            e.printStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1725
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1726
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1727
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1728
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1729
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1730
     * Waits for the Java event queue to empty.  Ensures that all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1731
     * events are processed (including paint events), and that if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1732
     * recursive events were generated, they are also processed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1733
     * Should return <code>true</code> if more processing is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1734
     * necessary, <code>false</code> otherwise.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1735
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1736
    protected final boolean waitForIdle(final long timeout) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1737
        flushPendingEvents();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1738
        boolean queueWasEmpty = isEQEmpty();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1739
        queueEmpty = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1740
        eventDispatched = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1741
        synchronized(waitLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1742
            postEvent(AppContext.getAppContext(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1743
                      new PeerEvent(getSystemEventQueueImpl(), null, PeerEvent.LOW_PRIORITY_EVENT) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1744
                          public void dispatch() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1745
                              // Here we block EDT.  It could have some
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1746
                              // events, it should have dispatched them by
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1747
                              // now.  So native requests could have been
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1748
                              // generated.  First, dispatch them.  Then,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1749
                              // flush Java events again.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1750
                              int iters = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1751
                              while (iters < MIN_ITERS) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1752
                                  syncNativeQueue(timeout);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1753
                                  iters++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1754
                              }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1755
                              while (syncNativeQueue(timeout) && iters < MAX_ITERS) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1756
                                  iters++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1757
                              }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1758
                              flushPendingEvents();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1759
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1760
                              synchronized(waitLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1761
                                  queueEmpty = isEQEmpty();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1762
                                  eventDispatched = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1763
                                  waitLock.notifyAll();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1764
                              }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1765
                          }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1766
                      });
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1767
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1768
                while (!eventDispatched) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1769
                    waitLock.wait();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1770
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1771
            } catch (InterruptedException ie) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1772
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1773
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1774
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1775
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1776
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1777
            Thread.sleep(MINIMAL_EDELAY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1778
        } catch (InterruptedException ie) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1779
            throw new RuntimeException("Interrupted");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1780
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1781
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1782
        flushPendingEvents();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1783
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1784
        // Lock to force write-cache flush for queueEmpty.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1785
        synchronized (waitLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1786
            return !(queueEmpty && isEQEmpty() && queueWasEmpty);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1787
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1788
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1789
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1790
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1791
     * Grabs the mouse input for the given window.  The window must be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1792
     * visible.  The window or its children do not receive any
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1793
     * additional mouse events besides those targeted to them.  All
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1794
     * other events will be dispatched as before - to the respective
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1795
     * targets.  This Window will receive UngrabEvent when automatic
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1796
     * ungrab is about to happen.  The event can be listened to by
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1797
     * installing AWTEventListener with WINDOW_EVENT_MASK.  See
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1798
     * UngrabEvent class for the list of conditions when ungrab is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1799
     * about to happen.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1800
     * @see UngrabEvent
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1801
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1802
    public abstract void grab(Window w);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1803
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1804
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1805
     * Forces ungrab.  No event will be sent.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1806
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1807
    public abstract void ungrab(Window w);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1808
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1809
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1810
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1811
     * Locates the splash screen library in a platform dependent way and closes
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1812
     * the splash screen. Should be invoked on first top-level frame display.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1813
     * @see java.awt.SplashScreen
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1814
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1815
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1816
    public static native void closeSplashScreen();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1817
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1818
    /* The following methods and variables are to support retrieving
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1819
     * desktop text anti-aliasing settings
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1820
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1821
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1822
    /* Need an instance method because setDesktopProperty(..) is protected. */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1823
    private void fireDesktopFontPropertyChanges() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1824
        setDesktopProperty(SunToolkit.DESKTOPFONTHINTS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1825
                           SunToolkit.getDesktopFontHints());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1826
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1827
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1828
    private static boolean checkedSystemAAFontSettings;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1829
    private static boolean useSystemAAFontSettings;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1830
    private static boolean lastExtraCondition = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1831
    private static RenderingHints desktopFontHints;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1832
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1833
    /* Since Swing is the reason for this "extra condition" logic its
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1834
     * worth documenting it in some detail.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1835
     * First, a goal is for Swing and applications to both retrieve and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1836
     * use the same desktop property value so that there is complete
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1837
     * consistency between the settings used by JDK's Swing implementation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1838
     * and 3rd party custom Swing components, custom L&Fs and any general
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1839
     * text rendering that wants to be consistent with these.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1840
     * But by default on Solaris & Linux Swing will not use AA text over
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1841
     * remote X11 display (unless Xrender can be used which is TBD and may not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1842
     * always be available anyway) as that is a noticeable performance hit.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1843
     * So there needs to be a way to express that extra condition so that
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1844
     * it is seen by all clients of the desktop property API.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1845
     * If this were the only condition it could be handled here as it would
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1846
     * be the same for any L&F and could reasonably be considered to be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1847
     * a static behaviour of those systems.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1848
     * But GTK currently has an additional test based on locale which is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1849
     * not applied by Metal. So mixing GTK in a few locales with Metal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1850
     * would mean the last one wins.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1851
     * This could be stored per-app context which would work
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1852
     * for different applets, but wouldn't help for a single application
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1853
     * using GTK and some other L&F concurrently.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1854
     * But it is expected this will be addressed within GTK and the font
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1855
     * system so is a temporary and somewhat unlikely harmless corner case.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1856
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1857
    public static void setAAFontSettingsCondition(boolean extraCondition) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1858
        if (extraCondition != lastExtraCondition) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1859
            lastExtraCondition = extraCondition;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1860
            if (checkedSystemAAFontSettings) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1861
                /* Someone already asked for this info, under a different
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1862
                 * condition.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1863
                 * We'll force re-evaluation instead of replicating the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1864
                 * logic, then notify any listeners of any change.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1865
                 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1866
                checkedSystemAAFontSettings = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1867
                Toolkit tk = Toolkit.getDefaultToolkit();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1868
                if (tk instanceof SunToolkit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1869
                     ((SunToolkit)tk).fireDesktopFontPropertyChanges();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1870
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1871
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1872
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1873
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1874
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1875
    /* "false", "off", ""default" aren't explicitly tested, they
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1876
     * just fall through to produce a null return which all are equated to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1877
     * "false".
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1878
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1879
    private static RenderingHints getDesktopAAHintsByName(String hintname) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1880
        Object aaHint = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1881
        hintname = hintname.toLowerCase(Locale.ENGLISH);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1882
        if (hintname.equals("on")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1883
            aaHint = VALUE_TEXT_ANTIALIAS_ON;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1884
        } else if (hintname.equals("gasp")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1885
            aaHint = VALUE_TEXT_ANTIALIAS_GASP;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1886
        } else if (hintname.equals("lcd") || hintname.equals("lcd_hrgb")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1887
            aaHint = VALUE_TEXT_ANTIALIAS_LCD_HRGB;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1888
        } else if (hintname.equals("lcd_hbgr")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1889
            aaHint = VALUE_TEXT_ANTIALIAS_LCD_HBGR;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1890
        } else if (hintname.equals("lcd_vrgb")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1891
            aaHint = VALUE_TEXT_ANTIALIAS_LCD_VRGB;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1892
        } else if (hintname.equals("lcd_vbgr")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1893
            aaHint = VALUE_TEXT_ANTIALIAS_LCD_VBGR;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1894
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1895
        if (aaHint != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1896
            RenderingHints map = new RenderingHints(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1897
            map.put(KEY_TEXT_ANTIALIASING, aaHint);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1898
            return map;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1899
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1900
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1901
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1902
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1903
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1904
    /* This method determines whether to use the system font settings,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1905
     * or ignore them if a L&F has specified they should be ignored, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1906
     * to override both of these with a system property specified value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1907
     * If the toolkit isn't a SunToolkit, (eg may be headless) then that
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1908
     * system property isn't applied as desktop properties are considered
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1909
     * to be inapplicable in that case. In that headless case although
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1910
     * this method will return "true" the toolkit will return a null map.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1911
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1912
    private static boolean useSystemAAFontSettings() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1913
        if (!checkedSystemAAFontSettings) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1914
            useSystemAAFontSettings = true; /* initially set this true */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1915
            String systemAAFonts = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1916
            Toolkit tk = Toolkit.getDefaultToolkit();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1917
            if (tk instanceof SunToolkit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1918
                systemAAFonts =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1919
                    (String)AccessController.doPrivileged(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1920
                         new GetPropertyAction("awt.useSystemAAFontSettings"));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1921
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1922
            if (systemAAFonts != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1923
                useSystemAAFontSettings =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1924
                    Boolean.valueOf(systemAAFonts).booleanValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1925
                /* If it is anything other than "true", then it may be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1926
                 * a hint name , or it may be "off, "default", etc.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1927
                 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1928
                if (!useSystemAAFontSettings) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1929
                    desktopFontHints = getDesktopAAHintsByName(systemAAFonts);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1930
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1931
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1932
            /* If its still true, apply the extra condition */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1933
            if (useSystemAAFontSettings) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1934
                 useSystemAAFontSettings = lastExtraCondition;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1935
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1936
            checkedSystemAAFontSettings = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1937
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1938
        return useSystemAAFontSettings;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1939
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1940
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1941
    /* A variable defined for the convenience of JDK code */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1942
    public static final String DESKTOPFONTHINTS = "awt.font.desktophints";
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1943
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1944
    /* Overridden by subclasses to return platform/desktop specific values */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1945
    protected RenderingHints getDesktopAAHints() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1946
        return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1947
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1948
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1949
    /* Subclass desktop property loading methods call this which
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1950
     * in turn calls the appropriate subclass implementation of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1951
     * getDesktopAAHints() when system settings are being used.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1952
     * Its public rather than protected because subclasses may delegate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1953
     * to a helper class.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1954
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1955
    public static RenderingHints getDesktopFontHints() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1956
        if (useSystemAAFontSettings()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1957
             Toolkit tk = Toolkit.getDefaultToolkit();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1958
             if (tk instanceof SunToolkit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1959
                 Object map = ((SunToolkit)tk).getDesktopAAHints();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1960
                 return (RenderingHints)map;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1961
             } else { /* Headless Toolkit */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1962
                 return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1963
             }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1964
        } else if (desktopFontHints != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1965
            /* cloning not necessary as the return value is cloned later, but
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1966
             * its harmless.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1967
             */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1968
            return (RenderingHints)(desktopFontHints.clone());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1969
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1970
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1971
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1972
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1973
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1974
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1975
    public abstract boolean isDesktopSupported();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1976
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1977
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1978
     * consumeNextKeyTyped() method is not currently used,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1979
     * however Swing could use it in the future.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1980
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1981
    private static Method consumeNextKeyTypedMethod = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1982
    public static synchronized void consumeNextKeyTyped(KeyEvent keyEvent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1983
        if (consumeNextKeyTypedMethod == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1984
            consumeNextKeyTypedMethod = getMethod(DefaultKeyboardFocusManager.class,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1985
                                                  "consumeNextKeyTyped",
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1986
                                                  new Class[] {KeyEvent.class});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1987
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1988
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1989
            consumeNextKeyTypedMethod.invoke(KeyboardFocusManager.getCurrentKeyboardFocusManager(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1990
                                             keyEvent);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1991
        } catch (IllegalAccessException iae) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1992
            iae.printStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1993
        } catch (InvocationTargetException ite) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1994
            ite.printStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1995
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1996
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1997
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1998
    protected static void dumpPeers(final Logger aLog) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1999
        AWTAutoShutdown.getInstance().dumpPeers(aLog);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2000
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2001
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2002
    /**
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2003
     * Returns the <code>Window</code> ancestor of the component <code>comp</code>.
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2004
     * @return Window ancestor of the component or component by itself if it is Window;
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2005
     *         null, if component is not a part of window hierarchy
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2006
     */
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2007
    public static Window getContainingWindow(Component comp) {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2008
        while (comp != null && !(comp instanceof Window)) {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2009
            comp = comp.getParent();
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2010
        }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2011
        return (Window)comp;
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2012
    }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2013
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2014
    private static Boolean sunAwtDisableMixing = null;
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2015
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2016
    /**
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2017
     * Returns the value of "sun.awt.disableMixing" property. Default
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2018
     * value is {@code false}.
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2019
     */
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2020
    public synchronized static boolean getSunAwtDisableMixing() {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2021
        if (sunAwtDisableMixing == null) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2022
            sunAwtDisableMixing = Boolean.valueOf(
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2023
                    AccessController.doPrivileged(
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2024
                        new GetBooleanAction("sun.awt.disableMixing")));
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2025
        }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2026
        return sunAwtDisableMixing.booleanValue();
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2027
    }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1973
diff changeset
  2028
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2029
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2030
     * Returns true if the native GTK libraries are available.  The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2031
     * default implementation returns false, but UNIXToolkit overrides this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2032
     * method to provide a more specific answer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2033
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2034
    public boolean isNativeGTKAvailable() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2035
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2036
    }
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2037
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2038
    // Cosntant alpha
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2039
    public boolean isWindowOpacitySupported() {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2040
        return false;
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2041
    }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2042
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2043
    // Shaping
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2044
    public boolean isWindowShapingSupported() {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2045
        return false;
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2046
    }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2047
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2048
    // Per-pixel alpha
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2049
    public boolean isWindowTranslucencySupported() {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2050
        return false;
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2051
    }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2052
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2053
    public boolean isTranslucencyCapable(GraphicsConfiguration gc) {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2054
        return false;
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2055
    }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2056
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2057
    /**
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2058
     * Returns whether or not a containing top level window for the passed
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2059
     * component is
2648
aa45a227fce3 6802853: API: shaped & translucent windows
anthony
parents: 2464
diff changeset
  2060
     * {@link GraphicsDevice.WindowTranslucency#PERPIXEL_TRANSLUCENT PERPIXEL_TRANSLUCENT}.
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2061
     *
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2062
     * @param c a Component which toplevel's to check
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2063
     * @return {@code true}  if the passed component is not null and has a
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2064
     * containing toplevel window which is opaque (so per-pixel translucency
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2065
     * is not enabled), {@code false} otherwise
2648
aa45a227fce3 6802853: API: shaped & translucent windows
anthony
parents: 2464
diff changeset
  2066
     * @see GraphicsDevice.WindowTranslucency#PERPIXEL_TRANSLUCENT
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2067
     */
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2068
    public static boolean isContainingTopLevelOpaque(Component c) {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2069
        Window w = getContainingWindow(c);
2648
aa45a227fce3 6802853: API: shaped & translucent windows
anthony
parents: 2464
diff changeset
  2070
        return w != null && ((Window)w).getBackground() != null &&
aa45a227fce3 6802853: API: shaped & translucent windows
anthony
parents: 2464
diff changeset
  2071
            ((Window)w).getBackground().getAlpha() == 255;
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2072
    }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2073
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2074
    /**
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2075
     * Returns whether or not a containing top level window for the passed
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2076
     * component is
2648
aa45a227fce3 6802853: API: shaped & translucent windows
anthony
parents: 2464
diff changeset
  2077
     * {@link GraphicsDevice.WindowTranslucency#TRANSLUCENT TRANSLUCENT}.
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2078
     *
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2079
     * @param c a Component which toplevel's to check
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2080
     * @return {@code true} if the passed component is not null and has a
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2081
     * containing toplevel window which has opacity less than
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2082
     * 1.0f (which means that it is translucent), {@code false} otherwise
2648
aa45a227fce3 6802853: API: shaped & translucent windows
anthony
parents: 2464
diff changeset
  2083
     * @see GraphicsDevice.WindowTranslucency#TRANSLUCENT
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2084
     */
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2085
    public static boolean isContainingTopLevelTranslucent(Component c) {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2086
        Window w = getContainingWindow(c);
2648
aa45a227fce3 6802853: API: shaped & translucent windows
anthony
parents: 2464
diff changeset
  2087
        return w != null && ((Window)w).getOpacity() < 1.0f;
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2088
    }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2089
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2090
    /**
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2091
     * Returns whether the native system requires using the peer.updateWindow()
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2092
     * method to update the contents of a non-opaque window, or if usual
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2093
     * painting procedures are sufficient. The default return value covers
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2094
     * the X11 systems. On MS Windows this method is overriden in WToolkit
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2095
     * to return true.
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2096
     */
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2097
    public boolean needUpdateWindow() {
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2098
        return false;
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2099
    }
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
  2100
2810
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
  2101
    /**
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
  2102
     * Descendants of the SunToolkit should override and put their own logic here.
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
  2103
     */
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
  2104
    public int getNumberOfButtons(){
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
  2105
        return 3;
fa49c6a06baf 6799099: All automatic regression tests that create Robot fail on X11
dav
parents: 2648
diff changeset
  2106
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2107
} // class SunToolkit
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2108
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2109
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2110
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2111
 * PostEventQueue is a Thread that runs in the same AppContext as the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2112
 * Java EventQueue.  It is a queue of AWTEvents to be posted to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2113
 * Java EventQueue.  The toolkit Thread (AWT-Windows/AWT-Motif) posts
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2114
 * events to this queue, which then calls EventQueue.postEvent().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2115
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2116
 * We do this because EventQueue.postEvent() may be overridden by client
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2117
 * code, and we mustn't ever call client code from the toolkit thread.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2118
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2119
class PostEventQueue {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2120
    private EventQueueItem queueHead = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2121
    private EventQueueItem queueTail = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2122
    private final EventQueue eventQueue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2123
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2124
    PostEventQueue(EventQueue eq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2125
        eventQueue = eq;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2126
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2127
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2128
    public boolean noEvents() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2129
        return queueHead == null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2130
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2131
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2132
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2133
     * Continually post pending AWTEvents to the Java EventQueue.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2134
     */
1973
1c56524d207d 6699589: java/awt/EventQueue/PostEventOrderingTest.java fails
art
parents: 1190
diff changeset
  2135
    public synchronized void flush() {
1c56524d207d 6699589: java/awt/EventQueue/PostEventOrderingTest.java fails
art
parents: 1190
diff changeset
  2136
        EventQueueItem tempQueue = queueHead;
1c56524d207d 6699589: java/awt/EventQueue/PostEventOrderingTest.java fails
art
parents: 1190
diff changeset
  2137
        queueHead = queueTail = null;
1c56524d207d 6699589: java/awt/EventQueue/PostEventOrderingTest.java fails
art
parents: 1190
diff changeset
  2138
        while (tempQueue != null) {
1c56524d207d 6699589: java/awt/EventQueue/PostEventOrderingTest.java fails
art
parents: 1190
diff changeset
  2139
            eventQueue.postEvent(tempQueue.event);
1c56524d207d 6699589: java/awt/EventQueue/PostEventOrderingTest.java fails
art
parents: 1190
diff changeset
  2140
            tempQueue = tempQueue.next;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2141
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2142
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2143
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2144
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2145
     * Enqueue an AWTEvent to be posted to the Java EventQueue.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2146
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2147
    void postEvent(AWTEvent event) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2148
        EventQueueItem item = new EventQueueItem(event);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2149
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2150
        synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2151
            if (queueHead == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2152
                queueHead = queueTail = item;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2153
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2154
                queueTail.next = item;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2155
                queueTail = item;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2156
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2157
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2158
        SunToolkit.wakeupEventQueue(eventQueue, event.getSource() == AWTAutoShutdown.getInstance());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2159
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2160
} // class PostEventQueue