gantttree2.java

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

    }

    /** Return tru if the Project has tasks and false is no tasks on the project */
    public boolean hasTasks() {
        Enumeration e = (rootNode).preorderEnumeration();
        while (e.hasMoreElements()) {
            Object next = e.nextElement();

            if (rootNode != (DefaultMutableTreeNode) next
                    && (next instanceof TaskNode))
                return true;
        }
        return false;
    }

    /** Returnan ArrayList with all tasks. */
    public ArrayList getAllTasks() {
        ArrayList res = new ArrayList();
        Enumeration enumeration = rootNode.preorderEnumeration();
        while (enumeration.hasMoreElements()) {
            Object o = enumeration.nextElement();
            if (o instanceof TaskNode) {
                res.add(o);
    }
        }
        return res;
//        return Collections.list(rootNode.preorderEnumeration());
    }

    public List getAllVisibleNodes() {
        List res = new ArrayList();
        Enumeration enumeration = rootNode.preorderEnumeration();
        while (enumeration.hasMoreElements()) {
            DefaultMutableTreeNode o = (DefaultMutableTreeNode) enumeration
                    .nextElement();
            if (getTreeTable().getTree().isVisible(new TreePath(o.getPath())))
                res.add(o);
        }
        return res;
    }

    /** Return all sub task for the tree node base */
    public ArrayList getAllChildTask(Task task) {
        ArrayList res = new ArrayList();
        if (task == null)
            return null;
        DefaultMutableTreeNode base = (DefaultMutableTreeNode) getNode(task
                .getTaskID());
        if (base == null)
            return res;
        Enumeration e = base.children();
        while (e.hasMoreElements()) {
            res.add(e.nextElement());
        }
        return res;
    }

    /** Return all sub task for the tree node base */
    public ArrayList getAllChildTask(DefaultMutableTreeNode base) {
        ArrayList res = new ArrayList();
        if (base == null || !(base instanceof TaskNode))
            return res;
        Enumeration e = base.children();
        while (e.hasMoreElements()) {
            Object next = e.nextElement();
            if (next instanceof TaskNode)
                res.add(next);
        }
        return res;
    }

    /** Return the last default tree node */
    public DefaultMutableTreeNode getLastNode() {
        return rootNode.getLastLeaf();
    }

    /** Remove the current node. 
     * @param current */
    void removeCurrentNode(DefaultMutableTreeNode currentNode) {
            DefaultMutableTreeNode parent = (DefaultMutableTreeNode) (currentNode
                    .getParent());
            getTaskManager().deleteTask((Task) currentNode.getUserObject());
            if (parent != null) {
                ((GanttTreeTableModel) treeModel)
                        .removeNodeFromParent(currentNode);
                forwardScheduling();
                nbTasks--;
                appli.refreshProjectInfos();
                return;
            }
        }

    /** Clear the JTree. */
    public void clearTree() {
        // expand.clear();
        rootNode.removeAllChildren();
        initRootNode();
        treeModel.setRoot(rootNode);
        treeModel.reload();
        nbTasks = 0;
        hiddenTask.clear();
    }

    /** Select the row of the tree */
    public void selectTreeRow(int row) {
        treetable.getTree().setSelectionRow(row);
    }

    public void selectTasks(List tasksList) {
        boolean multi = false;
        Iterator it = tasksList.iterator();
        if (it.hasNext())
            selectTask((Task) it.next(), false);
        while (it.hasNext())
            selectTask((Task) it.next(), true);
    }

    public void selectTask(Task task, boolean multipleSelection) {
        DefaultMutableTreeNode taskNode = null;
        for (Enumeration nodes = rootNode.preorderEnumeration(); nodes
                .hasMoreElements();) {
            DefaultMutableTreeNode nextNode = (DefaultMutableTreeNode) nodes
                    .nextElement();
            if (!(nextNode instanceof TaskNode))
                continue;
            if (nextNode.getUserObject().equals(task)) {
                taskNode = nextNode;
                break;
            }
        }
        if (taskNode != null) {
            TreePath taskPath = new TreePath(taskNode.getPath());
            if (multipleSelection)
                if (treetable.getTree().getSelectionModel().isPathSelected(
                        taskPath))
                    treetable.getTree().getSelectionModel()
                            .removeSelectionPath(taskPath);
                else
                    treetable.getTree().getSelectionModel().addSelectionPath(
                            taskPath);
            else
                treetable.getTree().getSelectionModel().setSelectionPath(
                        taskPath);
        }

        TreePath paths[] = treetable.getTree().getSelectionModel()
                .getSelectionPaths();
        Mediator.getTaskSelectionManager().clear();
        if (paths != null)
            for (int i = 0; i < paths.length; i++) {
                TaskNode tn = (TaskNode) paths[i].getLastPathComponent();
                if (!tn.isRoot())
                    Mediator.getTaskSelectionManager().addTask(
                            (Task) tn.getUserObject());
            }
    }

    /** Returne the mother task. */
    public DefaultMutableTreeNode getFatherNode(Task node) {
        if (node == null) {
            return null;
        }
        DefaultMutableTreeNode tmp = (DefaultMutableTreeNode) getNode(node
                .getTaskID());
        if (tmp == null) {
            return null;
        }

        return (DefaultMutableTreeNode) tmp.getParent();
    }

    /** Returne the mother task. */
    public DefaultMutableTreeNode getFatherNode(DefaultMutableTreeNode node) {
        if (node == null) {
            return null;
        }
        return (DefaultMutableTreeNode) node.getParent();
    }

    /** Return the JTree. */
    public JTree getJTree() {
        return treetable.getTree();
    }

    public JTable getTable() {
        return treetable.getTable();
    }

    public GanttTreeTable getTreeTable() {
        return treetable;
    }

    class HiddenTask implements Comparable {
        private DefaultMutableTreeNode node = null;

        private DefaultMutableTreeNode parent = null;

        private int index = -1;

        public HiddenTask(DefaultMutableTreeNode node,
                DefaultMutableTreeNode parent, int index) {
            this.node = node;
            this.parent = parent;
            this.index = index;
            // this.node.setParent(this.parent);
        }

        public DefaultMutableTreeNode getNode() {
            return node;
        }

        public DefaultMutableTreeNode getParent() {
            return parent;
        }

        public int getIndex() {
            return index;
        }

        /**
         * @see java.lang.Comparable#compareTo(java.lang.Object)
         */
        public int compareTo(Object o) {
            if (o == null)
                return 0;
            if (o instanceof HiddenTask) {
                HiddenTask ht = (HiddenTask) o;
                return this.index - ht.index;
            }
            return 0;
        }

    }

    private List hiddenTask = new ArrayList();

    public Set/*<Task>*/ getHiddenTasks() {
        HashSet result = new HashSet();
        for (int i=0; i<hiddenTask.size(); i++) {
            HiddenTask next = (HiddenTask) hiddenTask.get(i);
            result.add(next.getNode().getUserObject());
        }
        return result;
    }
    /**
     * Hides the selected tasks.
     */
    public void hideSelectedNodes() {
        DefaultMutableTreeNode[] t = getSelectedNodes();
        for (int i = 0; i < t.length; i++) {
            DefaultMutableTreeNode parent = (DefaultMutableTreeNode) t[i]
                    .getParent();
            hiddenTask.add(new HiddenTask(t[i], parent, parent.getIndex(t[i])));
        }

        for (int i = 0; i < hiddenTask.size(); i++) {
            HiddenTask ht = (HiddenTask) hiddenTask.get(i);
            TreeNode parent = ht.node.getParent();
            if (parent != null)
                ((GanttTreeTableModel) getTreeTable().getTreeTableModel())
                        .removeNodeFromParent(((HiddenTask) hiddenTask.get(i))
                                .getNode());
        }

    }

    /**
     * Displays the hidden tasks.
     */
    public void displayHiddenTasks() {
        for (int i = 0; i < hiddenTask.size(); i++) {
            HiddenTask ht = (HiddenTask) hiddenTask.get(i);

            DefaultMutableTreeNode node = ht.getNode();
            DefaultMutableTreeNode parent = ht.getParent();
            node.setParent(parent);
        }
        Collections.sort(hiddenTask);
        for (int i = 0; i < hiddenTask.size(); i++) {
            HiddenTask ht = (HiddenTask) hiddenTask.get(i);

            DefaultMutableTreeNode node = ht.getNode();
            DefaultMutableTreeNode parent = ht.getParent();
            int index = ht.getIndex();
            node.setParent(null);
            ((GanttTreeTableModel) getTreeTable().getTreeTableModel())
                    .insertNodeInto(node, parent, index);

            if (node instanceof TaskNode)
                restoreExpand((TaskNode) node);
        }

        hiddenTask.clear();

    }

    /**
     * Retores the expand state of the node and its children.
     * 
     * @param node
     */
    private void restoreExpand(TaskNode node) {
        Task task = (Task) node.getUserObject();
        boolean expand = task.getExpand();

        Enumeration enumeration = node.children();
        while (enumeration.hasMoreElements())
            restoreExpand((TaskNode) enumeration.nextElement());

        if (expand)
            getTreeTable().getTree().expandPath(new TreePath(node.getPath()));
        else
            getTreeTable().getTree().collapsePath(new TreePath(node.getPath()));
        task.setExpand(expand);
    }

    /** Return the root node */
    public DefaultMutableTreeNode getRoot() {
        return rootNode;
    }

    /** Function to put up the selected tasks */
    public void upCurrentNodes() {

        final DefaultMutableTreeNode[] cdmtn = getSelectedNodes();
        if (cdmtn == null) {
            myUIFacade.setStatusText(language.getText("msg21"));
            return;
        }
        final TreePath[] selectedPaths = new TreePath[cdmtn.length];
        final GanttTree2 gt2 = this;
        appli.getUndoManager().undoableEdit("Up", new Runnable() {
            public void run()
            {
                for (int i = 0; i < cdmtn.length; i++)
                {
                    DefaultMutableTreeNode father = gt2.getFatherNode(cdmtn[i]);
                    int index = father.getIndex((TreeNode) cdmtn[i]);

                    index--;
                    
                    Task task = (Task) cdmtn[i].getUserObject();
                    
                    if (index >= 0)
                    {
                    	DefaultMutableTreeNode [] child = new DefaultMutableTreeNode[cdmtn[i].getChildCount()];
                    	
                    	if(task.getExpand())
                    	{
                    		for(int j=0; j<cdmtn[i].getChildCount(); j++)
                    		{
                    			child[j] = (DefaultMutableTreeNode)cdmtn[i].getChildAt(j);
                    		}
                    	
                    		for(int j=0; j<child.length; j++)
                    		{
                    			child[j].removeFromParent();
                    			treeModel.nodesWereRemoved(cdmtn[i],
                    					new int[] { 0 },
                    					new Object[] { child });