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.SubPopulation;
36 import p3j.pppm.parameters.ParameterAssignment;
37 import p3j.pppm.parameters.ParameterInstance;
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<>();
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<>(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().isGenerationDependent()
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 for (SubPopulation subPopulation : pTreeRoot.getEntity()
193 .getSubPopulationModel().getSubPopulations()) {
194 List<ParameterInstance> popInst = ProjectionModel
195 .filterParamInstancesBySubPopulation(instances, subPopulation);
196 if (popInst.isEmpty())
197 continue;
198 SubPopulationNode popNode = new SubPopulationNode(subPopulation);
199 root.add(popNode);
200 addInstancesSubTree(popNode, set, popInst);
201 }
202 }
203
204
205
206
207
208
209
210
211
212
213
214 protected void addInstancesSubTree(SubPopulationNode root, Set set,
215 List<ParameterInstance> instances) {
216 for (ParameterInstance instance : instances) {
217 ParameterInstanceNode instNode = new ParameterInstanceNode(instance);
218 root.add(instNode);
219 addAssumptionsSubTree(instNode, set, instance);
220 }
221 }
222
223
224
225
226
227
228
229
230
231
232
233 protected void addAssumptionsSubTree(ParameterInstanceNode root, Set set,
234 ParameterInstance instance) {
235 List<ParameterAssignment> assignments = new ArrayList<ParameterAssignment>(
236 set.getParameterAssignments(instance).getAssignments());
237
238
239 Collections.sort(assignments, new Comparator<ParameterAssignment>() {
240 @Override
241 public int compare(ParameterAssignment o1, ParameterAssignment o2) {
242 return o1.getName().compareTo(o2.getName());
243 }
244 });
245
246 for (ParameterAssignment assignment : assignments) {
247 root.add(new ParameterAssignmentNode(assignment));
248 }
249
250 }
251
252 @Override
253 public void refreshNode(ProjectionTreeNode<?> node) {
254 getTreeModel().nodeChanged(node);
255 }
256
257 @Override
258 public void refreshNodeSubStructure(ProjectionTreeNode<?> node) {
259 getTreeModel().nodeStructureChanged(node);
260
261 }
262
263 @Override
264 public void nodeAdded(ParameterInstanceNode node, int index) {
265 getTreeModel().nodesWereInserted(node, new int[] { index });
266 }
267
268 @Override
269 public void selectNode(ProjectionTreeNode<?> node) {
270 selectProjectionTreePath(new TreePath(getTreeModel().getPathToRoot(node)));
271 }
272
273 @Override
274 public void recursiveRefresh(ProjectionTreeNode<?> node) {
275 node.refreshRecursively(getTreeModel());
276 getTree().repaint();
277 }
278
279 @Override
280 public void removeNode(ProjectionTreeNode<?> node) {
281 TreePath path = new TreePath(getTreeModel().getPathToRoot(node.getParent()));
282 getTreeModel().removeNodeFromParent(node);
283 selectProjectionTreePath(path);
284 }
285
286
287
288
289
290
291
292 void selectProjectionTreePath(TreePath path) {
293 getTree().setSelectionPath(path);
294 getTree().scrollPathToVisible(path);
295 }
296
297 @Override
298 public void removeNodes(ProjectionTreeNode<?> node,
299 Collection<? extends Object> repRemovObjects) {
300 if (repRemovObjects.contains(node.getEntity())) {
301 getTreeModel().removeNodeFromParent(node);
302 } else {
303 for (ProjectionTreeNode<?> child : node.getChilds()) {
304 removeNodes(child, repRemovObjects);
305 }
306 }
307 }
308
309 @Override
310 public void cleanTree() {
311 cleanTree((ProjectionTreeNode<?>) getTreeModel().getRoot());
312 }
313
314
315
316
317
318
319
320 protected void cleanTree(ProjectionTreeNode<?> node) {
321 for (ProjectionTreeNode<?> child : node.getChilds()) {
322 cleanTree(child);
323 }
324 if (node.getChildCount() == 0
325 && (node instanceof SubPopulationNode || node instanceof GenerationNode)) {
326 getTreeModel().removeNodeFromParent(node);
327 }
328 }
329
330 @Override
331 public SetNode createNewSetStructure(SetTypeNode stNode, Set set) {
332 return addSetSubTree(stNode, set, stNode.getEntity());
333 }
334
335 @Override
336 public void totalRefresh() {
337
338
339 for (ProjectionTreeNode<?> child : pTreeRoot.getChilds()) {
340 getTreeModel().removeNodeFromParent(child);
341 }
342
343
344 addSetTypeSubTree(pTreeRoot, getProjectionModel().getDefaultSetType());
345 for (SetType type : getProjectionModel().getUserDefinedTypes()) {
346 addSetTypeSubTree(pTreeRoot, type);
347 }
348
349 getTreeModel().nodeStructureChanged(pTreeRoot);
350 getTree().repaint();
351 }
352 }