1
2
3
4
5
6
7 package com.vikash.firsttool.UI;
8 import com.vikash.firsttool.Diagram.*;
9 import com.vikash.firsttool.ProfileImpl.*;
10 import org.jgraph.JGraph;
11 import org.jgraph.event.GraphModelListener;
12
13 import org.jgraph.graph.*;
14 import javax.swing.tree.*;
15 import javax.swing.event.*;
16 import javax.swing.*;
17
18 import java.util.*;
19
20 /***
21 *
22 * @author studajb
23 */
24 public class DiagramElementTreeModel extends DefaultTreeModel implements GraphModelListener{
25
26
27 ToolModel model;
28 DiagramElementTreePane Elementtree;
29 DefaultMutableTreeNode root;
30 int elementCount;
31 SWOTElements SWOTelement =new SWOTElements();
32 AssetElements Assetelement= new AssetElements();
33 RiskElements Riskelement=new RiskElements();
34 StakeholderElements Stakeholderelement=new StakeholderElements();
35 EntityElements Entityelement=new EntityElements();
36 ThreatAgentElements Threatagentelement=new ThreatAgentElements();
37 ThreatScenarioElements Threatscenarioelement=new ThreatScenarioElements();
38 UnwantedIncidentElements Unwantedincidentelement=new UnwantedIncidentElements();
39 TreatmentElements Treatmentelement=new TreatmentElements();
40 TreatmentEffectElements Treatmenteffectelement=new TreatmentEffectElements();
41 JDesktopPane desktoppane;
42 boolean changed;
43
44
45 public DiagramElementTreeModel(DefaultMutableTreeNode root,ToolModel diagmodel,
46 DiagramElementTreePane tree,JDesktopPane pane) {
47 super(root);
48 Elementtree=tree;
49 model=diagmodel;
50 desktoppane=pane;
51 addTreeModelListener(new DiagramElementTreeModelListener());
52 addElementTypes(root);
53 }
54 public void addElementTypes(DefaultMutableTreeNode root){
55 this.root=root;
56
57 root.add(SWOTelement);
58 root.add(Assetelement);
59 root.add(Stakeholderelement);
60 root.add(Entityelement);
61 root.add(Threatagentelement);
62 root.add(Threatscenarioelement);
63 root.add(Unwantedincidentelement);
64 root.add(Riskelement);
65 root.add(Treatmentelement);
66 root.add(Treatmenteffectelement);
67 if(model.getRootCount()!=0){
68 for(int i=0;i<model.getRootCount();i++){
69
70 DefaultGraphCell insertednode=( DefaultGraphCell)model.getRootAt(i);
71 addElement(insertednode);
72
73 }
74 }
75 }
76 public void graphChanged(org.jgraph.event.GraphModelEvent e) {
77
78
79
80 if(model.getRootCount()!=getNumberOfElements()){
81 Object[] cells;
82
83
84
85 cells=e.getChange().getInserted();
86 if(cells!=null){
87 java.util.List list = new ArrayList();
88 for (int i = 0; i < cells.length; i++){
89 if (!(cells[i] instanceof Port))
90 list.add(cells[i]);
91 }
92 cells = list.toArray();
93 if(cells.length!=0) {
94 DefaultGraphCell insertednode=null;
95 for(int i=0;i<cells.length;i++){
96 insertednode=( DefaultGraphCell)cells[i];
97 addElement(insertednode);
98 }
99 showTreeElement(insertednode);
100 }
101
102 }
103
104
105 cells=e.getChange().getRemoved();
106 if(cells!=null){
107 java.util.List list = new ArrayList();
108 for (int i = 0; i < cells.length; i++){
109 if (!(cells[i] instanceof Port))
110 list.add(cells[i]);
111 }
112 cells = list.toArray();
113 if(cells.length!=0) {
114 for(int i=0;i<cells.length;i++){
115 DefaultGraphCell deletednode=( DefaultGraphCell)cells[i];
116 removeElement(deletednode);
117 }
118 }
119
120 }
121
122 }
123 setTreeChanged(true);
124
125 }
126
127 public void addElement(DefaultGraphCell insnode){
128 DefaultGraphCell insertednode=insnode;
129 TreeElement node=new TreeElement(insertednode);
130
131 node.setInternalFrame((ToolInternalFrame)desktoppane.getSelectedFrame());
132
133 if(insertednode instanceof SWOTGraphCell){
134
135 insertNodeInto(node,SWOTelement,SWOTelement.getChildCount());
136
137 }
138
139 else if(insertednode instanceof AssetGraphCell){
140
141 insertNodeInto(node,Assetelement,Assetelement.getChildCount());
142
143 }
144 else if(insertednode instanceof StakeholderGraphCell){
145
146 insertNodeInto(node,Stakeholderelement,Stakeholderelement.getChildCount());
147
148 }
149 else if(insertednode instanceof EntityGraphCell){
150
151 insertNodeInto(node,Entityelement,Entityelement.getChildCount());
152
153 }
154 else if(insertednode instanceof ThreatAgentGraphCell){
155
156 insertNodeInto(node,Threatagentelement,Threatagentelement.getChildCount());
157
158 }
159 else if(insertednode instanceof ThreatScenarioGraphCell){
160
161 insertNodeInto(node,Threatscenarioelement,Threatscenarioelement.getChildCount());
162
163 }
164 else if(insertednode instanceof UnwantedIncidentGraphCell){
165
166 insertNodeInto(node,Unwantedincidentelement,Unwantedincidentelement.getChildCount());
167
168 }
169 else if(insertednode instanceof TreatmentGraphCell){
170
171 insertNodeInto(node,Treatmentelement,Treatmentelement.getChildCount());
172
173 }
174 else if(insertednode instanceof RiskGraphCell){
175
176 insertNodeInto(node,Riskelement,Riskelement.getChildCount());
177
178 }
179 else if(insertednode instanceof TreatmentEffectGraphCell){
180 insertNodeInto(node,Treatmenteffectelement,Treatmenteffectelement.getChildCount());
181
182 }
183 else if(insertednode instanceof ToolEdge)
184 {
185 addEdge(insertednode);
186 }
187 numberOfElements(model.getRootCount());
188
189 }
190
191 public void addEdge(DefaultGraphCell node){
192 ToolEdge edge=(ToolEdge) node;
193 DefaultGraphCell edgeSource=(DefaultGraphCell)(((DefaultPort)edge.getSource()).getParent());
194 DefaultMutableTreeNode treeElement=findTreeElementOf(edgeSource);
195 if(treeElement!=null){
196
197 TreeElement edgeNode=new TreeElement(edge);
198
199 edgeNode.setInternalFrame((ToolInternalFrame)desktoppane.getSelectedFrame());
200 insertNodeInto(edgeNode, treeElement, treeElement.getChildCount());
201 }
202 }
203 public void removeElement(DefaultGraphCell deletednode){
204 DefaultMutableTreeNode treeElement=findTreeElementOf(deletednode);
205 if(treeElement!=null){
206 if(deletednode instanceof ToolEdge){
207 if(treeElement.getParent()!=null)
208 removeNodeFromParent(treeElement);
209 }
210 else
211 {
212 removeNodeFromParent(treeElement);
213 }
214 }
215 numberOfElements(model.getRootCount());
216 }
217
218 public void showTreeElement(DefaultGraphCell cell){
219 if(cell!=null){
220
221 DefaultMutableTreeNode node=findTreeElementOf(cell);
222 if(node==null)return;
223 TreeNode[] nodes=getPathToRoot(node);
224 TreePath path=new TreePath(nodes);
225 Elementtree.scrollPathToVisible(path);
226 Elementtree.setSelectionPath(path);
227 }
228 }
229 public DefaultMutableTreeNode findTreeElementOf(DefaultGraphCell cell){
230 Enumeration e=root.breadthFirstEnumeration();
231 while(e.hasMoreElements()){
232
233 DefaultMutableTreeNode node=(DefaultMutableTreeNode)e.nextElement();
234 if(node instanceof TreeElement){
235 DefaultGraphCell element =(DefaultGraphCell)((TreeElement)node).getUserObject();
236 if(element==cell){
237 return node;
238
239 }
240
241 }
242 }
243 return null;
244
245 }
246 public void numberOfElements(int count){
247 this.elementCount=count;
248 }
249 public int getNumberOfElements(){
250 return this.elementCount;
251 }
252 public void setTreeChanged(boolean flag){
253 this.changed=flag;
254 }
255 public boolean isTreeChanged(){
256 return this.changed;
257 }
258 class DiagramElementTreeModelListener implements TreeModelListener{
259
260 public void treeNodesChanged(TreeModelEvent e){
261 setTreeChanged(true);
262 }
263
264 public void treeNodesInserted(TreeModelEvent e){
265 setTreeChanged(true);
266 }
267
268 public void treeNodesRemoved(TreeModelEvent e){
269 setTreeChanged(true);
270 }
271
272 public void treeStructureChanged(TreeModelEvent e){
273 setTreeChanged(true);
274 }
275
276 }
277 }
278
279
280
281 class SWOTElements extends DefaultMutableTreeNode{
282
283 public int getIndex(TreeNode aChild) {
284
285 if (aChild == null) {
286 throw new IllegalArgumentException("argument is null");
287 }
288
289 return children.indexOf(aChild);
290 }
291
292 public String toString() {
293 return "SWOT Elements";
294 }
295 }
296
297 class AssetElements extends DefaultMutableTreeNode{
298 public int getIndex(TreeNode aChild) {
299 if (aChild == null) {
300 throw new IllegalArgumentException("argument is null");
301 }
302
303 return children.indexOf(aChild);
304 }
305
306 public String toString() {
307 return "Asset Elements";
308 }
309 }
310
311 class UnwantedIncidentElements extends DefaultMutableTreeNode{
312 public int getIndex(TreeNode aChild) {
313 if (aChild == null) {
314 throw new IllegalArgumentException("argument is null");
315 }
316
317 return children.indexOf(aChild);
318 }
319
320 public String toString() {
321 return "UnwantedIncident Elements";
322 }
323 }
324 class RiskElements extends DefaultMutableTreeNode{
325 public int getIndex(TreeNode aChild) {
326 if (aChild == null) {
327 throw new IllegalArgumentException("argument is null");
328 }
329
330 return children.indexOf(aChild);
331 }
332
333 public String toString() {
334 return "Risk Elements";
335 }
336 }
337
338 class TreatmentElements extends DefaultMutableTreeNode{
339 public int getIndex(TreeNode aChild) {
340 if (aChild == null) {
341 throw new IllegalArgumentException("argument is null");
342 }
343
344 return children.indexOf(aChild);
345 }
346
347 public String toString() {
348 return "Treatment Elements";
349 }
350 }
351 class TreatmentEffectElements extends DefaultMutableTreeNode{
352 public int getIndex(TreeNode aChild) {
353 if (aChild == null) {
354 throw new IllegalArgumentException("argument is null");
355 }
356
357 return children.indexOf(aChild);
358 }
359
360 public String toString() {
361 return "TreatmentEffect Elements";
362 }
363 }
364 class StakeholderElements extends DefaultMutableTreeNode{
365
366 public int getIndex(TreeNode aChild) {
367 if (aChild == null) {
368 throw new IllegalArgumentException("argument is null");
369 }
370
371 return children.indexOf(aChild);
372 }
373
374 public String toString() {
375 return "Stakeholder Elements";
376 }
377 }
378 class ThreatScenarioElements extends DefaultMutableTreeNode{
379 public int getIndex(TreeNode aChild) {
380 if (aChild == null) {
381 throw new IllegalArgumentException("argument is null");
382 }
383
384 return children.indexOf(aChild);
385 }
386 public String toString() {
387 return "ThreatScenario Elements";
388 }
389 }
390
391 class EntityElements extends DefaultMutableTreeNode{
392 public int getIndex(TreeNode aChild) {
393 if (aChild == null) {
394 throw new IllegalArgumentException("argument is null");
395 }
396
397 return children.indexOf(aChild);
398 }
399
400 public String toString() {
401 return "Entity Elements";
402 }
403 }
404 class ThreatAgentElements extends DefaultMutableTreeNode{
405 public int getIndex(TreeNode aChild) {
406 if (aChild == null) {
407 throw new IllegalArgumentException("argument is null");
408 }
409
410 return children.indexOf(aChild);
411 }
412
413 public String toString() {
414 return "ThreatAgents Elements";
415 }
416
417
418 }
419