task.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.io.IOException;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Stack;
import java.util.Vector;

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

/**
 * Tarea de una carta gantt, contiene los datos necesarios
 * para cada tarea. Se enlaza con sus tareas hijas a traves
 * de {@link #getChilds()} y {@link #addChild()}.
 * 
 * Los plugins pueden acceder y modificar el arbol de tareas
 * directamente a traves de este objeto y desde las funciones 
 * del objeto {@link Project}.
 * 
 *  
 * @version $Header: /cvs/java/App_JGantt/source/jgantt/model/Task.java,v 1.51 2005/08/19 15:50:42 csilva Exp $ 
 * @author Carlos Silva
 */
public class Task {
	// Instancia
	/**
	 * id
	 */
	protected int id = 0;
	/**
	 * Nombre
	 */
	protected String name = Messages.getString("task.defaultName"); //$NON-NLS-1$
	/**
	 * Largo de la tarea en minutos habiles.
	 */
	protected int length = 0;
	/**
	 * Fecha antes de la cual la tarea no debe comenzar.
	 * Esta restriccion solo aplica a tareas no contenedoras.
	 */
	protected Date notBeforeDate = null;
	/**
	 * Comentarios
	 */
	protected String comments = Messages.getString("task.defaultComment"); //$NON-NLS-1$
	/**
	 * Porcentaje completado de la tarea
	 */
	protected int completed = 0;
	/**
	 * Prioridad de la tarea (numero entero)
	 */
	protected int priority = 0;
	/**
	 * indicador si ta tarea se marca como hito.
	 */
	protected boolean hito = false;

	/**
	 * notas
	 */
	protected String notes = "";

	/**
	 * Largo minimo de la tarea en minutos habiles.
	 */
	int minLength = 0;
	/**
	 * Largo maximo de la tarea en minutos habiles.
	 */
	int maxLength = 0;

	/**
	 * Datos para ser utilizados por la aplicacion de despliege/edicion.
	 * los datos son no transientes. sin embargo, al serializar, solo 
	 * se graban objetos de clases String, Number y Date.
	 */
	protected Hashtable attributes = new Hashtable();

	// Asociaciones con otros objetos
	/**
	 * Lista de tareas que componen un resumen.
	 * Esta tarea es un resumen si childTasks.size()>0
	 */
	protected Vector childTasks = new Vector();
	/**
	 * Tarea padre (o resumen) de esta tarea.
	 */
	protected Task parentTask = null;
	/**
	 * lista de dependencias que nacen de esta tarea
	 * Esta variable es llenada por la clase {@link Constraint}
	 */
	protected Vector childConstraints = new Vector();
	/**
	 * lista de dependencias que afectan a esta tarea.
	 * Esta variable es llenada por la clase {@link Constraint}
	 */
	protected Vector constraints = new Vector();
	/**
	 * Referencia al proyecto al cual pertenecen las tareas
	 */
	protected Project project = null;
	/**
	 * Recursos asociados a la ejecucion de la tarea
	 * Contiene elementos de tipo {@link Asignation}
	 */
	protected Vector resources = new Vector();

	// Transientes
	/**
	 * Fecha de inicio calculada segun el {@link DateOrganizer}.
	 * Solo es valida si dirty==false
	 */
	transient Date startDate = null;
	/**
	 * Indicacion de si la tarea requiere recalcularse
	 */
	transient boolean dirty = true;
	/**
	 * fecha de termino de la tarea
	 * solo es valida si dirty==false
	 */
	transient Date finishDate = null;
	/**
	 * indicacion de si la tarea se esta borrando
	 * para no enviar multiples notificaciones al borrar un arbol.
	 * @param p
	 */
	transient boolean removed = false;

