View Javadoc
   package com.bonevich.erj.app;
   
   import com.bonevich.erj.db.*;
   import com.bonevich.erj.db.DatabaseLogin;
   import com.bonevich.erj.db.IDdlGenerator;
   import com.bonevich.erj.db.SupportedDatabase;
   import com.bonevich.erj.model.Schema;
   import com.bonevich.erj.ui.ErjFrame;
   import com.bonevich.erj.xml.DatabaseSupportDigester;
  import com.bonevich.util.CollectionUtilities;
  import com.bonevich.util.Functor;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import java.util.*;
  import java.util.prefs.BackingStoreException;
  import java.util.prefs.Preferences;
  import java.util.prefs.PreferencesFactory;
  
  /***
   * ClassDescription
   * 
   * @author jbonevic
   * @version $Id: Application.html,v 1.1 2009/03/07 17:55:55 jbonevic Exp $
   */
  public class Application
  {
  	private final static Log _logger = LogFactory.getLog(Application.class);
  	private final static String DB_SUPPORT_PATH = "com/bonevich/erj/xml/dbsupport.xml";
  	
  	private Project _currentProject;
  	private List    _supportedDatabases = new LinkedList();
  	private static SupportedDatabase _defaultDatabase = null;
  	//private Preferences _prefs;
  	
  	/***
  	 * Constructor for Application.
  	 */
  	public Application()
  	{
  		super();
  	}
  
  	/***
  	 * Track the current Project (i.e. might be a Project in the process
  	 * of being loaded).
  	 */
  	public Project getCurrentProject()
  	{
  		return _currentProject;
  	}
  
  	/***
  	 * Sets the currentProject.
  	 * @param currentProject The currentProject to set
  	 */
  	public void setCurrentProject(Project currentProject)
  	{
  		_currentProject = currentProject;
  		ErjFrame.getInstance().setupProjectResources(_currentProject);
  	}
  
  	public Project createDefaultProject()
  	{
  		Project project = new Project(this);
  
  		// init datatypes with defaults
  
  		Schema model = new Schema();
  		model.setName(Schema.NEW_SCHEMA_STR);
  		model.setIdentifier(Schema.NEW_SCHEMA_STR);
  		project.setModel(model);
  		project.setTargetDatabase(DatabaseLogin.getDefaultInstance());
  		project.setName(model.getName());
  		project.createDiagram();
  		project.markAsNew();
  
  		setCurrentProject(project);
  		return project;
  	}
  
  	public Project loadProject(String filepath)
  	{
  		Project project = new Project(this);
  		project.setFilepath(filepath);
  		project.load();
  
  		setCurrentProject(project);
  		return project;
  	}
  
  	/***
  	 * Returns the supportedDatabases.
  	 * @return List
  	 */
  	public List getSupportedDatabases()
  	{
  		return _supportedDatabases;
 	}
 
 	/***
 	 * Returns the supportedDatabases.
 	 * @return List
 	 */
 	public SupportedDatabase getSupportedDatabase(String dbName)
 	{
 		Iterator itr = _supportedDatabases.iterator();
 		while (itr.hasNext())
 		{
 			SupportedDatabase db = (SupportedDatabase) itr.next();
 			if (db.getDisplayName().equals(dbName))
 			{
 				return db;
 			}
 		}
 		return _defaultDatabase;
 	}
 
 	/***
 	 * Returns the defaultDatabase.
 	 * @return SupportedDatabase
 	 */
 	public static SupportedDatabase getDefaultDatabase()
 	{
 		return _defaultDatabase;
 	}
 
 	/***
 	 * Sets the supportedDatabases.
 	 * @param supportedDatabases The supportedDatabases to set
 	 */
 	public void addSupportedDatabase(SupportedDatabase supportedDatabase)
 	{
 		if (supportedDatabase.getName().equals(SupportedDatabase.DEFAULT_DB))
 		{
 			_defaultDatabase = supportedDatabase;
 		}
 		_supportedDatabases.add(supportedDatabase);
 	}
 
 	/***
 	 * Returns the supportedDatabases.
 	 * @return List
 	 */
 	public Vector getSupportedDatabaseNames()
 	{
 		return CollectionUtilities.map(
 			new Functor()
 			{
 				public Object function(Object arg)
 				{
 					SupportedDatabase db = (SupportedDatabase) arg;
 					return db.getDisplayName();
 				}
 			},
 			_supportedDatabases
 		);
 	}
 	
 	/***
 	 * Setup database support.
 	 */
 	public void initDatabaseSupport()
 	{
 		DatabaseSupportDigester digester = new DatabaseSupportDigester(this);
 		digester.digest(DB_SUPPORT_PATH);
 	}
 
 	/***
 	 * Load the application preferences
 	 */
 	public void initPreferences()
 	{
 		Iterator itr = getSupportedDatabases().iterator();
 		while (itr.hasNext())
 		{
 			SupportedDatabase db = (SupportedDatabase) itr.next();
 			Preferences dbPrefs = Preferences.userNodeForPackage(db.getClass());
 			try
 			{
 				if (dbPrefs.nodeExists(db.getName()))
 				{
 					Preferences prefs = dbPrefs.node(db.getName());
 					String[] generatorNames = prefs.childrenNames();
 					for (int j = 0; j < generatorNames.length; j++)
 					{
 						String generatorName = generatorNames[j];
 						IDdlGenerator generator = db.addGenerator(generatorName);
 						try
 						{
 							if (prefs.nodeExists(generatorName))
 							{
 								Preferences generatorPrefs = prefs.node(generatorName);
 								String[] optionIds = generatorPrefs.keys();
 								for (int i = 0; i < optionIds.length; i++)
 								{
 									generator.setOption(optionIds[i], generatorPrefs.getBoolean(optionIds[i], false));
 								}
 							}
 						}
 						catch(Exception e)
 						{
 							_logger.warn("No preferences found for generator: " + generatorName);
 						}
 					}
 				}
 			}
 			catch (Exception e)
 			{
 				_logger.warn("No preferences found for database support: " + db.getName());
 			}
 		}
 	}
 
 	/***
 	 * Save the application preferences
 	 */
 	public void savePreferences()
 	{
 		Iterator itr = getSupportedDatabases().iterator();
 		while (itr.hasNext())
 		{
 			SupportedDatabase db = (SupportedDatabase) itr.next();
 			Preferences pkgPrefs = Preferences.userNodeForPackage(db.getClass());
 			Preferences dbPrefs  = pkgPrefs.node(db.getName());
 			try
 			{
 				dbPrefs.removeNode();
 			}
 			catch (BackingStoreException e)
 			{
 				_logger.warn("Unable to remove preferences in preparation for save!");
 			}
 			// recreate the node
 			dbPrefs  = pkgPrefs.node(db.getName());
 			
 			Iterator genNames = db.getGeneratorNames();
 			while (genNames.hasNext())
 			{
 				String genName = (String) genNames.next();
 				IDdlGenerator generator = db.getGenerator(genName);
 				Preferences genPrefs = dbPrefs.node(genName);
 				
 				GenerationOptionMetaData md = generator.getOptionMetaData();
 				Iterator options = md.getOptionIds();
 				while (options.hasNext())
 				{
 					String optionId = (String) options.next();
 					genPrefs.putBoolean(optionId, generator.isOptionSet(optionId));
 				}
 			}
 		}
 	}
 
 }