View Javadoc
   package com.bonevich.erj.app;
   
   import com.bonevich.erj.model.Schema;
   import com.bonevich.erj.model.ModelElement;
   import com.bonevich.erj.model.ModelElementTraverser;
   import com.bonevich.erj.ErjConstants;
   import com.bonevich.erj.db.*;
   import com.bonevich.erj.diagram.ERDiagram;
   
  import com.bonevich.util.Functor;
  import com.bonevich.util.dependency.Dynamic;
  import com.bonevich.java.util.ImmutableIterator;
  
  import org.tigris.gef.base.*;
  
  import java.util.*;
  import java.util.zip.*;
  import java.io.*;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  
  public final class Project implements PropertyChangeListener, ErjConstants
  {
  	//////////////////////////////////////////////////////////
  	// Constants
  	private static final String FILE_EXTENSION_STR = ".zerj";
  
  	//////////////////////////////////////////////////////////
  	// Attributes
  	private String _name;
  	private String _author      = EMPTY_STR;
  	private String _version     = EMPTY_STR;
  	private String _description = EMPTY_STR;
  
  	private Application   _parentApp;
  	private DatabaseLogin _targetDatabase;
  
  	private transient String _filepath    = EMPTY_STR;
  	private transient boolean _modified   = false;
  	private transient boolean _new        = false;
  
  	private Schema  _model;
  	private HashMap _modelRegistry;
  
  	private List _diagrams     = new ArrayList(); // of Diagram instances
  	private int  _diagramCount = 0;
  
  	private ProjectComponents _components = new ProjectComponents();
  
  	//////////////////////////////////////////////////////////
  	// Dynamic sentries
  	private Dynamic _dyn_name = new Dynamic();
  	private Dynamic _dyn_diagrams = new Dynamic();
  	private Dynamic _dyn_modified = new Dynamic();
  
  	//////////////////////////////////////////////////////////
  	// Constructors
  	/***
  	 * Prevent instantiation by anyone but me.
  	 */
  	protected Project(Application app)
  	{
  		_parentApp = app;
  		_components.addComponent(new ProjectProperties(this));
  	}
  
  	//////////////////////////////////////////////////////////
  	// Operations
  
  	// Vector cuz JList wants it that way
  	public Vector getComponents()
  	{
  		return _components.getComponents();
  	}
  
  	public void addComponent(ProjectComponent cmp)
  	{
  		_components.addComponent(cmp);
  	}
  	
  	/***
  	 * Returns an instance of one of the well-known project component types.
  	 */
  	public ProjectComponent createComponent(String type)
  	{
  		// FIXME: setup a ProjectComponentFactory class
  		ProjectComponent newCmp = null;
  		if (ProjectComponent.ERJ.equals(type))
  		{
  			newCmp = new ProjectProperties(this);
  		}
  		else if (ProjectComponent.XMI.equals(type))
  		{
  			_model = new Schema();
  			newCmp = new ProjectModel(this, _model);
  			initModelRegistry();
  		}
  		else if (ProjectComponent.SVG.equals(type))
  		{
 			newCmp = new ProjectDiagram(this, null);
 		}
 		//System.err.println("newCmp = " + newCmp);
 		addComponent(newCmp);
 		return newCmp;
 	}
 
 	public void createDiagram()
 	{
 		ERDiagram d = new ERDiagram(_model);
 		try 
 		{
 			d.setName("diagram_" + (++_diagramCount));
 		}
 		catch (Exception e) {}
 
 		ProjectDiagram cmp = new ProjectDiagram(this, d);
 		addComponent(cmp);
 		addDiagram(d);
 	}
 
 	/***
 	 * Needed by ProjectDiagram during loading, but should not be
 	 * utilized by anyone else.
 	 */
 	protected void addDiagram(Diagram d)
 	{
 		if (!_diagrams.contains(d))
 		{
 			_dyn_diagrams.onSet();
 			_diagrams.add(d);
 			setModified(true);
 		}
 	}
 	
 	public void removeDiagram(Diagram d)
 	{
 		if (_diagrams.remove(d))
 		{
 			_dyn_diagrams.onSet();
 			_components.removeDiagramComponent(d);
 			setModified(true);
 		}
 	}
 	
 	public Iterator getDiagramIterator()
 	{
 		_dyn_diagrams.onGet();
 		return new ImmutableIterator(_diagrams.iterator());
 	}
 
 	public Schema getModel()
 	{
 		return _model;
 	}
 
 	public void setModel(Schema model)
 	{
 		_model = model;
 		initModelRegistry();
 		addComponent(new ProjectModel(this, _model));
 	}
 
 	/***
 	 * Provides a map of model elements owned by the model schema.
 	 */
 	protected HashMap getModelRegistry()
 	{
 		return _modelRegistry;
 	}
 	private void initModelRegistry()
 	{
 		if (_model != null)
 		{
 			_modelRegistry = new HashMap();
 
 			// key = {{ModelElement instance class name}}:{{ModelElement instance identifier value}}
 			// value = {{ModelElement instance}}
 			ModelElementTraverser traverser = new ModelElementTraverser
 			(
 				new Functor()
 				{
 					public Object function(Object arg)
 					{
 						ModelElement me = (ModelElement) arg;
 						String key = me.getOclReferenceId();
 						_modelRegistry.put(key, me);
 						return key;
 					}
 				}
 			);
 			traverser.traverse(_model);
 		}
 	}
 
 	public String getName()
 	{
 		_dyn_name.onGet();
 		return _name;
 	}
 	public void setName(String name)
 	{
 		if (!name.equals(_name))
 		{
 			_dyn_name.onSet();
 			_name = name;
 			setModified(true);
 		}
 	}
 	
 	public String getDescription()
 	{
 		return _description;
 	}
 	public void setDescription(String description)
 	{
 		if (!description.equals(_description))
 		{
 			_description = description;
 			setModified(true);
 		}
 	}
 	
 	public String getAuthor()
 	{
 		return _author;
 	}
 	public void setAuthor(String author)
 	{
 		if (!author.equals(_author))
 		{
 			_author = author;
 			setModified(true);
 		}
 	}
 	
 	public String getVersion()
 	{
 		return _version;
 	}
 	public void setVersion(String version)
 	{
 		if (!version.equals(_version))
 		{
 			_version = version;
 			setModified(true);
 		}
 	}
 	
 	public String getFilepath()
 	{
 		return _filepath;
 	}
 	public void setFilepath(String filepath)
 	{
 		if (filepath.endsWith(FILE_EXTENSION_STR))
 		{
 			_filepath = filepath;
 		}
 		else
 		{
 			_filepath = filepath + FILE_EXTENSION_STR;
 		}
 
 		if (_name == null || EMPTY_STR.equals(_name))
 		{
 			int nameIdx = _filepath.lastIndexOf(System.getProperty("file.separator"));
 			int dotIdx = _filepath.lastIndexOf('.');
 			if (nameIdx < 0) nameIdx = 0;
 			if (dotIdx < 0) dotIdx = _filepath.length();
 			setName(_filepath.substring(nameIdx + 1, dotIdx));
 		}
 	}
 
 	public DatabaseLogin getTargetDatabase()
 	{
 		return _targetDatabase;
 	}
 	public void setTargetDatabase(DatabaseLogin targetDatabase)
 	{
 		_targetDatabase = targetDatabase;
 		setModified(true);
 	}
 	
 	public DatabaseLogin createDatabaseLogin(String dbName)
 	{
 		SupportedDatabase db = _parentApp.getSupportedDatabase(dbName);
 		DatabaseLogin newLogin = db.createDatabaseLogin();
 		setTargetDatabase(newLogin);
 		return newLogin;
 	}
 	
 	public Application getParent()
 	{
 		return _parentApp;
 	}
 	
 	public void load()
 	{
 		Globals.showStatus("Loading project from " + _filepath + "...");
 
 		// Load the properties file first - this sets up all the other
 		// components
 		ProjectComponent cmp = _components.getPropertiesComponent();
 		loadComponent(cmp, cmp.getEntryExtension());
 
 		cmp = _components.getModelComponent();
 		// FIXME: cmp could be null!
 		loadComponent(cmp, cmp.getEntryFilename());
 		_model = ((ProjectModel) cmp).getModel();
 		initModelRegistry();
 
 		Iterator diagrams = _components.getDiagramComponentIterator();
 		while (diagrams.hasNext())
 		{
 			cmp = (ProjectDiagram) diagrams.next();
 			loadComponent(cmp, cmp.getEntryFilename());
 		}
 
 		Globals.showStatus("Project " + _name + " loaded");
 
 		//loaded projects are never marked as new!
 		setModified(false);
 		_new = false;
 	}
 
 	private void loadComponent(ProjectComponent cmp, String targetPattern)
 	{
 		try
 		{
 			File file = new File(_filepath);
 			ZipInputStream zis = new ZipInputStream(new FileInputStream(file));
 			String entryName = zis.getNextEntry().getName();
 			while (!entryName.endsWith(targetPattern))
 			{
 				ZipEntry next = zis.getNextEntry();
 				if (next != null)
 				{
 					entryName = next.getName();
 				}
 				else
 				{
 					break;
 				}
 			}
 			//System.err.println("entryName = " + entryName);
 			//System.err.println("targetPattern = " + targetPattern);
 			cmp.load(zis);
 			zis.close();
 		}
 		catch (FileNotFoundException e)
 		{
 			e.printStackTrace();
 			Globals.showStatus("ERROR loading project " + _name);
 		}
 		catch (IOException e)
 		{
 			e.printStackTrace();
 			Globals.showStatus("ERROR loading project " + _name);
 		}
 	}
 
 	public void save()
 	{
 		try
 		{
 			Globals.showStatus("Saving project to " + _filepath + "...");
 
 			File file = new File(_filepath);
 			ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(file));
 
 			// save the components of this project
 			_components.prepareForSave();
 			Iterator itr = _components.iterator();
 			while (itr.hasNext())
 			{
 				ProjectComponent pc = (ProjectComponent) itr.next();
 
 				System.err.println("saving component as " + pc.getEntryFilename());
 				ZipEntry cmpEntry = new ZipEntry(pc.getEntryFilename());
 				zos.putNextEntry(cmpEntry);
 
 				pc.save(zos);
 				
 				zos.closeEntry();
 			}
 			zos.close();
 
 			Globals.showStatus("Project " + _name + " saved");
 
 			setModified(false);
 			_new = false;
 		}
 		catch (FileNotFoundException e)
 		{
 			e.printStackTrace();
 			Globals.showStatus("ERROR saving project " + _name);
 		}
 		catch (IOException e)
 		{
 			e.printStackTrace();
 			Globals.showStatus("ERROR saving project " + _name);
 		}
 	}
 
 	public void save(String projectFile)
 	{
 		setFilepath(projectFile);
 		save();
 	}
 
 	public boolean isModified()
 	{
 		_dyn_modified.onGet();
 		return _modified;
 	}
 	private void setModified(boolean modified)
 	{
 		if (_modified ^ modified)
 		{
 			_dyn_modified.onSet();
 			_modified = modified;
 		}
 	}
 
 	public void markAsModified()
 	{
 		setModified(true);
 	}
 
 	public boolean isNew()
 	{
 		return _new;
 	}
 	
 	public void markAsNew()
 	{
 		_new = true;
 		setModified(false);
 	}
 
 	protected String convertNameToIdentifier()
 	{
 		StringBuffer buf = new StringBuffer();
 		char[] chars = _name.toCharArray();
 		boolean first = true;
 		for (int i = 0; i < _name.length(); i++)
 		{
 			char chr = Character.toLowerCase(chars[i]);
 			if (first)
 			{
 				if (Character.isUnicodeIdentifierStart(chr))
 				{
 					buf.append(chr);
 					first = false;
 				}
 			}
 			else
 			{
 				if (Character.isUnicodeIdentifierPart(chr))
 				{
 					buf.append(chr);
 				}
 			}
 		}
 
 		return buf.toString();
 	}
 
 	//////////////////////////////////////////////////////////
 	// PropertyChangeListener implementation
 
 	/***
 	 * Receive diagram property change notification and, if appropriate,
 	 * mark the project as modified.
 	 */
 	public void propertyChange(PropertyChangeEvent e)
 	{
 		//System.err.println("propertyChanged: property = " + e.getPropertyName() +
 		//                   " from " + e.getOldValue() + " to " + e.getNewValue());
 		// FIXME: for now we always mark modified; be more selective based on
 		// source Fig and/or newVal <> oldVal??
 		markAsModified();
 	}
 
 
 	//////////////////////////////////////////////////////////
 	// Inner Classes
 	class ProjectComponents
 	{
 		private ProjectProperties _propertiesCmp;
 		private ProjectModel      _modelCmp;
 		private List              _diagramCmps = new LinkedList();
 
 		public void addComponent(ProjectComponent cmp)
 		{
 			if (cmp == null) return;
 			if (cmp instanceof ProjectProperties) _propertiesCmp = (ProjectProperties) cmp;
 			else if (cmp instanceof ProjectModel) _modelCmp = (ProjectModel) cmp;
 			else if (cmp instanceof ProjectDiagram) _diagramCmps.add(cmp);
 		}
 
 		public Vector getComponents()
 		{
 			Vector tmp = new Vector();
 			tmp.add(_propertiesCmp);
 			tmp.add(_modelCmp);
 			tmp.addAll(_diagramCmps);
 			return tmp;
 		}
 
 		public ProjectProperties getPropertiesComponent()
 		{
 			return _propertiesCmp;
 		}
 
 		public ProjectModel getModelComponent()
 		{
 			return _modelCmp;
 		}
 
 		public Iterator getDiagramComponentIterator()
 		{
 			return _diagramCmps.iterator();
 		}
 
 		public void removeDiagramComponent(Diagram d)
 		{
 			Iterator itr = getDiagramComponentIterator();
 			while (itr.hasNext())
 			{
 				ProjectDiagram cmp = (ProjectDiagram) itr.next();
 				if (cmp.getDiagram() == d)
 				{
 					itr.remove();
 					break;
 				}
 			}
 		}
 
 		public Iterator iterator()
 		{
 			return getComponents().iterator();
 		}
 
 		public void prepareForSave()
 		{
 			_propertiesCmp.initEntryFilename();
 			_modelCmp.initEntryFilename();
 			Iterator diagrams = _diagramCmps.iterator();
 			while (diagrams.hasNext())
 			{
 				((ProjectComponent) diagrams.next()).initEntryFilename();
 			}
 		}
 
 	} /* end inner class ProjectComponents */
 
 } /* end class Project */