/*

 * 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 sun.awt.windows;

import java.awt.*;

import java.awt.im.InputMethodHighlight;

import java.awt.im.spi.InputMethodDescriptor;

import java.awt.image.*;

import java.awt.peer.*;

import java.awt.event.KeyEvent;

import java.awt.datatransfer.Clipboard;

import java.awt.TrayIcon;

import java.beans.PropertyChangeListener;

import java.security.AccessController;

import java.security.PrivilegedAction;

import sun.awt.AWTAutoShutdown;

import sun.awt.SunToolkit;

import sun.awt.Win32GraphicsDevice;

import sun.awt.Win32GraphicsEnvironment;

import sun.java2d.d3d.D3DRenderQueue;

import sun.java2d.opengl.OGLRenderQueue;

import sun.print.PrintJob2D;

import java.awt.dnd.DragSource;

import java.awt.dnd.DragGestureListener;

import java.awt.dnd.DragGestureEvent;

import java.awt.dnd.DragGestureRecognizer;

import java.awt.dnd.MouseDragGestureRecognizer;

import java.awt.dnd.InvalidDnDOperationException;

import java.awt.dnd.peer.DragSourceContextPeer;

import java.util.Hashtable;

import java.util.Locale;

import java.util.Map;

import java.util.Properties;

import sun.font.FontManager;

import sun.font.FontManagerFactory;

import sun.font.SunFontManager;

import sun.misc.PerformanceLogger;

import sun.util.logging.PlatformLogger;

public class WToolkit extends SunToolkit implements Runnable {

    private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.windows.WToolkit");

    static GraphicsConfiguration config;

    // System clipboard.

    WClipboard clipboard;

    // cache of font peers

    private Hashtable cacheFontPeer;

    // Windows properties

    private WDesktopProperties  wprops;

    // Dynamic Layout Resize client code setting

    protected boolean dynamicLayoutSetting = false;

    //Is it allowed to generate events assigned to extra mouse buttons.

    //Set to true by default.

    private static boolean areExtraMouseButtonsEnabled = true;

    /**

     * Initialize JNI field and method IDs

     */

    private static native void initIDs();

    private static boolean loaded = false;

    public static void loadLibraries() {

        if (!loaded) {

            java.security.AccessController.doPrivileged(

                          new sun.security.action.LoadLibraryAction("awt"));

            loaded = true;

        }

    }

    private static native String getWindowsVersion();

    static {

        loadLibraries();

        // Force Win32GE to load if it is not already loaded; this loads

        // various other classes that are required for basic awt functionality

        Win32GraphicsEnvironment.init();

        initIDs();

        // Print out which version of Windows is running

        if (log.isLoggable(PlatformLogger.FINE)) {

            log.fine("Win version: " + getWindowsVersion());

        }

        java.security.AccessController.doPrivileged(

            new java.security.PrivilegedAction()

        {

            public Object run() {

                String browserProp = System.getProperty("browser");

                if (browserProp != null && browserProp.equals("sun.plugin")) {

                    disableCustomPalette();

                }

                return null;

            }

        });

    }

    private static native void disableCustomPalette();

    /*

     * Reset the static GraphicsConfiguration to the default.  Called on

     * startup and when display settings have changed.

     */

    public static void resetGC() {

        if (GraphicsEnvironment.isHeadless()) {

            config = null;

        } else {

          config = (GraphicsEnvironment

                  .getLocalGraphicsEnvironment()

          .getDefaultScreenDevice()

          .getDefaultConfiguration());

        }

    }

    /*

     * NOTE: The following embedded*() methods are non-public API intended

     * for internal use only.  The methods are unsupported and could go

     * away in future releases.

     *

     * New hook functions for using the AWT as an embedded service. These

     * functions replace the global C function AwtInit() which was previously

     * exported by awt.dll.

     *

     * When used as an embedded service, the AWT does NOT have its own

     * message pump. It instead relies on the parent application to provide

     * this functionality. embeddedInit() assumes that the thread on which it

     * is called is the message pumping thread. Violating this assumption

     * will lead to undefined behavior.

     *

     * embeddedInit must be called before the WToolkit() constructor.

     * embeddedDispose should be called before the applicaton terminates the

     * Java VM. It is currently unsafe to reinitialize the toolkit again

     * after it has been disposed. Instead, awt.dll must be reloaded and the

     * class loader which loaded WToolkit must be finalized before it is

     * safe to reuse AWT. Dynamic reusability may be added to the toolkit in

     * the future.

     */

    /**

     * Initializes the Toolkit for use in an embedded environment.

     *

     * @return true if the the initialization succeeded; false if it failed.

     *         The function will fail if the Toolkit was already initialized.

     * @since 1.3

     */

    public static native boolean embeddedInit();

    /**

     * Disposes the Toolkit in an embedded environment. This method should

     * not be called on exit unless the Toolkit was constructed with

     * embeddedInit.

     *

     * @return true if the disposal succeeded; false if it failed. The

     *         function will fail if the calling thread is not the same

     *         thread which called embeddedInit(), or if the Toolkit was

     *         already disposed.

     * @since 1.3

     */

    public static native boolean embeddedDispose();

    /**

     * To be called after processing the event queue by users of the above

     * embeddedInit() function.  The reason for this additional call is that

     * there are some operations performed during idle time in the AwtToolkit

     * event loop which should also be performed during idle time in any

     * other native event loop.  Failure to do so could result in

     * deadlocks.

     *

     * This method was added at the last minute of the jdk1.4 release

     * to work around a specific customer problem.  As with the above

     * embedded*() class, this method is non-public and should not be

     * used by external applications.

     *

     * See bug #4526587 for more information.

     */

    public native void embeddedEventLoopIdleProcessing();

    public static final String DATA_TRANSFERER_CLASS_NAME = "sun.awt.windows.WDataTransferer";

    static class ToolkitDisposer implements sun.java2d.DisposerRecord {

        public void dispose() {

            WToolkit.postDispose();

        }

    }

    private final Object anchor = new Object();

    private static native void postDispose();

    private static native boolean startToolkitThread(Runnable thread);

    public WToolkit() {

        // Startup toolkit threads

        if (PerformanceLogger.loggingEnabled()) {

            PerformanceLogger.setTime("WToolkit construction");

        }

        sun.java2d.Disposer.addRecord(anchor, new ToolkitDisposer());

        synchronized (this) {

            // Fix for bug #4046430 -- Race condition

            // where notifyAll can be called before

            // the "AWT-Windows" thread's parent thread is

            // waiting, resulting in a deadlock on startup.

            /*

             * Fix for 4701990.

             * AWTAutoShutdown state must be changed before the toolkit thread

             * starts to avoid race condition.

             */

            AWTAutoShutdown.notifyToolkitThreadBusy();

            if (!startToolkitThread(this)) {

                Thread toolkitThread = new Thread(this, "AWT-Windows");

                toolkitThread.setDaemon(true);

                toolkitThread.start();

            }

            try {

                wait();

            }

            catch (InterruptedException x) {

            }

        }

        SunToolkit.setDataTransfererClassName(DATA_TRANSFERER_CLASS_NAME);

        // Enabled "live resizing" by default.  It remains controlled

        // by the native system though.

        setDynamicLayout(true);

        areExtraMouseButtonsEnabled = Boolean.parseBoolean(System.getProperty("sun.awt.enableExtraMouseButtons", "true"));

        //set system property if not yet assigned

        System.setProperty("sun.awt.enableExtraMouseButtons", ""+areExtraMouseButtonsEnabled);

        setExtraMouseButtonsEnabledNative(areExtraMouseButtonsEnabled);

    }

    public void run() {

        Thread.currentThread().setPriority(Thread.NORM_PRIORITY+1);

        boolean startPump = init();

        if (startPump) {

            AccessController.doPrivileged(new PrivilegedAction() {

                public Object run() {

                    ThreadGroup currentTG =

                        Thread.currentThread().getThreadGroup();

                    ThreadGroup parentTG = currentTG.getParent();

                    while (parentTG != null) {

                        currentTG = parentTG;

                        parentTG = currentTG.getParent();

                    }

                    Thread shutdown = new Thread(currentTG, new Runnable() {

                            public void run() {

                                shutdown();

                            }

                        });

                    shutdown.setContextClassLoader(null);

                    Runtime.getRuntime().addShutdownHook(shutdown);

                    return null;

                }

            });

        }

        synchronized(this) {

            notifyAll();

        }

        if (startPump) {

            eventLoop(); // will Dispose Toolkit when shutdown hook executes

        }

    }

    /*

     * eventLoop() begins the native message pump which retrieves and processes

     * native events.

     *

     * When shutdown() is called by the ShutdownHook added in run(), a

     * WM_QUIT message is posted to the Toolkit thread indicating that

     * eventLoop() should Dispose the toolkit and exit.

     */

    private native boolean init();

    private native void eventLoop();

    private native void shutdown();

    /*

     * Instead of blocking the "AWT-Windows" thread uselessly on a semaphore,

     * use these functions. startSecondaryEventLoop() corresponds to wait()

     * and quitSecondaryEventLoop() corresponds to notify.

     *

     * These functions simulate blocking while allowing the AWT to continue

     * processing native events, eliminating a potential deadlock situation

     * with SendMessage.

     *

     * WARNING: startSecondaryEventLoop must only be called from the "AWT-

     * Windows" thread.

     */

    public static native void startSecondaryEventLoop();

    public static native void quitSecondaryEventLoop();

    /*

     * Create peer objects.

     */

    public ButtonPeer createButton(Button target) {

        ButtonPeer peer = new WButtonPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public TextFieldPeer createTextField(TextField target) {

        TextFieldPeer peer = new WTextFieldPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public LabelPeer createLabel(Label target) {

        LabelPeer peer = new WLabelPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public ListPeer createList(List target) {

        ListPeer peer = new WListPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public CheckboxPeer createCheckbox(Checkbox target) {

        CheckboxPeer peer = new WCheckboxPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public ScrollbarPeer createScrollbar(Scrollbar target) {

        ScrollbarPeer peer = new WScrollbarPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public ScrollPanePeer createScrollPane(ScrollPane target) {

        ScrollPanePeer peer = new WScrollPanePeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public TextAreaPeer createTextArea(TextArea target) {

        TextAreaPeer peer = new WTextAreaPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public ChoicePeer createChoice(Choice target) {

        ChoicePeer peer = new WChoicePeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public FramePeer  createFrame(Frame target) {

        FramePeer peer = new WFramePeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public CanvasPeer createCanvas(Canvas target) {

        CanvasPeer peer = new WCanvasPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public void disableBackgroundErase(Canvas canvas) {

        WCanvasPeer peer = (WCanvasPeer)canvas.getPeer();

        if (peer == null) {

            throw new IllegalStateException("Canvas must have a valid peer");

        }

        peer.disableBackgroundErase();

    }

    public PanelPeer createPanel(Panel target) {

        PanelPeer peer = new WPanelPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public WindowPeer createWindow(Window target) {

        WindowPeer peer = new WWindowPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public DialogPeer createDialog(Dialog target) {

        DialogPeer peer = new WDialogPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public FileDialogPeer createFileDialog(FileDialog target) {

        FileDialogPeer peer = new WFileDialogPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public MenuBarPeer createMenuBar(MenuBar target) {

        MenuBarPeer peer = new WMenuBarPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public MenuPeer createMenu(Menu target) {

        MenuPeer peer = new WMenuPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public PopupMenuPeer createPopupMenu(PopupMenu target) {

        PopupMenuPeer peer = new WPopupMenuPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public MenuItemPeer createMenuItem(MenuItem target) {

        MenuItemPeer peer = new WMenuItemPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public CheckboxMenuItemPeer createCheckboxMenuItem(CheckboxMenuItem target) {

        CheckboxMenuItemPeer peer = new WCheckboxMenuItemPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public RobotPeer createRobot(Robot target, GraphicsDevice screen) {

        // (target is unused for now)

        // Robot's don't need to go in the peer map since

        // they're not Component's

        return new WRobotPeer(screen);

    }

    public WEmbeddedFramePeer createEmbeddedFrame(WEmbeddedFrame target) {

        WEmbeddedFramePeer peer = new WEmbeddedFramePeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    WPrintDialogPeer createWPrintDialog(WPrintDialog target) {

        WPrintDialogPeer peer = new WPrintDialogPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    WPageDialogPeer createWPageDialog(WPageDialog target) {

        WPageDialogPeer peer = new WPageDialogPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public TrayIconPeer createTrayIcon(TrayIcon target) {

        WTrayIconPeer peer = new WTrayIconPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public SystemTrayPeer createSystemTray(SystemTray target) {

        return new WSystemTrayPeer(target);

    }

    public boolean isTraySupported() {

        return true;

    }

    public KeyboardFocusManagerPeer createKeyboardFocusManagerPeer(KeyboardFocusManager manager)

      throws HeadlessException

    {

        return new WKeyboardFocusManagerPeer(manager);

    }

    protected native void setDynamicLayoutNative(boolean b);

    public void setDynamicLayout(boolean b) {

        if (b == dynamicLayoutSetting) {

            return;

        }

        dynamicLayoutSetting = b;

        setDynamicLayoutNative(b);

    }

    protected boolean isDynamicLayoutSet() {

        return dynamicLayoutSetting;

    }

    /*

     * Called from lazilyLoadDynamicLayoutSupportedProperty because