/*
 * Copyright (c) 2000 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 2nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book (recommended),
 * visit http://www.davidflanagan.com/javaexamples2.
 */
package com.davidflanagan.examples.gui;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.beans.*;
import java.lang.reflect.*;
import java.util.Vector;

/**
 * This class is a program that uses reflection and JavaBeans introspection to
 * create a set of named components, set named properties on those components,
 * and display them.  It allows the user to view the components using any
 * installed look-and-feel.  It is intended as a simple way to experiment with
 * AWT and Swing components, and to view a number of the other examples
 * developed in this chapter.  It also demonstrates frames, menus, and the
 * JTabbedPane component.
 **/
public class ShowComponent {
    // The main program
    public static void main(String[] args) {
	// Process the command line to get the components to display
	Vector components = getComponentsFromArgs(args);

	// Create a frame (a window) to display them in
	JFrame frame = new JFrame("ShowComponent");

	// Handle window close requests by exiting the VM
	frame.addWindowListener(new WindowAdapter() { // Anonymous inner class
		public void windowClosing(WindowEvent e) { System.exit(0); }
	    });
	
	// Set up a menu system that allows the user to select the 
	// look-and-feel of the component from a list of installed PLAFs
	JMenuBar menubar = new JMenuBar();      // Create a menubar
	frame.setJMenuBar(menubar);             // Tell the frame to display it
	JMenu plafmenu = createPlafMenu(frame); // Create a menu
	menubar.add(plafmenu);                  // Add the menu to the menubar

	// Create a JTabbedPane to display each of the components
	JTabbedPane pane = new JTabbedPane();

	// Now add each component as a tab of the tabbed pane
	// Use the unqualified component classname as the tab text
	for(int i = 0; i < components.size(); i++) {
	    Component c = (Component)components.elementAt(i);
	    String classname = c.getClass().getName();
	    String tabname = classname.substring(classname.lastIndexOf('.')+1);
	    pane.addTab(tabname, c);
	}

	// Add the tabbed pane to the frame.  Note the call to getContentPane()
	// This is required for JFrame, but not for most Swing components
	frame.getContentPane().add(pane);

	// Set the frame size and pop it up
	frame.pack();              // Make frame as big as its kids need 
	frame.setVisible(true);    // Make the frame visible on the screen

	// The main() method exits now but the Java VM keeps running because
	// all AWT programs automatically start an event-handling thread.
    }

    /**
     * This static method queries the system to find out what Pluggable
     * Look-and-Feel (PLAF) implementations are available.  Then it creates a
     * JMenu component that lists each of the implementations by name and
     * allows the user to select one of them using JRadioButtonMenuItem
     * components.  When the user selects one, the selected menu item
     * traverses the component hierarchy and tells all components to use the
     * new PLAF.
     **/
    public static JMenu createPlafMenu(final JFrame frame) {
	// Create the menu
	JMenu plafmenu = new JMenu("Look and Feel");

	// Create an object used for radio button mutual exclusion
	ButtonGroup radiogroup = new ButtonGroup();  

	// Look up the available look and feels
	UIManager.LookAndFeelInfo[] plafs =
	    UIManager.getInstalledLookAndFeels();

	// Loop through the plafs, and add a menu item for each one
	for(int i = 0; i < plafs.length; i++) {
	    String plafName = plafs[i].getName();
	    final String plafClassName = plafs[i].getClassName();

	    // Create the menu item
	    JMenuItem item = plafmenu.add(new JRadioButtonMenuItem(plafName));
	    
	    // Tell the menu item what to do when it is selected
	    item.addActionListener(new ActionListener() {
		    public void actionPerformed(ActionEvent e) {
			try {
			    // Set the new look and feel
			    UIManager.setLookAndFeel(plafClassName);
			    // Tell each component to change its look-and-feel
			    SwingUtilities.updateComponentTreeUI(frame);
			    // Tell the frame to resize itself to the its
			    // children's new desired sizes
			    frame.pack();
			}
			catch(Exception ex) { System.err.println(ex); }
		    }

		});

	    // Only allow one menu item to be selected at once
	    radiogroup.add(item);  
	}
	return plafmenu;
    }

