home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / UIManager.java < prev    next >
Text File  |  1998-02-26  |  22KB  |  661 lines
  1. /*
  2.  * @(#)UIManager.java    1.54 98/02/23
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not disclose
  8.  * such Confidential Information and shall use it only in accordance with the
  9.  * terms of the license agreement you entered into with Sun.
  10.  * 
  11.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  12.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  13.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
  14.  * OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY
  15.  * LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR
  16.  * ITS DERIVATIVES.
  17.  * 
  18.  */
  19. package com.sun.java.swing;
  20.  
  21. import java.awt.Container;
  22. import java.awt.Window;
  23. import java.awt.Font;
  24. import java.awt.Color;
  25.  
  26. import com.sun.java.swing.plaf.ComponentUI;
  27. import com.sun.java.swing.border.Border;
  28.  
  29. import java.beans.PropertyChangeSupport;
  30. import java.beans.PropertyChangeListener;
  31. import java.beans.PropertyChangeEvent;
  32.  
  33. import java.io.FileOutputStream;
  34. import java.io.IOException;
  35. import java.io.ObjectOutputStream;
  36. import java.io.ObjectInputStream;
  37. import java.io.Serializable;
  38. import java.io.File;
  39. import java.io.FileInputStream;
  40. import java.io.BufferedInputStream;
  41.  
  42. import java.util.Enumeration;
  43. import java.util.Hashtable;
  44. import java.util.Properties;
  45. import java.util.StringTokenizer;
  46. import java.util.Vector;
  47.  
  48.  
  49. /**
  50.  * This class keeps track of the current look and feel and its
  51.  * defaults.
  52.  * <p>
  53.  * We manage three levels of defaults: user defaults, look
  54.  * and feel defaults, system defaults.  A call to UIManager.get()
  55.  * checks all three levels in order and returns the first non-null 
  56.  * value for a key, if any.  A call to UIManager.put() just
  57.  * affects the user defaults.  Note that a call to 
  58.  * setLookAndFeel() doesn't affect the user defaults, it just
  59.  * replaces the middle defaults "level".
  60.  * <p>
  61.  * Warning: serialized objects of this class will not be compatible with
  62.  * future swing releases.  The current serialization support is appropriate 
  63.  * for short term storage or RMI between Swing1.0 applications.  It will
  64.  * not be possible to load serialized Swing1.0 objects with future releases
  65.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  66.  * baseline for the serialized form of Swing objects.
  67.  *
  68.  * @version 1.54 02/23/98
  69.  * @author Thomas Ball
  70.  * @author Hans Muller
  71.  */
  72. public class UIManager implements Serializable 
  73. {
  74.     /**
  75.      * This class defines the state managed by the UIManager.  For 
  76.      * Swing applications the fields in this class could just as well
  77.      * be static members of UIManager however we give them "AppContext"
  78.      * scope instead so that applets (and potentially multiple lightweight
  79.      * applications running in a single VM) have their own state. For 
  80.      * example an applet can it's look and feel, see setLookAndFeel().
  81.      * Doing so has no affect on other applets (or the browser).
  82.      */
  83.     private static class LAFState 
  84.     {
  85.     private UIDefaults[] tables = new UIDefaults[2];
  86.  
  87.     boolean initialized = false;
  88.     MultiUIDefaults multiUIDefaults = new MultiUIDefaults(tables);
  89.     LookAndFeel lookAndFeel;
  90.     LookAndFeel multiLookAndFeel = null;
  91.     Vector auxLookAndFeels = null;
  92.     PropertyChangeSupport changeSupport = new PropertyChangeSupport(UIManager.class);
  93.  
  94.     UIDefaults getLookAndFeelDefaults() { return tables[0]; }
  95.     void setLookAndFeelDefaults(UIDefaults x) { tables[0] = x; }
  96.  
  97.     UIDefaults getSystemDefaults() { return tables[1]; }
  98.     void setSystemDefaults(UIDefaults x) { tables[1] = x; }
  99.     }
  100.  
  101.  
  102.     /**
  103.      * The AppContext key for our one LAFState instance.
  104.      */
  105.     private static final Object lafStateACKey = new StringBuffer("LookAndFeel State");
  106.  
  107.  
  108.     /**
  109.      * Return the LAFState object, lazily create one if neccessary.  All access
  110.      * to the LAFState fields is done via this method, e.g.:
  111.      * <pre>
  112.      *     getLAFState().initialized = true;
  113.      * </pre>
  114.      */
  115.     private static LAFState getLAFState() {
  116.     LAFState rv = (LAFState)SwingUtilities.appContextGet(lafStateACKey);
  117.     if (rv != null) {
  118.         return rv;
  119.     }
  120.     synchronized(UIManager.class) {
  121.         rv = (LAFState)SwingUtilities.appContextGet(lafStateACKey);
  122.         if (rv != null) {
  123.         return rv;
  124.         }
  125.         SwingUtilities.appContextPut(lafStateACKey, (rv = new LAFState()));
  126.         return rv;
  127.     }
  128.     }
  129.  
  130.  
  131.     /* Keys used for the properties file in <java.home>/lib/swing.properties.
  132.      * See loadUserProperties(), initialize().
  133.      */
  134.  
  135.     private static final String defaultLAFKey = "swing.defaultlaf";
  136.     private static final String auxiliaryLAFsKey = "swing.auxiliarylaf";
  137.     private static final String multiplexingLAFKey = "swing.plaf.multiplexinglaf";
  138.     private static final String installedLAFsKey = "swing.installedlafs";
  139.  
  140.     /**
  141.      * Return a swing.properties file key for the attribute of specified 
  142.      * look and feel.  The attr is either "name" or "class", a typical
  143.      * key would be: "swing.installedlaf.windows.name"
  144.      */
  145.     private static String makeInstalledLAFKey(String laf, String attr) {
  146.         return "swing.installedlaf." + laf + "." + attr;
  147.     }
  148.  
  149.     /**
  150.      * The filename for swing.properties is a path like this (Unix version):
  151.      * <java.home>/lib/swing.properties.  This method returns a bogus
  152.      * filename if java.home isn't defined.  
  153.      */
  154.     private static String makeSwingPropertiesFilename() {
  155.         String sep = File.separator;
  156.         String homeDir = System.getProperty("java.home", "<java.home undefined>");
  157.         return homeDir + sep + "lib" + sep + "swing.properties";
  158.     }
  159.  
  160.  
  161.     /** 
  162.      * Provide a little information about an installed LookAndFeel
  163.      * for the sake of configuring a menu or for initial application 
  164.      * set up.
  165.      * 
  166.      * @see #getInstalledLookAndFeels
  167.      * @see LookAndFeel
  168.      */
  169.     public static class LookAndFeelInfo {
  170.         private String name;
  171.         private String className;
  172.  
  173.         public LookAndFeelInfo(String name, String className) {
  174.             this.name = name;
  175.             this.className = className;
  176.         }
  177.  
  178.         /**
  179.          * @return a name suitable for a menu or other presentation
  180.          * @see LookAndFeel#getName
  181.          */
  182.         public String getName() {
  183.             return name;
  184.         }
  185.  
  186.         /**
  187.          * @return the name of the class that implements this LookAndFeel.
  188.          * @see LookAndFeel
  189.          */
  190.         public String getClassName() {
  191.             return className;
  192.         }
  193.  
  194.         public String toString() {
  195.             return getClass().getName() + "[" + getName() + " " + getClassName() + "]";
  196.         }
  197.     }
  198.  
  199.  
  200.     /**
  201.      * The default value of installedLAFS is used when no swing.properties
  202.      * file is available or if the file doesn't contain a "swing.installedlafs"
  203.      * property.   
  204.      * 
  205.      * @see #initializeInstalledLAFs
  206.      */
  207.     private static LookAndFeelInfo[] installedLAFs = {
  208.         new LookAndFeelInfo("Metal", "com.sun.java.swing.plaf.metal.MetalLookAndFeel"),
  209.         new LookAndFeelInfo("CDE/Motif", "com.sun.java.swing.plaf.motif.MotifLookAndFeel"),
  210.         new LookAndFeelInfo("Windows", "com.sun.java.swing.plaf.windows.WindowsLookAndFeel")
  211.     };
  212.  
  213.  
  214.     /** 
  215.      * Return an array of objects that provide some information about the
  216.      * LookAndFeel implementations that have been installed with this 
  217.      * java development kit.  The LookAndFeel info objects can be used
  218.      * by an application to construct a menu of look and feel options for 
  219.      * the user or to set the look and feel at start up time.  Note that 
  220.      * we do not return the LookAndFeel classes themselves here to avoid the
  221.      * cost of unnecessarily loading them.
  222.      * <p>
  223.      * Given a LookAndFeelInfo object one can set the current look and feel
  224.      * like this:
  225.      * <pre>
  226.      * UIManager.setLookAndFeel(info.getClassName());
  227.      * </pre>
  228.      * 
  229.      * @see #setLookAndFeel
  230.      */
  231.     public static LookAndFeelInfo[] getInstalledLookAndFeels() {
  232.         maybeInitialize();
  233.         LookAndFeelInfo[] ilafs = installedLAFs;
  234.         LookAndFeelInfo[] rv = new LookAndFeelInfo[ilafs.length];
  235.         System.arraycopy(ilafs, 0, rv, 0, ilafs.length);
  236.         return rv;
  237.     }
  238.  
  239.  
  240.     /**
  241.      * Replaces the current array of installed LookAndFeelInfos.
  242.      * 
  243.      * @see #getInstalledLookAndFeels
  244.      */
  245.     public static void setInstalledLookAndFeels(LookAndFeelInfo[] infos)
  246.         throws SecurityException
  247.     {
  248.         LookAndFeelInfo[] newInfos = new LookAndFeelInfo[infos.length];
  249.         System.arraycopy(infos, 0, newInfos, 0, infos.length);
  250.         installedLAFs = newInfos;
  251.     }
  252.  
  253.  
  254.     /**
  255.      * Adds the specified look and feel to the current array and
  256.      * then calls setInstalledLookAndFeels.
  257.      * 
  258.      * @see #setInstalledLookAndFeels
  259.      */
  260.     public static void installLookAndFeel(LookAndFeelInfo info) {
  261.         LookAndFeelInfo[] infos = getInstalledLookAndFeels();
  262.         LookAndFeelInfo[] newInfos = new LookAndFeelInfo[infos.length + 1];
  263.         System.arraycopy(infos, 0, newInfos, 0, infos.length);
  264.         newInfos[infos.length] = info;
  265.         setInstalledLookAndFeels(newInfos);
  266.     }
  267.  
  268.  
  269.     public static void installLookAndFeel(String name, String className) {
  270.         installLookAndFeel(new LookAndFeelInfo(name, className));
  271.     }
  272.  
  273.  
  274.     /**
  275.      * Returns The current default look and feel, or null.
  276.      *
  277.      * @return The current default look and feel, or null.
  278.      * @see #setLookAndFeel
  279.      */
  280.     public static LookAndFeel getLookAndFeel() {
  281.         maybeInitialize();
  282.         return getLAFState().lookAndFeel;
  283.     }
  284.     
  285.  
  286.     /**
  287.      * Set the current default look and feel.  
  288.      * <p>
  289.      * This is a JavaBeans bound property.
  290.      * 
  291.      * @exception UnsupportedLookAndFeelException If <code>lnf.isSupportedLookAndFeel()</code> is false.
  292.      * @see #getLookAndFeel
  293.      */
  294.     public static void setLookAndFeel(LookAndFeel newLookAndFeel) 
  295.         throws UnsupportedLookAndFeelException 
  296.     {
  297.         if ((newLookAndFeel != null) && !newLookAndFeel.isSupportedLookAndFeel()) {
  298.             String s = newLookAndFeel.toString() + " not supported on this platform";
  299.             throw new UnsupportedLookAndFeelException(s);
  300.         }
  301.  
  302.     LookAndFeel oldLookAndFeel = getLAFState().lookAndFeel;
  303.         if (oldLookAndFeel != null) {
  304.             oldLookAndFeel.uninitialize();
  305.         }
  306.  
  307.     getLAFState().lookAndFeel = newLookAndFeel;
  308.         if (newLookAndFeel != null) {
  309.             newLookAndFeel.initialize();
  310.         getLAFState().setLookAndFeelDefaults(newLookAndFeel.getDefaults());
  311.         }
  312.         else {
  313.         getLAFState().setLookAndFeelDefaults(null);
  314.         }
  315.  
  316.         getLAFState().changeSupport.firePropertyChange("lookAndFeel", oldLookAndFeel, newLookAndFeel);
  317.     }
  318.  
  319.     
  320.     /**
  321.      * @exception ClassNotFoundException If the LookAndFeel class could not be found.
  322.      * @exception InstantiationException If a new instance of the class couldn't be creatd.
  323.      * @exception IllegalAccessException If the class or initializer isn't accessible. 
  324.      * @exception UnsupportedLookAndFeelException If <code>lnf.isSupportedLookAndFeel()</code> is false.
  325.      */
  326.     public static void setLookAndFeel(String className) 
  327.         throws ClassNotFoundException, 
  328.                InstantiationException, 
  329.                IllegalAccessException,
  330.                UnsupportedLookAndFeelException 
  331.     {
  332.         Class lnfClass = Class.forName(className);
  333.         setLookAndFeel((LookAndFeel)(lnfClass.newInstance()));
  334.     }
  335.  
  336.  
  337.     /**
  338.      * Returns the name of the LookAndFeel class that implements
  339.      * the native systems look and feel if there is one,
  340.      * otherwise the name of the default cross platform LookAndFeel
  341.      * class.
  342.      * 
  343.      * @see #setLookAndFeel()
  344.      * @see #getCrossPlatformLookAndFeelClassName
  345.      */
  346.     public static String getSystemLookAndFeelClassName() {
  347.         String osName = System.getProperty("os.name");
  348.         if (osName != null) {
  349.         if (osName.indexOf("Windows") != -1) {
  350.         return "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
  351.         }
  352.         else if (osName.indexOf("Solaris") != -1) {
  353.         return "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
  354.         }
  355.         }
  356.     return getCrossPlatformLookAndFeelClassName();
  357.     }
  358.  
  359.  
  360.     /**
  361.      * Returns the name of the LookAndFeel class that implements
  362.      * the default cross platform look and feel, i.e. the "metal"
  363.      * look and feel.
  364.      * 
  365.      * @return "com.sun.java.swing.plaf.metal.MetalLookAndFeel"
  366.      * @see #setLookAndFeel()
  367.      * @see #getSystemLookAndFeelClassName
  368.      */
  369.     public static String getCrossPlatformLookAndFeelClassName() {
  370.     return "com.sun.java.swing.plaf.metal.MetalLookAndFeel";
  371.     }
  372.  
  373.  
  374.     public static UIDefaults getDefaults() {
  375.         maybeInitialize();
  376.     return getLAFState().multiUIDefaults;
  377.     }
  378.     
  379.     public static Font getFont(Object key) { 
  380.         return getDefaults().getFont(key); 
  381.     }
  382.  
  383.     public static Color getColor(Object key) { 
  384.         return getDefaults().getColor(key); 
  385.     }
  386.  
  387.     public static Icon getIcon(Object key) { 
  388.         return getDefaults().getIcon(key); 
  389.     }
  390.  
  391.     public static Border getBorder(Object key) { 
  392.         return getDefaults().getBorder(key); 
  393.     }
  394.  
  395.     public static String getString(Object key) { 
  396.         return getDefaults().getString(key); 
  397.     }
  398.  
  399.     public static Object get(Object key) { 
  400.         return getDefaults().get(key); 
  401.     }
  402.  
  403.     public static Object put(Object key, Object value) { 
  404.         return getDefaults().put(key, value); 
  405.     }
  406.  
  407.     public static ComponentUI getUI(JComponent target) {
  408.         maybeInitialize();
  409.         ComponentUI ui = null;
  410.         LookAndFeel multiLAF = getLAFState().multiLookAndFeel;
  411.         if (multiLAF != null) {
  412.         // This can return null if the multiplexing look and feel
  413.         // doesn't support a particular UI.
  414.         ui = multiLAF.getDefaults().getUI(target);
  415.         }
  416.         if (ui == null) {
  417.             ui = getDefaults().getUI(target);
  418.         }
  419.         return ui;
  420.     }
  421.  
  422.  
  423.     public static UIDefaults getLookAndFeelDefaults() {
  424.         maybeInitialize();
  425.     return getLAFState().getLookAndFeelDefaults();
  426.     }
  427.  
  428.  
  429.     /**
  430.      * Return the list of auxiliary look and feels (can be null).  The
  431.      * auxiliary look and feels tell the multiplexing look and feel what
  432.      * other LookAndFeel classes for a component instance are to be used 
  433.      * in addition to the default LookAndFeel class when creating a 
  434.      * multiplexing UI.  
  435.      * <p>Note these are not the same as the installed look and feels.
  436.      * @see #getInstalledLookAndFeels
  437.      */
  438.     static public LookAndFeel[] getAuxiliaryLookAndFeels() 
  439.     {
  440.         maybeInitialize();
  441.  
  442.     Vector v = getLAFState().auxLookAndFeels;
  443.     if ((v == null) || (v.size() == 0)) {
  444.         return null;
  445.     } 
  446.     else {
  447.         LookAndFeel[] rv = new LookAndFeel[v.size()];
  448.         for (int i = 0; i < rv.length; i++) {
  449.         rv[i] = (LookAndFeel)v.elementAt(i);
  450.         }
  451.         return rv;
  452.     }
  453.     }
  454.  
  455.  
  456.     /**
  457.      * Add a PropertyChangeListener to the listener list.
  458.      * The listener is registered for all properties.
  459.      *
  460.      * @param listener  The PropertyChangeListener to be added
  461.      * @see java.beans.PropertyChangeSupport
  462.      */
  463.     public synchronized static void addPropertyChangeListener(PropertyChangeListener listener) 
  464.     {
  465.         getLAFState().changeSupport.addPropertyChangeListener(listener);
  466.     }
  467.  
  468.  
  469.     /**
  470.      * Remove a PropertyChangeListener from the listener list.
  471.      * This removes a PropertyChangeListener that was registered
  472.      * for all properties.
  473.      *
  474.      * @param listener  The PropertyChangeListener to be removed
  475.      * @see java.beans.PropertyChangeSupport
  476.      */
  477.     public synchronized static void removePropertyChangeListener(PropertyChangeListener listener) 
  478.     {
  479.     getLAFState().changeSupport.removePropertyChangeListener(listener);
  480.     }
  481.  
  482.  
  483.     private static Properties loadSwingProperties()
  484.     {
  485.         Properties properties = new Properties();
  486.  
  487.         if (UIManager.class.getClassLoader() == null) {
  488.             String sep = File.separator;
  489.             try {
  490.                 File propertiesFile = new File(makeSwingPropertiesFilename());
  491.                 BufferedInputStream ins = new BufferedInputStream(
  492.                     new FileInputStream(propertiesFile));
  493.                 properties.load(ins);
  494.                 ins.close();
  495.             } 
  496.             catch (Exception e) {
  497.                 properties.clear();
  498.             }
  499.         }
  500.  
  501.         return properties;
  502.     }
  503.  
  504.  
  505.     /**
  506.      * If a swing.properties file exist and it has a swing.installedlafs property
  507.      * then initialize the installedLAFs field.
  508.      * 
  509.      * @see #getInstalledLookAndFeels
  510.      */
  511.     private static void initializeInstalledLAFs(Properties swingProps) 
  512.     {
  513.         String ilafsString = swingProps.getProperty(installedLAFsKey);
  514.         if (ilafsString == null) {
  515.             return;
  516.         }
  517.  
  518.         /* Create a vector that contains the value of the swing.installedlafs
  519.          * property.  For example given "swing.installedlafs=motif,windows"
  520.          * lafs = {"motif", "windows"}.
  521.          */
  522.         Vector lafs = new Vector();
  523.         StringTokenizer st = new StringTokenizer(ilafsString, ",", false);
  524.         while (st.hasMoreTokens()) {
  525.             lafs.addElement(st.nextToken());
  526.         }
  527.  
  528.         /* Look up the name and class for each name in the "swing.installedlafs"
  529.          * list.  If they both exist then add a LookAndFeelInfo to 
  530.          * the installedLafs array.
  531.          */
  532.         Vector ilafs = new Vector(lafs.size());
  533.         for(int i = 0; i < lafs.size(); i++) {
  534.             String laf = (String)lafs.elementAt(i);
  535.             String name = swingProps.getProperty(makeInstalledLAFKey(laf, "name"), laf);
  536.             String cls = swingProps.getProperty(makeInstalledLAFKey(laf, "class"));
  537.             if (cls != null) {
  538.                 ilafs.addElement(new LookAndFeelInfo(name, cls));
  539.             }
  540.         }
  541.  
  542.         installedLAFs = new LookAndFeelInfo[ilafs.size()];
  543.         for(int i = 0; i < ilafs.size(); i++) {
  544.             installedLAFs[i] = (LookAndFeelInfo)(ilafs.elementAt(i));
  545.         }
  546.     }
  547.  
  548.  
  549.     /**
  550.      * If the user has specified a default look and feel, use that.  
  551.      * Otherwise use the look and feel that's native to this platform.
  552.      * If this code is called after the application has expclicitly
  553.      * set it's look and feel, do nothing.
  554.      *
  555.      * @see #maybeInitialize
  556.      */
  557.     private static void initializeDefaultLAF(Properties swingProps)
  558.     {
  559.         if (getLAFState().lookAndFeel != null) {
  560.             return;
  561.         }
  562.  
  563.         String metalLnf = getCrossPlatformLookAndFeelClassName();
  564.         String lnfDefault = metalLnf;
  565.  
  566.         String lnfName = "<undefined>" ;
  567.         try {
  568.             lnfName = swingProps.getProperty(defaultLAFKey, lnfDefault);
  569.             Class lnfClass = Class.forName(lnfName);
  570.             setLookAndFeel((LookAndFeel)(lnfClass.newInstance()));
  571.         } catch (Exception e) {
  572.             try {
  573.                 lnfName = swingProps.getProperty(defaultLAFKey, metalLnf);
  574.                 Class lnfClass = Class.forName(lnfName);
  575.                 setLookAndFeel((LookAndFeel)(lnfClass.newInstance()));
  576.             } catch (Exception e2) {
  577.                 throw new Error("can't load " + lnfName);
  578.             }
  579.         }
  580.     }
  581.  
  582.  
  583.     private static void initializeAuxiliaryLAFs(Properties swingProps)
  584.     {
  585.         String auxLookAndFeelNames = swingProps.getProperty(auxiliaryLAFsKey);
  586.         if (auxLookAndFeelNames == null) {
  587.             return;
  588.         }
  589.  
  590.         Vector auxLookAndFeels = new Vector();
  591.  
  592.         StringTokenizer p = new StringTokenizer(auxLookAndFeelNames,",");
  593.         String factoryName;
  594.  
  595.         /* Try to load each LookAndFeel subclass in the list.
  596.          */
  597.  
  598.         while (p.hasMoreTokens()) {
  599.             String className = p.nextToken();
  600.             try {
  601.                 Class lnfClass = Class.forName(className);
  602.                 auxLookAndFeels.addElement(lnfClass.newInstance());
  603.             } 
  604.             catch (Exception e) {
  605.                 System.err.println("UIManager: failed loading auxiliary look and feel " + className);
  606.             }
  607.         }
  608.  
  609.         /* If there were problems and no auxiliary look and feels were 
  610.          * loaded, make sure we reset auxLookAndFeels to null.
  611.          * Otherwise, we are going to use the MultiLookAndFeel to get
  612.          * all component UI's, so we need to load it now.
  613.          */
  614.  
  615.         if (auxLookAndFeels.size() == 0) {
  616.             auxLookAndFeels = null;
  617.         } 
  618.         else {
  619.             String defaultName = "com.sun.java.swing.plaf.multi.MultiLookAndFeel";
  620.             String className = swingProps.getProperty(multiplexingLAFKey, defaultName);
  621.             try {
  622.                 Class lnfClass = Class.forName(className);
  623.                 getLAFState().multiLookAndFeel = (LookAndFeel)lnfClass.newInstance();
  624.             } 
  625.             catch (Exception exc) {
  626.                 System.err.println("UIManager: failed loading " + className);
  627.                 auxLookAndFeels = null;
  628.             }
  629.         }
  630.  
  631.     getLAFState().auxLookAndFeels = auxLookAndFeels;
  632.     }
  633.  
  634.  
  635.     private static void initializeSystemDefaults(Properties swingProps)
  636.     {
  637.         Object defaults[] = {
  638.             "FocusManagerClassName", "com.sun.java.swing.DefaultFocusManager"
  639.         };
  640.         getLAFState().setSystemDefaults(new UIDefaults(defaults));
  641.     }
  642.  
  643.  
  644.     private static void initialize()
  645.     {
  646.         Properties swingProps = loadSwingProperties();
  647.         initializeSystemDefaults(swingProps);
  648.         initializeDefaultLAF(swingProps);
  649.         initializeAuxiliaryLAFs(swingProps);
  650.         initializeInstalledLAFs(swingProps);
  651.     }
  652.  
  653.  
  654.     synchronized private static void maybeInitialize() {
  655.     if (!getLAFState().initialized) {
  656.         initialize();
  657.         getLAFState().initialized = true;
  658.     }
  659.     }
  660. }
  661.