	/**
	 * Contructor de una tarea.
	 * Inicializa el proyecto como una referencia interna.
	 */
	public Task(Project p) {
		project = p;
	}
	/**
	 * Crea una tarea a partir de un proyecto y un nombre
	 * @param p
	 * @param name
	 */
	public Task(Project p, String name) {
		project = p;
		setName(name);
	}
	/**
	 * Crea una tarea a partir de un proyecto, un nombre y una duracion en dias. 
	 * @param p
	 * @param name
	 * @param length
	 */
	public Task(Project p, String name, int length) {
		project = p;
		this.name = name;
		try {
			// En teoria se deberia llamar a setLength, pero esta genera un Comando (undo/redo) 
			// que no deberia funcionar aparte de crear una tarea 
			this.length = length;
			setDirty();
		} catch (Exception e) {
			// nunca ocurrira, esta tarea nueva no tiene hijos.
		}
	}

	/**
	 * Datos para ser utilizados por la aplicacion de despliege/edicion
	 * En la lista de atributos se puede almacenar cualquier valor (no null)
	 */
	public Object getAttribute(String name) {
		return attributes.get(name);
	}

	/**
	 * Datos para ser utilizados por la aplicacion de despliege/edicion.
	 * En la lista de atributos se puede almacenar cualquier valor.
	 */
	public void setAttribute(String name, Object data) {
		attributes.put(name, data);
	}

	/**
	 * Datos para ser utilizados por la aplicacion de despliege/edicion
	 */
	public void removeAttribute(String name) {
		attributes.remove(name);
	}

	// Metodos protegidos	
	/**
	 * Asigna el Id de la tarea.
	 * Este Id es interno, parte de 0 para la tarea principal (invisible)
	 * del proyecto y es asignada por el proyecto.
	 */
	protected void setId(int i) {
		id = i;
	}

	/**
	 * retorna el Id de la tarea. La tarea 
	 * principal del proyecto (invisible) tiene Id ==0. 
	 */
	public int getId() {
		return id;
	}

	/**
	 * indica si la tarea es un resumen de otras tareas.
	 */
	public boolean isResume() {
		return childTasks.size() > 0;
	}

	/**
	 * Remueve la tarea del proyecto.
	 * para remover la tarea se remueven sus constraints  de la lista de objetos.
	 * ademas se remueve de la lista de hijos de la tarea resumen
	 * y llama a la funcion removeTask() del proyecto.</P>
	 * </P>Esta funcion puede ser llamada por los elementos externos.
	 * notifica del borrado llamando a la funcion {@link Project#removeTask}.</P>
	 * <P>Esta funcion solo notifica la eliminacion del primer hijo. No envia 
	 * notificaciones para las tareas hijas que dependen.</P>
	 */
	public void remove() {
		removed = true;
		for (Enumeration e = childConstraints.elements();
			e.hasMoreElements();
			) {
			Constraint c = (Constraint) e.nextElement();
			c.getSlaveTask().setDirty();
			c.remove();
		}
		for (Enumeration e = constraints.elements(); e.hasMoreElements();) {
			Constraint c = (Constraint) e.nextElement();
			c.remove();
		}
		// borrar los hijos.
		for (Enumeration e = childTasks.elements(); e.hasMoreElements();) {
			Task t = (Task) e.nextElement();
			t.remove();
		}
		parentTask.childTasks.remove(this);
		parentTask.setDirty();
		// Solo notifica si esta es la tarea principal borrada.

		if (!parentTask.removed) {

			project.removeTask(this);

			TaskCommand cmd = new TaskCommand(this) {
				public void execute() {
					task.remove();
				}

				public void undo() {
					parentTask.addChild(task);
				}
			};
			project.registerCommand(cmd);
		}
	}

	/**
	 * marca esta tarea como una tarea resumen al agregar una 
	 * tarea hija.
	 * Esta funcion asigna el Id de la tarea hija dejandola como
	 * el ultimo hijo.
	 */
	public void addChild(Task t) {
		notBeforeDate = null;
		t.parentTask = this;
		int idx = id;
		int childs = childTasks.size();

		childTasks.addElement(t);
		TaskCommand cmd = new TaskCommand(t) {
			public void execute() {
				addChild(task);
			}

			public void undo() {
				task.remove();
			}
		};
		project.registerCommand(cmd);
		project.childInserted(t);
		setDirty();
	}
	
