project.java

Owing to the applet Gantt chart source yard, already Chinese melt, Gantt chart can demonstrate a Chi

/**
 *   Copyright 2004 Carlos Silva A.
 * 
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License. 
 *   You may obtain a copy of the License at  
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 * 
 */
package jgantt.model;
import java.util.Date;
import java.util.Iterator;
import java.util.Stack;
import java.util.Vector;

import jgantt.Messages;
import jgantt.cmds.Command;
import jgantt.cmds.TaskCommand;

import com.csa.lib.xml.dom.Node;

/**
 * Proyecto representa un proyecto para una carta gantt.
 * <p>Cada proyecto tiene una tarea principal (invisible) de la cual
 * se incluye todo el resto.</p> 
 * <p>La fecha de inicio del proyecto se lleva al campo not before 
 * de la tarea principal.</p> 
 * <p>Las opciones de UNDO, REDO son manejadas por este objeto, pero 
 * talvez sea mejor mover esta funcionalidad a ViewModel</p> 
 * 
 * TODO: agregar una tarea que ya tiene referencias hijas (eliminar constraints).
 * 
 * @version $Header: /cvs/java/App_JGantt/source/jgantt/model/Project.java,v 1.36 2005/08/19 15:50:42 csilva Exp $
 * @author Carlos Silva
 */
public class Project {

	// SOPORTE A UNDO/REDO
	transient private Stack undoStack = new Stack();
	transient private Stack redoStack = new Stack();
	transient private boolean insideRedo = false;
	transient private boolean insideUndo = false;

	/**
	 * Desrealiza el ultimo comando realizado.
	 * Cuando una accion es deshecha, esta pasa a 
	 * lista de comandos por rehacer.
	 */
	public void undo() {
		if (undoStack.isEmpty())
			return;
		insideUndo = true;
		TaskCommand cmd = (TaskCommand) undoStack.pop();
		redoStack.push(cmd);
		
		cmd.undo();		
		insideUndo = false;
	}

	/**
	 * Realiza nuevamente una actividad que ha sido deshecha.
	 */
	public void redo() {
		if (redoStack.isEmpty())
			return;
		insideRedo = true;
		Command cmd = (Command) redoStack.pop();
		cmd.execute();
		insideRedo = false;
	}

	/**
	 * Registra una accion deshacible. Normalmente es 
	 * llamado por los setters de las tareas.
	 */
	public void registerCommand(Command cmd) {
		if (!insideUndo) {
			undoStack.push(cmd);
			if (!insideRedo)
				redoStack.clear();
		}
	}

	/**
	 * Limpia las areas de las acciones de undo y redo.
	 */
	public void clearUndoRedo() {
		undoStack.clear();
		redoStack.clear();
	}

	/**
	 * Pregunta si hay acciones en el area de undo
	 * @return
	 */
	public boolean isUndoEmpty() {
		return undoStack.isEmpty();
	}

	/**
	 * Pregunta si hay acciones en el area de redo
	 * @return
	 */
	public boolean isRedoEmpty() {
		return redoStack.isEmpty();
	}

	/// Tarea principal
	Task mainTask;
	/// Fecha de inicio
	Date startDate;
	/// Nombre del proyecto
	String name;
	/// Juez para realizar consultas frecuentemente
	Referee referee = null;
	/// Organizador de fechas
	DateOrganizer dOrg = new DateOrganizer();
	/// formato grafico
	ViewOptions viewOptions = null;
	/// Colores para graficos
	GraphColors graphColors = null;
	/// Colores para la tabla
	TaskTreeOptions treeColors;
	/// Lista de snapshots
	Vector snapshots = new Vector();

	/**
	 * Recursos asociados al proyecto
	 * Contiene elementos de tipo Resource
	 */
	protected Vector resources = new Vector();

	//transient	
	transient Vector taskList = new Vector();

	// constructor
	public Project(DateOrganizer dorg) {
		mainTask = new Task(this);
		mainTask.setName(Messages.getString("prj.mainTaskName")); //$NON-NLS-1$
		taskList.addElement(mainTask);
		mainTask.setId(0);
		setDateOrganizer(dorg);
	}

	public Task createTask(String name) {
		return new Task(this, name);
	}

	public Task createTask(String name, int length) {
		return new Task(this, name, length);
	}
	public Resource createResource(
		int id,
		String name,
		String alias,
		String initials) {
		Resource person = new Resource(this);
		person.setId(id);
		person.setName(name);
		person.setAlias(alias);
		person.setInitials(initials);
		return person;
	}

	public void taskMoved(Task t) {
		taskList.clear();
		rebuildIds(getMainTask(), 0);
		sendChange(new ProjectChange(ProjectChange.STRUCTURE, t));
	}

	/**
	 * Cuando se agrega una nueva tarea se debe recalcular todos los Id de las tareas.
	 * @param child
	 */
	public void childInserted(Task child) {
		taskList.clear();
		rebuildIds(getMainTask(), 0);
		sendChange(new ProjectChange(ProjectChange.TASK_ADDED, child));
	}
	/**
	 * Remueve a una tarea de la lista de tareas
	 * esta funcion es gatillada por la funcion remove de la tarea.
	 */
	void removeTask(Task child) {
		taskList.clear();
		rebuildIds(getMainTask(), 0);
		// Avisa a los escuchadores despues de eliminar la tarea.
		sendChange(new ProjectChange(ProjectChange.TASK_REMOVED, child));
	}