    /**
     * This method loops through the command line arguments looking for
     * class names of components to create and property settings for those
     * components in the form name=value.  This method demonstrates 
     * reflection and JavaBeans introspection as they can be applied to
     * dynamically created GUIs
     **/
    public static Vector getComponentsFromArgs(String[] args) {
	Vector components = new Vector();       // List of components to return
	Component component = null;             // The current component 
	PropertyDescriptor[] properties = null; // Properties of the component
	Object[] methodArgs = new Object[1];    // We'll use this below

      nextarg:  // This is a labeled loop
	for(int i = 0; i < args.length; i++) {  // Loop through all arguments
	    // If the argument does not contain an equal sign, then it is
	    // a component class name.  Otherwise it is a property setting
	    int equalsPos = args[i].indexOf('=');
	    if (equalsPos == -1) {  // Its the name of a component
		try {
		    // Load the named component class
		    Class componentClass = Class.forName(args[i]);
		    // Instantiate it to create the component instance
		    component = (Component)componentClass.newInstance();
		    // Use JavaBeans to introspect the component
		    // And get the list of properties it supports
		    BeanInfo componentBeanInfo =
			Introspector.getBeanInfo(componentClass);
		    properties = componentBeanInfo.getPropertyDescriptors();
		}
		catch(Exception e) {  
		    // If any step failed, print an error and exit
		    System.out.println("Can't load, instantiate, " +
				       "or introspect: " + args[i]);
		    System.exit(1);
		}

		// If we succeeded, store the component in the vector
		components.addElement(component);
	    }
	    else { // The arg is a name=value property specification 
		String name =args[i].substring(0, equalsPos); // property name
		String value =args[i].substring(equalsPos+1); // property value

		// If we don't have a component to set this property on, skip!
		if (component == null) continue nextarg;

		// Now look through the properties descriptors for this
		// component to find one with the same name.
		for(int p = 0; p < properties.length; p++) {
		    if (properties[p].getName().equals(name)) {
			// Okay, we found a property of the right name.
			// Now get its type, and the setter method
			Class type = properties[p].getPropertyType();
			Method setter = properties[p].getWriteMethod();

			// Check if property is read-only!
			if (setter == null) {  
			    System.err.println("Property " + name+
					       " is read-only");
			    continue nextarg;  // continue with next argument
			}

			// Try to convert the property value to the right type
			// We support a small set of common property types here
			// Store the converted value in an Object[] so it can
			// be easily passed when we invoke the property setter
			try {
			    if (type == String.class) { // no conversion needed
				methodArgs[0] = value;   
			    }
			    else if (type == int.class) {     // String to int
				methodArgs[0] = Integer.valueOf(value);
			    }
			    else if (type == boolean.class) { // to boolean
				methodArgs[0] = Boolean.valueOf(value);
			    }
			    else if (type == Color.class) {   // to Color
				methodArgs[0] = Color.decode(value);
			    }
			    else if (type == Font.class) {    // String to Font
				methodArgs[0] = Font.decode(value);
			    }
			    else {
				// If we can't convert, ignore the property
				System.err.println("Property " + name + 
						   " is of unsupported type " +
						   type.getName());
				continue nextarg;
			    }
			}
			catch (Exception e) {
			    // If conversion failed, continue with the next arg
			    System.err.println("Can't convert  '" + value +
					       "' to type " + type.getName() +
					       " for property " + name);
			    continue nextarg;
			}

			// Finally, use reflection to invoke the property
			// setter method of the component we created, and pass
			// in the converted property value.
			try { setter.invoke(component, methodArgs); }
			catch (Exception e) {
			    System.err.println("Can't set property: " + name);
			}

			// Now go on to next command-line arg
			continue nextarg;  
		    }
		}

		// If we get here, we didn't find the named property
		System.err.println("Warning: No such property: " + name);
	    }
	}

	return components;
    }
}