gantttree2.java

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

                    		}
                    	}
                    	
                    	cdmtn[i].removeFromParent();
                        treeModel.nodesWereRemoved(father,
                                        new int[] { index + 1 },
                                        new Object[] { cdmtn });
                        
                        father.insert(cdmtn[i], index);
                        treeModel.nodesWereInserted(father, new int[] {index});
                        
                        if(task.getExpand())
                        {
                        	for(int j=0; j<child.length; j++)
                        	{
                        		cdmtn[i].insert(child[j], j);
                        		treeModel.nodesWereInserted(cdmtn[i], new int[] {j});
                        	}
                        }
                        
                        forwardScheduling();
                    }
                }
            }
        });
        
        area.repaint();
    }

    /** Function to put down the selected tasks */
    public void downCurrentNodes() {

        final DefaultMutableTreeNode[] cdmtn = getSelectedNodes();
        if (cdmtn == null) {
            myUIFacade.setStatusText(language.getText("msg21"));
            return;
        }

        //final TreePath[] selectedPaths = new TreePath[cdmtn.length];

        // Parse in reverse mode because tasks are sorted from top to bottom.
        // appli.setQuickSave (false);
        final GanttTree2 gt2 = this;
        appli.getUndoManager().undoableEdit("Down", new Runnable(){
            public void run()
            {
                for (int i = cdmtn.length - 1; i >= 0; i--)
                {
                    DefaultMutableTreeNode father = gt2.getFatherNode(cdmtn[i]);
                    int index = father.getIndex((TreeNode) cdmtn[i]);
                    index++;
                    
                    Task task = (Task) cdmtn[i].getUserObject();
                    
                    // New position
                    if ((index < father.getChildCount()))
                    {
                    	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 });
                    		}
                    	}
                    	
                    	cdmtn[i].removeFromParent();
                        treeModel.nodesWereRemoved(father,
                                        new int[] { index - 1 },
                                        new Object[] { cdmtn });
                        
                        father.insert(cdmtn[i], index);
                        treeModel.nodesWereInserted(father, new int[] {index});
                        
                        if(task.getExpand())
                        {
                        	for(int j=0; j<child.length; j++)
                        	{
                        		cdmtn[i].insert(child[j], j);
                        		treeModel.nodesWereInserted(cdmtn[i], new int[] {j});
                        	}
                        }
                        
                        forwardScheduling();
                    }
                }
            }
        });
        
        /*
        treetable.getTree().setSelectionPaths(selectedPaths);
        
        for(int i=0; i<cdmtn.length; i++)
        {
        	if(toExpand[i])
            {
            	//treetable.getTree().expandPath(selectedPaths[i]);
            	//System.out.println("toExpand");
        		//this.restoreExpand((TaskNode)cdmtn[i]);
            }
        }
        */
        area.repaint();
    }
    
    public DefaultMutableTreeNode removeChild(DefaultMutableTreeNode node)
    {
    	DefaultMutableTreeNode nodeCopy = new DefaultMutableTreeNode(node.getUserObject());
    	Enumeration children = node.children();
    	while(children.hasMoreElements())
    	{
    		DefaultMutableTreeNode child = (DefaultMutableTreeNode)children.nextElement();
    		
    		DefaultMutableTreeNode childCopy = this.removeChild(child);
    		nodeCopy.add(childCopy);
    		
    		child.removeFromParent();
    		treeModel.nodesWereRemoved(node,
                    new int[] { 0 },
                    new Object[] { child });
    	}
    	
    	return nodeCopy;
    }
    
    public void insertChild(DefaultMutableTreeNode node, DefaultMutableTreeNode copy)
    {
    	Enumeration children = copy.children();
    	
    	int index = 0;
    	while(children.hasMoreElements())
    	{
    		DefaultMutableTreeNode childCopy = (DefaultMutableTreeNode)children.nextElement();
    		DefaultMutableTreeNode child = new DefaultMutableTreeNode(childCopy.getUserObject());
    		node.insert(child, index);
    		treeModel.nodesWereInserted(node, new int[] {index});
    		this.insertChild(child, childCopy);
    		index++;
    	}
    }

    /**
     * Indent several nodes that are selected. Based on the IndentCurrentNode
     * method.
     */
    private void indentCurrentNodes() {

        final DefaultMutableTreeNode[] cdmtn = getSelectedTaskNodes();
        if (cdmtn == null) {
            myUIFacade.setStatusText(language.getText("msg21"));
            return;
        }
        final GanttTree2 gt2 = this;
        getUndoManager().undoableEdit("Indent", new Runnable() {
            public void run() {
                TreePath[] selectedPaths = new TreePath[cdmtn.length];

                for (int i = 0; i < cdmtn.length; i++) {
                    DefaultMutableTreeNode father = gt2.getFatherNode(cdmtn[i]);
                    // Where is my nearest sibling in ascending order ?
                    DefaultMutableTreeNode newFather = cdmtn[i]
                            .getPreviousSibling();
                    // If there is no more indentation possible we must stop
                    if (newFather == null || !(newFather instanceof TaskNode)) {
                        continue;
                    }
                    if (cdmtn[i] instanceof TaskNode && newFather instanceof TaskNode) {
                    	Task nextTask = (Task) cdmtn[i].getUserObject();
                    	Task container = (Task) newFather.getUserObject();
                    	getTaskManager().getTaskHierarchy().move(nextTask, container);
                    }
                }
                area.repaint();
                appli.repaint2();
            }
        });

    }

    /**
     * Function to dedent selected task this will change the parent child
     * relationship. This Code is based on the UP/DOWN Coder I found in here
     * barmeier
     */
    /** Unindent the selected nodes. */
    public void dedentCurrentNodes() {
        final DefaultMutableTreeNode[] cdmtn = getSelectedTaskNodes();
        if (cdmtn == null) {
            myUIFacade.setStatusText(language.getText("msg21"));
            return;
        }
        final GanttTree2 gt2 = this;
        getUndoManager().undoableEdit("Dedent", new Runnable() {
            public void run() {

                TreePath[] selectedPaths = new TreePath[cdmtn.length];

                for (int i = 0; i < cdmtn.length; i++) {
                    DefaultMutableTreeNode father = gt2.getFatherNode(cdmtn[i]);

                    // Getting the fathers father !? The grandpa I think :)
                    DefaultMutableTreeNode newFather = gt2
                            .getFatherNode(father);
                    // If no grandpa is available we must stop.
                    if (newFather == null) {
                        return;
                    }

                    int oldIndex = father.getIndex((TreeNode) cdmtn[i]);

                    cdmtn[i].removeFromParent();
                    treeModel.nodesWereRemoved(father, new int[] { oldIndex },
                            new Object[] { cdmtn });

                    ((GanttTreeTableModel) treeModel).insertNodeInto(
                            (MutableTreeNode) cdmtn[i],
                            (MutableTreeNode) newFather, newFather
                                    .getIndex((TreeNode) father) + 1);

                    // Select tagain this node
                    TreeNode[] treepath = cdmtn[i].getPath();
                    TreePath path = new TreePath(treepath);
                    // tree.setSelectionPath(path);
                    selectedPaths[i] = path;

                    // refresh the father date
                    // Task current = (Task)(cdmtn[i].getUserObject());
                    // refreshAllFather(current.toString());

                    expandRefresh(cdmtn[i]);

                    forwardScheduling();

                    if (father.getChildCount() == 0)
                        ((Task) father.getUserObject()).setProjectTask(false);
                }

                treetable.getTree().setSelectionPaths(selectedPaths);

                area.repaint();

                // appli.setQuickSave (true);
                // appli.quickSave ("Dedent");
            }
        });
    }

    // update 21/03/2003
    /** Refresh the expantion (recursive function) */
    public void expandRefresh(DefaultMutableTreeNode moved) {
        if (moved instanceof TaskNode) {
            Task movedTask = (Task) moved.getUserObject();
            // if (expand.contains(new Integer(movedTask.getTaskID()))) {
            if (movedTask.getExpand())
                treetable.getTree().expandPath(new TreePath(moved.getPath()));

            Enumeration children = moved.children();
            while (children.hasMoreElements()) {
                expandRefresh((DefaultMutableTreeNode) children.nextElement());
            }
        }
    }

    /**
     * In elder version, this function refresh all the related tasks to the
     * taskToMove. In the new version, this function is same as
     * forwardScheduling(). It will refresh all the tasks.
     * 
     * @param taskToMove
     */
    public void refreshAllChild(String taskToMove) {
        forwardScheduling();
    }

    // ////////////////////////////////////////////////////////////////////////////////////////
    /**
     * Listener when scrollbar move
     */
    public class GanttAdjustmentListener implements AdjustmentListener {
        public void adjustmentValueChanged(AdjustmentEvent e) {
            if (area != null) {
            	int v = e.getValue();

                area.setScrollBar(v);
                area.repaint();
            }
        }
    }

    // ////////////////////////////////////////////////////////////////////////////////////////
    /**
     * Class for expansion and collapse of node
     */
    public class GanttTreeExpansionListener implements TreeExpansionListener {
        /** Expansion */
        public void treeExpanded(TreeExpansionEvent e) {
            if (area != null) {
                area.repaint();
            }
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) (e.getPath()
                    .getLastPathComponent());
            Task task = (Task) node.getUserObject();

            /*
             * if(!expand.contains(new Integer(task.getTaskID()))) {
             * expand.add(new Integer(task.getTaskID()));
             * appli.setAskForSave(true); }
             */

            task.setExpand(true);
            appli.setAskForSave(true);

        }

        /** Collapse */
        public void treeCollapsed(TreeExpansionEvent e) {
            if (area != null) {
                area.repaint();
            }

            DefaultMutableTreeNode node = (DefaultMutableTreeNode) (e.getPath()
                    .getLastPathComponent());
            Task task = (Task) node.getUserObject();

            /*
             * int index = expand.indexOf(new Integer(task.getTaskID())); if
             * (index >= 0) { expand.remove(index); appli.setAskForSave(true); }
             */

            task.setExpand(false);
            appli.setAskForSave(true);
        }
    }

    // ////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Listener to generate modification on the model
     */
    public class GanttTreeModelListener implements TreeModelListener {
        /** modify a node */
        public void treeNodesChanged(TreeModelEvent e) {
            if (area != null) {
                area.repaint();
            }
        }

        /** Insert a new node. */
        public void treeNodesInserted(TreeModelEvent e) {

            DefaultMutableTreeNode node = (DefaultMutableTreeNode) (e