← Back to branch summary

~veger/ganttproject/manual-import

« back to all changes in this revision

Viewing changes to ganttproject/src/net/sourceforge/ganttproject/GanttTree2.java

  • Committer: Maarten Bezemer
  • Date: 2012-01-22 12:20:00 UTC
  • Revision ID: maarten.bezemer@gmail.com-20120122122000-qwyec45rjx86wi7o
Updated till 2fe683a778c3 

Show diffs side-by-side

added added

removed removed

Lines of Context:
ganttproject/src/net/sourceforge/ganttproject/GanttTree2.java
1
1
/*
2
 
GanttProject is an opensource project management tool. License: GPL2
 
2
GanttProject is an opensource project management tool. License: GPL3
3
3
Copyright (C) 2002-2011 Thomas Alexandre, GanttProject Team
4
4
 
5
5
This program is free software; you can redistribute it and/or
6
6
modify it under the terms of the GNU General Public License
7
 
as published by the Free Software Foundation; either version 2
 
7
as published by the Free Software Foundation; either version 3
8
8
of the License, or (at your option) any later version.
9
9
 
10
10
This program is distributed in the hope that it will be useful,
19
19
package net.sourceforge.ganttproject;
20
20
 
21
21
import java.awt.AlphaComposite;
22
 
import java.awt.BorderLayout;
23
22
import java.awt.Color;
24
 
import java.awt.Component;
25
23
import java.awt.GradientPaint;
26
24
import java.awt.Graphics2D;
27
25
import java.awt.Point;
47
45
import java.awt.event.ActionListener;
48
46
import java.awt.event.FocusAdapter;
49
47
import java.awt.event.FocusEvent;
50
 
import java.awt.event.KeyAdapter;
51
48
import java.awt.event.KeyEvent;
52
49
import java.awt.event.MouseAdapter;
53
50
import java.awt.event.MouseEvent;
70
67
import javax.swing.Icon;
71
68
import javax.swing.JComponent;
72
69
import javax.swing.JLabel;
73
 
import javax.swing.JPanel;
74
70
import javax.swing.JScrollBar;
75
71
import javax.swing.JTable;
76
72
import javax.swing.JTree;
81
77
import javax.swing.event.ChangeEvent;
82
78
import javax.swing.event.TreeExpansionEvent;
83
79
import javax.swing.event.TreeExpansionListener;
84
 
import javax.swing.event.TreeModelEvent;
85
 
import javax.swing.event.TreeModelListener;
86
80
import javax.swing.event.TreeSelectionEvent;
87
81
import javax.swing.event.TreeSelectionListener;
88
82
import javax.swing.tree.DefaultMutableTreeNode;
91
85
import javax.swing.tree.TreePath;
92
86
 
93
87
import net.sourceforge.ganttproject.action.GPAction;
94
 
import net.sourceforge.ganttproject.action.NewTaskAction;
95
 
import net.sourceforge.ganttproject.action.task.DeleteTasksAction;
 
88
import net.sourceforge.ganttproject.action.task.TaskActionBase;
 
89
import net.sourceforge.ganttproject.action.task.TaskDeleteAction;
 
90
import net.sourceforge.ganttproject.action.task.TaskIndentAction;
 
91
import net.sourceforge.ganttproject.action.task.TaskLinkAction;
 
92
import net.sourceforge.ganttproject.action.task.TaskMoveDownAction;
 
93
import net.sourceforge.ganttproject.action.task.TaskMoveUpAction;
 
94
import net.sourceforge.ganttproject.action.task.TaskNewAction;
96
95
import net.sourceforge.ganttproject.action.task.TaskPropertiesAction;
 
96
import net.sourceforge.ganttproject.action.task.TaskUnindentAction;
 
97
import net.sourceforge.ganttproject.action.task.TaskUnlinkAction;
 
98
import net.sourceforge.ganttproject.chart.Chart;
97
99
import net.sourceforge.ganttproject.chart.VisibleNodesFilter;
98
100
import net.sourceforge.ganttproject.delay.Delay;
99
101
import net.sourceforge.ganttproject.delay.DelayObserver;
114
116
import net.sourceforge.ganttproject.task.dependency.TaskDependencyException;
115
117
import net.sourceforge.ganttproject.task.event.TaskListenerAdapter;
116
118
import net.sourceforge.ganttproject.undo.GPUndoManager;
 
119
import net.sourceforge.ganttproject.util.collect.Pair;
117
120
 
118
121
/**
119
122
 * Class that generate the JTree
120
123
 */
121
 
