/*
* 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);
}
}
}