gantttree2.java

It is all about project scheduling. GanttProject is a tool for creating a project schedule by means

/***************************************************************************
 * GanttTree.java  -  description
 * -------------------
 * begin                : dec 2002
 * copyright            : (C) 2002 by Thomas Alexandre
 * email                : alexthomas(at)ganttproject.org
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

package net.sourceforge.ganttproject;

import java.awt.AlphaComposite;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.GradientPaint;
import java.awt.Graphics2D;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.SystemColor;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.dnd.Autoscroll;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DragGestureEvent;
import java.awt.dnd.DragGestureListener;
import java.awt.dnd.DragSource;
import java.awt.dnd.DragSourceDragEvent;
import java.awt.dnd.DragSourceDropEvent;
import java.awt.dnd.DragSourceEvent;
import java.awt.dnd.DragSourceListener;
import java.awt.dnd.DropTarget;
import java.awt.dnd.DropTargetDragEvent;
import java.awt.dnd.DropTargetDropEvent;
import java.awt.dnd.DropTargetEvent;
import java.awt.dnd.DropTargetListener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.JTree;
import javax.swing.KeyStroke;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
import javax.swing.ToolTipManager;
import javax.swing.border.EtchedBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;

import net.sourceforge.ganttproject.action.AddBlankLineAction;
import net.sourceforge.ganttproject.action.GPAction;
import net.sourceforge.ganttproject.action.NewTaskAction;
import net.sourceforge.ganttproject.delay.Delay;
import net.sourceforge.ganttproject.delay.DelayObserver;
import net.sourceforge.ganttproject.font.Fonts;
import net.sourceforge.ganttproject.gui.TaskTreeUIFacade;
import net.sourceforge.ganttproject.gui.UIFacade;
import net.sourceforge.ganttproject.language.GanttLanguage;
import net.sourceforge.ganttproject.task.BlankLineNode;
import net.sourceforge.ganttproject.task.ResourceAssignment;
import net.sourceforge.ganttproject.task.Task;
import net.sourceforge.ganttproject.task.TaskManager;
import net.sourceforge.ganttproject.task.TaskManagerImpl;
import net.sourceforge.ganttproject.task.TaskNode;
import net.sourceforge.ganttproject.task.algorithm.AdjustTaskBoundsAlgorithm;
import net.sourceforge.ganttproject.task.algorithm.RecalculateTaskScheduleAlgorithm;
import net.sourceforge.ganttproject.task.dependency.TaskDependency;
import net.sourceforge.ganttproject.task.dependency.TaskDependencyConstraint;
import net.sourceforge.ganttproject.task.dependency.TaskDependencyException;
import net.sourceforge.ganttproject.undo.GPUndoManager;

import org.jdesktop.swing.treetable.DefaultTreeTableModel;

/**
 * Class that generate the JTree
 */