	/**
	 * Fuerza el recalculo completo.
	 * Esto se requiere cuando hay cambios globales (como el calendario)
	 */
	public void forceRecalc() {
		for (int i = 0; i < taskList.size(); i++) {
			Task t = (Task) taskList.get(i);
			t.setDirty();
		}
		sendChange(new ProjectChange(ProjectChange.FORCED_CHANGE, mainTask));
	}

	/**
	 * Regenera los Ids de las tareas y la lista de tareas taskList
	 * @param t
	 * @param id
	 * @return
	 */
	int rebuildIds(Task t, int id) {
		int oid = id;
		t.setId(id++);
		taskList.add(t);
		for (Iterator i = t.getChildTasks().iterator(); i.hasNext();) {
			Task c = (Task) i.next();
			id = rebuildIds(c, id);
		}
		if (oid == 0)
			rebuildVIds();
		return id;
	}

	int vtCount = 0;
	void rebuildVIds() {
		vtCount = 0;
		//System.out.println("Project.rebuildVIds()");
		for (int i = 0; i < taskList.size(); i++) {
			Task t = (Task) taskList.get(i);
			if (t.isVisible())
				t.visibleIndex = vtCount++;
			else
				t.visibleIndex = -1;
			//System.out.println("   task "+t.getId()+" "+ t.getName()+" visibleIndex="+t.visibleIndex);
		}
		vtCount--; // mainTask no se cuenta
	}

	/**
	 * 
	 * @return cantidad de tareas visibles sin inlcuir mainTask
	 */
	public int getVisibleTaskCount() {
		return vtCount;
	}

	/**
	 * Obtiene la tarea iesima
	 * @param n id de la tarea 0..visibleTaskCount
	 * @return Tarea en la posicion n-esima
	 */
	public Task getVisibleTask(int n) {
		n++;
		for (int i = 0; i < taskList.size(); i++) {
			Task t = (Task) taskList.get(i);
			if (t.getVisibleIndex() == n)
				return t;
		}
		//System.out.println("Project.getVisibleTask()" + n + "  not found");
		return null;
	}

	/**
	 * Al contrario de la funcion removeTask(Task), esta funcion puede
	 * ser llamada por la interfaz para eliminar una cierta tarea
	 * Para borrar una tarea de la cual se tiene la referencia se debe
	 * usar task.remove().
	 */
	public void removeTask(int id) {
		Task child = (Task) taskList.elementAt(id);
		child.remove();
	}

	public int getTaskCount() {
		return taskList.size() - 1;
	}
	public Task getTask(int i) {
		return (Task) taskList.elementAt(i + 1);
	}
    
    void allDirty(){
        for (int i = 0; i < taskList.size(); i++) {
            Task t = (Task) taskList.get(i);
            t.dirty=true;
        }
    }

	public void setDateOrganizer(DateOrganizer d) {
		dOrg = d;
	}
	public DateOrganizer getDateOrganizer() {
		return dOrg;
	}

	public Task getMainTask() {
		return mainTask;
	}

	public Date getStartDate() {
		return startDate;
	}

	public void setStartDate(Date newStartDate) {
		if (dOrg == null) {
			throw new RuntimeException(Messages.getString("prj.error.noCalendar")); //$NON-NLS-1$
		}
		// cambia la hora de inicio de la jornada
		startDate = dOrg.getNormalizedStartDate(newStartDate);

		for (Iterator i = taskList.iterator(); i.hasNext();) {
			Task t = (Task) i.next();
			t.setDirty();
		}
		sendChange(new ProjectChange(ProjectChange.START_DATE, null));
	}

	public String getName() {
		return name;
	}

	public void setName(String newName) {
		name = newName;
	}
	/**
	 * agrega un nuevo recurso y le asigna un id.
	 * @param r
	 */
	protected void addResource(Resource r) {
		resources.add(r);
		r.setId(resources.size());
	}

	/**
	 * Retorna la lista de recursos asociados al proyecto.
	 * @return
	 */
	public Vector getResources() {
		return resources;
	}

	/**
	 * Retorna una lista con los recursos y la cantidad de horas hombre total de cada uno.
	 * Las unidades de asignation estan en minutos habiles.
	 * 
	 * @return Vector donde cada elemento es de tipo Asignation
	 */
	public Vector getTotalAsignations() {
		Vector v = new Vector();
		for (Iterator i = resources.iterator(); i.hasNext();) {
			Resource r = (Resource) i.next();
			int units = mainTask.getTotalResourceUnits(r);
			Asignation a = new Asignation(r, units);
			v.add(a);
		}
		return v;
	}
	public Vector getWorkedAsignations() {
		Vector v = new Vector();
		for (Iterator i = resources.iterator(); i.hasNext();) {
			Resource r = (Resource) i.next();
			int units = mainTask.getWorkedResourceUnits(r);
			Asignation a = new Asignation(r, units);
			v.add(a);
		}
		return v;
	}

