LayeredNode.java 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318
  1. package Model;
  2. import java.util.ArrayList;
  3. import org.eclipse.elk.graph.ElkEdge;
  4. import org.eclipse.elk.graph.ElkNode;
  5. /**
  6. * Die Implementation eines Knotens in einem Layered Graph
  7. *
  8. * @author kolja
  9. *
  10. */
  11. public class LayeredNode implements LayeredGraphNode {
  12. // for this node
  13. private ElkNode original;
  14. private LayeredGraphNode parent;
  15. double x;
  16. double y;
  17. double w;
  18. double h;
  19. String name;
  20. // for subgraph in this node
  21. private ArrayList< LayeredGraphEdge > edges;
  22. private ArrayList< LayeredGraphNode > nodes;
  23. private ArrayList< ArrayList< LayeredGraphNode > > layers;
  24. public LayeredNode( ElkNode original, LayeredGraphNode parent )
  25. {
  26. this.original = original;
  27. this.parent = parent;
  28. edges = new ArrayList<>();
  29. nodes = new ArrayList<>();
  30. layers = new ArrayList<>();
  31. w = 10;
  32. h = 10;
  33. }
  34. @Override
  35. public void setName( String n ) {
  36. name = n;
  37. }
  38. @Override
  39. public String getName()
  40. {
  41. return name;
  42. }
  43. @Override
  44. public ElkNode getOriginalNode() {
  45. return original;
  46. }
  47. @Override
  48. public void remove() {
  49. parent.removeNode( this );
  50. }
  51. @Override
  52. public LayeredGraphNode parent() {
  53. return parent;
  54. }
  55. @Override
  56. public void setLayer(int index) {
  57. parent.setNodeLayer( this, index );
  58. }
  59. @Override
  60. public int getLayer() {
  61. return parent.getNodeLayer( this );
  62. }
  63. @Override
  64. public void setX(double x) {
  65. if( original != null )
  66. original.setX( x );
  67. this.x = x;
  68. }
  69. @Override
  70. public void setY(double y) {
  71. if( original != null )
  72. original.setY( y );
  73. this.y = y;
  74. }
  75. @Override
  76. public double getX() {
  77. return x;
  78. }
  79. @Override
  80. public double getY() {
  81. return y;
  82. }
  83. @Override
  84. public double getWidth() {
  85. if( original != null )
  86. return original.getWidth();
  87. if( nodes.size() > 0 )
  88. {
  89. double max = 0;
  90. for( LayeredGraphNode n : nodes )
  91. {
  92. if( max < n.getX() + n.getWidth() )
  93. max = n.getX() + n.getWidth();
  94. }
  95. return Math.max( max, w );
  96. }
  97. return w;
  98. }
  99. @Override
  100. public double getHeight() {
  101. if( original != null )
  102. return original.getHeight();
  103. if( nodes.size() > 0 )
  104. {
  105. double max = 0;
  106. for( LayeredGraphNode n : nodes )
  107. {
  108. if( max < n.getY() + n.getHeight() )
  109. max = n.getY() + n.getHeight();
  110. }
  111. return Math.max( max, h );
  112. }
  113. return h;
  114. }
  115. @Override
  116. public void removeEdge(LayeredGraphEdge e) {
  117. edges.remove( e );
  118. }
  119. @Override
  120. public void removeNode(LayeredGraphNode n) {
  121. for( LayeredGraphEdge e : n.getIncomingEdges() )
  122. e.remove();
  123. for( LayeredGraphEdge e : n.getOutgoingEdges() )
  124. e.remove();
  125. nodes.remove( n );
  126. for( ArrayList<LayeredGraphNode> l : layers )
  127. {
  128. l.remove( n );
  129. }
  130. }
  131. @Override
  132. public void setNodeLayer(LayeredGraphNode n, int index) {
  133. while( index >= layers.size() )
  134. layers.add( new ArrayList<>() );
  135. int old = n.getLayer();
  136. if( old >= 0 )
  137. layers.get( old ).remove( n );
  138. layers.get( index ).add( n );
  139. }
  140. @Override
  141. public void setOrderedLayer(ArrayList<Double> indizes, int layerIndex) {
  142. ArrayList<LayeredGraphNode> l2 = layers.get( layerIndex );
  143. ArrayList<LayeredGraphNode> result = new ArrayList<LayeredGraphNode>();
  144. while( indizes.size() > 0 )
  145. {
  146. int mIndex = 0;
  147. double min = indizes.get( 0 );
  148. for( int i = 1; i < indizes.size(); i++ )
  149. {
  150. if( min > indizes.get( i ) )
  151. {
  152. mIndex = i;
  153. min = indizes.get( i );
  154. }
  155. }
  156. result.add( l2.get( mIndex ) );
  157. l2.remove( mIndex );
  158. indizes.remove( mIndex );
  159. }
  160. layers.set( layerIndex, result );
  161. }
  162. @Override
  163. public ArrayList<LayeredGraphEdge> getOutgoingEdges() {
  164. return parent.getOutgoingEdges( this );
  165. }
  166. @Override
  167. public ArrayList<LayeredGraphEdge> getIncomingEdges() {
  168. return parent.getIncomingEdges( this );
  169. }
  170. @Override
  171. public ArrayList<LayeredGraphEdge> getContainedEdges() {
  172. return edges;
  173. }
  174. @Override
  175. public ArrayList<LayeredGraphNode> getContainedNodes() {
  176. return nodes;
  177. }
  178. @Override
  179. public ArrayList<ArrayList<LayeredGraphNode>> getContainedLayers() {
  180. return layers;
  181. }
  182. @Override
  183. public int getNodeLayer(LayeredGraphNode n) {
  184. for( int i = 0; i < layers.size(); i++ )
  185. {
  186. if( layers.get( i ).contains( n ) )
  187. return i;
  188. }
  189. return -1;
  190. }
  191. @Override
  192. public ArrayList<LayeredGraphEdge> getOutgoingEdges(LayeredGraphNode n) {
  193. ArrayList<LayeredGraphEdge> result = new ArrayList<>();
  194. for( LayeredGraphEdge e : edges )
  195. {
  196. if( e.getSources().contains( n ) )
  197. result.add( e );
  198. }
  199. return result;
  200. }
  201. @Override
  202. public ArrayList<LayeredGraphEdge> getIncomingEdges(LayeredGraphNode n) {
  203. ArrayList<LayeredGraphEdge> result = new ArrayList<>();
  204. for( LayeredGraphEdge e : edges )
  205. {
  206. if( e.getTargets().contains( n ) )
  207. result.add( e );
  208. }
  209. return result;
  210. }
  211. @Override
  212. public LayeredGraphNode createNode(ElkNode original) {
  213. LayeredGraphNode n = new LayeredNode( original, this );
  214. nodes.add( n );
  215. return n;
  216. }
  217. @Override
  218. public LayeredGraphEdge createEdge(ElkEdge original, ArrayList<LayeredGraphNode> sources, ArrayList<LayeredGraphNode> targets) {
  219. LayeredGraphEdge e = new LayeredEdge( original, sources, targets, this );
  220. edges.add( e );
  221. return e;
  222. }
  223. @Override
  224. public LayeredGraphEdge createSimpleEdge(ElkEdge original, LayeredGraphNode source, LayeredGraphNode target) {
  225. ArrayList<LayeredGraphNode> sources = new ArrayList<>();
  226. ArrayList<LayeredGraphNode> targets = new ArrayList<>();
  227. sources.add( source );
  228. targets.add( target );
  229. LayeredGraphEdge e = new LayeredEdge( original, sources, targets, this );
  230. edges.add( e );
  231. return e;
  232. }
  233. @Override
  234. public LayeredGraphEdge findEdgeFromOriginal(Object original) {
  235. for( LayeredGraphEdge e : edges )
  236. {
  237. if( e.getOriginalEdge() == original )
  238. return e;
  239. }
  240. return null;
  241. }
  242. @Override
  243. public LayeredGraphNode findNodeFromOriginal(Object original) {
  244. for( LayeredGraphNode n : nodes )
  245. {
  246. if( n.getOriginalNode() == original )
  247. return n;
  248. }
  249. return null;
  250. }
  251. @Override
  252. public LayeredGraphNode findNodeByName( String name )
  253. {
  254. for( LayeredGraphNode n : nodes )
  255. {
  256. if( n.getName() == name )
  257. return n;
  258. }
  259. return null;
  260. }
  261. @Override
  262. public void addNode(LayeredGraphNode n) {
  263. nodes.add( n );
  264. n.setParent( this );
  265. }
  266. @Override
  267. public void addEdge(LayeredGraphEdge e) {
  268. edges.add( e );
  269. e.setGraph( this );
  270. }
  271. @Override
  272. public void setParent(LayeredGraphNode parent) {
  273. this.parent = parent;
  274. }
  275. }