public class GanttTree2 extends JPanel implements DragSourceListener,
        DragGestureListener, DelayObserver, ProjectEventListener, TaskTreeUIFacade {
    /** The root node of the Tree */
    private TaskNode rootNode;

    /** The model for the JTableTree */
    private GanttTreeTableModel treeModel;

    private UIFacade myUIFacade;

    /** The GanttTreeTable. */
    private GanttTreeTable treetable;

    /** Pointer on graphic area */
    private GanttGraphicArea area = null;

    /** Pointer on application */
    private GanttProject appli;

    /** An array for expansion */
    // private ArrayList expand = new ArrayList();
    private static final int AUTOSCROLL_MARGIN = 12;

    /** The vertical scrollbar on the JTree */
    private JScrollBar vbar;

    /** The horizontal scrollbar on the JTree */
    private JScrollBar hbar;

    /** The language use */
    private GanttLanguage language = GanttLanguage.getInstance();

    /** Number of tasks on the tree. */
    private int nbTasks = 0;

    private TreePath dragPath = null;

    private BufferedImage ghostImage = null; // The 'drag image'

    private Point offsetPoint = new Point(); // Where, in the drag image, the

    // mouse was clicked

    private final TaskManager myTaskManager;

    private final GPAction myIndentAction = new GPAction() {
        protected String getIconFilePrefix() {
            return "indent_";
        }

        public void actionPerformed(ActionEvent e) {
            indentCurrentNodes();
        }
        protected String getLocalizedName() {
            return getI18n("indentTask");
        }
    };
    private final GPAction myDedentAction = new GPAction() {

        protected String getIconFilePrefix() {
            return "unindent_";
        }

        public void actionPerformed(ActionEvent e) {
            dedentCurrentNodes();
        }
        protected String getLocalizedName() {
            return getI18n("dedentTask");
        }
    };
    private final GPAction myMoveUpAction = new GPAction() {
        protected String getIconFilePrefix() {
            return "up_";
        }
        public void actionPerformed(ActionEvent e) {
            upCurrentNodes();
        }
        protected String getLocalizedName() {
            return getI18n("upTask");
        }        
    };
    private final GPAction myMoveDownAction = new GPAction() {
        protected String getIconFilePrefix() {
            return "down_";
        }
        public void actionPerformed(ActionEvent e) {
            downCurrentNodes();
        }
        protected String getLocalizedName() {
            return getI18n("downTask");
        }        
    };
    private Action myLinkTasksAction;
    private Action myUnlinkTasksAction;
    
    private class AutoscrollingTree extends JTree implements Autoscroll {

        public AutoscrollingTree(DefaultTreeModel treeModel) {
            super(treeModel);
        }

        // Calculate the insets for the *JTREE*, not the viewport
        // the tree is in. This makes it a bit messy.
        public Insets getAutoscrollInsets() {
            Rectangle raOuter = getBounds();
            Rectangle raInner = getParent().getBounds();
            return new Insets(raInner.y - raOuter.y + AUTOSCROLL_MARGIN,
                    raInner.x - raOuter.x + AUTOSCROLL_MARGIN, raOuter.height
                            - raInner.height - raInner.y + raOuter.y
                            + AUTOSCROLL_MARGIN, raOuter.width - raInner.width
                            - raInner.x + raOuter.x + AUTOSCROLL_MARGIN);
        }

        public void autoscroll(Point pt) {
            // Figure out which row we�e on.
            int nRow = this.getClosestRowForLocation(pt.x, pt.y);

            // If we are not on a row then ignore this autoscroll request
            if (nRow < 0)
                return;

            Rectangle raOuter = getBounds();
            // Now decide if the row is at the top of the screen or at the
            // bottom. We do this to make the previous row (or the next
            // row) visible as appropriate. If we�e at the absolute top or
            // bottom, just return the first or last row respectively.

            nRow = (pt.y + raOuter.y <= AUTOSCROLL_MARGIN) // Is row at top of
                    // screen?
                    ? (nRow <= 0 ? 0 : nRow - 1) // Yes, scroll up one row
                    : (nRow < this.getRowCount() - 1 ? nRow + 1 : nRow); // No,
            // scroll
            // down
            // one
            // row

            this.scrollRowToVisible(nRow);
        }

    }

    /**
     * Constructor.
     * 
     * @param facade
     */
    public GanttTree2(final GanttProject app, TaskManager taskManager,
            UIFacade uiFacade) {

        super();
        app.getProject().addProjectEventListener(this);
        myUIFacade = uiFacade;

        myTaskManager = taskManager;
        this.appli = app;

        // Create the root node
        initRootNode();

        treeModel = new GanttTreeTableModel(rootNode, taskManager);
        treeModel.addTreeModelListener(new GanttTreeModelListener());
        // Create the JTree
        treetable = new GanttTreeTable(treeModel);
        treetable.getActionMap().put(myIndentAction.getValue(Action.NAME), myIndentAction);
        treetable.getActionMap().put(myDedentAction.getValue(Action.NAME), myDedentAction);
        treetable.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0), myIndentAction.getValue(Action.NAME));
        treetable.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, KeyEvent.SHIFT_DOWN_MASK), myDedentAction.getValue(Action.NAME));
        treetable.getActionMap().put("newTask", new AbstractAction() {
			public void actionPerformed(ActionEvent e) {
                    if (getSelectedTask() != null)
                        setEditingTask(getSelectedTask());
                    Mediator.getGanttProjectSingleton().getUndoManager()
                            .undoableEdit("New Task", new Runnable() {
                                public void run() {
                                    Task t = Mediator
                                            .getGanttProjectSingleton()
                                            .newTask();

                                    setEditingTask(t);
                                }
                            });
                }
        });
        treetable.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(GPAction.getKeyStroke("newArtifact.shortcut"), "newTask");
        treetable.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_X, KeyEvent.ALT_DOWN_MASK), "cutTask");
        treetable.addKeyListener(new KeyAdapter() {
			public void keyPressed(KeyEvent e) {
				if (false==treetable.getTable().isEditing()) {
					app.keyPressed(e);
            }
            }
        }); // callback for keyboard pressed
        treetable.getTree().addTreeSelectionListener(
                new TreeSelectionListener() {

                    public void valueChanged(TreeSelectionEvent e) {
                        Mediator.getTaskSelectionManager().clear();
                        TaskNode tn[] = (TaskNode[]) getSelectedTaskNodes();
                        if (tn != null)
                            for (int i = 0; i < tn.length; i++)
                                Mediator.getTaskSelectionManager().addTask(
                                        (Task) tn[i].getUserObject());
                    }
                });

        treetable.setBackground(new Color(1.0f, 1.0f, 1.0f));
        treetable.getTree().addTreeExpansionListener(
                new GanttTreeExpansionListener());

        ToolTipManager.sharedInstance().registerComponent(treetable);

        // Add The tree on a Scrollpane
        JScrollPane scrollpane = new JScrollPane();
        setLayout(new BorderLayout());
        add(scrollpane, BorderLayout.CENTER);
        scrollpane.getViewport().add(treetable);
        scrollpane
                .setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_NEVER);

        vbar = treetable.getVerticalScrollBar();
        final JPanel jp = new JPanel(new BorderLayout());
        jp.add(vbar, BorderLayout.CENTER);
        jp.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.LOWERED));
        jp.setVisible(false);
        vbar.addAdjustmentListener(new AdjustmentListener() {