	/**
	 * Agrega como hijas de esta tarea el contenido de otro proyecto.
	 * @param p proyecto a cargar 
	 */
	public void addChild(Project p ){
		notBeforeDate = null;
		int idx = id;
		int childs = childTasks.size();

		for (int i=0;i<p.taskList.size(); i++){
			((Task)p.taskList.get(i)).project=project;
		}		
		for (int i=0;i<p.mainTask.childTasks.size(); i++){
			((Task)p.mainTask.childTasks.get(i)).parentTask=this;
		}
		childTasks.addAll(p.mainTask.childTasks);

		
		//TODO: Soporte undo/redo para esta operacion
		project.childInserted(this);
		setDirty();
		
		
	}
	
	
	/**
	 * Agrega una tarea como hija pero antes que otra. 	 
	 * Esta funcion asigna el Id de la tarea hija dejandola como
	 * el ultimo hijo.
	 */
	private void addChildBefore(Task newTask, Task before) {
		notBeforeDate = null;
		newTask.parentTask = this;
		newTask.setId(before.getId());
		int childs = childTasks.size();
		if (before != null) {
			int i = childTasks.indexOf(before);
			if (i >= 0)
				childTasks.add(i, newTask);
			else
				childTasks.add(newTask);
		} else
			childTasks.add(newTask);

		TaskCommand cmd = new TaskCommand(newTask, before) {
			public void execute() {
				addChildBefore(task, refTask);
			}

			public void undo() {
				task.remove();
			}
		};
		project.registerCommand(cmd);
		project.childInserted(newTask);
	}
	/**
	 * Agrega una tarea como hermana anterior
	 * @param newTask tarea nueva
	 */
	public void addBefore(Task newTask) {
		getParentTask().addChildBefore(newTask, this);
	}

	/**
	 * Agrega una tarea como hija pero antes que otra. 	 
	 * Esta funcion asigna el Id de la tarea hija dejandola como
	 * el ultimo hijo.
	 */
	private void addChildAfter(Task newTask, Task after) {
		notBeforeDate = null;
		newTask.parentTask = this;
		newTask.setId(after.getId());
		int childs = childTasks.size();
		if (after != null) {
			int i = childTasks.indexOf(after);
			if (i >= 0)
				childTasks.add(i + 1, newTask);
			else
				childTasks.add(newTask);
		} else
			childTasks.add(newTask);

		TaskCommand cmd = new TaskCommand(newTask, after) {
			public void execute() {
				addChildAfter(task, refTask);
			}

			public void undo() {
				task.remove();
			}
		};
		project.registerCommand(cmd);

		project.childInserted(newTask);
	}

	/**
	 * Agrega una tarea como hermana posterior
	 * @param newTask tarea nueva
	 */
	public void addAfter(Task newTask) {
		getParentTask().addChildAfter(newTask, this);
	}

	/**
	 * Retorna el nombre de la tarea(titulo)
	 */
	public String getName() {
		return name;
	}

	/**
	 * Transforma esta tarea en hija de su hermana anterior
	 * No deben haber contraints entre hermana y hermana (eliminar)
	 * 	 
	 */
	public void asChild() {
		int i = parentTask.childTasks.indexOf(this);
		if (i == 0)
			return;
		parentTask.childTasks.remove(i);
		Task t = (Task) parentTask.childTasks.elementAt(i - 1);
		//System.out.println("childing " + getId() + " -> " + t.getId());
		for (int j = 0; j < t.childConstraints.size(); j++) {
			//System.out.println(j);
			Constraint c = (Constraint) t.childConstraints.get(j);
			//System.out.println("Constraint "+ c.getMasterTask().getId()+ " -> "+ c.getSlaveTask().getId());
			if (hasChild(c.getSlaveTask()))
				c.remove();
		}
		t.addChild(this);
		project.taskMoved(this);
	}

