/*

 * Copyright (c) 1995, 2016, Oracle and/or its affiliates. All rights reserved.

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

 *

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

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

 * published by the Free Software Foundation.  Oracle designates this

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

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

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

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

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

 * questions.

 */

package java.awt;

import java.awt.datatransfer.Clipboard;

import java.awt.dnd.DragGestureListener;

import java.awt.dnd.DragGestureRecognizer;

import java.awt.dnd.DragSource;

import java.awt.event.*;

import java.awt.im.InputMethodHighlight;

import java.awt.image.ColorModel;

import java.awt.image.ImageObserver;

import java.awt.image.ImageProducer;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.io.File;

import java.io.FileInputStream;

import java.net.URL;

import java.util.ArrayList;

import java.util.EventListener;

import java.util.HashMap;

import java.util.Map;

import java.util.MissingResourceException;

import java.util.Properties;

import java.util.ResourceBundle;

import java.util.StringTokenizer;

import java.util.WeakHashMap;

import sun.awt.AWTAccessor;

import sun.awt.AWTPermissions;

import sun.awt.AppContext;

import sun.awt.HeadlessToolkit;

import sun.awt.PeerEvent;

import sun.awt.SunToolkit;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.Arrays;

import java.util.ServiceLoader;

import java.util.Set;

import java.util.stream.Collectors;

import javax.accessibility.AccessibilityProvider;

/**

 * This class is the abstract superclass of all actual

 * implementations of the Abstract Window Toolkit. Subclasses of

 * the {@code Toolkit} class are used to bind the various components

 * to particular native toolkit implementations.

 * <p>

 * Many GUI events may be delivered to user

 * asynchronously, if the opposite is not specified explicitly.

 * As well as

 * many GUI operations may be performed asynchronously.

 * This fact means that if the state of a component is set, and then

 * the state immediately queried, the returned value may not yet

 * reflect the requested change.  This behavior includes, but is not

 * limited to:

 * <ul>

 * <li>Scrolling to a specified position.

 * <br>For example, calling {@code ScrollPane.setScrollPosition}

 *     and then {@code getScrollPosition} may return an incorrect

 *     value if the original request has not yet been processed.

 *

 * <li>Moving the focus from one component to another.

 * <br>For more information, see

 * <a href="http://docs.oracle.com/javase/tutorial/uiswing/misc/focus.html#transferTiming">Timing

 * Focus Transfers</a>, a section in

 * <a href="http://docs.oracle.com/javase/tutorial/uiswing/">The Swing

 * Tutorial</a>.

 *

 * <li>Making a top-level container visible.

 * <br>Calling {@code setVisible(true)} on a {@code Window},

 *     {@code Frame} or {@code Dialog} may occur

 *     asynchronously.

 *

 * <li>Setting the size or location of a top-level container.

 * <br>Calls to {@code setSize}, {@code setBounds} or

 *     {@code setLocation} on a {@code Window},

 *     {@code Frame} or {@code Dialog} are forwarded

 *     to the underlying window management system and may be

 *     ignored or modified.  See {@link java.awt.Window} for

 *     more information.

 * </ul>

 * <p>

 * Most applications should not call any of the methods in this

 * class directly. The methods defined by {@code Toolkit} are

 * the "glue" that joins the platform-independent classes in the

 * {@code java.awt} package with their counterparts in

 * {@code java.awt.peer}. Some methods defined by

 * {@code Toolkit} query the native operating system directly.

 *

 * @author      Sami Shaio

 * @author      Arthur van Hoff

 * @author      Fred Ecks

 * @since       1.0

 */

public abstract class Toolkit {

    // The following method is called by the private method

    // <code>updateSystemColors</code> in <code>SystemColor</code>.

    /**

     * Fills in the integer array that is supplied as an argument

     * with the current system color values.

     *

     * @param     systemColors an integer array.

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     * returns true

     * @see       java.awt.GraphicsEnvironment#isHeadless

     * @since     1.1

     */

    protected void loadSystemColors(int[] systemColors)

        throws HeadlessException {

        GraphicsEnvironment.checkHeadless();

    }

