Application: gvSIG desktop

import org.gvsig.andami.firewall.DefaultFirewallConfiguration;

import org.gvsig.andami.firewall.FirewallConfiguration;

import org.gvsig.andami.plugins.ExclusiveUIExtension;

import org.gvsig.andami.plugins.IExtension;

import org.gvsig.andami.plugins.PluginClassLoader;

import org.gvsig.installer.lib.api.PackageInfo;

    }

    public PluginServices getPlugin(Object obj) {

        if ( obj instanceof IExtension ) {

            Class<? extends IExtension> klass = (Class<? extends IExtension>) obj.getClass();

            return this.getPlugin(klass);

        if ( !(Launcher.getAndamiConfig() == null || Launcher.getAndamiConfig().getPluginsDirectory() == null) ) {

            folderPath = Launcher.getAndamiConfig().getPluginsDirectory();

        }

        this.pluginsFolders = new ArrayList<File>();

        folder = new File(this.getApplicationFolder(), folderPath);

        if( !folder.exists() ) {

            try {

            }

        }

        this.pluginsFolders.add(folder);

        folder = new File(this.getApplicationHomeFolder(), "installation");

        folder = new File(folder, folderPath);

        if( !folder.exists() ) {

            }

        }

        this.pluginsFolders.add(folder);

        return this.pluginsFolders;

    }

    public File getApplicationI18nFolder() {

        return new File(this.getApplicationFolder(), "i18n");

    }

    public FirewallConfiguration getFirewallConfiguration() {

        return new DefaultFirewallConfiguration();

    }

        Version version = pinfo.getVersion();

        return version;

    }

}

public abstract class Extension implements IExtension, IExtensionQueryByAction, IExtensionExecuteWithArgs  {

	private static Logger logger = LoggerFactory.getLogger(Extension.class);

	/*

	 *  (non-Javadoc)

	 * @see com.iver.andami.plugins.IExtension#terminate()

	public IExtensionStatus getStatus(IExtension extension) {

		return extension.getStatus();

	}

	public String getText(String msg) {

	    return PluginsLocator.getManager().getText(this, msg);

	}

	}

	public boolean isEnabled(String action) {

		return isEnabled();

	}

	public boolean isVisible(String action) {

		return isVisible();

	}

	public boolean canQueryByAction() {

		return false;

	}

			logger.info("calling execute with args in a extension that not support ("+this.getClass().getSimpleName()+").");

		}

		execute(command);

}

 * Andami's launching class. This is the class used to create the Andami's

 * plugin environment.<br>

 * </p>

 * <p>

 * <b>Syntax:</b> <br>

 * java [-Xmx512M (for 512MB of RAM)] [-classpath={a colon-separated(unix) or

 * PATH_TO_APPLICATION_HOME_DIRECTORY PATH_TO_APPLICATION_PLUGINS_DIRECTORY

 * [{list of additional custom application arguments separated by spaces}]

 * </p>

 * @author $author$

 * @version $Revision: 40305 $

 */

public class Launcher {

	public static abstract class MapWithAlias<Item> extends HashMap<String, Item> {

		public abstract String[] getAliases(Item item);

		public boolean isAlias(String key) {

			return aliases.get(key)!=null ;

		}

			}

			return null;

		}

			Item item = super.get(key);

			if( item != null ) {

				return item;

			}

