/* java.beans.Beans
   Copyright (C) 1998, 1999 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.

As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */


package java.beans;

import java.io.*;
import java.applet.*;
import gnu.java.io.*;

/**
 * <code>Beans</code> provides some helper methods that allow the basic operations of Bean-ness.
 *
 * @author John Keiser
 * @since JDK1.1
 * @version 1.1.0, 29 Jul 1998
 *
 */
public class Beans {
	static boolean designTime = false;
	static boolean guiAvailable = true;


	/**
	 * Once again, we have a java.beans class with only
	 * static methods that can be instantiated.  When
	 * will the madness end? :)
	 */
	public Beans() {
	}

	/**
	 * Allows you to instantiate a Bean.  This method takes
	 * a ClassLoader from which to read the Bean and the
	 * name of the Bean.<P>
	 *
	 * The Bean name should be a dotted name, like a class.
	 * It can represent several things.  Beans will search
	 * for the Bean using the name like this:<P>
	 * <OL>
	 * <LI>Searches for a serialized instance of the Bean
	 * using getResource(), mangling the Bean name by
	 * replacing the dots with slashes and appending .ser
	 * (for example, gnu.beans.BlahDeBlah would cause
	 * Beans to search for gnu/beans/BlahDeBlah.ser using
	 * getResource()).</LI>
	 * <LI>Searches for the Bean class using the beanName,
	 * and then instantiates it with the no-arg constructor.
	 * At that point, if it is an Applet, it provides it
	 * with AppletContext and AppletStub, and then calls
	 * init().</LI>
	 * </OL>
	 * @param cl the ClassLoader to use, or <CODE>null</CODE>
	 *        to use the default ClassLoader.
	 * @param beanName the name of the Bean.
	 * @return the Bean.
	 * @XXX
	 */
	public static Object instantiate(ClassLoader cl, String beanName) throws IOException, ClassNotFoundException {
		Object bean;

		InputStream serStream;
		if(cl == null) {
			serStream = ClassLoader.getSystemResourceAsStream(beanName.replace('.','/')+".ser");
		} else {
			serStream = cl.getResourceAsStream(beanName.replace('.','/')+".ser");
		}
		if(serStream != null) {
			if(cl == null) {
				ObjectInputStream ois = new ObjectInputStream(serStream);
				bean = ois.readObject();
			} else {
				ClassLoaderObjectInputStream ois = new ClassLoaderObjectInputStream(serStream, cl);
				bean = ois.readObject();
			}
		} else if(cl == null) {
			Class beanClass = Class.forName(beanName);
			try {
				bean = beanClass.newInstance();
			} catch(IllegalAccessException E) {
				bean = null;
			} catch(InstantiationException E) {
				bean = null;
			}
		} else {
			Class beanClass = cl.loadClass(beanName);
			try {
				bean = beanClass.newInstance();
			} catch(IllegalAccessException E) {
				bean = null;
			} catch(InstantiationException E) {
				bean = null;
			}
		}

		if(bean instanceof Applet) {
			Applet a = (Applet)bean;
			//a.setAppletContext(???);
			//a.setStub(???);
			if(serStream == null) {
				a.init();
			}
		}

		return bean;
	}

	/**
	 * Get the Bean as a different class type.
	 * This should be used instead of casting to get a new
	 * type view of a Bean, because in the future there may
	 * be new types of Bean, even Beans spanning multiple
	 * Objects.
	 * @param bean the Bean to cast.
	 * @param newClass the Class to cast it to.
	 * @return the Bean as a new view, or if the operation
	 *         could not be performed, the Bean itself.
	 */
	public static Object getInstanceOf(Object bean, Class newClass) {
		return bean;
	}

	/**
	 * Determine whether the Bean can be cast to a different
	 * class type.
	 * This should be used instead of instanceof to determine
	 * a Bean's castability, because in the future there may
	 * be new types of Bean, even Beans spanning multiple
	 * Objects.
	 * @param bean the Bean to cast.
	 * @param newClass the Class to cast it to.
	 * @return whether the Bean can be cast to the class type
	 *         in question.
	 */
	public static boolean isInstanceOf(Object bean, Class newBeanClass) {
		return newBeanClass.isInstance(bean);
	}

	/**
	 * Find out whether the GUI is available to use.
	 * Defaults to true.
	 * @return whether the GUI is available to use.
	 */
	public static boolean isGuiAvailable() {
		return guiAvailable;
	}

	/**
	 * Find out whether it is design time.  Design time means
	 * we are in a RAD tool.
	 * Defaults to false.
	 * @return whether it is design time.
	 */
	public static boolean isDesignTime() {
		return designTime;
	}

	/**
	 * Set whether the GUI is available to use.
	 * @param guiAvailable whether the GUI is available to use.
	 */
	public static void setGuiAvailable(boolean guiAvailable) throws SecurityException {
		Beans.guiAvailable = guiAvailable;
	}

	/**
	 * Set whether it is design time.  Design time means we
	 * are in a RAD tool.
	 * @param designTime whether it is design time.
	 */
	public static void setDesignTime(boolean designTime) throws SecurityException {
		Beans.designTime = designTime;
	}
}