gantttree2.java

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

            public void adjustmentValueChanged(AdjustmentEvent e) {
                if (treetable.getSize().getHeight() - 20 < e.getAdjustable()
                        .getMaximum())
                    jp.setVisible(true);
                else
                    jp.setVisible(false);
                repaint();
            }
        });

        this.add(jp, BorderLayout.WEST);
        hbar = scrollpane.getHorizontalScrollBar();
        vbar.addAdjustmentListener(new GanttAdjustmentListener());

        // A listener on mouse click (menu)
        MouseListener ml = new MouseAdapter() {

            public void mouseReleased(MouseEvent e) {
                handlePopupTrigger(e);
            }

            public void mousePressed(MouseEvent e) {
                handlePopupTrigger(e);
            }

            public void mouseClicked(MouseEvent e) {
                // TODO Auto-generated method stub
                if (e.getClickCount()==2 && e.getButton() == MouseEvent.BUTTON1) {
                    TreePath selPath = treetable.getTreeTable().getPathForLocation(e.getX(), e.getY());
                    if (selPath!=null) {
                        e.consume();
                        appli.propertiesTask();
                    }
                }
                else  {
                    handlePopupTrigger(e);
                }
            }

            private void handlePopupTrigger(MouseEvent e) {
                if (e.isPopupTrigger() || e.getButton() == MouseEvent.BUTTON3) {
                    TreePath selPath = treetable.getTreeTable().getPathForLocation(e.getX(), e.getY());
                    if (selPath!=null) {
                            TreePath[] currentSelection = treetable.getTree()
                                    .getSelectionPaths();

                            if (currentSelection == null
                                    || currentSelection.length == 0)
                                treetable.getTree().setSelectionPath(selPath);
                            else {
                                boolean contains = false;
                                for (int i = 0; i < currentSelection.length
                                        && !contains; i++)
                                    if (currentSelection[i] == selPath)
                                        contains = true;
                                if (!contains)
                                    treetable.getTree().setSelectionPath(
                                            selPath);
                            }
                        createPopupMenu(e.getX(), e.getY(), true);
                    }
                    else {
                    treetable.getTree().setSelectionPath(null);
                        createPopupMenu(e.getX(), e.getY(), false);
                }
                    e.consume();
                }

            }
        };
        if (!app.isOnlyViewer)
            treetable.addMouseListener(ml);

        DragSource dragSource = DragSource.getDefaultDragSource();
        dragSource.createDefaultDragGestureRecognizer(treetable,
                DnDConstants.ACTION_COPY_OR_MOVE, this);
        dragSource.addDragSourceListener(this);
        DropTarget dropTarget = new DropTarget(treetable,
                new GanttTreeDropListener());
        dropTarget.setDefaultActions(DnDConstants.ACTION_COPY_OR_MOVE);

        getTreeTable().setToolTipText("aze");
        getTreeTable().getTreeTable().setToolTipText("rty");

    }

    public void setActions() {
        treetable.setAction(appli.getCopyAction());
        treetable.setAction(appli.getPasteAction());
        treetable.setAction(appli.getCutAction());
        treetable.addAction(myIndentAction, KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
        treetable.addAction(myDedentAction, KeyStroke.getKeyStroke(KeyEvent.VK_TAB, KeyEvent.SHIFT_DOWN_MASK));
    }

    /**
     * Edits the <code>t</code> task name in the treetable.
     */
    public void setEditingTask(Task t) {
        selectTask(t, false);
        TreePath tp = new TreePath(getSelectedTaskNode().getPath());
        int c = getTable().convertColumnIndexToView(
                getTable().getColumn(GanttTreeTableModel.strColName)
                        .getModelIndex());
        treetable.getTreeTable().editingStopped(
                new ChangeEvent(treetable.getTreeTable()));
        treetable.editNewTask(t);
//        treetable.getTreeTable().editCellAt(
//                treetable.getTree().getRowForPath(tp), c);
//        treetable.requestFocus();
        treetable.centerViewOnSelectedCell();

    }

    public void stopEditing() {
        treetable.getTable().editingCanceled(
                new ChangeEvent(treetable.getTreeTable()));
        treetable.getTreeTable().editingCanceled(
                new ChangeEvent(treetable.getTreeTable()));
    }

    public void changeLanguage(GanttLanguage ganttLanguage) {
        this.language = ganttLanguage;
        //this.treetable.changeLanguage(language);
    }

    private void initRootNode() {
        getTaskManager().getRootTask().setName("root");
        rootNode = new TaskNode(getTaskManager().getRootTask());
    }

    public Action[] getPopupMenuActions() {
        List actions = new ArrayList();
        actions.add(new NewTaskAction((IGanttProject) appli));
        if (!Mediator.getTaskSelectionManager().getSelectedTasks().isEmpty()) {
            actions.add(getTaskPropertiesAction());
        // }
        actions.add(createMenuAction(GanttProject.correctLabel(language
                .getText("deleteTask")), "/icons/delete_16.gif"));
        actions.add(null);
        actions.add(myIndentAction);
        actions.add(myDedentAction);
        actions.add(getMoveUpAction());
        actions.add(getMoveDownAction());
        actions.add(null);
        actions.add(getUnlinkTasksAction());
        actions.add(getLinkTasksAction());
        actions.add(null);
        actions.add(appli.getCutAction());
        actions.add(appli.getCopyAction());
        actions.add(appli.getPasteAction());
            /*
            actions.add(null);
            actions.add(createMenuAction(language.getText("hideTask"),
            "/icons/hide_16.gif"));
            actions.add(createMenuAction(language.getText("displayHiddenTasks"),
                    "/icons/show_16.gif"));
                    */
        }
        return (Action[]) actions.toArray(new Action[0]);
    }

    private Action createMenuAction(String label, String iconPath) {
        AbstractAction result = new AbstractAction(label, new ImageIcon(
                getClass().getResource(iconPath))) {
            public void actionPerformed(ActionEvent e) {
                appli.actionPerformed(e);
            }
        };
        return result;

    }

    /** Create a popup menu when mous click */
    private void createPopupMenu(int x, int y, boolean all) {
        JPopupMenu menu = new JPopupMenu();
        Action[] popupMenuActions = getPopupMenuActions();
        myUIFacade.showPopupMenu(this, popupMenuActions, x - hbar.getValue()
                + (vbar.isVisible() ? vbar.getWidth() : 0), y - vbar.getValue()
                + 20);
    }

    /** Change grpahic part */
    public void setGraphicArea(GanttGraphicArea area) {
        this.area = area;
    }
    /** add an object with the expand information */
    public DefaultMutableTreeNode addObjectWithExpand(Object child,
            DefaultMutableTreeNode parent) {

        DefaultMutableTreeNode childNode = new TaskNode((Task) child);

        if (parent == null)
            parent = rootNode;

        treeModel.insertNodeInto(childNode, parent, parent.getChildCount());
        //forwardScheduling();

        Task task = (Task) (childNode.getUserObject());

        boolean res = true;

        if (parent == null)
            res = false;

        // test for expantion
        while (parent != null) {
            Task taskFather = (Task) (parent.getUserObject());
            if (!taskFather.getExpand()) {
                res = false;
                break;
            }
            parent = (DefaultMutableTreeNode) (parent.getParent());
        }

        treetable.getTree().scrollPathToVisible(
                new TreePath(childNode.getPath()));
        if (!res && parent!=null) {
            treetable.getTree().collapsePath(new TreePath(parent.getPath()));
        }
//        else
//            task.setExpand(false);
        nbTasks++;
        appli.refreshProjectInfos();

        return childNode;
    }

    public void addBlankLine(final DefaultMutableTreeNode select,
            final int index) {
        treeModel.insertNodeInto(new BlankLineNode(),
                select == null ? getRoot() : (DefaultMutableTreeNode) select
                        .getParent(), index == -1 ? getRoot().getChildCount()
                        : index);

        appli.setAskForSave(true);

    }

    /** Add a sub task. */
    public TaskNode addObject(Object child, MutableTreeNode parent, int index) {
        TaskNode childNode = new TaskNode((Task) child);

        if (parent == null)
            parent = rootNode;

        // GanttTask tmpTask = (GanttTask)(childNode.getUserObject());
        // tmpTask.indentID((String)(((GanttTask)(parent.getUserObject())).getID()));

        treeModel.insertNodeInto(childNode, parent, index == -1 ? parent
                .getChildCount() : index);
        forwardScheduling();

        treetable.getTree().scrollPathToVisible(
                new TreePath(childNode.getPath()));

        nbTasks++;
        appli.refreshProjectInfos();

        return childNode;
    }

    /** Return the selected task */
    private GanttTask getSelectedTask() {
        DefaultMutableTreeNode node = getSelectedTaskNode();
        if (node == null)
            return null;
        return (GanttTask) (node.getUserObject());
    }

    /** Return the selected node */
    public DefaultMutableTreeNode getSelectedNode() {
        TreePath currentSelection = treetable.getTree().getSelectionPath();
        if (currentSelection == null) {
            return null;
        }
        DefaultMutableTreeNode dmtnselected = (DefaultMutableTreeNode) currentSelection
                .getLastPathComponent();
        return dmtnselected;
    }

    /** Return the selected node */
    private DefaultMutableTreeNode getSelectedTaskNode() {
        TreePath currentSelection = treetable.getTree().getSelectionPath();
        if (currentSelection == null
                || !(currentSelection.getLastPathComponent() instanceof TaskNode)) {
            return null;
        }
        DefaultMutableTreeNode dmtnselected = (DefaultMutableTreeNode) currentSelection
                .getLastPathComponent();
        return dmtnselected;
    }

    public TaskNode[] getSelectedTaskNodes() {
        TreePath[] currentSelection = treetable.getTree().getSelectionPaths();

        if (currentSelection == null || currentSelection.length == 0)
            return null;

        DefaultMutableTreeNode[] dmtnselected = new DefaultMutableTreeNode[currentSelection.length];
        for (int i = 0; i < currentSelection.length; i++)
            dmtnselected[i] = (DefaultMutableTreeNode) currentSelection[i]
                    .getLastPathComponent();

        TaskNode[] res = getOnlyTaskNodes(dmtnselected);

        return res;
    }

    /** @return the list of the selected nodes. */
    public DefaultMutableTreeNode[] getSelectedNodes() {
        TreePath[] currentSelection = treetable.getTree().getSelectionPaths();

        if (currentSelection == null || currentSelection.length == 0) // no
            // elements
            // are
            // selectionned
            return null;

        DefaultMutableTreeNode[] dmtnselected = new DefaultMutableTreeNode[currentSelection.length];
        for (int i = 0; i < currentSelection.length; i++)
            dmtnselected[i] = (DefaultMutableTreeNode) currentSelection[i]
                    .getLastPathComponent();

        DefaultMutableTreeNode[] res = dmtnselected;

        return res;
    }

    private TaskNode[] getOnlyTaskNodes(DefaultMutableTreeNode[] array) {
        List resAsList = new ArrayList();
        for (int i = 0; i < array.length; i++) {
            DefaultMutableTreeNode next = array[i];
            if (next instanceof TaskNode)
                resAsList.add(next);
        }
        return (TaskNode[]) resAsList.toArray(new TaskNode[0]);
    }

    /** Return the DefaultMutableTreeNode with the name name. */
    public DefaultMutableTreeNode getNode(int id /* String name */) {
        DefaultMutableTreeNode res, base;
        base = (DefaultMutableTreeNode) treetable.getTreeTableModel().getRoot();
        Enumeration e = base.preorderEnumeration();
        while (e.hasMoreElements()) {
            res = ((DefaultMutableTreeNode) e.nextElement());
            if (res instanceof TaskNode)
                if (((Task) (res.getUserObject())).getTaskID() == id) {
                    return res;
                }
        }
        return null;
    }

    public static List convertNodesListToItemList(List nodesList) {
        List res = new ArrayList(nodesList.size());
        Iterator itNodes = nodesList.iterator();
        while (itNodes.hasNext()) {
            res.add(((DefaultMutableTreeNode) itNodes.next()).getUserObject());
        }
        return res;