public class GanttTree2 extends JPanel implements DragSourceListener,
122
 
        DragGestureListener, DelayObserver, TaskTreeUIFacade {
123
 
    /** The root node of the Tree */
124
 
    private TaskNode rootNode;
125
 
 
126
 
    /** The model for the JTableTree */
127
 
    private GanttTreeTableModel treeModel;
128
 
 
 
124
public class GanttTree2 extends TreeTableContainer<Task, GanttTreeTable, GanttTreeTableModel>
 
125
        implements DragSourceListener, DragGestureListener, DelayObserver, TaskTreeUIFacade {
129
126
    private UIFacade myUIFacade;
130
127
 
131
 
    /** The GanttTreeTable. */
132
 
    private GanttTreeTable treetable;
133
 
 
134
128
    /** Pointer on graphic area */
135
129
    private ChartComponentBase area = null;
136
130
 
137
131
    /** Pointer on application */
138
 
    private GanttProject appli;
139
 
 
140
 
    private Action myLinkTasksAction;
141
 
 
142
 
    private Action myUnlinkTasksAction;
 
132
    private final GanttProject appli;
143
133
 
144
134
    /** The language use */
145
 
    private GanttLanguage language = GanttLanguage.getInstance();
 
135
    private static GanttLanguage language = GanttLanguage.getInstance();
146
136
 
147
 
    /** Number of tasks on the tree. */
148
 
    private int nbTasks = 0;
149
137
 
150
138
    private TreePath dragPath = null;
151
139
 
156
144
    private final TaskManager myTaskManager;
157
145
    private final TaskSelectionManager mySelectionManager;
158
146
 
159
 
    private final GPAction myIndentAction = new GPAction() {
160
 
        @Override
161
 
        protected String getIconFilePrefix() {
162
 
            return "indent_";
163
 
        }
164
 
 
165
 
        public void actionPerformed(ActionEvent e) {
166
 
            indentCurrentNodes();
167
 
        }
168
 
 
169
 
        @Override
170
 
        protected String getLocalizedName() {
171
 
            return getI18n("indentTask");
172
 
        }
173
 
    };
174
 
 
175
 
    private final GPAction myDedentAction = new GPAction() {
176
 
 
177
 
        @Override
178
 
        protected String getIconFilePrefix() {
179
 
            return "unindent_";
180
 
        }
181
 
 
182
 
        public void actionPerformed(ActionEvent e) {
183
 
            dedentCurrentNodes();
184
 
        }
185
 
 
186
 
        @Override
187
 
        protected String getLocalizedName() {
188
 
            return getI18n("dedentTask");
189
 
        }
190
 
    };
191
 
 
192
 
    private final GPAction myMoveUpAction = new GPAction() {
193
 
        @Override
194
 
        protected String getIconFilePrefix() {
195
 
            return "up_";
196
 
        }
197
 
 
198
 
        public void actionPerformed(ActionEvent e) {
199
 
            upCurrentNodes();
200
 
        }
201
 
 
202
 
        @Override
203
 
        protected String getLocalizedName() {
204
 
            return getI18n("upTask");
205
 
        }
206
 
    };
207
 
 
208
 
    private final GPAction myMoveDownAction = new GPAction() {
209
 
        @Override
210
 
        protected String getIconFilePrefix() {
211
 
            return "down_";
212
 
        }
213
 
 
214
 
        public void actionPerformed(ActionEvent e) {
215
 
            downCurrentNodes();
216
 
        }
217
 
 
218
 
        @Override
219
 
        protected String getLocalizedName() {
220
 
            return getI18n("downTask");
221
 
        }
222
 
    };
223
 
 
224
 
    private final Action myNewTaskAction = new AbstractAction() {
225
 
        public void actionPerformed(ActionEvent e) {
226
 
            if (getSelectedTask() != null) {
227
 
                setEditingTask(getSelectedTask());
228
 
            }
229
 
            getUiFacade().getUndoManager().undoableEdit("New Task", new Runnable() {
230
 
                        public void run() {
231
 
                            Task t = getAppFrame().newTask();
232
 
                            setEditingTask(t);
233
 
                        }
234
 
                    });
235
 
        }
236
 
    };
237
 
 
238
 
    private final Action myDeleteAction;
 
147
    private final GPAction myIndentAction;
 
148
 
 
149
    private final GPAction myUnindentAction;
 
150
 
 
151
    private final GPAction myMoveUpAction;
 
152
 
 
153
    private final GPAction myMoveDownAction;
 
154
 
 
155
    private final GPAction myLinkTasksAction;
 
156
 
 
157
    private final GPAction myUnlinkTasksAction;
 
158
 
 
159
    private final GPAction myNewTaskAction;
 
160
 
 
161
    private final TaskActionBase myDeleteAction;
 
162
 
 
163
    private final TaskActionBase myTaskPropertiesAction;
239
164
 
240
165
    private boolean isOnTaskSelectionEventProcessing;
241
166
 
 
167
    private static Pair<GanttTreeTable, GanttTreeTableModel> createTreeTable(IGanttProject project, UIFacade uiFacade) {
 
168
        GanttTreeTableModel tableModel = new GanttTreeTableModel(project.getTaskManager(), project.getTaskCustomColumnManager());
 
169
        return Pair.create(new GanttTreeTable(project, uiFacade, tableModel), tableModel);
 
170
    }
242
171
    public GanttTree2(final GanttProject app, TaskManager taskManager,
243
172
            TaskSelectionManager selectionManager, final UIFacade uiFacade) {
244
173
 
245
 
        super(new BorderLayout());
 
174
        super(createTreeTable(app.getProject(), uiFacade));
246
175
        myUIFacade = uiFacade;
247
 
 
 
176
        appli = app;
248
177
        myTaskManager = taskManager;
 
178
        mySelectionManager = selectionManager;
 
179
 
249
180
        myTaskManager.addTaskListener(new TaskListenerAdapter() {
250
181
            @Override
251
182
            public void taskModelReset() {
252
183
                clearTree();
253
184
            }
254
185
        });
255
 
        mySelectionManager = selectionManager;
256
186
        mySelectionManager.addSelectionListener(new TaskSelectionManager.Listener() {
257
187
            @Override
258
188
            public void userInputConsumerChanged(Object newConsumer) {
262
192
                onTaskSelectionChanged(currentSelection);
263
193
            }
264
194
        });
265
 
        this.appli = app;
 
195
 
 
196
 
 
197
        // Create the root node
 
198
        initRootNode();
 
199
 
 
200
        // Create Actions
266
201
        myTaskPropertiesAction = new TaskPropertiesAction(app.getProject(), selectionManager, uiFacade);
267
 
        myDeleteAction = new DeleteTasksAction(taskManager, selectionManager, uiFacade, this);
268
 
        // Create the root node
269
 
        initRootNode();
270
 
 
271
 
        treeModel = new GanttTreeTableModel(rootNode, app.getProject().getTaskCustomColumnManager());
272
 
        treeModel.addTreeModelListener(new GanttTreeModelListener());
273
 
        // Create the JTree
274
 
        treetable = new GanttTreeTable(app.getProject(), uiFacade, treeModel);
275
 
 
276
 
        treetable.setupActionMaps(myMoveUpAction, myMoveDownAction, myIndentAction, myDedentAction, myNewTaskAction,
 
202
        myDeleteAction = new TaskDeleteAction(taskManager, selectionManager, uiFacade, this);
 
203
        myNewTaskAction = new TaskNewAction(app.getProject(), getUndoManager());
 
204
        myLinkTasksAction = new TaskLinkAction(taskManager, selectionManager, uiFacade);
 
205
        myUnlinkTasksAction = new TaskUnlinkAction(taskManager, selectionManager, uiFacade);
 
206
        myIndentAction = new TaskIndentAction(taskManager, selectionManager, uiFacade, this);
 
207
        myUnindentAction = new TaskUnindentAction(taskManager, selectionManager, uiFacade, this);
 
208
        myMoveUpAction = new TaskMoveUpAction(taskManager, selectionManager, uiFacade, this);
 
209
        myMoveDownAction = new TaskMoveDownAction(taskManager, selectionManager, uiFacade, this);
 
210
        getTreeTable().setupActionMaps(myMoveUpAction, myMoveDownAction, myIndentAction, myUnindentAction, myNewTaskAction,
277
211
            getAppFrame().getCutAction(), getAppFrame().getCopyAction(), getAppFrame().getPasteAction(),
278
212
            getTaskPropertiesAction(), myDeleteAction);
279
213
 
280
 
        treetable.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_X, KeyEvent.ALT_DOWN_MASK), "cutTask");
281
 
        treetable.addKeyListener(new KeyAdapter() {
282
 
            @Override
283
 
            public void keyPressed(KeyEvent e) {
284
 
                if (false == treetable.getTable().isEditing()) {
285
 
                    app.keyPressed(e);
286
 
                }
287
 
            }
288
 
        }); // callback for keyboard pressed
289
 
        treetable.getTree().addTreeSelectionListener(
 
214
        getTreeTable().getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_X, KeyEvent.ALT_DOWN_MASK), "cutTask");
 
215
        getTreeTable().getTree().addTreeSelectionListener(
290
216
                new TreeSelectionListener() {
 
217
                    @Override
291
218
                    public void valueChanged(TreeSelectionEvent e) {
292
219
                        if (isOnTaskSelectionEventProcessing) {
293
220
                            return;
306
233
                    }
307
234
                });
308
235
 
309
 
        treetable.setBackground(new Color(1.0f, 1.0f, 1.0f));
310
 
        treetable.getTree().addTreeExpansionListener(
 
236
        getTreeTable().setBackground(new Color(1.0f, 1.0f, 1.0f));
 
237
        getTreeTable().getTree().addTreeExpansionListener(
311
238
                new GanttTreeExpansionListener());
312
239
 
313
 
        ToolTipManager.sharedInstance().registerComponent(treetable);
 
240
        ToolTipManager.sharedInstance().registerComponent(getTreeTable());
314
241
 
315
 
        treetable.insertWithLeftyScrollBar(this);
 
242
        getTreeTable().insertWithLeftyScrollBar(this);
316
243
        mySelectionManager.addSelectionListener(new Listener() {
 
244
            @Override
317
245
            public void selectionChanged(List<Task> currentSelection) {
318
246
            }
 
247
            @Override
319
248
            public void userInputConsumerChanged(Object newConsumer) {
320
 
                if (treetable.getTable().isEditing()) {
321
 
                    treetable.getTable().editingStopped(new ChangeEvent(treetable.getTreeTable()));
 
249
                if (getTreeTable().getTable().isEditing()) {
 
250
                    getTreeTable().getTable().editingStopped(new ChangeEvent(getTreeTable().getTreeTable()));
322
251
                }
323
252
            }
324
253
        });
325
 
        treetable.getTree().addFocusListener(new FocusAdapter() {
 
254
        getTreeTable().getTree().addFocusListener(new FocusAdapter() {
326
255
            @Override
327
256
            public void focusGained(FocusEvent e) {
328
257
                super.focusGained(e);
345
274
            @Override
346
275
            public void mouseClicked(MouseEvent e) {
347
276
                if (e.getClickCount() == 2 && e.getButton() == MouseEvent.BUTTON1) {
348
 
                    TreePath selPath = treetable.getTreeTable().getPathForLocation(e.getX(), e.getY());
 
277
                    TreePath selPath = getTreeTable().getTreeTable().getPathForLocation(e.getX(), e.getY());
349
278
                    if (selPath != null) {
350
279
                        e.consume();
351
280
                        appli.propertiesTask();
357
286
 
358
287
            private void handlePopupTrigger(MouseEvent e) {
359
288
                if (e.isPopupTrigger() || e.getButton() == MouseEvent.BUTTON3) {
360
 
                    TreePath selPath = treetable.getTreeTable().getPathForLocation(e.getX(), e.getY());
 
289
                    TreePath selPath = getTreeTable().getTreeTable().getPathForLocation(e.getX(), e.getY());
361
290
                    if (selPath == null) {
362
291
                        return;
363
292
                    }
372
301
                }
373
302
            }
374
303
        };
375
 
        treetable.addMouseListener(ml);
 
304
        getTreeTable().addMouseListener(ml);
376
305
        DragSource dragSource = DragSource.getDefaultDragSource();
377
 
        dragSource.createDefaultDragGestureRecognizer(treetable,
 
306
        dragSource.createDefaultDragGestureRecognizer(getTreeTable(),
378
307
                DnDConstants.ACTION_COPY_OR_MOVE, this);
379
308
        dragSource.addDragSourceListener(this);
380
 
        DropTarget dropTarget = new DropTarget(treetable,
 
309
        DropTarget dropTarget = new DropTarget(getTreeTable(),
381
310
                new GanttTreeDropListener());
382
311
        dropTarget.setDefaultActions(DnDConstants.ACTION_COPY_OR_MOVE);
383
312
 
401
330
     * Edits the <code>t</code> task name in the treetable.
402
331
     */
403
332
    public void setEditingTask(Task t) {
404
 
        treetable.getTreeTable().editingStopped(new ChangeEvent(treetable.getTreeTable()));
 
333
        getTreeTable().getTreeTable().editingStopped(new ChangeEvent(getTreeTable().getTreeTable()));
405
334
 
406
335
        TaskSelectionManager taskSelectionManager = getTaskSelectionManager();
407
336
        taskSelectionManager.clear();
408
337
        taskSelectionManager.addTask(t);
409
338
 
410
 
        treetable.editSelectedTask();
411
 
        treetable.centerViewOnSelectedCell();
 
339
        getTreeTable().editSelectedTask();
 
340
        getTreeTable().centerViewOnSelectedCell();
412
341
    }
413
342
 
414
343
    public void stopEditing() {
415
 
        treetable.getTable().editingCanceled(
416
 
                new ChangeEvent(treetable.getTreeTable()));
417
 
        treetable.getTreeTable().editingCanceled(
418
 
                new ChangeEvent(treetable.getTreeTable()));
 
344
        getTreeTable().getTable().editingCanceled(
 
345
                new ChangeEvent(getTreeTable().getTreeTable()));
 
346
        getTreeTable().getTreeTable().editingCanceled(
 
347
                new ChangeEvent(getTreeTable().getTreeTable()));
419
348
    }
420
349
 
421
350
    public void changeLanguage(GanttLanguage ganttLanguage) {
424
353
    }
425
354
 
426
355
    private void initRootNode() {
427
 
        getTaskManager().getRootTask().setName("root");
428
 
        rootNode = new TaskNode(getTaskManager().getRootTask());
 
356
        getRootNode().setUserObject(getTaskManager().getRootTask());
429
357
    }
430
358
 
431
 
    Action[] getPopupMenuActions() {
 
359
    public Action[] getPopupMenuActions() {
432
360
        List<Action> actions = new ArrayList<Action>();
433
 
        actions.add(new NewTaskAction(appli, appli.getUndoManager()));
 
361
        actions.add(getTaskNewAction());
434
362
        if (!getTaskSelectionManager().getSelectedTasks().isEmpty()) {
435
363
            actions.add(getTaskPropertiesAction());
436
 
            actions.add(getDeleteTasksAction());
437
 
            actions.add(null);
438
 
            actions.add(myIndentAction);
439
 
            actions.add(myDedentAction);
440
 
            actions.add(getMoveUpAction());
441
 
            actions.add(getMoveDownAction());
442
 
            actions.add(null);
443
 
            actions.add(getUnlinkTasksAction());
444
 
            actions.add(getLinkTasksAction());
 
364
            actions.add(getTaskDeleteAction());
 
365
            actions.add(null);
 
366
            for(AbstractAction a : getTreeActions()) {
 
367
                actions.add(a);
 
368
            }
445
369
            actions.add(null);
446
370
            actions.add(appli.getCutAction());
447
371
            actions.add(appli.getCopyAction());
453
377
    /** Create a popup menu when mouse click */
454
378
    private void createPopupMenu(int x, int y) {
455
379
        Action[] popupMenuActions = getPopupMenuActions();
456
 
        JScrollBar vbar = treetable.getVerticalScrollBar();
 
380
        JScrollBar vbar = getTreeTable().getVerticalScrollBar();
457
381
        myUIFacade.showPopupMenu(this, popupMenuActions,
458
 
                x - treetable.getHorizontalScrollBar().getValue()
 
382
                x - getTreeTable().getHorizontalScrollBar().getValue()
459
383
                    + (vbar.isVisible() ? vbar.getWidth() : 0),
460
 
                y - vbar.getValue() + treetable.getTable().getTableHeader().getHeight());
 
384
                y - vbar.getValue() + getTreeTable().getTable().getTableHeader().getHeight());
461
385
    }
462
386
 
463
387
    /** Change graphic part */
471
395
        DefaultMutableTreeNode childNode = new TaskNode((Task) child);
472
396
 
473
397
        if (parent == null) {
474
 
            parent = rootNode;
 
398
            parent = getRootNode();
475
399
        }
476
400
 
477
 
        treeModel.insertNodeInto(childNode, parent, parent.getChildCount());
 
401
        getTreeModel().insertNodeInto(childNode, parent, parent.getChildCount());
478
402
        //forwardScheduling();
479
403
 
480
404
        // Task task = (Task) (childNode.getUserObject());
490
414
            parent = (DefaultMutableTreeNode) (parent.getParent());
491
415
        }
492
416
 
493
 
        treetable.getTree().scrollPathToVisible(
 
417
        getTreeTable().getTree().scrollPathToVisible(
494
418
                new TreePath(childNode.getPath()));
495
419
        if (!res && parent != null) {
496
 
            treetable.getTree().collapsePath(new TreePath(parent.getPath()));
497
 
        } //else {
498
 
        //    task.setExpand(false);
499
 
        // }
500
 
 
501
 
        nbTasks++;
 
420
            getTreeTable().getTree().collapsePath(new TreePath(parent.getPath()));
 
421
        }
502
422
        appli.refreshProjectInfos();
503
423
 
504
424
        return childNode;
509
429
        TaskNode childNode = new TaskNode((Task) child);
510
430
 
511
431
        if (parent == null)
512
 
            parent = rootNode;
 
432
            parent = getRootNode();
513
433
 
514
434
        // GanttTask tmpTask = (GanttTask)(childNode.getUserObject());
515
435
        // tmpTask.indentID((String)(((GanttTask)(parent.getUserObject())).getID()));
516
436
 
517
 
        treeModel.insertNodeInto(childNode, parent, index == -1 ? parent
 
437
        getTreeModel().insertNodeInto(childNode, parent, index == -1 ? parent
518
438
                .getChildCount() : index);
519
439
 
520
 
        treetable.getTree().scrollPathToVisible(
 
440
        getTreeTable().getTree().scrollPathToVisible(
521
441
                new TreePath(childNode.getPath()));
522
442
 
523
 
        nbTasks++;
524
443
        appli.refreshProjectInfos();
525
444
 
526
445
        return childNode;
527
446
    }
528
447
 
529
 
    /** @return the selected task */
530
 
    private GanttTask getSelectedTask() {
531
 
        DefaultMutableTreeNode node = getSelectedTaskNode();
532
 
        if (node == null)
533
 
            return null;
534
 
        return (GanttTask) (node.getUserObject());
535
 
    }
536
 
 
537
 
    /** @return the selected node */
538
 
    DefaultMutableTreeNode getSelectedNode() {
539
 
        TreePath currentSelection = treetable.getTree().getSelectionPath();
540
 
        if (currentSelection == null) {
541
 
            return null;
542
 
        }
543
 
        DefaultMutableTreeNode dmtnselected = (DefaultMutableTreeNode) currentSelection
544
 
                .getLastPathComponent();
545
 
        return dmtnselected;
546
 
    }
547
 
 
548
448
    /** @return the selected node */
549
449
    private DefaultMutableTreeNode getSelectedTaskNode() {
550
 
        TreePath currentSelection = treetable.getTree().getSelectionPath();
551
 
        if (currentSelection == null
552
 
                || !(currentSelection.getLastPathComponent() instanceof TaskNode)) {
553
 
            return null;
554
 
        }
555
 
        DefaultMutableTreeNode dmtnselected = (DefaultMutableTreeNode) currentSelection
556
 
                .getLastPathComponent();
557
 
        return dmtnselected;
 
450
        DefaultMutableTreeNode selectedNode = getSelectedNode();
 
451
        return selectedNode instanceof TaskNode ? selectedNode : null;
558
452
    }
559
453
 
560
454
    private TaskNode[] getSelectedTaskNodes() {
561
 
        TreePath[] currentSelection = treetable.getTree().getSelectionPaths();
 
455
        TreePath[] currentSelection = getTreeTable().getTree().getSelectionPaths();
562
456
 
563
457
        if (currentSelection == null || currentSelection.length == 0)
564
458
            return null;
575
469
 
576
470
    /** @return the list of the selected nodes. */
577
471
    public DefaultMutableTreeNode[] getSelectedNodes() {
578
 
        TreePath[] currentSelection = treetable.getTree().getSelectionPaths();
 
472
        TreePath[] currentSelection = getTreeTable().getTree().getSelectionPaths();
579
473
 
580
474
        if (currentSelection == null || currentSelection.length == 0) {
581
475
            // no elements are selected
605
499
    /** @return the DefaultMutableTreeNode with the name name. */
606
500
    private DefaultMutableTreeNode getNode(int id /* String name */) {
607
501
        DefaultMutableTreeNode res, base;
608
 
        base = (DefaultMutableTreeNode) treetable.getTreeTableModel().getRoot();
 
502
        base = (DefaultMutableTreeNode) getTreeTable().getTreeTableModel().getRoot();
609
503
        Enumeration<DefaultMutableTreeNode> e = base.preorderEnumeration();
610
504
        while (e.hasMoreElements()) {
611
505
            res = e.nextElement();
630
524
    /** @return an ArrayList with all tasks. */
631
525
    ArrayList<TaskNode> getAllTasks() {
632
526
        ArrayList<TaskNode> res = new ArrayList<TaskNode>();
633
 
        Enumeration<TreeNode> enumeration = rootNode.preorderEnumeration();
 
527
        Enumeration<TreeNode> enumeration = getRootNode().preorderEnumeration();
634
528
        while (enumeration.hasMoreElements()) {
635
529
            Object o = enumeration.nextElement();
636
530
            if (o instanceof TaskNode) {
642
536
 
643
537
    List<DefaultMutableTreeNode> getAllVisibleNodes() {
644
538
        List<DefaultMutableTreeNode> res = new ArrayList<DefaultMutableTreeNode>();
645
 
        Enumeration<TreeNode> enumeration = rootNode.preorderEnumeration();
 
539
        Enumeration<TreeNode> enumeration = getRootNode().preorderEnumeration();
646
540
        while (enumeration.hasMoreElements()) {
647
541
            DefaultMutableTreeNode o = (DefaultMutableTreeNode) enumeration
648
542
                    .nextElement();
673
567
        TreeNode parent = currentNode.getParent();
674
568
        getTaskManager().deleteTask((Task) currentNode.getUserObject());
675
569
        if (parent != null) {
676
 
            treeModel.removeNodeFromParent(currentNode);
677
 
            nbTasks--;
 
570
            getTreeModel().removeNodeFromParent(currentNode);
678
571
            appli.refreshProjectInfos();
679
572
        }
680
573
    }
682
575
    /** Clear the JTree. */
683
576
    private void clearTree() {
684
577
        // expand.clear();
685
 
        rootNode.removeAllChildren();
 
578
        getRootNode().removeAllChildren();
686
579
        initRootNode();
687
 
        treeModel.setRoot(rootNode);
688
 
        treeModel.reload();
689
 
        nbTasks = 0;
 
580
        getTreeModel().setRoot(getRootNode());
 
581
        getTreeModel().reload();
690
582
    }
691
583
 
692
584
    private void selectTasks(List<Task> tasksList) {
 
585
        clearSelection();
 
586
        for (Task t : tasksList) {
 
587
            setSelected(t, false);
 
588
        }
 
589
    }
 
590
 
 
591
    @Override
 
592
    public void setSelected(Task task, boolean clear) {
 
593
        if (clear) {
 
594
            clearSelection();
 
595
        }
 
596
        getTaskSelectionManager().addTask(task);
 
597
    }
 
598
 
 
599
    @Override
 
600
    public void clearSelection() {
693
601
        getTaskSelectionManager().clear();
694
 
        for (Task t : tasksList) {
695
 
            getTaskSelectionManager().addTask(t);
696
 
        }
697
 
    }
698
 
 
699
 
    private DefaultMutableTreeNode getTreeNode(Task t) {
700
 
        for (Enumeration<TreeNode> nodes = rootNode.preorderEnumeration(); nodes.hasMoreElements();) {
701
 
            DefaultMutableTreeNode nextNode = (DefaultMutableTreeNode) nodes.nextElement();
702
 
            if (!(nextNode instanceof TaskNode)) {
703
 
                continue;
704
 
            }
705
 
            if (nextNode.getUserObject().equals(t)) {
706
 
                return nextNode;
707
 
            }
708
 
        }
709
 
        return null;
710
602
    }
711
603
 
712
604
    private void onTaskSelectionChanged(List<Task> tasks) {
713
605
        isOnTaskSelectionEventProcessing = true;
714
606
        List<TreePath> paths = new ArrayList<TreePath>();
715
607
        for (Task t : tasks) {
716
 
            DefaultMutableTreeNode treeNode = getTreeNode(t);
 
608
            DefaultMutableTreeNode treeNode = getNode(t);
717
609
            assert treeNode != null;
718
610
            paths.add(new TreePath(treeNode.getPath()));
719
611
        }
722
614
    }
723
615
 
724
616
    /** @return the mother task. */
725
 
    DefaultMutableTreeNode getFatherNode(Task node) {
 
617
    DefaultMutableTreeNode getParentNode(Task node) {
726
618
        if (node == null) {
727
619
            return null;
728
620
        }
729
 
        DefaultMutableTreeNode tmp = (DefaultMutableTreeNode) getNode(node
730
 
                .getTaskID());
731
 
        if (tmp == null) {
732
 
            return null;
733
 
        }
734
 
 
735
 
        return (DefaultMutableTreeNode) tmp.getParent();
 
621
        return(getParentNode(getNode(node.getTaskID())));
736
622
    }
737
623
 
738
624
    /** @return the mother task. */
739
 
    private DefaultMutableTreeNode getFatherNode(DefaultMutableTreeNode node) {
 
625
    public static DefaultMutableTreeNode getParentNode(DefaultMutableTreeNode node) {
740
626
        if (node == null) {
741
627
            return null;
742
628
        }
745
631
 
746
632
    /** Return the JTree. */
747
633
    JTree getJTree() {
748
 
        return treetable.getTree();
 
634
        return getTreeTable().getTree();
749
635
    }
750
636
 
751
637
    JTable getTable() {
752
 
        return treetable.getTable();
753
 
    }
754
 
 
755
 
    public GanttTreeTable getTreeTable() {
756
 
        return treetable;
 
638
        return getTreeTable().getTable();
757
639
    }
758
640
 
759
641
    /** @return the root node */
760
642
    public DefaultMutableTreeNode getRoot() {
761
 
        return rootNode;
762
 
    }
763
 
 
764
 
    /** Function to move the selected tasks up */
765
 
    private void upCurrentNodes() {
766
 
        final DefaultMutableTreeNode[] cdmtn = getSelectedNodes();
767
 
        if (cdmtn == null) {
768
 
            myUIFacade.setStatusText(language.getText("msg21"));
769
 
            return;
770
 
        }
771
 
        final GanttTree2 gt2 = this;
772
 
        appli.getUndoManager().undoableEdit("Up", new Runnable() {
773
 
            public void run() {
774
 
                for (int i = 0; i < cdmtn.length; i++) {
775
 
                    DefaultMutableTreeNode father = gt2.getFatherNode(cdmtn[i]);
776
 
                    int index = father.getIndex((TreeNode) cdmtn[i]);
777
 
 
778
 
                    index--;
779
 
 
780
 
                    Task task = (Task) cdmtn[i].getUserObject();
781
 
 
782
 
                    if (index >= 0) {
783
 
                        DefaultMutableTreeNode[] child = new DefaultMutableTreeNode[cdmtn[i]
784
 
                                .getChildCount()];
785
 
 
786
 
                        if (task.getExpand()) {
787
 
                            for (int j = 0; j < cdmtn[i].getChildCount(); j++) {
788
 
                                child[j] = (DefaultMutableTreeNode) cdmtn[i]
789
 
                                        .getChildAt(j);
790
 
                            }
791
 
 
792
 
                            for (int j = 0; j < child.length; j++) {
793
 
                                child[j].removeFromParent();
794
 
                                treeModel.nodesWereRemoved(cdmtn[i],
795
 
                                        new int[] { 0 },
796
 
                                        new Object[] { child });
797
 
                            }
798
 
                        }
799
 
 
800
 
                        cdmtn[i].removeFromParent();
801
 
                        treeModel.nodesWereRemoved(father,
802
 
                                new int[] { index + 1 },
803
 
                                new Object[] { cdmtn });
804
 
 
805
 
                        father.insert(cdmtn[i], index);
806
 
                        treeModel.nodesWereInserted(father, new int[] { index });
807
 
 
808
 
                        if (task.getExpand()) {
809
 
                            for (int j = 0; j < child.length; j++) {
810
 
                                cdmtn[i].insert(child[j], j);
811
 
                                treeModel.nodesWereInserted(cdmtn[i], new int[] { j });
812
 
                            }
813
 
                        }
814
 
                        forwardScheduling();
815
 
                    }
816
 
                }
817
 
            }
818
 
        });
819
 
 
820
 
        //treetable.getTree().setSelectionPaths(selectedPaths);
821
 
 
822
 
        appli.setAskForSave(true);
823
 
        area.repaint();
824
 
    }
825
 
 
826
 
    /** Function to move the selected tasks down */
827
 
    private void downCurrentNodes() {
828
 
 
829
 
        final DefaultMutableTreeNode[] cdmtn = getSelectedNodes();
830
 
        if (cdmtn == null) {
831
 
            myUIFacade.setStatusText(language.getText("msg21"));
832
 
            return;
833
 
        }
834
 
 
835
 
        //final TreePath[] selectedPaths = new TreePath[cdmtn.length];
836
 
 
837
 
        // Parse in reverse mode because tasks are sorted from top to bottom.
838
 
        // appli.setQuickSave (false);
839
 
        final GanttTree2 gt2 = this;
840
 
        appli.getUndoManager().undoableEdit("Down", new Runnable() {
841
 
            public void run() {
842
 
                for (int i = cdmtn.length - 1; i >= 0; i--) {
843
 
                    DefaultMutableTreeNode father = gt2.getFatherNode(cdmtn[i]);
844
 
                    int index = father.getIndex((TreeNode) cdmtn[i]);
845
 
                    index++;
846
 
 
847
 
                    Task task = (Task) cdmtn[i].getUserObject();
848
 
 
849
 
                    // New position
850
 
                    if (index < father.getChildCount()) {
851
 
                        DefaultMutableTreeNode[] child = new DefaultMutableTreeNode[cdmtn[i].getChildCount()];
852
 
 
853
 
                        if (task.getExpand()) {
854
 
                            for (int j = 0; j < cdmtn[i].getChildCount(); j++) {
855
 
                                child[j] = (DefaultMutableTreeNode) cdmtn[i].getChildAt(j);
856
 
                            }
857
 
 
858
 
                            for (int j = 0; j < child.length; j++) {
859
 
                                child[j].removeFromParent();
860
 
                                treeModel.nodesWereRemoved(cdmtn[i],
861
 
                                        new int[] { 0 },
862
 
                                        new Object[] { child });
863
 
                            }
864
 
                        }
865
 
 
866
 
                        cdmtn[i].removeFromParent();
867
 
                        treeModel.nodesWereRemoved(father,
868
 
                                new int[] { index - 1 },
869
 
                                new Object[] { cdmtn });
870
 
 
871
 
                        father.insert(cdmtn[i], index);
872
 
                        treeModel.nodesWereInserted(father, new int[] {index});
873
 
 
874
 
                        if (task.getExpand()) {
875
 
                            for (int j = 0; j < child.length; j++) {
876
 
                                cdmtn[i].insert(child[j], j);
877
 
                                treeModel.nodesWereInserted(cdmtn[i], new int[] { j });
878
 
                            }
879
 
                        }
880
 
 
881
 
                        forwardScheduling();
882
 
                    }
883
 
                }
884
 
            }
885
 
        });
886
 
 
887
 
        appli.setAskForSave(true);
888
 
        area.repaint();
889
 
    }
890
 
 
891
 
    /**
892
 
     * Indent several nodes that are selected. Based on the IndentCurrentNode
893
 
     * method.
894
 
     */
895
 
    private void indentCurrentNodes() {
896
 
 
897
 
        final DefaultMutableTreeNode[] cdmtn = getSelectedTaskNodes();
898
 
        if (cdmtn == null) {
899
 
            myUIFacade.setStatusText(language.getText("msg21"));
900
 
            return;
901
 
        }
902
 
        getUndoManager().undoableEdit("Indent", new Runnable() {
903
 
            public void run() {
904
 
                for (int i = 0; i < cdmtn.length; i++) {
905
 
                    // Where is my nearest sibling in ascending order ?
906
 
                    DefaultMutableTreeNode newFather = cdmtn[i].getPreviousSibling();
907
 
                    // If there is no more indentation possible we must stop
908
 
                    if (!(newFather instanceof TaskNode)) {
909
 
                        continue;
910
 
                    }
911
 
                    if (cdmtn[i] instanceof TaskNode && newFather instanceof TaskNode) {
912
 
                        Task nextTask = (Task) cdmtn[i].getUserObject();
913
 
                        Task container = (Task) newFather.getUserObject();
914
 
                        if (!getTaskManager().getDependencyCollection().canCreateDependency(container, nextTask)) {
915
 
                            continue;
916
 
                        }
917
 
                        getTaskManager().getTaskHierarchy().move(nextTask, container);
918
 
                    }
919
 
                }
920
 
                area.repaint();
921
 
                appli.repaint2();
922
 
            }
923
 
        });
924
 
    }
925
 
 
926
 
    /**
927
 
     * Method to dedent selected task this will change the parent child
928
 
     * relationship. This Code is based on the UP/DOWN Coder I found in here
929
 
     * barmeier
930
 
     * <br/><br/>
931
 
     * Unindent the selected nodes. */
932
 
    private void dedentCurrentNodes() {
933
 
        final DefaultMutableTreeNode[] cdmtn = getSelectedTaskNodes();
934
 
        if (cdmtn == null) {
935
 
            myUIFacade.setStatusText(language.getText("msg21"));
936
 
            return;
937
 
        }
938
 
        final GanttTree2 gt2 = this;
939
 
        getUndoManager().undoableEdit("Dedent", new Runnable() {
940
 
            public void run() {
941
 
                TreePath[] selectedPaths = new TreePath[cdmtn.length];
942
 
 
943
 
                // Information about previous node is needed to determine if current node had sibling that was moved.
944
 
                DefaultMutableTreeNode previousFather = new DefaultMutableTreeNode();
945
 
                DefaultMutableTreeNode father = new DefaultMutableTreeNode();
946
 
 
947
 
                HashSet<Task> targetContainers = new HashSet<Task>();
948
 
                for (int i = 0; i < cdmtn.length; i++) {
949
 
 
950
 
                    // We use information about previous father to determine new index of the node in the tree.
951
 
                    if (i > 0) {
952
 
                        previousFather = father;
953
 
                    }
954
 
                    father = gt2.getFatherNode(cdmtn[i]);
955
 
 
956
 
                    // Getting the fathers father !? The grandpa I think  :)
957
 
                    DefaultMutableTreeNode newFather = gt2.getFatherNode(father);
958
 
                    // If no grandpa is available we must stop.
959
 
                    if (newFather == null) {
960
 
                        return;
961
 
                    }
962
 
 
963
 
                    int oldIndex = father.getIndex((TreeNode) cdmtn[i]);
964
 
 
965
 
                    cdmtn[i].removeFromParent();
966
 
                    treeModel.nodesWereRemoved(father, new int[] { oldIndex }, new Object[] { cdmtn });
967
 
 
968
 
                    targetContainers.add((Task) father.getUserObject());
969
 
                    // If node and previous node were siblings add current node after its previous sibling
970
 
                    int newIndex;
971
 
                    if (i > 0 && father.equals(previousFather) ) {
972
 
                        newIndex = newFather.getIndex(cdmtn[i-1]) + 1;
973
 
                    } else {
974
 
                        newIndex = newFather.getIndex(father) + 1;
975
 
                    }
976
 
 
977
 
                    treeModel.insertNodeInto(cdmtn[i], newFather, newIndex);
978
 
 
979
 
                    // Select again this node
980
 
                    TreeNode[] treepath = cdmtn[i].getPath();
981
 
                    TreePath path = new TreePath(treepath);
982
 
                    // tree.setSelectionPath(path);
983
 
                    selectedPaths[i] = path;
984
 
 
985
 
                    // refresh the father date
986
 
                    // Task current = (Task)(cdmtn[i].getUserObject());
987
 
                    // refreshAllFather(current.toString());
988
 
 
989
 
                    expandRefresh(cdmtn[i]);
990
 
 
991
 
                    if (father.getChildCount() == 0)
992
 
                        ((Task) father.getUserObject()).setProjectTask(false);
993
 
                }
994
 
                getTaskManager().getAlgorithmCollection().getAdjustTaskBoundsAlgorithm().run(
995
 
                        targetContainers.toArray(new Task[0]));
996
 
                forwardScheduling();
997
 
                treetable.getTree().setSelectionPaths(selectedPaths);
998
 
 
999
 
                area.repaint();
1000
 
 
1001
 
                // appli.setQuickSave (true);
1002
 
                // appli.quickSave ("Dedent");
1003
 
            }
1004
 
        });
 
643
        return getRootNode();
1005
644
    }
1006
645
 
1007
646
    /** Refresh the expansion (recursive function) */
1008
 
    private void expandRefresh(DefaultMutableTreeNode moved) {
 
647
    public void expandRefresh(DefaultMutableTreeNode moved) {
1009
648
        if (moved instanceof TaskNode) {
1010
649
            Task movedTask = (Task) moved.getUserObject();
1011
650
            // if (expand.contains(new Integer(movedTask.getTaskID()))) {
1012
651
            if (movedTask.getExpand()) {
1013
 
                treetable.getTree().expandPath(new TreePath(moved.getPath()));
 
652
                getTreeTable().getTree().expandPath(new TreePath(moved.getPath()));
1014
653
            }
1015
654
 
1016
655
            Enumeration children = moved.children();
1024
663
     * Class for expansion and collapse of node
1025
664
     */
1026
665
    private class GanttTreeExpansionListener implements TreeExpansionListener {
 
666
        @Override
1027
667
        public void treeExpanded(TreeExpansionEvent e) {
1028
668
            if (area != null) {
1029
669
                area.repaint();
1035
675
            appli.setAskForSave(true);
1036
676
        }
1037
677
 
 
678
        @Override
1038
679
        public void treeCollapsed(TreeExpansionEvent e) {
1039
680
            if (area != null) {
1040
681
                area.repaint();
1051
692
 
1052
693
    //////////////////////////////////////////////////////////////////////////////////////////
1053
694
 
1054
 
    /**
1055
 
     * Listener to generate modification on the model
1056
 
     */
1057
 
    private class GanttTreeModelListener implements TreeModelListener {
1058
 
        /** modify a node */
1059
 
        public void treeNodesChanged(TreeModelEvent e) {
1060
 
            if (area != null) {
1061
 
                area.repaint();
1062
 
            }
1063
 
        }
1064
 
 
1065
 
        /** Insert a new node. */
1066
 
        public void treeNodesInserted(TreeModelEvent e) {
1067
 
            if (area != null)
1068
 
                area.repaint();
1069
 
        }
1070
 
 
1071
 
        /** Delete a node. */
1072
 
        public void treeNodesRemoved(TreeModelEvent e) {
1073
 
            if (area != null) {
1074
 
                area.repaint();
1075
 
            }
1076
 
        }
1077
 
 
1078
 
        /** Structure change. */
1079
 
        public void treeStructureChanged(TreeModelEvent e) {
1080
 
            if (area != null) {
1081
 
                area.repaint();
1082
 
            }
1083
 
        }
1084
 
    }
1085
695
 
1086
696
    private class GanttTreeDropListener implements DropTargetListener {
1087
697
        private TreePath lastPath = null;
1105
715
            // expanded or collapsed
1106
716
            // if the user lingers on it for more than a short time
1107
717
            hoverTimer = new Timer(1000, new ActionListener() {
 
718
                @Override
1108
719
                public void actionPerformed(ActionEvent e) {
1109
 
                    if (!treetable.getTree().isExpanded(lastPath)) {
1110
 
                        treetable.getTree().expandPath(lastPath);
 
720
                    if (!getTreeTable().getTree().isExpanded(lastPath)) {
 
721
                        getTreeTable().getTree().expandPath(lastPath);
1111
722
                    }
1112
723
                }
1113
724
            });
1116
727
            hoverTimer.setRepeats(false);
1117
728
        }
1118
729
 
 
730
        @Override
1119
731
        public void dragEnter(DropTargetDragEvent dtde) {
1120
732
            if (ghostImage == null) {
1121
733
                // In case if you drag a file from out and it's not an
1130
742
            }
1131
743
        }
1132
744
 
 
745
        @Override
1133
746
        public void dragOver(DropTargetDragEvent dtde) {
1134
747
            if (!isDragAcceptable(dtde)) {
1135
748
                dtde.rejectDrag();
1146
759
 
1147
760
            lastEventPoint = pt;
1148
761
 
1149
 
            Graphics2D g2 = (Graphics2D) treetable.getGraphics();
 
762
            Graphics2D g2 = (Graphics2D) getTreeTable().getGraphics();
1150
763
 
1151
764
            // If a drag image is not supported by the platform, then draw our
1152
765
            // own drag image
1153
766
            if (!DragSource.isDragImageSupported()) {
1154
767
                // Rub out the last ghost image and cue line
1155
 
                treetable.paintImmediately(ghostImageRect.getBounds());
 
768
                getTreeTable().paintImmediately(ghostImageRect.getBounds());
1156
769
                // And remember where we are about to draw the new ghost image
1157
770
                ghostImageRect.setRect(pt.x - offsetPoint.x, pt.y
1158
771
                        - offsetPoint.y, ghostImage.getWidth(), ghostImage
1161
774
                        ghostImageRect.getX(), ghostImageRect.getY()), null);
1162
775
            } else {
1163
776
                // Just rub out the last cue line
1164
 
                treetable.paintImmediately(cueLineRect.getBounds());
 
777
                getTreeTable().paintImmediately(cueLineRect.getBounds());
1165
778
            }
1166
779
 
1167
 
            TreePath path = treetable.getTree().getClosestPathForLocation(pt.x,
 
780
            TreePath path = getTreeTable().getTree().getClosestPathForLocation(pt.x,
1168
781
                    pt.y);
1169
782
            if (!(path == lastPath)) {
1170
783
                lastPath = path;
1173
786
 
1174
787
            // In any case draw (over the ghost image if necessary) a cue line
1175
788
            // indicating where a drop will occur
1176
 
            Rectangle raPath = treetable.getTree().getPathBounds(path);
 
789
            Rectangle raPath = getTreeTable().getTree().getPathBounds(path);
1177
790
            if (raPath == null)
1178
791
                raPath = new Rectangle(1, 1);
1179
792
            cueLineRect.setRect(0, raPath.y + (int) raPath.getHeight(),
1187
800
 
1188
801
        }
1189
802
 
 
803
        @Override
1190
804
        public void dropActionChanged(DropTargetDragEvent dtde) {
1191
805
            if (!isDragAcceptable(dtde)) {
1192
806
                dtde.rejectDrag();
1195
809
            }
1196
810
        }
1197
811
 
 
812
        @Override
1198
813
        public void drop(DropTargetDropEvent dtde) {
1199
814
            if (!isDropAcceptable(dtde)) {
1200
815
                dtde.rejectDrop();
1216
831
                        .isMimeTypeEqual(DataFlavor.javaJVMLocalObjectMimeType)) {
1217
832
                    try {
1218
833
                        Point pt = dtde.getLocation();
1219
 
                        DefaultMutableTreeNode target = (DefaultMutableTreeNode) treetable
 
834
                        DefaultMutableTreeNode target = (DefaultMutableTreeNode) getTreeTable()
1220
835
                                .getTree()
1221
836
                                .getClosestPathForLocation(pt.x, pt.y)
1222
837
                                .getLastPathComponent();
1229
844
                        int index = sourceFather.getIndex(source);
1230
845
                        source.removeFromParent();
1231
846
 
1232
 
                        treeModel.nodesWereRemoved(sourceFather,
 
847
                        getTreeModel().nodesWereRemoved(sourceFather,
1233
848
                                new int[] { index }, new Object[] { source });
1234
849
 
1235
 
                        treeModel.insertNodeInto(source, target, 0);
 
850
                        getTreeModel().insertNodeInto(source, target, 0);
1236
851
 
1237
852
                        TreePath pathNewChild = new TreePath(
1238
853
                                ((DefaultMutableTreeNode) pathSource
1239
854
                                        .getLastPathComponent()).getPath());
1240
855
                        // Mark this as the selected path in the tree
1241
 
                        treetable.getTree().setSelectionPath(pathNewChild);
 
856
                        getTreeTable().getTree().setSelectionPath(pathNewChild);
1242
857
 
1243
858
                        // refreshAllFather(source.getUserObject().toString());
1244
859
 
1265
880
            dtde.dropComplete(true);
1266
881
        }
1267
882
 
 
883
        @Override
1268
884
        public void dragExit(DropTargetEvent dte) {
1269
885
            if (!DragSource.isDragImageSupported()) {
1270
886
                repaint(ghostImageRect.getBounds());
1271
887
            }
1272
 
            treetable.repaint();
 
888
            getTreeTable().repaint();
1273
889
        }
1274
890
 
1275
891
        public boolean isDragAcceptable(DropTargetDragEvent e) {
1285
901
 
1286
902
            // Do not accept dropping on the source node
1287
903
            Point pt = e.getLocation();
1288
 
            TreePath path = treetable.getTree().getClosestPathForLocation(pt.x,
 
904
            TreePath path = getTreeTable().getTree().getClosestPathForLocation(pt.x,
1289
905
                    pt.y);
1290
906
            if (dragPath.isDescendant(path)) {
1291
907
                return false;
1317
933
 
1318
934
            // prohibit dropping onto the drag source
1319
935
            Point pt = e.getLocation();
1320
 
            TreePath path = treetable.getTree().getClosestPathForLocation(pt.x,
 
936
            TreePath path = getTreeTable().getTree().getClosestPathForLocation(pt.x,
1321
937
                    pt.y);
1322
938
            if (path.equals(dragPath)) {
1323
939
                return false;
1344
960
        }
1345
961
 
1346
962
        // Transferable interface methods...
 
963
        @Override
1347
964
        public DataFlavor[] getTransferDataFlavors() {
1348
965
            return _flavors;
1349
966
        }
1350
967
 
 
968
        @Override
1351
969
        public boolean isDataFlavorSupported(DataFlavor flavor) {
1352
970
            return java.util.Arrays.asList(_flavors).contains(flavor);
1353
971
        }
1354
972
 
 
973
        @Override
1355
974
        public synchronized Object getTransferData(DataFlavor flavor)
1356
975
                throws UnsupportedFlavorException {
1357
976
            if (flavor.isMimeTypeEqual(TREEPATH_FLAVOR.getMimeType())) {
1374
993
    private Map<Integer, Integer> mapOriginalIDCopyID;
1375
994
 
1376
995
    /** Cut the current selected tree node */
1377
 
    void cutSelectedNode() {
1378
 
        final TreePath currentSelection = treetable.getTree()
 
996
    public void cutSelectedNode() {
 
997
        final TreePath currentSelection = getTreeTable().getTree()
1379
998
                .getSelectionPath();
1380
999
        final DefaultMutableTreeNode[] cdmtn = getSelectedNodes();
1381
1000
        if (currentSelection != null) {
1382
1001
            getUndoManager().undoableEdit("Cut", new Runnable() {
 
1002
                @Override
1383
1003
                public void run() {
1384
1004
                    cpNodesArrayList = new ArrayList<DefaultMutableTreeNode>();
1385
1005
                    cpAllDependencies(cdmtn);
1386
1006
                    GanttTask taskFather = null;
1387
 
                    DefaultMutableTreeNode father = null;
 
1007
                    DefaultMutableTreeNode parent = null;
1388
1008
                    DefaultMutableTreeNode current = null;
1389
1009
                    for (int i = 0; i < cdmtn.length; i++) {
1390
1010
                        current = getSelectedTaskNode();
1391
1011
                        if (current != null) {
1392
1012
                            cpNodesArrayList.add(cdmtn[i]);
1393
 
                            father = getFatherNode(current/* task */);
1394
 
                            where = father.getIndex(current);
 
1013
                            parent = getParentNode(current/* task */);
 
1014
                            where = parent.getIndex(current);
1395
1015
                            removeCurrentNode(current);
1396
 
                            current.setParent(father);
1397
 
                            taskFather = (GanttTask) father.getUserObject();
 
1016
                            current.setParent(parent);
 
1017
                            taskFather = (GanttTask) parent.getUserObject();
1398
1018
                            AdjustTaskBoundsAlgorithm alg = getTaskManager()
1399
1019
                                    .getAlgorithmCollection()
1400
1020
                                    .getAdjustTaskBoundsAlgorithm();
1401
1021
                            alg.run(taskFather);
1402
1022
                            // taskFather.refreshDateAndAdvancement(this);
1403
 
                            father.setUserObject(taskFather);
 
1023
                            parent.setUserObject(taskFather);
1404
1024
                        }
1405
1025
                    }
1406
 
                    if (father.getChildCount() == 0) {
1407
 
                        ((Task) father.getUserObject()).setProjectTask(false);
 
1026
                    if (parent.getChildCount() == 0) {
 
1027
                        ((Task) parent.getUserObject()).setProjectTask(false);
1408
1028
                    }
1409
1029
                    if (taskFather != null) {
1410
1030
                        getTaskSelectionManager().addTask(taskFather);
1418
1038
 
1419
1039
    private int where = -1;
1420
1040
 
1421
 
    private final Action myTaskPropertiesAction;
 
1041
    private AbstractAction[] myTreeActions;
1422
1042
 
1423
1043
    /** Copy the current selected tree node */
1424
 
    void copySelectedNode() {
 
1044
    public void copySelectedNode() {
1425
1045
        DefaultMutableTreeNode[] selectedNodes = getSelectedNodes();
1426
1046
        if (selectedNodes != null) {
1427
1047
            DefaultMutableTreeNode[] selectedRoots = findSelectedSubtreeRoots(selectedNodes);
1450
1070
    }
1451
1071
 
1452
1072
    /** Paste the node and its child node to current selected position */
1453
 
    void pasteNode() {
 
1073
    public void pasteNode() {
1454
1074
        if (cpNodesArrayList != null) {
1455
1075
            getUndoManager().undoableEdit("Paste", new Runnable() {
 
1076
                @Override
1456
1077
                public void run() {
1457
 
                    TaskNode current = (TaskNode) treetable.getTree()
1458
 
                            .getLastSelectedPathComponent();
 
1078
                    DefaultMutableTreeNode current = (DefaultMutableTreeNode)
 
1079
                            getTreeTable().getTree().getLastSelectedPathComponent();
1459
1080
                    List<Task> tasksList = new ArrayList<Task>();
1460
1081
                    if (current == null) {
1461
 
                        current = rootNode;
 
1082
                        current = getRootNode();
1462
1083
                    }
1463
1084
 
1464
1085
                    boolean isAProjectTaskChild = false;
1492
1113
                                where = parent.getIndex(sel);
1493
1114
                        }
1494
1115
                        tasksList.add((Task) insertClonedNode(
1495
 
                                current == rootNode ? current : (DefaultMutableTreeNode) current.getParent(),
 
1116
                                current == getRootNode() ? current : (DefaultMutableTreeNode) current.getParent(),
1496
1117
                                cpNodesArrayList.get(i), where + 1, true)
1497
1118
                                .getUserObject());
1498
 
                        nbTasks++;
1499
1119
                    }
1500
1120
                    if (cpDependencies != null) {
1501
1121
                        for (int i = 0; i < cpDependencies.size(); i++) {
1580
1200
            location = parent.getChildCount();
1581
1201
        }
1582
1202
 
1583
 
        treeModel.insertNodeInto(cloneChildNode, parent, location);
 
1203
        getTreeModel().insertNodeInto(cloneChildNode, parent, location);
1584
1204
 
1585
 
        treetable.getTree().scrollPathToVisible(
 
1205
        getTreeTable().getTree().scrollPathToVisible(
1586
1206
                new TreePath(cloneChildNode.getPath()));
1587
1207
 
1588
1208
        // Remove the node from the expand list
1609
1229
        return myTaskManager;
1610
1230
    }
1611
1231
 
 
1232
    @Override
1612
1233
    public void dragEnter(DragSourceDragEvent dsde) {
1613
1234
    }
1614
1235
 
 
1236
    @Override
1615
1237
    public void dragOver(DragSourceDragEvent dsde) {
1616
1238
    }
1617
1239
 
 
1240
    @Override
1618
1241
    public void dropActionChanged(DragSourceDragEvent dsde) {
1619
1242
    }
1620
1243
 
 
1244
    @Override
1621
1245
    public void dragDropEnd(DragSourceDropEvent dsde) {
1622
1246
    }
1623
1247
 
 
1248
    @Override
1624
1249
    public void dragExit(DragSourceEvent dse) {
1625
1250
    }
1626
1251
 
 
1252
    @Override
1627
1253
    public void dragGestureRecognized(DragGestureEvent dge) {
1628
1254
 
1629
1255
        Point ptDragOrigin = dge.getDragOrigin();
1630
 
        TreePath path = treetable.getTree().getPathForLocation(ptDragOrigin.x,
 
1256
        TreePath path = getTreeTable().getTree().getPathForLocation(ptDragOrigin.x,
1631
1257
                ptDragOrigin.y);
1632
1258
        if (path == null) {
1633
1259
            return;
1635
1261
 
1636
1262
        // Work out the offset of the drag point from the TreePath bounding
1637
1263
        // rectangle origin
1638
 
        Rectangle raPath = treetable.getTree().getPathBounds(path);
 
1264
        Rectangle raPath = getTreeTable().getTree().getPathBounds(path);
1639
1265
        offsetPoint.setLocation(ptDragOrigin.x - raPath.x, ptDragOrigin.y
1640
1266
                - raPath.y);
1641
1267
 
1677
1303
 
1678
1304
        g2.dispose();
1679
1305
 
1680
 
        treetable.getTree().setSelectionPath(path); // Select this path in the tree
 
1306
        getTreeTable().getTree().setSelectionPath(path); // Select this path in the tree
1681
1307
 
1682
1308
        // Wrap the path being transferred into a Transferable object
1683
1309
        Transferable transferable = new GanttTransferableTreePath(path);
1728
1354
        }
1729
1355
    }
1730
1356
 
1731
 
    public ArrayList<TaskNode> getProjectTasks() {
1732
 
        ArrayList<TaskNode> projectTasks = new ArrayList<TaskNode>();
1733
 
        getProjectTasks(rootNode, projectTasks);
1734
 
        return projectTasks;
1735
 
    }
1736
 
 
1737
 
    private void getProjectTasks(TaskNode node, ArrayList<TaskNode> list) {
1738
 
        ArrayList<TaskNode> childs = getAllChildTasks(node);
1739
 
        for (TaskNode child : childs) {
1740
 
            if (((Task) child.getUserObject()).isProjectTask()) {
1741
 
                list.add(child);
1742
 
            } else {
1743
 
                getProjectTasks(child, list);
1744
 
            }
1745
 
        }
1746
 
    }
1747
 
 
 
1357
    @Override
1748
1358
    public void setDelay(final Task task, final Delay delay) {
1749
1359
        SwingUtilities.invokeLater(new Runnable() {
 
1360
            @Override
1750
1361
            public void run() {
1751
1362
                TaskNode taskNode = (TaskNode) getNode(task.getTaskID());
1752
1363
                if (taskNode != null) {
1753
 
                    treetable.setDelay(taskNode, delay);
 
1364
                    getTreeTable().setDelay(taskNode, delay);
1754
1365
                }
1755
1366
            }
1756
1367
        });
1757
1368
    }
1758
1369
 
1759
1370
    GanttTreeTableModel getModel() {
1760
 
        return treeModel;
 
1371
        return getTreeModel();
1761
1372
    }
1762
1373
 
1763
1374
    private GPUndoManager getUndoManager() {
1764
1375
        return myUIFacade.getUndoManager();
1765
1376
    }
1766
1377
 
 
1378
    public void setSelectionPaths(TreePath[] selectedPaths) {
 
1379
        getTreeTable().getTree().setSelectionPaths(selectedPaths);
 
1380
    }
 
1381
 
1767
1382
    ////////////////////////////////////////////////////////////////////////
1768
1383
    // TaskTreeUIFacade
1769
 
    public Component getTreeComponent() {
1770
 
        return this;
1771
 
    }
1772
 
 
1773
 
    public Action getIndentAction() {
1774
 
        return myIndentAction;
1775
 
    }
1776
 
 
1777
 
    public Action getUnindentAction() {
1778
 
        return myDedentAction;
1779
 
    }
1780
 
 
1781
 
    // FIXME naming of method and returned variable seems wrong!
1782
 
    public Action getMoveDownAction() {
1783
 
        return myMoveUpAction;
1784
 
    }
1785
 
 
1786
 
    // FIXME naming of method and returned variable seems wrong!
1787
 
    public Action getMoveUpAction() {
1788
 
        return myMoveDownAction;
1789
 
    }
1790
 
 
1791
 
    public void setLinkTasksAction(Action action) {
1792
 
        myLinkTasksAction = action;
1793
 
    }
1794
 
 
1795
 
    public Action getLinkTasksAction() {
1796
 
        return myLinkTasksAction;
1797
 
    }
1798
 
 
1799
 
    public void setUnlinkTasksAction(Action action) {
1800
 
        myUnlinkTasksAction = action;
1801
 
    }
1802
 
 
1803
 
    public Action getUnlinkTasksAction() {
1804
 
        return myUnlinkTasksAction;
1805
 
    }
1806
 
 
1807
 
    Action getTaskPropertiesAction() {
 
1384
    @Override
 
1385
    public AbstractAction[] getTreeActions() {
 
1386
        if(myTreeActions == null) {
 
1387
            myTreeActions = new AbstractAction[] { myUnindentAction, myIndentAction, myMoveUpAction, myMoveDownAction,
 
1388
                    myLinkTasksAction, myUnlinkTasksAction };
 
1389
        }
 
1390
        return myTreeActions;
 
1391
    }
 
1392
 
 
1393
    public TaskActionBase getTaskPropertiesAction() {
1808
1394
        return myTaskPropertiesAction;
1809
1395
    }
1810
1396
 
1811
 
    Action getDeleteTasksAction() {
 
1397
    public GPAction getTaskNewAction() {
 
1398
        return myNewTaskAction;
 
1399
    }
 
1400
 
 
1401
    public TaskActionBase getTaskDeleteAction() {
1812
1402
        return myDeleteAction;
1813
1403
    }
1814
1404
 
 
1405
    @Override
1815
1406
    public TableHeaderUIFacade getVisibleFields() {
1816
 
        return treetable.getVisibleFields();
 
1407
        return getTreeTable().getVisibleFields();
1817
1408
    }
1818
1409
 
1819
1410
    public List<Task> getVisibleNodes(VisibleNodesFilter visibleNodesFilter) {
1821
1412
                getJTree(), getTreeTable().getVerticalScrollBar().getValue(), getHeight(),
1822
1413
                getTreeTable().getRowHeight());
1823
1414
    }
 
1415
 
 
1416
    @Override
 
1417
    protected DefaultMutableTreeNode getRootNode() {
 
1418
        return getTreeModel().getRootNode();
 
1419
    }
 
1420
 
 
1421
    @Override
 
1422
    protected Chart getChart() {
 
1423
        return myUIFacade.getGanttChart();
 
1424
    }
1824
1425
}