← Back to branch summary

~veger/ganttproject/manual-import

« back to all changes in this revision

Viewing changes to ganttproject/src/net/sourceforge/ganttproject/TaskContainmentHierarchyFacadeImpl.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/TaskContainmentHierarchyFacadeImpl.java
1
1
/*
2
 
 * Created on 29.09.2005
3
 
 */
 
2
GanttProject is an opensource project management tool.
 
3
Copyright (C) 2005-2011 GanttProject Team
 
4
 
 
5
This program is free software; you can redistribute it and/or
 
6
modify it under the terms of the GNU General Public License
 
7
as published by the Free Software Foundation; either version 3
 
8
of the License, or (at your option) any later version.
 
9
 
 
10
This program is distributed in the hope that it will be useful,
 
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
GNU General Public License for more details.
 
14
 
 
15
You should have received a copy of the GNU General Public License
 
16
along with this program; if not, write to the Free Software
 
17
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
18
*/
4
19
package net.sourceforge.ganttproject;
5
20
 
6
21
import java.util.ArrayList;
44
59
        myTree = tree;
45
60
    }
46
61
 
 
62
    @Override
47
63
    public Task[] getNestedTasks(Task container) {
48
64
        Task[] result = null;
49
65
        DefaultMutableTreeNode treeNode = myTask2treeNode
63
79
        return result == null ? new Task[0] : result;
64
80
    }
65
81
 
 
82
    @Override
66
83
    public Task[] getDeepNestedTasks(Task container) {
67
84
        ArrayList<Task> result = new ArrayList<Task>();
68
85
        DefaultMutableTreeNode treeNodes = myTask2treeNode.get(container);
87
104
     * @param container
88
105
     *            The Task on which to check for children.
89
106
     */
 
107
    @Override
90
108
    public boolean hasNestedTasks(Task container) {
91
109
        DefaultMutableTreeNode treeNode = myTask2treeNode
92
110
                .get(container);
98
116
        return false;
99
117
    }
100
118
 
 
119
    @Override
101
120
    public Task getRootTask() {
102
121
        return myRootTask;
103
122
    }
104
123
 
 
124
    @Override
105
125
    public Task getContainer(Task nestedTask) {
106
126
        DefaultMutableTreeNode treeNode = myTask2treeNode
107
127
                .get(nestedTask);
114
134
                .getUserObject();
115
135
    }
116
136
 
 
137
    @Override
 
138
    public Task getPreviousSibling(Task nestedTask) {
 
139
        DefaultMutableTreeNode treeNode = myTask2treeNode.get(nestedTask);
 
140
        assert treeNode != null : "TreeNode of " + nestedTask + " not found. Please inform GanttProject developers";
 
141
        DefaultMutableTreeNode siblingNode = treeNode.getPreviousSibling();
 
142
        return siblingNode == null ? null : (Task) siblingNode.getUserObject();
 
143
    }
 
144
 
 
145
    @Override
 
146
    public Task getNextSibling(Task nestedTask) {
 
147
        DefaultMutableTreeNode treeNode = myTask2treeNode.get(nestedTask);
 
148
        assert treeNode != null : "TreeNode of " + nestedTask + " not found. Please inform GanttProject developers";
 
149
        DefaultMutableTreeNode siblingNode = treeNode.getNextSibling();
 
150
        return siblingNode == null ? null : (Task) siblingNode.getUserObject();
 
151
    }
 
152
 
 
153
    @Override
 
154
    public int getTaskIndex(Task nestedTask) {
 
155
        DefaultMutableTreeNode treeNode = myTask2treeNode.get(nestedTask);
 
156
        assert treeNode != null : "TreeNode of " + nestedTask + " not found. Please inform GanttProject developers";
 
157
        DefaultMutableTreeNode containerNode = (DefaultMutableTreeNode) treeNode.getParent();
 
158
        return containerNode.getIndex(treeNode);
 
159
    }
 
160
 
 
161
    @Override
117
162
    public boolean areUnrelated(Task first, Task second) {
118
163
        myPathBuffer.clear();
119
164
        for (Task container = getContainer(first); container != null; container = getContainer(container)) {
132
177
        return true;
133
178
    }
134
179
 
 
180
    @Override
135
181
    public void move(Task whatMove, Task whereMove) {
136
 
        DefaultMutableTreeNode targetNode = myTask2treeNode
137
 
                .get(whereMove);
138
 
        DefaultMutableTreeNode movedNode = myTask2treeNode
139
 
                .get(whatMove);
 
182
        DefaultMutableTreeNode targetNode = myTask2treeNode.get(whereMove);
 
183
        assert targetNode != null : "Failed to find tree node for task=" + whereMove;
 
184
        move(whatMove, whereMove, targetNode.getChildCount());
 
185
    }
 
186
 
 
187
    @Override
 
188
    public void move(Task whatMove, Task whereMove, int index) {
 
189
        DefaultMutableTreeNode targetNode = myTask2treeNode.get(whereMove);
 
190
        DefaultMutableTreeNode movedNode = myTask2treeNode.get(whatMove);
140
191
        if (movedNode != null) {
141
192
            TreePath movedPath = new TreePath(movedNode.getPath());
142
193
            boolean wasSelected = (myTree.getJTree().getSelectionModel()
145
196
                myTree.getJTree().getSelectionModel().removeSelectionPath(movedPath);
146
197
            }
147
198
            myTree.getModel().removeNodeFromParent(movedNode);
148
 
            myTree.getModel().insertNodeInto(movedNode, targetNode,
149
 
                    targetNode.getChildCount());
 
199
            myTree.getModel().insertNodeInto(movedNode, targetNode, index);
150
200
            if (wasSelected) {
151
201
                movedPath = new TreePath(movedNode.getPath());
152
202
                myTree.getJTree().getSelectionModel().addSelectionPath(movedPath);
167
217
        return myRootTask.getManager();
168
218
    }
169
219
 
 
220
    @Override
170
221
    public int getDepth(Task task) {
171
222
        DefaultMutableTreeNode treeNode = myTask2treeNode
172
223
                .get(task);
173
224
        return treeNode.getLevel();
174
225
    }
175
226
 
 
227
    @Override
176
228
    public int compareDocumentOrder(Task task1, Task task2) {
177
229
        Integer index1 = myTask2index.get(task1);
178
230
        Integer index2 = myTask2index.get(task2);
179
231
        return index1.intValue() - index2.intValue();
180
232
    }
181
233
 
 
234
    @Override
182
235
    public boolean contains(Task task) {
183
236
        return myTask2treeNode.containsKey(task);
184
237
    }
185
238
 
 
239
    @Override
186
240
    public List<Task> getTasksInDocumentOrder() {
187
241
        List<Task> result = new ArrayList<Task>();
188
242
        DefaultMutableTreeNode rootNode = myTask2treeNode.get(getRootTask());