1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package p3j.gui.panels.projections;
17
18 import java.util.ArrayList;
19 import java.util.Collection;
20 import java.util.Collections;
21 import java.util.Comparator;
22 import java.util.HashMap;
23 import java.util.List;
24 import java.util.Map;
25
26 import javax.swing.JPanel;
27 import javax.swing.JScrollPane;
28 import javax.swing.JTree;
29 import javax.swing.tree.DefaultMutableTreeNode;
30 import javax.swing.tree.DefaultTreeModel;
31 import javax.swing.tree.TreePath;
32
33 import p3j.gui.panels.AbstractNavigationPanel;
34 import p3j.pppm.ProjectionModel;
35 import p3j.pppm.parameters.ParameterAssignment;
36 import p3j.pppm.parameters.ParameterInstance;
37 import p3j.pppm.parameters.Population;
38 import p3j.pppm.sets.Set;
39 import p3j.pppm.sets.SetType;
40
41
42
43
44
45
46
47
48
49
50
51 public class ProjectionTreePanel extends AbstractNavigationPanel implements
52 IProjectionTree {
53
54
55 private static final long serialVersionUID = 1648793294436076701L;
56
57
58 private ProjectionNode pTreeRoot;
59
60
61
62
63
64
65
66
67
68 public ProjectionTreePanel(ProjectionModel proj, JPanel content) {
69 super(proj, content);
70 }
71
72
73
74
75 @Override
76 protected void initTree() {
77 pTreeRoot = new ProjectionNode(getProjectionModel());
78 setTreeModel(new DefaultTreeModel(pTreeRoot));
79 setTree(new JTree(getTreeModel()));
80 getTree().setCellRenderer(new ProjectionTreeCellRenderer());
81 setScrollPane(new JScrollPane(getTree()));
82
83 totalRefresh();
84 getTree().addTreeSelectionListener(
85 new ProjectionTreeSelectionListener(getContentPanel(), this));
86 getTree().setSelectionPath(new TreePath(pTreeRoot));
87 }
88
89
90
91
92
93
94
95
96
97 protected void addSetTypeSubTree(DefaultMutableTreeNode root, SetType setType) {
98 SetTypeNode stNode = new SetTypeNode(setType);
99 root.add(stNode);
100 for (p3j.pppm.sets.Set set : setType.getSets()) {
101 addSetSubTree(stNode, set, setType);
102 }
103 }
104
105
106
107
108
109
110
111
112
113
114
115
116 protected SetNode addSetSubTree(SetTypeNode root, Set set, SetType setType) {
117 SetNode sNode = new SetNode(set);
118 root.add(sNode);
119
120 Map<Integer, List<ParameterInstance>> generationMap = new HashMap<Integer, List<ParameterInstance>>();
121
122 for (ParameterInstance instance : setType.getDefinedParameters()) {
123 int generation = retrieveGeneration(instance);
124 List<ParameterInstance> genInstList = generationMap.get(generation);
125 if (genInstList == null) {
126 genInstList = new ArrayList<ParameterInstance>();
127 generationMap.put(generation, genInstList);
128 }
129 genInstList.add(instance);
130 }
131
132 List<Integer> genIndices = new ArrayList<Integer>(generationMap.keySet());
133 Collections.sort(genIndices);
134
135 for (Integer genIndex : genIndices) {
136 if (genIndex < 0) {
137 addPopulationsSubTree(sNode, set, generationMap.get(genIndex));
138 } else {
139 addGenerationSubTree(sNode, generationMap.get(genIndex));
140 }
141 }
142
143 return sNode;
144 }
145
146
147
148
149
150
151
152
153
154
155 private int retrieveGeneration(ParameterInstance instance) {
156 int generation = instance.getGeneration();
157 if (instance.getParameter().getPopulation() != Population.NATIVES
158 && instance.getGeneration() == 0) {
159 generation = -1;
160 }
161 return generation;
162 }
163
164
165
166
167
168
169
170
171
172
173 protected void addGenerationSubTree(SetNode root,
174 List<ParameterInstance> instances) {
175 GenerationNode gNode = new GenerationNode(instances);
176 root.add(gNode);
177 addPopulationsSubTree(gNode, root.getEntity(), instances);
178 }
179
180
181
182
183
184
185
186
187
188
189
190 protected void addPopulationsSubTree(ProjectionTreeNode<?> root, Set set,
191 List<ParameterInstance> instances) {
192
193 Map<Population, List<ParameterInstance>> popMap = new HashMap<Population, List<ParameterInstance>>();
194 for (ParameterInstance instance : instances) {
195 List<ParameterInstance> popInsts = popMap.get(instance.getParameter()
196 .getPopulation());
197 if (popInsts == null) {
198 popInsts = new ArrayList<ParameterInstance>();
199 popMap.put(instance.getParameter().getPopulation(), popInsts);
200 }
201 popInsts.add(instance);
202 }
203
204
205 List<Population> populations = new ArrayList<Population>(popMap.keySet());
206 Collections.sort(populations, new Comparator<Population>() {
207 @Override
208 public int compare(Population o1, Population o2) {
209 return o1.compareTo(o2);
210 }
211 });
212
213 for (Population population : populations) {
214 List<ParameterInstance> popInst = popMap.get(population);
215 PopulationNode popNode = new PopulationNode(population);
216 root.add(popNode);
217 addInstancesSubTree(popNode, set, popInst);
218 }
219 }
220
221
222
223
224
225
226
227
228
229
230
231 protected void addInstancesSubTree(PopulationNode root, Set set,
232 List<ParameterInstance> instances) {
233 for (ParameterInstance instance : instances) {
234 ParameterInstanceNode instNode = new ParameterInstanceNode(instance);
235 root.add(instNode);
236 addAssumptionsSubTree(instNode, set, instance);
237 }
238 }
239
240
241
242
243
244
245
246
247
248
249
250 protected void addAssumptionsSubTree(ParameterInstanceNode root, Set set,
251 ParameterInstance instance) {
252 List<ParameterAssignment> assignments = new ArrayList<ParameterAssignment>(
253 set.getParameterAssignments(instance).getAssignments());
254
255
256 Collections.sort(assignments, new Comparator<ParameterAssignment>() {
257 @Override
258 public int compare(ParameterAssignment o1, ParameterAssignment o2) {
259 return o1.getName().compareTo(o2.getName());
260 }
261 });
262
263 for (ParameterAssignment assignment : assignments) {
264 root.add(new ParameterAssignmentNode(assignment));
265 }
266
267 }
268
269 @Override
270 public void refreshNode(ProjectionTreeNode<?> node) {
271 getTreeModel().nodeChanged(node);
272 }
273
274 @Override
275 public void refreshNodeSubStructure(ProjectionTreeNode<?> node) {
276 getTreeModel().nodeStructureChanged(node);
277
278 }
279
280 @Override
281 public void nodeAdded(ParameterInstanceNode node, int index) {
282 getTreeModel().nodesWereInserted(node, new int[] { index });
283 }
284
285 @Override
286 public void selectNode(ProjectionTreeNode<?> node) {
287 selectProjectionTreePath(new TreePath(getTreeModel().getPathToRoot(node)));
288 }
289
290 @Override
291 public void recursiveRefresh(ProjectionTreeNode<?> node) {
292 node.refreshRecursively(getTreeModel());
293 getTree().repaint();
294 }
295
296 @Override
297 public void removeNode(ProjectionTreeNode<?> node) {
298 TreePath path = new TreePath(getTreeModel().getPathToRoot(node.getParent()));
299 getTreeModel().removeNodeFromParent(node);
300 selectProjectionTreePath(path);
301 }
302
303
304
305
306
307
308
309 void selectProjectionTreePath(TreePath path) {
310 getTree().setSelectionPath(path);
311 getTree().scrollPathToVisible(path);
312 }
313
314 @Override
315 public void removeNodes(ProjectionTreeNode<?> node,
316 Collection<? extends Object> repRemovObjects) {
317 if (repRemovObjects.contains(node.getEntity())) {
318 getTreeModel().removeNodeFromParent(node);
319 } else {
320 for (ProjectionTreeNode<?> child : node.getChilds()) {
321 removeNodes(child, repRemovObjects);
322 }
323 }
324 }
325
326 @Override
327 public void cleanTree() {
328 cleanTree((ProjectionTreeNode<?>) getTreeModel().getRoot());
329 }
330
331
332
333
334
335
336
337 protected void cleanTree(ProjectionTreeNode<?> node) {
338 for (ProjectionTreeNode<?> child : node.getChilds()) {
339 cleanTree(child);
340 }
341 if (node.getChildCount() == 0
342 && (node instanceof PopulationNode || node instanceof GenerationNode)) {
343 getTreeModel().removeNodeFromParent(node);
344 }
345 }
346
347 @Override
348 public SetNode createNewSetStructure(SetTypeNode stNode, Set set) {
349 return addSetSubTree(stNode, set, stNode.getEntity());
350 }
351
352 @Override
353 public void totalRefresh() {
354
355
356 for (ProjectionTreeNode<?> child : pTreeRoot.getChilds()) {
357 getTreeModel().removeNodeFromParent(child);
358 }
359
360
361 addSetTypeSubTree(pTreeRoot, getProjectionModel().getDefaultSetType());
362 for (SetType type : getProjectionModel().getUserDefinedTypes()) {
363 addSetTypeSubTree(pTreeRoot, type);
364 }
365
366 getTreeModel().nodeStructureChanged(pTreeRoot);
367 getTree().repaint();
368 }
369 }