View Javadoc
   /*
    * (C) 2002 David Carr  david@carr.name
    *
    * This program 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 of the License, or
    * (at your option) any later version.
    *
    * This program 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 this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package net.sourceforge.mflow.impl;
  
  import java.lang.reflect.InvocationTargetException;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.logging.Logger;
  
  import javax.swing.Icon;
  import javax.swing.JDialog;
  
  import net.sourceforge.mflow.api.Plugin;
  import net.sourceforge.mflow.api.PluginManager;
  import net.sourceforge.mflow.reflect.ParamArgPair;
  import net.sourceforge.mflow.reflect.ReflectionException;
  import net.sourceforge.mflow.reflect.ReflectionUtil;
  
  /***
   * @author carrd
   */
  class PluginImpl implements Plugin {
    private static final Logger log =
      Logger.getLogger(PluginImpl.class.getName());
    private PluginManager pluginManager;
    private String className;
    private String name;
    private String type;
    private String description;
    private String version;
    private Object plugin;
    private Icon icon;
    private JDialog dialog;
  
    PluginImpl(
      PluginManager pluginManager,
      String className,
      String name,
      String type,
      String description,
      String version,
      Icon icon,
      JDialog dialog) {
      this.pluginManager = pluginManager;
      this.className = className;
      this.name = name;
      this.type = type;
      this.description = description;
      this.version = version;
      this.icon = icon;
      this.dialog = dialog;
    }
  
    /***
     * Get the version number for this plugin.
     * 
     * @return The version number.
     */
    public String getVersion() {
      return this.version;
    }
  
    /***
     * Get the class name for this plugin.
     * 
     * @return The class name.
     */
  
    public String getClassName() {
      return this.className;
    }
  
    /***
     * Get the name of this plugin.
     * 
     * @return The name.
     */
  
    public String getName() {
      return this.name;
    }
  
    /***
    * Get the type of this plugin.
    * 
    * @return The type.
    */
 
   public String getType() {
     return this.type;
   }
 
   /***
    * Get the description of this plugin.
    * 
    * @return The description, or <b>null</b> if no description is available.
    */
   public String getDescription() {
     return this.description;
   }
 
   /***
    * Get the icon for this plugin.
    * 
    * @return The icon, or <b>null</b> if no icon is available.
    */
 
   public Icon getIcon() {
     return this.icon;
   }
 
   /***
    * Load the plugin. This method attempts to load the plugin entry-point class
    * and create an instance of it. The entry-point class must have a public
    * constructor that accepts a <code>Plugin</code> object as an argument; it
    * will be invoked with a reference to this plugin.
    * 
    * @throws InvocationTargetException If the plugin could not be loaded.
    */
   public void load() throws InvocationTargetException {
     if (this.plugin != null) {
       return;
     }
     Class[] paramType = new Class[] { PluginManager.class };
     Object[] arg = new Object[] { this.pluginManager };
     List sigs = new ArrayList();
     ParamArgPair pair = new ParamArgPair(paramType, arg);
     sigs.add(pair);
     try {
       this.plugin = ReflectionUtil.instantiate(this.className, sigs);
     } catch (ReflectionException re) {
       throw new InvocationTargetException(re);
     }
   }
 
   /***
    * Dispose of the plugin. This method calls the <code>dispose()</code>
    * method on the plugin entry-point class, if there is one, and then destroys
    * its reference to the class. The class can be re-loaded via another call to
    * <code>load()</code>.
    */
   public void dispose() {
     if (this.plugin != null) {
       List sigs = new ArrayList();
       sigs.add(new ParamArgPair());
       try {
         ReflectionUtil.invokeMethod(this.plugin, "dispose", sigs);
       } catch (ReflectionException re) {
         log.throwing(getClass().getName(), "dispose", re);
       }
       this.plugin = null;
     }
   }
 
   /***
    * Get a reference to the instance of the plugin Activator class.
    * 
    * @return The instance, or <code>null</code> if the class has not yet been
    *         loaded.
    */
   public Object getPluginObject() {
     return this.plugin;
   }
 
   public String toString() {
     String ret;
     if (this.version != null) {
       ret = this.name + " " + this.version;
     } else {
       ret = this.name;
     }
     return ret;
   }
 
   public boolean isLoaded() {
     return this.plugin != null;
   }
 
   public JDialog getConfigurationDialog() {
     return this.dialog;
   }
 }