	/**
	 * Retorna verdadero si esta tarea depende de otra.
	 * <p>Una tarea <code>A</code> depende de otra <code>B</code> si:</p>
	 * <ol>
	 * <li>A==B
	 * <li>A es descendiente de B
	 * <li>algun ancestro de B tiene un Constraint hacia algun ancestro de A
	 * <li>algun descendiente de B tiene un constraint hacia algun descendiente de A 
	 * </ol>  
	 * <p>Otra forma de verlo es: Una tarea <code>A</code> depende de otra <code>B</code> si:</p>
	 * <ol>
	 * <li>El conjunto de descendientes y restrictos de descendientes y restrictos incluye a A. 
	 * </ol>
	 * 
	 * @param master Task que puede ser una tarea que contiene una dependencia.
	 * @return verdadero segun las condiciones enumeradas.
	 */
	public void checkConstrained(Task master) throws GanttException {
		Task t = null;

		// 1.- A==B
		if (master == this)
			throw new GanttException(Messages.getString("task.error.selfConstraint")); //$NON-NLS-1$
		// 2.- A es descendiente de B
		if (isChildOf(master))
			throw new GanttException(Messages.getString("task.error.parentConstraint")); //$NON-NLS-1$

		// 3.- Conjunto de restrictos.
		Vector set = new Vector();
		Stack porRevisar = new Stack();

		porRevisar.push(master);
		t = master;
		while (t != null) {
			set.add(t);
			// add constrained tasks 
			for (Iterator it = t.childConstraints.iterator(); it.hasNext();) {
				Constraint c = (Constraint) it.next();
				porRevisar.push(c.getSlaveTask());
			}
			t = t.parentTask;
		}
		while (!porRevisar.empty()) {
			t = (Task) porRevisar.pop();
			set.add(t);
			// agregar hijos
			for (Iterator it = t.childTasks.iterator(); it.hasNext();)
				porRevisar.push(it.next());
			//	agregar tasks constrained
			for (Iterator it = t.childConstraints.iterator(); it.hasNext();) {
				Constraint c = (Constraint) it.next();
				porRevisar.push(c.getSlaveTask());
			}
		}
		if (set.contains(this))
			throw new GanttException(Messages.getString("task.error.dependantConstraint")+" Task '"+this.name+"' depends on '"+master.name+"'.");
	}

	/**
	 * Convierte una tarea en hermana de su padre.
	 */
	public void deChild() {
		if (getChildLevel() == 1)
			return;
		Task parent = parentTask;
		parentTask.childTasks.remove(this);
		parentTask.parentTask.addChild(this);
		parent.setDirty();
		setDirty();
		project.taskMoved(this);
	}
	/**
	 * Convierte mueve una herma a su tarea anterior
	 */
	public void goUp() {
		int i = parentTask.childTasks.indexOf(this);
		if (i == 0)
			return;
		parentTask.childTasks.add(i - 1, this);
		parentTask.childTasks.remove(i + 1);
		setDirty();
		project.taskMoved(this);
	}
	/**
	 * Convierte mueve una herma a su tarea anterior
	 */
	public void goDown() {
		int i = parentTask.childTasks.indexOf(this);
		if (i + 1 >= parentTask.childTasks.size())
			return;
		parentTask.childTasks.add(i + 2, this);
		parentTask.childTasks.remove(i);
		parentTask.setDirty();
		project.taskMoved(this);
	}

	/**
	 * Determina si una tarea es hija de esta.
	 * 
	 * @param child
	 * @return true si this tiene como descendiente child
	 */
	public boolean hasChild(Task child) {
		if (this == child)
			return true;
		for (Iterator it = childTasks.iterator(); it.hasNext();) {
			Task c = (Task) it.next();
			if (c.hasChild(child))
				return true;
		}
		return false;
	}

	/**
	 * getChildLevel retorna el nivel de profundidad de la tarea
	 * comienza desde 1.
	 * @return profundidad desde 1.
	 */
	public int getChildLevel() {
		if (parentTask == null)
			return 0;
		return parentTask.getChildLevel() + 1;
	}
	/**
	 * Retorna el nombre de la tarea(titulo) con indentacion dependiendo
	 * de la profundidad en descendientes de la tarea principal del proyecto.
	 */