diff --git a/src/main/java/attacktrees/AttackNode.java b/src/main/java/attacktrees/AttackNode.java
index fd12ae3cff2b09fc8793106b833bd9c22067279f..ffcf9e0b1bb775cfec57c7b1854519d8240ae53c 100644
--- a/src/main/java/attacktrees/AttackNode.java
+++ b/src/main/java/attacktrees/AttackNode.java
@@ -87,6 +87,9 @@ public abstract class AttackNode extends AttackElement {
public ArrayList<Attack> getInputAttacks() {
return inputAttacks;
}
+ public ArrayList<Integer> getInputValues() {
+ return inputValues;
+ }
public void addInputAttack(Attack _attack, Integer _val) {
inputAttacks.add(_attack);
diff --git a/src/main/java/ui/AttackTreePanel.java b/src/main/java/ui/AttackTreePanel.java
index 778c01e53828ffed3a90c3f887a9a116644ef930..f1fa1e2df4440df9b058774ed83084a47c098176 100644
--- a/src/main/java/ui/AttackTreePanel.java
+++ b/src/main/java/ui/AttackTreePanel.java
@@ -41,6 +41,7 @@
package ui;
+import attacktrees.AttackTree;
import myutil.GraphicLib;
import ui.atd.AttackTreeDiagramPanel;
import ui.atd.AttackTreeDiagramToolbar;
@@ -187,4 +188,6 @@ public class AttackTreePanel extends TURTLEPanel {
}
+
+
}
diff --git a/src/main/java/ui/MainGUI.java b/src/main/java/ui/MainGUI.java
index c813bc093ae6b1f099a671ed7b0a8bb1ad6b0844..37325cddcb819a05973543fbeb9779a7a626c351 100644
--- a/src/main/java/ui/MainGUI.java
+++ b/src/main/java/ui/MainGUI.java
@@ -1883,6 +1883,25 @@ public class MainGUI implements ActionListener, WindowListener, KeyListener, Per
return tabs.get(index);
}
+ public void drawAttackTreeDiagram(AttackTree _at) {
+ DateFormat dateFormat = new SimpleDateFormat("_yyyyMMdd_HHmmss");
+ Date date = new Date();
+ String dateAndTime = dateFormat.format(date);
+ String tabName = "AttackTree_" + dateAndTime;
+ TraceManager.addDev("Drawing AttackTreee Spec in " + tabName);
+ TraceManager.addDev("Draw AT 1");
+ int index = createAttackTree(tabName);
+ TraceManager.addDev("Draw AT 2, in tab index=" + index);
+ AttackTreePanel atp = (AttackTreePanel) (tabs.elementAt(index));
+ TraceManager.addDev("Draw AT 3");
+ atp.addAttackTreeDiagram(tabName);
+ atp.atdp.drawable = false;
+ atp.atdp.drawFromAttackTreeModel(_at);
+ atp.atdp.drawable = true;
+ atp.atdp.repaint();
+ TraceManager.addDev("Draw AT 4");
+ }
+
public void drawAvatarSpecification(AvatarSpecification av) {
DateFormat dateFormat = new SimpleDateFormat("_yyyyMMdd_HHmmss");
Date date = new Date();
diff --git a/src/main/java/ui/atd/AttackTreeDiagramPanel.java b/src/main/java/ui/atd/AttackTreeDiagramPanel.java
index 1565cad54391a509c1c236fe753623e9178a5a87..e7bdd1d97d660f28df2a27186b880198a3b73a67 100644
--- a/src/main/java/ui/atd/AttackTreeDiagramPanel.java
+++ b/src/main/java/ui/atd/AttackTreeDiagramPanel.java
@@ -43,13 +43,21 @@ package ui.atd;
//import java.awt.*;
+import attacktrees.Attack;
+import attacktrees.AttackElement;
+import attacktrees.AttackNode;
+import attacktrees.AttackTree;
+import avatartranslator.AvatarElement;
+import avatartranslator.avatarucd.AvatarActor;
import myutil.NameChecker;
+import myutil.TraceManager;
import ui.*;
+import ui.ucd.TGConnectorInclude;
+import ui.ucd.TGConnectorUseCase;
+import ui.ucd.UCDActor;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.ListIterator;
+import java.awt.*;
+import java.util.*;
//import org.w3c.dom.*;
//import org.xml.sax.*;
@@ -167,5 +175,121 @@ public class AttackTreeDiagramPanel extends TDiagramPanel implements TDPWithAttr
componentList.add(tgc1);
}
}
+
+ public String drawFromAttackTreeModel(AttackTree _at) {
+ Attack root = null;
+
+ // find the root attack
+ for(Attack att: _at.getAttacks()) {
+ if (att.isRoot()) {
+ root = att;
+ break;
+ }
+ }
+
+ if (root == null) {
+ return "No root attack";
+ }
+
+ HashMap<AttackElement, TGComponent> mapOfComponents = new HashMap<>();
+
+
+ return drawAttackFromAttackTreeModel(mapOfComponents, _at, root, null, -1, 600, 100, 1200);
+ }
+
+ public String drawAttackFromAttackTreeModel(HashMap<AttackElement, TGComponent> _mapOfComponents, AttackTree _at, Attack _att,
+ ATDConstraint _const, int _valueConst, int _x, int _y, int _length) {
+
+ // We draw the attack
+ ATDAttack attack = new ATDAttack(_x, _y, getMinX(), getMaxX(), getMinY(), getMaxY(), true, null, this);
+ attack.setValue(_att.getName());
+ addBuiltComponent(attack);
+ _mapOfComponents.put(_att, attack);
+
+ // If the constraint is non-null, we link the attack to the constraint
+ if (_const != null) {
+ TGConnectingPoint p1 = attack.closerFreeTGConnectingPoint(_const.getX(), _const.getY(), false, true);
+ TGConnectingPoint p2 = _const.closerFreeTGConnectingPoint(attack.getX(), attack.getY(), true, false);
+
+ if (p1 != null && p2 != null) {
+ p1.setFree(false);
+ p2.setFree(false);
+
+ TGConnector conn = null;
+ Vector<Point> points = new Vector<Point>();
+ conn = new ATDAttackConnector(0, 0, 0, 0, 0, 0, true, null,
+ this, p1, p2, points);
+ if (_valueConst != -1) {
+ conn.setValue("" + _valueConst);
+ }
+
+ if (conn != null) {
+ addComponent(conn, 0, 0, false, true);
+ }
+ }
+ }
+
+ // We look for the constraint linked to this attack
+ AttackNode nextNode = null;
+ for(AttackNode node: _at.getAttackNodes()) {
+ if (node.getResultingAttack() == _att) {
+ nextNode = node;
+ break;
+ }
+ }
+
+ // Leaf attack?
+ if (nextNode == null) {
+ return null;
+ }
+
+ // We create the ATDConstraint
+ _y = _y + 70;
+ ATDConstraint constraint = new ATDConstraint(_x, _y, getMinX(), getMaxX(), getMinY(), getMaxY(), true, null, this);
+ constraint.setValue(nextNode.getName());
+ addBuiltComponent(constraint);
+ _mapOfComponents.put(nextNode, constraint);
+
+ TGConnectingPoint p1 = constraint.closerFreeTGConnectingPoint(attack.getX(), attack.getY(), false, true);
+ TGConnectingPoint p2 = attack.closerFreeTGConnectingPoint(constraint.getX(), constraint.getY(), true, false);
+
+ if (p1 != null && p2 != null) {
+ p1.setFree(false);
+ p2.setFree(false);
+
+ TGConnector conn = null;
+ Vector<Point> points = new Vector<Point>();
+ conn = new ATDAttackConnector(0, 0, 0, 0, 0, 0, true, null,
+ this, p1, p2, points);
+ if (_valueConst != -1) {
+ conn.setValue("" + _valueConst);
+ }
+
+ if (conn != null) {
+ addComponent(conn, 0, 0, false, true);
+ }
+ }
+
+ // We now create all the sub attacks
+ int size = nextNode.getInputAttacks().size();
+ int currentBeg = _x - _length/2;
+ int slotSize = _length / size;
+ for(int i=0; i<size ; i++) {
+ Attack nextAttack = nextNode.getInputAttacks().get(i);
+ Integer nextValue = nextNode.getInputValues().get(i);
+
+ String s = drawAttackFromAttackTreeModel(_mapOfComponents, _at, nextAttack, constraint, nextValue, currentBeg+ slotSize/2 , _y+70,
+ slotSize);
+ currentBeg += slotSize;
+
+ if (s != null) {
+ return s;
+ }
+
+ }
+
+
+ return null;
+ }
}