			return null;

		}

		public boolean containsKey(Object key) {

			boolean contains = super.containsKey(key);

			if( contains ) {

			String alias = aliases.get(key);

			return super.containsKey(alias);

		}

		public Item put(String key, Item value) {

			super.put(key, value);

			String[] aliases = getAliases(value);

			}

			return value;

		}

		public void putAll(Map<? extends String, ? extends Item> m) {

			Iterator<?> it = m.entrySet().iterator();

			while( it.hasNext() ) {

				this.put(x.getKey(), x.getValue());

			}

		}

		public Item remove(Object key) {

			Item item = super.get(key);

			if( item == null ) {

				return item;

			}

			// Rebuild the alias list

			Iterator<java.util.Map.Entry<String, Item>> it = this.entrySet().iterator();

			while(it.hasNext()) {

				java.util.Map.Entry<String, Item> entry = it.next();

			return item;

		}

	}

	public static class PluginsConfig extends MapWithAlias<org.gvsig.andami.plugins.config.generate.PluginConfig>  {

		public String[] getAliases(

				org.gvsig.andami.plugins.config.generate.PluginConfig item) {

			return getAlternativeNames(item);

			}

			return r;

		}

	}

	public static class PluginsServices extends MapWithAlias<org.gvsig.andami.PluginServices>  {

		public String[] getAliases(org.gvsig.andami.PluginServices item) {

			return item.getAlternativeNames();

		}

	}

	protected static Logger logger = LoggerFactory.getLogger(Launcher.class

			.getName());

	protected static Preferences prefs = Preferences.userRoot().node(

	protected static MultiSplashWindow splashWindow;

	protected static String appName;

	protected static Locale locale;

	protected static PluginsServices pluginsServices = new PluginsServices();

	protected static MDIFrame frame;

	protected static HashMap<Class<? extends IExtension>, ExtensionDecorator> classesExtensions = new HashMap<Class<? extends IExtension>, ExtensionDecorator>();

	protected static ListBaseException launcherrors = null;

	protected static Theme theme = null;

	private List<String> deprecatedPluginNames = null;

	private static final class ProxyAuth extends Authenticator {

		}

		return launcherInstance;

	}

	public static void main(String[] args) throws Exception {

		Launcher launcher = getInstance();

		boolean install = false;

	private String translate(String msg) {

		return PluginServices.getText(Launcher.class,msg);

	}

	private List<String> getDeprecatedPluginNames() {

		if( deprecatedPluginNames == null ) {

			String[] ss = new String[] {

		}

		return deprecatedPluginNames;

	}

	public void doMain(String[] args) throws Exception {

		if (args.length < 1) {

			public void refresh() {

			}

		});

        new DefaultLibrariesInitializer().fullInitialize(true);

        InstallerLocator.getInstallerManager().setDownloadBaseURL(

            new URL("http://downloads.gvsig.org/download/gvsig-desktop/"));

					ex);

		}

                UIManager.put("Desktop.background", theme.getBackgroundColor());

		// Mostrar la ventana de inicio

		Frame f = new Frame();

		splashWindow = new MultiSplashWindow(f, theme, 27);

		splashWindow.process(translate("SplashWindow.initialize_install_manager"));

                initializeInstallerManager();

                InstallerManager installerManager = InstallerLocator.getInstallerManager();

                PackageInfo[] installedPackages = null;

                try {

                logger_info(getInformation(installedPackages));

                saveEnvironInformation(installedPackages);

                // Se leen los config.xml de los plugins

		splashWindow.process(translate("SplashWindow.load_plugins_configuration"));

		try {

		splashWindow.process(translate("SplashWindow.check_incompatible_plugins"));

		fixIncompatiblePlugins(installedPackages);

		// Se configura el classloader del plugin

		splashWindow.process(translate("SplashWindow.setup_plugins_configuration"));

		try {

		} catch (Throwable ex) {

			this.addError("Can't initialize plugin's classloaders  ", ex);

		}

                initializeIdentityManagement(new File(andamiConfig.getPluginsDirectory()).getAbsoluteFile());

		// Initialize libraries

		message(translate("SplashWindow.initializing_server_data_persistence"));

		ServerDataPersistence.registerPersistence();

		// Se instalan las etiquetas de las extensiones de los plugins

		message(translate("SplashWindow.installing_extensions_labels"));

		SwingUtilities.invokeAndWait(new Runnable() {

                            }

			}

		});

		// Se ejecuta el postInitialize

		message(translate("SplashWindow.post_initializing_extensions"));

		SwingUtilities.invokeAndWait(new Runnable() {

				postInitializeExtensions();

			}

		});

		message(translate("SplashWindow.enable_controls"));

		SwingUtilities.invokeAndWait(new Runnable() {

			public void run() {

		});

		splashWindow.close();

		frame.setCursor(Cursor.DEFAULT_CURSOR);

		if (launcherrors != null) {

		}

		org.apache.log4j.Logger.getRootLogger().addAppender(

				new NotificationAppender());

		/*

		 * Executes additional tasks required by plugins

		 */

            PluginsManager pluginmgr = PluginsLocator.getManager();

            InstallerManager installerManager = InstallerLocator.getInstallerManager();

            // Configure repository of plugins

            //

            List<File> folders = pluginmgr.getPluginsFolders();

                installerManager.addLocalAddonRepository(folder, "plugin");

            }

            installerManager.setDefaultLocalAddonRepository(folders.get(0), "plugin");

            // Configure repository of iconsets

            //

            IconThemeManager iconManager = ToolsSwingLocator.getIconThemeManager();

                        installerManager.setDefaultLocalAddonRepository(entry.getFolder(),"iconset");

                    }

            }

        }

	private void message(final String msg) {

		Utilities.cleanUpTempFiles();

		if( args.length<2 ) {

		} else {

			loadAndamiConfig(args[1]);

		}

	}

	/**

     */

	private void configureLookAndFeel() {

		// Se pone el lookAndFeel

	}

	/**

     */

	private void getOrCreateConfigFolder() {

		// Create application configuration folder

		protected void append(LoggingEvent event) {

			if (event.getLevel() == org.apache.log4j.Level.ERROR

					|| event.getLevel() == org.apache.log4j.Level.FATAL) {

			    Throwable th = null;

			    ThrowableInformation thi = event.getThrowableInformation();

			    if (thi != null) {

			// }

		}

		@Override

		public void close() {

			// TODO Auto-generated method stub

	public static String getApplicationDirectory() {

		return getApplicationFolder().getAbsolutePath();

	}

    public static File getApplicationFolder() {

        // TODO: check if there is a better way to handle this

        return new File(System.getProperty("user.dir"));

	private void registerIcons() {

		IconTheme theme = PluginServices.getIconTheme();

		String[][] icons = {

				// MultiSplashWindow

				{ "main", "splash-default" },

			} catch(Exception e) {

				logger.info("Can't register icon '"+icons[i][0]+"' ("+icons[i][1]+").");

			}

		theme.setDefaultIcon(loader.getResource("images/main/default-icon.png" ));

	}

            }

            return p;

        }

	/**

	 * Obtiene la personalizaci�n de los iconos, splash, fondo y el nombre de la

	 * aplicaci�n.

	 * @return Theme

	 */

    private Theme getTheme(String pluginsDirectory) {

            File[] pluginDirs = pluginsDir.listFiles();

            if ( pluginDirs.length > 0 ) {

                for ( int i = 0; i < pluginDirs.length; i++ ) {

                            "theme" + File.separator + "andami-theme.xml");

                    if ( pluginThemeFile.exists() ) {

                        Theme theme = new Theme(loadProperties(infoFile));

	 * Recupera la geometr�a (tama�o, posic�n y estado) de la ventana principal

	 * de Andami. TODO Pendiente de ver como se asigna un pluginServices para el

	 * launcher.

	 * @author LWS

	 */

	private void restoreMDIStatus(XMLEntity xml) {

	/**

	 * Salva la persistencia de los plugins.

	 * @author LWS

	 */

	private void savePluginPersistence() {

	/**

	 * DOCUMENT ME!

	 * @throws MDIManagerLoadException

	 */

	private void skinPlugin(String defaultSkin) throws MDIManagerLoadException {

							.getClassLoader().loadClass(

									extension.getClassName());

					extensionInstance = extensionClass.newInstance();

					// CON DECORATOR

					// ANTES: classesExtensions.put(extensionClass,

							menu.setKey(actionInfo.getAccelerator());

							menu.setName(actionInfo.getName());

						}

					if( menu.getPosition() < 100000000 ) {

						logger.info("Invalid position in menu ("+ menu.getText() + ").");

						menu.setPosition( menu.getPosition() + 1000000000);

			}

		}

	}

	@SuppressWarnings("unchecked")

	private void registerActions() {

		logger.info("registerActions");

			logger.info("registerActions of plugin '"+pluginName+"'.");

			Extensions extensionConfig = pluginConfig.getExtensions();

			Enumeration<SkinExtensionType> extensiones = extensionConfig.enumerateExtension();

			registerActionOfExtensions(actionManager, extensiones, loader);

					while (menus2.hasMoreElements()) {

						Menu menu = menus2.nextElement();

						if (!menu.getIs_separator() ) {

								logger.info("Null name for popmenu '"+menu.getText()+"' in plugin "+ pluginService.getPluginName() );

							} else {

								ActionInfo actionInfo = actionManager.getAction(menu.getName());

					}

				}

			}

		}

	}

		TreeSet<SortableMenu> orderedMenus = new TreeSet<SortableMenu>(

				new MenuComparator());

			this.loader = loader;

			this.extension = extension;

		}

		public PluginServices getPlugin() {

			String pluginName = loader.getPluginName();

			return PluginServices.getPluginServices(pluginName);

		}

		public String getExtensionName() {

			return this.extension.getClassName();

		}

		public IExtension getExtension() {

			Class<?> extensionClass;

			try {

			}

			return PluginServices.getExtension(extensionClass);

		}

		public String getText() {

			return this.menu.getText();

		}

		public long getPosition() {

			return this.menu.getPosition();

		}

		public String getName() {

			return this.menu.getName();

		}

		public boolean isParent() {

			return menu.getIs_separator();

		}

		public String getPluginName() {

			return this.loader.getPluginName();

		}

		public ActionInfo getAction() {

			ActionInfoManager manager = PluginsLocator.getActionInfoManager();

			return manager.getAction(this.menu.getName());

		}

	}

	public List<PluginMenuItem> getPluginMenuItems() {

		List<PluginMenuItem> menuItems = new ArrayList<Launcher.PluginMenuItem>();

		return menuItems;

	}

	/**

	 * Installs the menus, toolbars, actiontools, selectable toolbars and

	 * combos. The order in which they are shown is determined here.

			}

		}

	}

        private URL[] getPluginClasspathURLs(PluginConfig pluginConfig) {

            URL[] urls = null;

                     try {

                         loader = new PluginClassLoader(

                                 loaders

                         PluginServices ps = new PluginServices(

                                 PluginsConfig.getAlternativeNames(config)

                         );

                         pluginsServices.put(ps.getPluginName(), ps);

			}

		}

	}

	private void pluginsMessages() {

		Iterator<String> iterator = pluginsOrdered.iterator();

		PluginConfig config;

	static String getPluginsDir() {

		return andamiConfig.getPluginsDirectory();

	}

        static File getPluginFolder(String pluginName) {

            return pluginsConfig.get(pluginName).getPluginFolder();

        }

		return frame;

	}

        private void loadPlugins() {

            InstallerManager installerManager = InstallerLocator.getInstallerManager();

            List<File> repositoriesFolders = installerManager.getLocalAddonRepositories("plugin");

			if (e2.menu.hasPosition() && !e1.menu.hasPosition()) {

				return Integer.MAX_VALUE;

			}

			if( e1.menu.getPosition() == e2.menu.getPosition() ) {

				// we don't return 0 unless both objects are the same, otherwise

				// the objects get overwritten in the treemap

				return Integer.MAX_VALUE;

			}

    		return Integer.MIN_VALUE;

		}

	}

			menu = menu2;

			this.loader = loader;

		}

	}

	private static class SortableTool {

	 * <li>If both tools have the same position (or they don't have a 'position'

	 * attribute), the priority of the extensions where the tool is defined.</li>

	 * </ul>

	 * @author cesar

	 * @version $Revision: 40305 $

	 */

	 * Gets the ISO 839 two-characters-long language code matching the provided

	 * language code (which may be an ISO 839-2/T three-characters-long code or

	 * an ISO 839-1 two-characters-long code).

	 * If the provided parameter is already two characters long, it returns the

	 * parameter without any modification.

	 * @param langCode

	 *            A language code representing either an ISO 839-2/T language

	 *            code or an ISO 839-1 code.

	/**

	 * Configures the locales (languages and local resources) to be used by the

	 * application.

	 * First it tries to get the locale from the command line parameters, then

	 * the andami-config file is checked.

	 * The locale name is normalized to get a two characters language code as

	 * defined by ISO-639-1 (although ISO-639-2/T three characters codes are

	 * also accepted from the command line or the configuration file).

	 * Finally, the gvsig-i18n library and the default locales for Java and

	 * Swing are configured.

	 */

    private static void configureLocales(String[] args) {

        // Configurar el locale

        logger.info("loading resources from classloader "+i18nClassLoader.toString()+".");

        org.gvsig.i18n.Messages.addResourceFamily("text", i18nClassLoader,

                "Andami Launcher");

         // Finally load the andami own i18n resources

         org.gvsig.i18n.Messages.addResourceFamily("org.gvsig.andami.text",

         "Andami Launcher");

            }

            return urls.toArray(new URL[urls.size()]);

        }

	/**

	 * Gets Home Directory location of the application into users home folder.

	 * May be set from outside the aplication by means of

	 * -DgvSIG.home=C:/data/gvSIG, where gvSIG its the name of the application

	 * @return

	 */

	public static String getAppHomeDir() {

		return appHomeDir;

	}

    public static File getApplicationHomeFolder() {

        return new File(getAppHomeDir());

    }

	 * Sets Home Directory location of the application. May be set from outside

	 * the aplication by means of -DgvSIG.home=C:/data/gvSIG, where gvSIG its

	 * the name of the application

	 * @param appHomeDir

	 */

	public static void setAppHomeDir(String appHomeDir) {

	 * this: <br>

	 * <br>

	 * -exclusiveUI={pathToExtensionClass} <br>

	 * @see org.gvsig.andami.plugins.IExtension#isEnabled(IExtension extension)

	 * @see org.gvsig.andami.plugins.IExtension#isVisible(IExtension extension)

	 */

	public static void initIconThemes() {

		PluginsManager pluginsManager = PluginsLocator.getManager();

		IconThemeManager iconManager = ToolsSwingLocator.getIconThemeManager();

		File f = new File(pluginsManager.getApplicationFolder(),"icon-theme");

			try {

				f.mkdir();

			} catch(Exception ex) {

			}

		}

		iconManager.getRepository().add(f,"_Global");

		f = new File(pluginsManager.getApplicationHomeFolder(),"icon-theme");

		if( !f.exists() ) {

			try {

			}

		}

		iconManager.getRepository().add(f,"_User");

		Preferences prefs = Preferences.userRoot().node("gvsig.icontheme");

		String defaultThemeID = prefs.get("default-theme", null);

		if( defaultThemeID != null ) {

	/**

	 * Manages Andami termination process

	 * @author Cesar Martinez Izquierdo <cesar.martinez@iver.es>

	 */

	public class TerminationProcess {

		/**

		 * Exectutes the terminate method for all the extensions, in the reverse

		 * order they were initialized

		 */

		private void finalizeExtensions() {

			for (int i = extensions.size() - 1; i >= 0; i--) {

		/**

		 * Checks if the extensions have some unsaved data, and shows a dialog

		 * to allow saving it. This dialog also allows to don't exit Andami.

		 * @return true if the user confirmed he wishes to exit, false otherwise

		 * @throws Exception

		 */

	/**

	 * Launch the gvSIG package installer.

	 * @throws Exception

	 *             if there is any error

	 */

        /*

         * Los parametros que deberian pasarse en el instalador oficial de gvSIG serian:

         * --install

         * --applicationName=gvSIG

         * --language=es

         * --pluginsFolder=gvSIG/extensiones

         * Opcionales (casi mejor que dejar los de por defecto y no pasarselos):

         * --installVersion=2.0.0

         * --installURL=http://downloads.gvsig.org/download/gvsig-desktop/dists

         * --installURLFile=gvSIG/extensiones/org.gvsig.installer.app.extension/defaultDownloadsURLs

         */

        CommandLineParser parser = new PosixParser();

        CommandLine line = null;

            if ( !hasAllMandatoryOptions ) {

                System.err.println(Messages.get("usage") + ": Launcher " +

                        "--install "+

                        "[--pluginsFolder=plugins-directory] " +

                        "[--installURLFile=File] " +

                        "[--installURL=URL] " +

        initializeApp(myArgs, "installer");

        initializeLibraries();

        AndamiConfig config = getAndamiConfig();

        config.setLocaleLanguage(locale.getLanguage());

        config.setLocaleCountry(locale.getCountry());

        config.setLocaleVariant(locale.getVariant());

        initializeInstallerManager();

        InstallerManager installerManager = InstallerLocator.getInstallerManager();

        packageInfo = getPackageInfo(myArgs[1]);

        private static final int INFO_APP_THEME = 16;

        private static final int INFO_APP_SKIN = 17;

        private static final int INFO_PACKAGES = 18;

        public static String getInformation(PackageInfo[] pkgs) {

                    +"    name    : {"+INFO_OS_NAME+"}\n"

                    +"    arch    : {"+INFO_OS_ARCH+"}\n"

                    +"    version : {"+INFO_OS_VERSION+"} \n"

                    +"    Skin                    : {"+INFO_APP_SKIN+"}\n"

                    +"Installed packages\n"

                    +"{"+INFO_PACKAGES+"}";

            String values[] = new String[INFO_PACKAGES+1];

            PluginsManager pluginmgr = PluginsLocator.getManager();

            LocaleManager localemgr = PluginsLocator.getLocaleManager();

            Properties props = System.getProperties();

            // OS information

            values[INFO_OS_NAME] = props.getProperty("os.name");

            values[INFO_OS_ARCH] = props.getProperty("os.arch");

            values[INFO_OS_VERSION] = props.getProperty("os.version");

            if ( values[INFO_OS_NAME].startsWith("Linux") ) {

                try {

                    StringWriter writer = new StringWriter();

                    String[] command = {"lsb_release", "-a"};

                    Process p = Runtime.getRuntime().exec(command);

                    InputStream is = p.getInputStream();

                    writer.write("\n");

                }

                values[INFO_PACKAGES] = writer.toString();

            } catch (Throwable e) {

                logger.warn("Can't get installed package information.",e);

            }

            String s = MessageFormat.format(template, values);

            return s;

        }

			logger.info(info[i]);

		}

	}

	private void saveEnvironInformation(PackageInfo[] pkgs) {

		PluginsManager manager = PluginsLocator.getManager();

		File fout = new File( manager.getApplicationHomeFolder(), "gvSIG-environ.info");

	private void fixIncompatiblePlugins(PackageInfo[] installedPackages) {

		final Set<String> incompatiblePlugins = new HashSet<String>();

		// Add installed packages to a Map to optimize searchs

		final Map<String, PackageInfo> packages = new HashMap<String, PackageInfo>();

		for( int i=0 ; i<installedPackages.length; i++) {

			Entry<String, PluginConfig> entry = it.next();

			PluginConfig pluginConfig = entry.getValue();

			pluginNames.add(entry.getKey());

			// Locate the package for this plugin.

			// Be care whith alias

			String[] aliases = pluginsConfig.getAliases(pluginConfig);

					break;

				}

			}

			// If package is found verify dependencies

			if( pkg!= null ) {

				Dependencies dependencies = pkg.getDependencies();

		if( pluginsToDissable  == null ) {

			return;

		}

		Iterator<String> it2 = pluginsToDissable.iterator();

		while( it2.hasNext() ) {

			String pluginName = it2.next();

			logger.info("Dissabling plugin '"+pluginName+"' by user action.");

			pluginsConfig.remove(pluginName);

	}

	private class DisablePluginsConflictingDialog extends JDialog {

		public static final int CONTINUE = 0;

		public static final int CLOSE = 1;

		private DisablePluginsConflictingLayoutPanel contents;

		private int action = 0;

		private List<Item> incompatiblePlugins = null;

		private Map<String, PackageInfo> packages;

		private class Item {

			private String code;

			private PackageInfo pkg;

		DisablePluginsConflictingDialog(Map<String, PackageInfo> packages, Set<String> incompatiblePlugins) {

			super((Frame)null, "",true);

			this.setTitle(translate("_Conflicting_plugins"));

			this.packages = packages;

			this.incompatiblePlugins  = new ArrayList<Item>();

			Item item = null;

			Iterator<String> it = incompatiblePlugins.iterator();

			}

			initComponents();

		}

		private void initComponents() {

			this.contents = new DisablePluginsConflictingLayoutPanel();

			doTranslations();

			this.contents.buttonClose.addActionListener( new ActionListener() {

	        setLocation((screenSize.width / 2) - (this.getWidth() / 2),

	            (screenSize.height / 2) - (this.getHeight()/ 2));

		}

		private void doTranslations() {

			DisablePluginsConflictingLayoutPanel c = this.contents;

			c.lblConflict.setText(translate("_Some_of_plugins_installed_conflict_with_each_other"));

			c.buttonClose.setText(translate("_Close"));

			c.buttonContinue.setText(translate("_Continue"));

		}

		private String translate(String msg) {

			return PluginServices.getText(this,msg);

		}

		private void doClose() {

			this.action = CLOSE;

			this.setVisible(false);

		}

		private void doContinue() {

			this.action = CONTINUE;

			this.setVisible(false);

		}

		public int getAction() {

			return this.action;

		}

			return values;

		}

	}

    private void initializeIdentityManagement(File pluginsFolder) {

        File identityManagementConfigFile = null;

        PluginServices plugin = null;

        }

        logger.info("Loaded an identity manager from plugin '"+plugin.getPluginName()+".");

    }

}