    /**

     * Controls whether the layout of Containers is validated dynamically

     * during resizing, or statically, after resizing is complete.

     * Use {@code isDynamicLayoutActive()} to detect if this feature enabled

     * in this program and is supported by this operating system

     * and/or window manager.

     * Note that this feature is supported not on all platforms, and

     * conversely, that this feature cannot be turned off on some platforms.

     * On these platforms where dynamic layout during resizing is not supported

     * (or is always supported), setting this property has no effect.

     * Note that this feature can be set or unset as a property of the

     * operating system or window manager on some platforms.  On such

     * platforms, the dynamic resize property must be set at the operating

     * system or window manager level before this method can take effect.

     * This method does not change support or settings of the underlying

     * operating system or

     * window manager.  The OS/WM support can be

     * queried using getDesktopProperty("awt.dynamicLayoutSupported") method.

     *

     * @param     dynamic  If true, Containers should re-layout their

     *            components as the Container is being resized.  If false,

     *            the layout will be validated after resizing is completed.

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     *            returns true

     * @see       #isDynamicLayoutSet()

     * @see       #isDynamicLayoutActive()

     * @see       #getDesktopProperty(String propertyName)

     * @see       java.awt.GraphicsEnvironment#isHeadless

     * @since     1.4

     */

    public void setDynamicLayout(final boolean dynamic)

        throws HeadlessException {

        GraphicsEnvironment.checkHeadless();

        if (this != getDefaultToolkit()) {

            getDefaultToolkit().setDynamicLayout(dynamic);

        }

    }

    /**

     * Returns whether the layout of Containers is validated dynamically

     * during resizing, or statically, after resizing is complete.

     * Note: this method returns the value that was set programmatically;

     * it does not reflect support at the level of the operating system

     * or window manager for dynamic layout on resizing, or the current

     * operating system or window manager settings.  The OS/WM support can

     * be queried using getDesktopProperty("awt.dynamicLayoutSupported").

     *

     * @return    true if validation of Containers is done dynamically,

     *            false if validation is done after resizing is finished.

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     *            returns true

     * @see       #setDynamicLayout(boolean dynamic)

     * @see       #isDynamicLayoutActive()

     * @see       #getDesktopProperty(String propertyName)

     * @see       java.awt.GraphicsEnvironment#isHeadless

     * @since     1.4

     */

    protected boolean isDynamicLayoutSet()

        throws HeadlessException {

        GraphicsEnvironment.checkHeadless();

        if (this != Toolkit.getDefaultToolkit()) {

            return Toolkit.getDefaultToolkit().isDynamicLayoutSet();

        } else {

            return false;

        }

    }

    /**

     * Returns whether dynamic layout of Containers on resize is currently

     * enabled on the underlying operating system and/or window manager). If the

     * platform supports it, {@code setDynamicLayout(boolean)} may be used to

     * programmatically enable or disable platform dynamic layout. Regardless of

     * whether that toggling is supported, or whether {@code true} or {@code

     * false} is specified as an argument, or has never been called at all, this

     * method will return the active current platform behavior and which will be

     * followed by the JDK in determining layout policy during resizing.

     * <p>

     * If dynamic layout is currently inactive then Containers re-layout their

     * components when resizing is completed. As a result the

     * {@code Component.validate()} method will be invoked only once per resize.

     * If dynamic layout is currently active then Containers re-layout their

     * components on every native resize event and the {@code validate()} method

     * will be invoked each time. The OS/WM support can be queried using the

     * getDesktopProperty("awt.dynamicLayoutSupported") method. This property

     * will reflect the platform capability but is not sufficient to tell if it

     * is presently enabled.

     *

     * @return true if dynamic layout of Containers on resize is currently

     *         active, false otherwise.

     * @throws HeadlessException if the GraphicsEnvironment.isHeadless() method

     *         returns true

     * @see #setDynamicLayout(boolean dynamic)

     * @see #isDynamicLayoutSet()

     * @see #getDesktopProperty(String propertyName)

     * @see java.awt.GraphicsEnvironment#isHeadless

     * @since 1.4

     */

    public boolean isDynamicLayoutActive()

        throws HeadlessException {

        GraphicsEnvironment.checkHeadless();

        if (this != Toolkit.getDefaultToolkit()) {

            return Toolkit.getDefaultToolkit().isDynamicLayoutActive();

        } else {

            return false;

        }

    }

