tasktree.java

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

					if (t.isResume()) {
						Image folderImage = (t.getChildsVisible() ? iminus
								: iplus);
						g.drawImage(folderImage, xp, y + imgOffset, null);
					}

					g.drawString(c.getValue(t), xp + iconWidth + 1, y
							+ fontOffset);
				} else {
					String s = c.getValue(t);
					if (s == null)
						s = "";
					switch (c.getAlign()) {
					case Column.LEFT:
						g.drawString(s, x + 5, y + 14);
						break;
					case Column.RIGHT: {
						int w = g.getFontMetrics().stringWidth(s);
						g.drawString(s, x + l - 5 - w, y + fontOffset);
					}
						break;
					default: {
						int w = g.getFontMetrics().stringWidth(s);
						g.drawString(s, x + (l - 3 - w) / 2, y + fontOffset);
					}
					}

				}

				x += l;
			}
			y += h;
			x = -scroll.getValue();
		}
		focusRect = frect;
	}

	// ******************************************************************************
	// Manejo del foco
	// ******************************************************************************
	/**
	 * Asigna el foco de este componente en la celda apuntada por x e y. Ademas
	 * cambia el estado de visualizacion de las tareas hijas del arbol
	 * 
	 * @param x
	 * @param y
	 */
	void setFocus(int x, int y) {
		x += scroll.getValue();
		int row = (y - treeOptions.headerHeight) / treeOptions.rowHeight;
		row += project.getViewOptions().getTopRow();
		if ((row >= 0) && (row < project.getVisibleTaskCount())) {
			// buscar columna
			int xp = 0;
			for (Iterator i = columns.iterator(); i.hasNext();) {
				Column c = (Column) i.next();
				xp += c.getLength();
				if (x < xp) {
					// found!!
					Task task = project.getVisibleTask(row);

					if (c.getProperty().equals("name")) {
						// marcar columna si se hizo click en la imagen.

						int left = x - xp + c.getLength();
						int x1 = 3 + (task.getChildLevel() - 1) * iconWidth;
						int x2 = x1 + iconWidth;

						if ((x1 < left) && (left < x2))
							if (task.isResume())
								task.setChildsVisible(!task.getChildsVisible());
					}

					setFocus(task, c, true);
					return;
				}
			}
		}
		setFocus(null, null);
	}

	/**
	 * Reasigna el foco en otra tarea, mantendiendo la columna
	 * 
	 * @param newTask
	 */
	public void setFocus(Task newTask) {
		setFocus(newTask, focusColumn, false);
	}

	/**
	 * Asigna el foco de esta tabla editora y se asegura que este visible.
	 * 
	 * @param newTask
	 * @param newColumn
	 */
	public void setFocus(Task newTask, Column newColumn) {
		setFocus(newTask, newColumn, false);
	}

	/**
	 * Asigna el foco
	 * 
	 * @param newTask
	 * @param newColumn
	 * @param forceRepaint
	 */
	public void setFocus(Task newTask, Column newColumn, boolean forceRepaint) {
		boolean a = focusColumn != newColumn;
		boolean b = focusTask != newTask;
		focusColumn = newColumn;
		focusTask = newTask;
		finishEdit();

		if (newColumn == null)
			return;
		if (newTask == null)
			return;
		Rectangle bounds = getBounds();

		// asegurar que se vea la fila/columna seleccionada
		// 0---------------s----e
		// x<------w----->r
		// 
		int inicial = newColumn.getX() - scroll.getValue();
		reactToScrolling = false;
		if (inicial < 0) // si esta a la izquierda de lo visible
			scroll.setValue(newColumn.getX());
		else {
			int end = newColumn.getX() + newColumn.getLength() + 1;
			int right = bounds.width + scroll.getValue();
			if (end > right) {
				if (newColumn.getLength() > bounds.width)
					// mas grande que la pantalla
					scroll.setValue(newColumn.getX());
				else
					scroll.setValue(end - bounds.width);
			}
		}
		reactToScrolling = true;
		if (b) {
			int rowsInScreen = (int) (bounds.getHeight() - treeOptions.headerHeight)
					/ treeOptions.rowHeight;
			int topRow = project.getViewOptions().getTopRow();
			int p = focusTask.getVisibleIndex() - topRow;

			if (p >= rowsInScreen) {
				project.getViewOptions().setTopRow(
						focusTask.getVisibleIndex() + 1 - rowsInScreen);
			} else if (p < 1) { // el primer visible index==1
				project.getViewOptions().setTopRow(
						focusTask.getVisibleIndex() - 1);
			}

			pvModel.setCurrentTask(focusTask);
		}
		if (a || b || forceRepaint)
			repaint();

		requestFocus();
	}

	// ******************************************************************************
	// Edicion volante
	// ******************************************************************************

	/**
	 * Inicia la edicion de los datos presentes en la fila y columna actual.
	 * Esto se realiza si y solo si la columna es editable.
	 * <P>
	 * Asigna acciones para aceptar y cancelar la edicion en base a que el
	 * usuario presione ENTER o ESC.
	 * </P>
	 */
	public void initEdit(KeyEvent ev) {
		if (focusTask == null)
			return;
		if (focusColumn.isReadOnly())
			return;

		Rectangle frect = new Rectangle(focusRect);
		frect.x -= 1;
		frect.y -= 2;
		frect.width += 3;
		frect.height += 5;

		String text = null;
		if ((ev != null) && (ev.getKeyChar() != '?'))
			movilEditor.start(frect, "" + ev.getKeyChar(), false);
		else
			movilEditor.start(frect, focusColumn.getValue(focusTask), true);
	}

	/**
	 * termina la edicion del dato en el foco. esto se realiza eliminando el
	 * componente d ela visualizacion.
	 */
	public void finishEdit() {
		if (movilEditor.getParent() == null)
			return;
		movilEditor.stop();
		grabFocus();
		recalcWidths = true;
		repaint();
	}

	/**
	 * Transfiere la informacion desde el editor puesto en la pantalla con
	 * {@link #initEdit} hacia el campo adecuado en la tarea. Ademas termina la
	 * ejecucion del componente de edicion.
	 */
	public void acceptEdit() {
		try {
			focusColumn.setValue(focusTask, movilEditor.getText());
		} catch (Exception e) {
			JOptionPane.showMessageDialog(this, e, "Error al asignar valor",
					JOptionPane.ERROR_MESSAGE);
		}
		finishEdit();
	}

	// ******************************************************************************
	// Notificaciones
	// ******************************************************************************
	/**
	 * Cambios en el proyecto
	 * 
	 * @see jgantt.model.ProjectListener#projectChanged(jgantt.model.ProjectChange)
	 */
	public void projectChanged(ProjectChange c) {
		recalcWidths = true;
		repaint();
	}

	/**
	 * Eventos del modelo
	 * 
	 * @see jgantt.view.adapters.ProjectViewModelListener#projectChanged(jgantt.view.adapters.ProjectViewModelChange)
	 */
	public void viewModelChanged(ProjectViewModelChange c) {
		switch (c.getId()) {
		case ProjectViewModelChange.NEW_PROJECT_LOADED:
			assignViewModel(c.getProjectViewModel());
			break;
		case ProjectViewModelChange.CURRENT_TASK_CHANGED:
			setFocus((Task) c.getSource(), focusColumn);
			break;
		}
	}

	/**
	 * Asigna el Modelo de Visualizacion
	 */
	public void assignViewModel(ProjectViewModel pvm) {
		if (project != null)
			project.removeListener(this);

		pvModel = pvm;
		project = pvm.getProject();
		project.addListener(this);
		pvModel.getViewOptions().addObserver(this);
		sdf = new SimpleDateFormat(pvModel.getViewOptions().dateFormat);
		recalcWidths = true;

		treeOptions = pvModel.getProject().getTreeColors();
		treeOptions.headerHeight = pvModel.getViewOptions().headerHeight;
		treeOptions.rowHeight = pvModel.getViewOptions().taskHeight;

		sdf = new SimpleDateFormat(pvModel.getViewOptions().dateFormat);
		setBackground(treeOptions.cellBg);

		// Si no hay columnas preseleccionadas usar un default.
		if (treeOptions.columns == null)
			treeOptions.columns = (Vector) defaultColumns.clone();

		columns.clear();
		for (Iterator iter = treeOptions.columns.iterator(); iter.hasNext();) {
			String element = (String) iter.next();
			Column col = (Column) allColumns.get(element);
			columns.add(col);
		}

		focusColumn = (Column) columns.get(0);

		repaint();
	}

	/**
	 * Se ejecuta cuando cambia la posicion del scrollbar, se debe alterar la
	 * columna inicial.
	 * 
	 * @see java.awt.event.AdjustmentListener#adjustmentValueChanged(java.awt.event.AdjustmentEvent)
	 */
	public void adjustmentValueChanged(AdjustmentEvent ev) {
		if (!reactToScrolling)
			return;
		repaint();
	}

	/**
	 * Repintar la la tarea cuando haya cambios en las opciones de visualizacion
	 * como el formato de fechas.
	 */
	public void viewOptionsChanged() {
		sdf = new SimpleDateFormat(pvModel.getViewOptions().dateFormat);
		treeOptions.rowHeight = pvModel.getViewOptions().taskHeight;
		recalcWidths = true;
		repaint();
	}

	void adjustScrollValues() {
		int cl = 0;
		for (Iterator i = columns.iterator(); i.hasNext();) {
			Column c = (Column) i.next();
			cl += c.getLength();
		}
		Rectangle r = getBounds();
		reactToScrolling = false;
		scroll.setMinimum(0);
		scroll.setMaximum(cl + 1);
		scroll.setVisibleAmount(r.width);
		reactToScrolling = true;
	}

	// ******************************************************************************
	// Exportacion de la imagen
	// ******************************************************************************

	/**
	 * Retorna el tama駉 de esta imagen (solo el arbol)
	 * 
	 * @return
	 */
	public Dimension getImageSize() {
		int width = 1;
		for (Iterator i = columns.iterator(); i.hasNext();) {
			Column c = (Column) i.next();
			width += c.getLength();
		}
		// altura tiene que ver solo con lo visible
		int visibles = 0;
		for (int i = 0; i < project.getTaskCount(); i++) {
			if (project.getTask(i).isVisible()) {
				visibles++;
			}
		}
		int height = (treeOptions.headerHeight) + treeOptions.rowHeight
				* visibles;
		return new Dimension(width, height);
	}

	/**
	 * Pinta una carta gantt. incluye el header y el viewer
	 * 
	 * @param g
	 * @param pvm
	 * @param rect
	 * @return int ancho de la tabla
	 */
	public void paintTree(Graphics g) {
		Dimension dim = getImageSize();
		Rectangle bounds = new Rectangle(0, 0, dim.width, dim.height);
		// no mostrar la fila con foco.
		Column c = focusColumn;
		Task t = focusTask;
		focusColumn = null;
		focusTask = null;
		paintComponent(g, bounds);
		focusColumn = c;
		focusTask = t;
	}
}