	protected boolean decide(Decision d) {
		if (referee == null)
			referee = new Referee();
		return referee.decide(d);
	}

	/**
	 * Transformar este objet en un nodo de XML
	 * retorna un Elemento XML (no lo agrega al arbol)
	 * @return Element
	 */
	public Node toXMLElement() {
		return XMLModel.toXML(this);
	}

	/**
	 * Equivalente de llamar a {@link resource.remove}.
	 * Quita al recurso de la lista de recursos y de las tareas que lo tienen con asignacion.
	 * @param i
	 */
	public void removeResource(int id) {
		Resource r = (Resource) resources.remove(id - 1);
		for (int j = 0; j < taskList.size(); j++) {
			Task t = (Task) taskList.get(j);
			t.removeResource(r);
		}
		// reajustar ids
		for (int j = 0; j < resources.size(); j++) {
			r = (Resource) resources.get(j);
			r.setId(j + 1);
		}
	}

	/**
	 * Retorna los colores generales del grafico de la gantt.
	 * @return
	 */
	public GraphColors getGraphColors() {
		if (graphColors == null) {
			graphColors = new GraphColors(true);

		}
		return graphColors;
	}

	public void setGraphColors(GraphColors gc) {
		graphColors = gc;
	}

	/** 
	 * Retorna las caracteristicas visuales del proyecto.
	 * @return
	 */
	public ViewOptions getViewOptions() {
		if (viewOptions == null) {
			viewOptions = new ViewOptions(this);
		}
		return viewOptions;
	}

	public TaskTreeOptions getTreeColors() {
		if (treeColors == null) {
			treeColors = new TaskTreeOptions();
		}
		return treeColors;
	}

	/**
	 * Guarda informacion de las tareas existentes sus fechas de inicio y termino
	 * y su estado de completitud. Asocia a cada tarea un resumen con su informacion 
	 * particular llamando a la funcion {@link Task#takeSnapshot} de cada subtarea.</p>
	 * <p>Cada snapshot tiene asociada una fecha de generacion y un nombre. 
	 * La llave de los snapshots es la fecha en que se toma el snapshot.</p>
	 * 
	 * @param name nombre del snapshot 
	 */
	public void takeSnapshot(String name) {
		Date date = new Date();
		for (int i = 0; i < taskList.size(); i++) {
			Task t = (Task) taskList.get(i);
			t.takeSnapshot(date);
		}
		SnapShot ss = new SnapShot(date, name);
		snapshots.add(ss);
		sendChange(new ProjectChange(ProjectChange.SNAPSHOT_ADDED, ss));
	}

	public static class SnapShot {
		public Date date;
		public String name;
		public SnapShot(Date d, String n) {
			date = d;
			name = n;
		}
		public String toString() {
			return XMLModel.sdf.format(date) + ": " + name;
		}
	}

	/**
	 * Recupera una tabla de hashing con los snapshots.
	 * donde la llave es la fecha...
	 * @return
	 */
	public Vector getSnapshots() {
		return snapshots;
	}

	/**
	 * Remueve este snapshot de todos los hijos
	 * @param d
	 */
	public void removeSnapshot(Date date) {
		SnapShot ss = null;
		for (int i = 0; i < snapshots.size(); i++) {
			ss = (SnapShot) snapshots.get(i);
			if (ss.date.equals(date)) {
				snapshots.remove(ss);
				for (int j = 0; j < taskList.size(); j++) {
					Task t = (Task) taskList.get(j);
					t.removeSnapshot(date);
				}
				break;
			}
		}
		sendChange(new ProjectChange(ProjectChange.SNAPSHOT_REMOVED, ss));
	}

	// Soporte a eventos
	/**
	 * Objeto para administrar listeners
	 */
	protected ChangeSupport changeSupport = new ChangeSupport() {
		protected void notifyListener(Object listener, Change change) {
			((ProjectListener) listener).projectChanged((ProjectChange) change);
		}
	};
	/**
	 * Agrega un listener a los suscritos
	 * @param o
	 */
	public void addListener(ProjectListener listener) {
		changeSupport.addListener(listener);
	}
	/**
	 * Remueve un listener de los suscritos
	 * @param listener
	 */
	public void removeListener(ProjectListener listener) {
		changeSupport.removeListener(listener);
	}
	/**
	 * Comienza una bloque de cambios que deben despacharse todos
	 * juntos al final.
	 * <p>El ultimo mensaje del bloque se envia con la marca:<code>isLast</code>.</p>
	 */
	public void beginBlockChanges() {
		changeSupport.beginBlockChanges();
	}
	/**
	 * Envia en bloque todos los cambios recibidos y que estan en la cola.
	 * <p>El ultimo mensaje del bloque se envia con la marca:<code>isLast</code>.</p>
	 */
	public void commitBlockChanges() {
		changeSupport.commitBlockChanges();
	}
	/**
	 * Envia una cambio a todos los escuchadores
	 * @param change ProjectChange
	 */
	public void sendChange(ProjectChange change) {
		changeSupport.sendChange(change);
	}

}