    /**

     * Gets the size of the screen.  On systems with multiple displays, the

     * primary display is used.  Multi-screen aware display dimensions are

     * available from {@code GraphicsConfiguration} and

     * {@code GraphicsDevice}.

     * @return    the size of this toolkit's screen, in pixels.

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     * returns true

     * @see       java.awt.GraphicsConfiguration#getBounds

     * @see       java.awt.GraphicsDevice#getDisplayMode

     * @see       java.awt.GraphicsEnvironment#isHeadless

     */

    public abstract Dimension getScreenSize()

        throws HeadlessException;

    /**

     * Returns the screen resolution in dots-per-inch.

     * @return    this toolkit's screen resolution, in dots-per-inch.

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     * returns true

     * @see       java.awt.GraphicsEnvironment#isHeadless

     */

    public abstract int getScreenResolution()

        throws HeadlessException;

    /**

     * Gets the insets of the screen.

     * @param     gc a {@code GraphicsConfiguration}

     * @return    the insets of this toolkit's screen, in pixels.

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     * returns true

     * @see       java.awt.GraphicsEnvironment#isHeadless

     * @since     1.4

     */

    public Insets getScreenInsets(GraphicsConfiguration gc)

        throws HeadlessException {

        GraphicsEnvironment.checkHeadless();

        if (this != Toolkit.getDefaultToolkit()) {

            return Toolkit.getDefaultToolkit().getScreenInsets(gc);

        } else {

            return new Insets(0, 0, 0, 0);

        }

    }

    /**

     * Determines the color model of this toolkit's screen.

     * <p>

     * {@code ColorModel} is an abstract class that

     * encapsulates the ability to translate between the

     * pixel values of an image and its red, green, blue,

     * and alpha components.

     * <p>

     * This toolkit method is called by the

     * {@code getColorModel} method

     * of the {@code Component} class.

     * @return    the color model of this toolkit's screen.

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     * returns true

     * @see       java.awt.GraphicsEnvironment#isHeadless

     * @see       java.awt.image.ColorModel

     * @see       java.awt.Component#getColorModel

     */

    public abstract ColorModel getColorModel()

        throws HeadlessException;

    /**

     * Returns the names of the available fonts in this toolkit.<p>

     * For 1.1, the following font names are deprecated (the replacement

     * name follows):

     * <ul>

     * <li>TimesRoman (use Serif)

     * <li>Helvetica (use SansSerif)

     * <li>Courier (use Monospaced)

     * </ul><p>

     * The ZapfDingbats fontname is also deprecated in 1.1 but the characters

     * are defined in Unicode starting at 0x2700, and as of 1.1 Java supports

     * those characters.

     * @return    the names of the available fonts in this toolkit.

     * @deprecated see {@link java.awt.GraphicsEnvironment#getAvailableFontFamilyNames()}

     * @see java.awt.GraphicsEnvironment#getAvailableFontFamilyNames()

     */

    @Deprecated

    public abstract String[] getFontList();

    /**

     * Gets the screen device metrics for rendering of the font.

     * @param     font   a font

     * @return    the screen metrics of the specified font in this toolkit

     * @deprecated  As of JDK version 1.2, replaced by the {@code Font}

     *          method {@code getLineMetrics}.

     * @see java.awt.font.LineMetrics

     * @see java.awt.Font#getLineMetrics

     * @see java.awt.GraphicsEnvironment#getScreenDevices

     */

    @Deprecated

    public abstract FontMetrics getFontMetrics(Font font);

    /**

     * Synchronizes this toolkit's graphics state. Some window systems

     * may do buffering of graphics events.

     * <p>

     * This method ensures that the display is up-to-date. It is useful

     * for animation.

     */

    public abstract void sync();

    /**

     * The default toolkit.

     */

    private static Toolkit toolkit;

    /**

     * Used internally by the assistive technologies functions; set at

     * init time and used at load time

     */

    private static String atNames;

    /**

     * Initializes properties related to assistive technologies.

     * These properties are used both in the loadAssistiveProperties()

     * function below, as well as other classes in the jdk that depend

     * on the properties (such as the use of the screen_magnifier_present

     * property in Java2D hardware acceleration initialization).  The

     * initialization of the properties must be done before the platform-

     * specific Toolkit class is instantiated so that all necessary

     * properties are set up properly before any classes dependent upon them

     * are initialized.

     */

