feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/com/sun/java/swing/plaf/windows/DesktopProperty.java

@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) 2001, 2009, 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 com.sun.java.swing.plaf.windows;
+
+import java.awt.*;
+import java.beans.*;
+import java.lang.ref.*;
+import javax.swing.*;
+import javax.swing.plaf.*;
+
+/**
+ * Wrapper for a value from the desktop. The value is lazily looked up, and
+ * can be accessed using the <code>UIManager.ActiveValue</code> method
+ * <code>createValue</code>. If the underlying desktop property changes this
+ * will force the UIs to update all known Frames. You can invoke
+ * <code>invalidate</code> to force the value to be fetched again.
+ *
+ */
+// NOTE: Don't rely on this class staying in this location. It is likely
+// to move to a different package in the future.
+public class DesktopProperty implements UIDefaults.ActiveValue {
+    /**
+     * Indicates if an updateUI call is pending.
+     */
+    private static boolean updatePending;
+
+    /**
+     * ReferenceQueue of unreferenced WeakPCLs.
+     */
+    private static final ReferenceQueue<DesktopProperty> queue = new ReferenceQueue<DesktopProperty>();
+
+    /**
+     * PropertyChangeListener attached to the Toolkit.
+     */
+    private WeakPCL pcl;
+    /**
+     * Key used to lookup value from desktop.
+     */
+    private final String key;
+    /**
+     * Value to return.
+     */
+    private Object value;
+    /**
+     * Fallback value in case we get null from desktop.
+     */
+    private final Object fallback;
+
+
+    /**
+     * Cleans up any lingering state held by unrefeernced
+     * DesktopProperties.
+     */
+    static void flushUnreferencedProperties() {
+        WeakPCL pcl;
+
+        while ((pcl = (WeakPCL)queue.poll()) != null) {
+            pcl.dispose();
+        }
+    }
+
+
+    /**
+     * Sets whether or not an updateUI call is pending.
+     */
+    private static synchronized void setUpdatePending(boolean update) {
+        updatePending = update;
+    }
+
+    /**
+     * Returns true if a UI update is pending.
+     */
+    private static synchronized boolean isUpdatePending() {
+        return updatePending;
+    }
+
+    /**
+     * Updates the UIs of all the known Frames.
+     */
+    private static void updateAllUIs() {
+        // Check if the current UI is WindowsLookAndfeel and flush the XP style map.
+        // Note: Change the package test if this class is moved to a different package.
+        Class uiClass = UIManager.getLookAndFeel().getClass();
+        if (uiClass.getPackage().equals(DesktopProperty.class.getPackage())) {
+            XPStyle.invalidateStyle();
+        }
+        Frame appFrames[] = Frame.getFrames();
+        for (Frame appFrame : appFrames) {
+            updateWindowUI(appFrame);
+        }
+    }
+
+    /**
+     * Updates the UI of the passed in window and all its children.
+     */
+    private static void updateWindowUI(Window window) {
+        SwingUtilities.updateComponentTreeUI(window);
+        Window ownedWins[] = window.getOwnedWindows();
+        for (Window ownedWin : ownedWins) {
+            updateWindowUI(ownedWin);
+        }
+    }
+
+
+    /**
+     * Creates a DesktopProperty.
+     *
+     * @param key Key used in looking up desktop value.
+     * @param fallback Value used if desktop property is null.
+     */
+    public DesktopProperty(String key, Object fallback) {
+        this.key = key;
+        this.fallback = fallback;
+        // The only sure fire way to clear our references is to create a
+        // Thread and wait for a reference to be added to the queue.
+        // Because it is so rare that you will actually change the look
+        // and feel, this stepped is forgoed and a middle ground of
+        // flushing references from the constructor is instead done.
+        // The implication is that once one DesktopProperty is created
+        // there will most likely be n (number of DesktopProperties created
+        // by the LookAndFeel) WeakPCLs around, but this number will not
+        // grow past n.
+        flushUnreferencedProperties();
+    }
+
+    /**
+     * UIManager.LazyValue method, returns the value from the desktop
+     * or the fallback value if the desktop value is null.
+     */
+    public Object createValue(UIDefaults table) {
+        if (value == null) {
+            value = configureValue(getValueFromDesktop());
+            if (value == null) {
+                value = configureValue(getDefaultValue());
+            }
+        }
+        return value;
+    }
+
+    /**
+     * Returns the value from the desktop.
+     */
+    protected Object getValueFromDesktop() {
+        Toolkit toolkit = Toolkit.getDefaultToolkit();
+
+        if (pcl == null) {
+            pcl = new WeakPCL(this, getKey(), UIManager.getLookAndFeel());
+            toolkit.addPropertyChangeListener(getKey(), pcl);
+        }
+
+        return toolkit.getDesktopProperty(getKey());
+    }
+
+    /**
+     * Returns the value to use if the desktop property is null.
+     */
+    protected Object getDefaultValue() {
+        return fallback;
+    }
+
+    /**
+     * Invalidates the current value.
+     *
+     * @param laf the LookAndFeel this DesktopProperty was created with
+     */
+    public void invalidate(LookAndFeel laf) {
+        invalidate();
+    }
+
+    /**
+     * Invalides the current value so that the next invocation of
+     * <code>createValue</code> will ask for the property again.
+     */
+    public void invalidate() {
+        value = null;
+    }
+
+    /**
+     * Requests that all components in the GUI hierarchy be updated
+     * to reflect dynamic changes in this look&feel.  This update occurs
+     * by uninstalling and re-installing the UI objects. Requests are
+     * batched and collapsed into a single update pass because often
+     * many desktop properties will change at once.
+     */
+    protected void updateUI() {
+        if (!isUpdatePending()) {
+            setUpdatePending(true);
+            Runnable uiUpdater = new Runnable() {
+                public void run() {
+                    updateAllUIs();
+                    setUpdatePending(false);
+                }
+            };
+            SwingUtilities.invokeLater(uiUpdater);
+        }
+    }
+
+    /**
+     * Configures the value as appropriate for a defaults property in
+     * the UIDefaults table.
+     */
+    protected Object configureValue(Object value) {
+        if (value != null) {
+            if (value instanceof Color) {
+                return new ColorUIResource((Color)value);
+            }
+            else if (value instanceof Font) {
+                return new FontUIResource((Font)value);
+            }
+            else if (value instanceof UIDefaults.LazyValue) {
+                value = ((UIDefaults.LazyValue)value).createValue(null);
+            }
+            else if (value instanceof UIDefaults.ActiveValue) {
+                value = ((UIDefaults.ActiveValue)value).createValue(null);
+            }
+        }
+        return value;
+    }
+
+    /**
+     * Returns the key used to lookup the desktop properties value.
+     */
+    protected String getKey() {
+        return key;
+    }
+
+
+
+    /**
+     * As there is typically only one Toolkit, the PropertyChangeListener
+     * is handled via a WeakReference so as not to pin down the
+     * DesktopProperty.
+     */
+    private static class WeakPCL extends WeakReference<DesktopProperty>
+                               implements PropertyChangeListener {
+        private String key;
+        private LookAndFeel laf;
+
+        WeakPCL(DesktopProperty target, String key, LookAndFeel laf) {
+            super(target, queue);
+            this.key = key;
+            this.laf = laf;
+        }
+
+        public void propertyChange(PropertyChangeEvent pce) {
+            DesktopProperty property = get();
+
+            if (property == null || laf != UIManager.getLookAndFeel()) {
+                // The property was GC'ed, we're no longer interested in
+                // PropertyChanges, remove the listener.
+                dispose();
+            }
+            else {
+                property.invalidate(laf);
+                property.updateUI();
+            }
+        }
+
+        void dispose() {
+            Toolkit.getDefaultToolkit().removePropertyChangeListener(key, this);
+        }
+    }
+}