    private static void initAssistiveTechnologies() {

        // Get accessibility properties

        final String sep = File.separator;

        final Properties properties = new Properties();

        atNames = java.security.AccessController.doPrivileged(

            new java.security.PrivilegedAction<String>() {

            public String run() {

                // Try loading the per-user accessibility properties file.

                try {

                    File propsFile = new File(

                      System.getProperty("user.home") +

                      sep + ".accessibility.properties");

                    FileInputStream in =

                        new FileInputStream(propsFile);

                    // Inputstream has been buffered in Properties class

                    properties.load(in);

                    in.close();

                } catch (Exception e) {

                    // Per-user accessibility properties file does not exist

                }

                // Try loading the system-wide accessibility properties

                // file only if a per-user accessibility properties

                // file does not exist or is empty.

                if (properties.size() == 0) {

                    try {

                        File propsFile = new File(

                            System.getProperty("java.home") + sep + "conf" +

                            sep + "accessibility.properties");

                        FileInputStream in =

                            new FileInputStream(propsFile);

                        // Inputstream has been buffered in Properties class

                        properties.load(in);

                        in.close();

                    } catch (Exception e) {

                        // System-wide accessibility properties file does

                        // not exist;

                    }

                }

                // Get whether a screen magnifier is present.  First check

                // the system property and then check the properties file.

                String magPresent = System.getProperty("javax.accessibility.screen_magnifier_present");

                if (magPresent == null) {

                    magPresent = properties.getProperty("screen_magnifier_present", null);

                    if (magPresent != null) {

                        System.setProperty("javax.accessibility.screen_magnifier_present", magPresent);

                    }

                }

                // Get the names of any assistive technologies to load.  First

                // check the system property and then check the properties

                // file.

                String classNames = System.getProperty("javax.accessibility.assistive_technologies");

                if (classNames == null) {

                    classNames = properties.getProperty("assistive_technologies", null);

                    if (classNames != null) {

                        System.setProperty("javax.accessibility.assistive_technologies", classNames);

                    }

                }

                return classNames;

            }

        });

    }

    /**

     * Rethrow the AWTError but include the cause.

     *

     * @param s the error message

     * @param e the original exception

     * @throws the new AWTError including the cause (the original exception)

     */

    private static void newAWTError(Throwable e, String s) {

        AWTError newAWTError = new AWTError(s);

        newAWTError.initCause(e);

        throw newAWTError;

    }

    /**

     * When a service provider for Assistive Technology is not found look for a

     * supporting class on the class path and instantiate it.

     *

     * @param atName the name of the class to be loaded

     */

    private static void fallbackToLoadClassForAT(String atName) {

        try {

            Class<?> c = Class.forName(atName, false, ClassLoader.getSystemClassLoader());

            c.newInstance();

        } catch (ClassNotFoundException e) {

            newAWTError(e, "Assistive Technology not found: " + atName);

        } catch (InstantiationException e) {

            newAWTError(e, "Could not instantiate Assistive Technology: " + atName);

        } catch (IllegalAccessException e) {

            newAWTError(e, "Could not access Assistive Technology: " + atName);

        } catch (Exception e) {

            newAWTError(e, "Error trying to install Assistive Technology: " + atName);

        }

    }

    /**

     * Loads accessibility support using the property assistive_technologies.

     * The form is assistive_technologies= followed by a comma-separated list of

     * assistive technology providers to load.  The order in which providers are

     * loaded is determined by the order in which the ServiceLoader discovers

     * implementations of the AccessibilityProvider interface, not by the order

     * of provider names in the property list.  When a provider is found its

     * accessibility implementation will be started by calling the provider's

     * activate method.  All errors are handled via an AWTError exception.

     */

    private static void loadAssistiveTechnologies() {

        // Load any assistive technologies

        if (atNames != null) {

            ClassLoader cl = ClassLoader.getSystemClassLoader();

            Set<String> names = Arrays.stream(atNames.split(","))

                                      .map(String::trim)

                                      .collect(Collectors.toSet());

            final Map<String, AccessibilityProvider> providers = new HashMap<>();

            AccessController.doPrivileged((PrivilegedAction<Void>) () -> {

                try {

                    for (AccessibilityProvider p : ServiceLoader.load(AccessibilityProvider.class, cl)) {

                        String name = p.getName();

                        if (names.contains(name) && !providers.containsKey(name)) {

                            p.activate();

                            providers.put(name, p);

                        }

                    }

                } catch (java.util.ServiceConfigurationError | Exception e) {

                    newAWTError(e, "Could not load or activate service provider");

                }