LayeredNode.java 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941
  1. package graph;
  2. import java.awt.Color;
  3. import java.util.ArrayList;
  4. import org.eclipse.elk.graph.ElkConnectableShape;
  5. import org.eclipse.elk.graph.ElkEdge;
  6. import org.eclipse.elk.graph.ElkNode;
  7. import org.eclipse.emf.common.util.EList;
  8. import bk.LayoutType;
  9. import view.NodeView;
  10. /**
  11. * Die Implementation eines Knotens in einem Layered Graph. Implementiert {@link LayeredGraphNode}.
  12. *
  13. * @author kolja
  14. *
  15. */
  16. public class LayeredNode implements LayeredGraphNode {
  17. private ElkNode original;
  18. private LayeredGraphNode parent;
  19. private boolean dummy;
  20. private class LayoutInfo {
  21. private double x;
  22. private double y;
  23. private double w;
  24. private double h;
  25. private Color color;
  26. private boolean selected;
  27. private boolean xUndef;
  28. // Block Calculation
  29. private LayeredGraphNode align;
  30. private LayeredGraphNode root;
  31. // HorizontalCompaction
  32. private LayeredGraphNode sink;
  33. private double shift;
  34. private NodeView view;
  35. }
  36. private class CombinedLayoutInfo {
  37. private double x;
  38. private double y;
  39. private double w;
  40. private double h;
  41. private boolean selected;
  42. private NodeView view;
  43. }
  44. private LayoutInfo[] layouts;
  45. private CombinedLayoutInfo combined;
  46. private String name;
  47. private boolean mouseOver;
  48. // for subgraph in this node
  49. private ArrayList<LayeredGraphEdge> edges;
  50. private ArrayList<LayeredGraphNode> nodes;
  51. private ArrayList<ArrayList<LayeredGraphNode>> layers;
  52. /**
  53. * Konvertiert einen Graph aus dem Elk format in einen Graph, der mehr Informationen enth�lt
  54. *
  55. * @param n
  56. * Der Graph, welcher konvertiert werden soll
  57. * @return Ein layered Graph, welcher im wesentlichen ein Wrapper f�r den urspr�nglichen Graphen ist
  58. */
  59. public static LayeredGraphNode convertToLayeredGraph(ElkNode n) {
  60. LayeredNode ln = new LayeredNode(n, null);
  61. for (ElkNode node : n.getChildren())
  62. ln.addNode(convertToLayeredGraph(node));
  63. for (ElkEdge edge : n.getContainedEdges()) {
  64. // TODO n.getProperty(Properties.LAYERPOS) reads position of node n in his layer
  65. ArrayList<LayeredGraphNode> sources = new ArrayList<>();
  66. ArrayList<LayeredGraphNode> targets = new ArrayList<>();
  67. EList<ElkConnectableShape> s = edge.getSources();
  68. EList<ElkConnectableShape> t = edge.getTargets();
  69. for (ElkConnectableShape shape : s)
  70. sources.add(ln.findNodeFromOriginal(shape));
  71. for (ElkConnectableShape shape : t)
  72. targets.add(ln.findNodeFromOriginal(shape));
  73. ln.createEdge(edge, sources, targets);
  74. }
  75. return ln;
  76. }
  77. /**
  78. * creates a {@link LayeredNode} from an {@link ElkNode}.
  79. * @param original the original {@link ElkNode}.
  80. * @param parent the graph containing the edge.
  81. */
  82. public LayeredNode(ElkNode original, LayeredGraphNode parent) {
  83. this.original = original;
  84. this.parent = parent;
  85. edges = new ArrayList<>();
  86. nodes = new ArrayList<>();
  87. layers = new ArrayList<>();
  88. layouts = new LayoutInfo[ 4 ];
  89. for( int i = 0; i < 4; i++ )
  90. layouts[ i ] = new LayoutInfo();
  91. int index = 0;
  92. for( LayoutInfo l : layouts )
  93. {
  94. if( original != null )
  95. {
  96. l.x = original.getX();
  97. l.y = original.getX();
  98. l.w = original.getWidth();
  99. l.h = original.getHeight();
  100. }
  101. l.align = this;
  102. l.root = this;
  103. l.sink = this;
  104. if( index == 0 || index == 2 )
  105. l.shift = Double.POSITIVE_INFINITY;
  106. else
  107. l.shift = Double.NEGATIVE_INFINITY;
  108. l.xUndef = true;
  109. index++;
  110. }
  111. dummy = false;
  112. combined = new CombinedLayoutInfo();
  113. if (original != null) {
  114. combined.x = original.getX();
  115. combined.y = original.getX();
  116. combined.w = original.getWidth();
  117. combined.h = original.getHeight();
  118. }
  119. combined.selected = false;
  120. setMouseOver(false);
  121. }
  122. public void setMouseOver( boolean over ) {
  123. mouseOver = over;
  124. }
  125. public boolean isMouseOver() {
  126. return mouseOver;
  127. }
  128. /**
  129. * associates the node with an {@link NodeView} in order to display it in the given layout.
  130. * @param view the view
  131. * @param layout the layout
  132. */
  133. public void setView(NodeView view, LayoutType layout) {
  134. if (layout == LayoutType.LEFTMOST_UPPER)
  135. this.layouts[0].view = view;
  136. if (layout == LayoutType.RIGHTMOST_UPPER)
  137. this.layouts[1].view = view;
  138. if (layout == LayoutType.LEFTMOST_LOWER)
  139. this.layouts[2].view = view;
  140. if (layout == LayoutType.RIGHTMOST_LOWER)
  141. this.layouts[3].view = view;
  142. if (layout == LayoutType.COMBINED)
  143. this.combined.view = view;
  144. }
  145. /**
  146. * returns the {@link NodeView} of this node in the given layout.
  147. * @param layout the layout
  148. * @return the view
  149. */
  150. public NodeView getView(LayoutType layout) {
  151. if (layout == LayoutType.LEFTMOST_UPPER)
  152. return layouts[0].view;
  153. if (layout == LayoutType.RIGHTMOST_UPPER)
  154. return layouts[1].view;
  155. if (layout == LayoutType.LEFTMOST_LOWER)
  156. return layouts[2].view;
  157. if (layout == LayoutType.RIGHTMOST_LOWER)
  158. return layouts[3].view;
  159. if (layout == LayoutType.COMBINED)
  160. return combined.view;
  161. return null;
  162. }
  163. @Override
  164. public void setDummyNode(boolean dummy) {
  165. this.dummy = dummy;
  166. }
  167. @Override
  168. public boolean isDummyNode() {
  169. return dummy;
  170. }
  171. @Override
  172. public void setShift(double shift, LayoutType layout) {
  173. if (layout == null) {
  174. this.layouts[0].shift = shift;
  175. this.layouts[1].shift = shift;
  176. this.layouts[2].shift = shift;
  177. this.layouts[3].shift = shift;
  178. }
  179. if (layout == LayoutType.LEFTMOST_UPPER)
  180. this.layouts[0].shift = shift;
  181. if (layout == LayoutType.RIGHTMOST_UPPER)
  182. this.layouts[1].shift = shift;
  183. if (layout == LayoutType.LEFTMOST_LOWER)
  184. this.layouts[2].shift = shift;
  185. if (layout == LayoutType.RIGHTMOST_LOWER)
  186. this.layouts[3].shift = shift;
  187. }
  188. @Override
  189. public double getShift(LayoutType layout) {
  190. if (layout == LayoutType.LEFTMOST_UPPER)
  191. return this.layouts[0].shift;
  192. if (layout == LayoutType.RIGHTMOST_UPPER)
  193. return this.layouts[1].shift;
  194. if (layout == LayoutType.LEFTMOST_LOWER)
  195. return this.layouts[2].shift;
  196. if (layout == LayoutType.RIGHTMOST_LOWER)
  197. return this.layouts[3].shift;
  198. return 0;
  199. }
  200. @Override
  201. public void setSink(LayeredGraphNode sink, LayoutType layout) {
  202. if (layout == null) {
  203. this.layouts[0].sink = sink;
  204. this.layouts[1].sink = sink;
  205. this.layouts[2].sink = sink;
  206. this.layouts[3].sink = sink;
  207. }
  208. if (layout == LayoutType.LEFTMOST_UPPER)
  209. this.layouts[0].sink = sink;
  210. if (layout == LayoutType.RIGHTMOST_UPPER)
  211. this.layouts[1].sink = sink;
  212. if (layout == LayoutType.LEFTMOST_LOWER)
  213. this.layouts[2].sink = sink;
  214. if (layout == LayoutType.RIGHTMOST_LOWER)
  215. this.layouts[3].sink = sink;
  216. }
  217. @Override
  218. public LayeredGraphNode getSink(LayoutType layout) {
  219. if (layout == LayoutType.LEFTMOST_UPPER)
  220. return this.layouts[0].sink;
  221. if (layout == LayoutType.RIGHTMOST_UPPER)
  222. return this.layouts[1].sink;
  223. if (layout == LayoutType.LEFTMOST_LOWER)
  224. return this.layouts[2].sink;
  225. if (layout == LayoutType.RIGHTMOST_LOWER)
  226. return this.layouts[3].sink;
  227. return null;
  228. }
  229. @Override
  230. public boolean isXUndefined(LayoutType layout) {
  231. if (layout == LayoutType.LEFTMOST_UPPER)
  232. return this.layouts[0].xUndef;
  233. if (layout == LayoutType.RIGHTMOST_UPPER)
  234. return this.layouts[1].xUndef;
  235. if (layout == LayoutType.LEFTMOST_LOWER)
  236. return this.layouts[2].xUndef;
  237. if (layout == LayoutType.RIGHTMOST_LOWER)
  238. return this.layouts[3].xUndef;
  239. return true;
  240. }
  241. @Override
  242. public void setAlign(LayeredGraphNode align, LayoutType layout) {
  243. if (layout == null) {
  244. this.layouts[0].align = align;
  245. this.layouts[1].align = align;
  246. this.layouts[2].align = align;
  247. this.layouts[3].align = align;
  248. }
  249. if (layout == LayoutType.LEFTMOST_UPPER)
  250. this.layouts[0].align = align;
  251. if (layout == LayoutType.RIGHTMOST_UPPER)
  252. this.layouts[1].align = align;
  253. if (layout == LayoutType.LEFTMOST_LOWER)
  254. this.layouts[2].align = align;
  255. if (layout == LayoutType.RIGHTMOST_LOWER)
  256. this.layouts[3].align = align;
  257. }
  258. @Override
  259. public LayeredGraphNode getAlign(LayoutType layout) {
  260. if (layout == LayoutType.LEFTMOST_UPPER)
  261. return this.layouts[0].align;
  262. if (layout == LayoutType.RIGHTMOST_UPPER)
  263. return this.layouts[1].align;
  264. if (layout == LayoutType.LEFTMOST_LOWER)
  265. return this.layouts[2].align;
  266. if (layout == LayoutType.RIGHTMOST_LOWER)
  267. return this.layouts[3].align;
  268. return null;
  269. }
  270. @Override
  271. public void setRoot(LayeredGraphNode root, LayoutType layout) {
  272. if (layout == null) {
  273. this.layouts[0].root = root;
  274. this.layouts[1].root = root;
  275. this.layouts[2].root = root;
  276. this.layouts[3].root = root;
  277. }
  278. if (layout == LayoutType.LEFTMOST_UPPER)
  279. this.layouts[0].root = root;
  280. if (layout == LayoutType.RIGHTMOST_UPPER)
  281. this.layouts[1].root = root;
  282. if (layout == LayoutType.LEFTMOST_LOWER)
  283. this.layouts[2].root = root;
  284. if (layout == LayoutType.RIGHTMOST_LOWER)
  285. this.layouts[3].root = root;
  286. }
  287. @Override
  288. public LayeredGraphNode getRoot(LayoutType layout) {
  289. if (layout == LayoutType.LEFTMOST_UPPER)
  290. return this.layouts[0].root;
  291. if (layout == LayoutType.RIGHTMOST_UPPER)
  292. return this.layouts[1].root;
  293. if (layout == LayoutType.LEFTMOST_LOWER)
  294. return this.layouts[2].root;
  295. if (layout == LayoutType.RIGHTMOST_LOWER)
  296. return this.layouts[3].root;
  297. return null;
  298. }
  299. @Override
  300. public void setSelected(LayoutType layout) {
  301. if (layout == null) {
  302. this.layouts[0].selected = true;
  303. this.layouts[1].selected = true;
  304. this.layouts[2].selected = true;
  305. this.layouts[3].selected = true;
  306. combined.selected = true;
  307. }
  308. if (layout == LayoutType.LEFTMOST_UPPER)
  309. this.layouts[0].selected = true;
  310. if (layout == LayoutType.RIGHTMOST_UPPER)
  311. this.layouts[1].selected = true;
  312. if (layout == LayoutType.LEFTMOST_LOWER)
  313. this.layouts[2].selected = true;
  314. if (layout == LayoutType.RIGHTMOST_LOWER)
  315. this.layouts[3].selected = true;
  316. if (layout == LayoutType.COMBINED)
  317. combined.selected = true;
  318. }
  319. @Override
  320. public void unselectGraph() {
  321. for (LayeredGraphNode n : nodes) {
  322. n.unselectGraph();
  323. }
  324. this.layouts[0].selected = false;
  325. this.layouts[1].selected = false;
  326. this.layouts[2].selected = false;
  327. this.layouts[3].selected = false;
  328. combined.selected = false;
  329. }
  330. @Override
  331. public boolean isSelected(LayoutType layout) {
  332. if (layout == LayoutType.LEFTMOST_UPPER) {
  333. return layouts[0].selected;
  334. }
  335. if (layout == LayoutType.RIGHTMOST_UPPER) {
  336. return layouts[1].selected;
  337. }
  338. if (layout == LayoutType.LEFTMOST_LOWER) {
  339. return layouts[2].selected;
  340. }
  341. if (layout == LayoutType.RIGHTMOST_LOWER) {
  342. return layouts[3].selected;
  343. }
  344. if (layout == LayoutType.COMBINED) {
  345. return combined.selected;
  346. }
  347. return false;
  348. }
  349. @Override
  350. public void setColor( Color c, LayoutType layout )
  351. {
  352. if( layout == null )
  353. {
  354. this.layouts[ 0 ].color = c;
  355. this.layouts[ 1 ].color = c;
  356. this.layouts[ 2 ].color = c;
  357. this.layouts[ 3 ].color = c;
  358. }
  359. if( layout == LayoutType.LEFTMOST_UPPER )
  360. this.layouts[ 0 ].color = c;
  361. if( layout == LayoutType.RIGHTMOST_UPPER )
  362. this.layouts[ 1 ].color = c;
  363. if( layout == LayoutType.LEFTMOST_LOWER )
  364. this.layouts[ 2 ].color = c;
  365. if( layout == LayoutType.RIGHTMOST_LOWER )
  366. this.layouts[ 3 ].color = c;
  367. }
  368. private int calcClassSize(LayeredGraphNode sink, LayoutType layout) {
  369. if (parent == null)
  370. return 1;
  371. int ret = 0;
  372. for (LayeredGraphNode n : parent.getContainedNodes()) {
  373. if (n.getRoot(layout).getSink(layout) == sink)
  374. ret++;
  375. }
  376. return ret;
  377. }
  378. @Override
  379. public Color getClassColor(LayoutType layout) {
  380. if (layout == LayoutType.LEFTMOST_UPPER && this.layouts[0].sink == this && calcClassSize(this, layout) == 1)
  381. return Color.LIGHT_GRAY;
  382. if (layout == LayoutType.LEFTMOST_UPPER && this.layouts[0].sink == this)
  383. return this.layouts[0].color;
  384. else if (layout == LayoutType.LEFTMOST_UPPER)
  385. return this.layouts[0].sink.getClassColor(layout);
  386. if (layout == LayoutType.RIGHTMOST_UPPER && this.layouts[1].sink == this && calcClassSize(this, layout) == 1)
  387. return Color.LIGHT_GRAY;
  388. if (layout == LayoutType.RIGHTMOST_UPPER && this.layouts[1].sink == this)
  389. return this.layouts[1].color;
  390. else if (layout == LayoutType.RIGHTMOST_UPPER)
  391. return this.layouts[1].sink.getClassColor(layout);
  392. if (layout == LayoutType.LEFTMOST_LOWER && this.layouts[2].sink == this && calcClassSize(this, layout) == 1)
  393. return Color.LIGHT_GRAY;
  394. if (layout == LayoutType.LEFTMOST_LOWER && this.layouts[2].sink == this)
  395. return this.layouts[2].color;
  396. else if (layout == LayoutType.LEFTMOST_LOWER)
  397. return this.layouts[2].sink.getClassColor(layout);
  398. if (layout == LayoutType.RIGHTMOST_LOWER && this.layouts[3].sink == this && calcClassSize(this, layout) == 1)
  399. return Color.LIGHT_GRAY;
  400. if( layout == LayoutType.RIGHTMOST_LOWER && this.layouts[ 3 ].sink == this )
  401. return this.layouts[ 3 ].color;
  402. else if( layout == LayoutType.RIGHTMOST_LOWER )
  403. return this.layouts[ 3 ].sink.getClassColor( layout );
  404. if( layout == LayoutType.COMBINED )
  405. return Color.LIGHT_GRAY;
  406. return null;
  407. }
  408. @Override
  409. public Color getColor( LayoutType layout )
  410. {
  411. if( layout == null )
  412. return this.layouts[ 0 ].color;
  413. if( layout == LayoutType.LEFTMOST_UPPER && this.layouts[ 0 ].root == this && this.layouts[ 0 ].align == this )
  414. return Color.LIGHT_GRAY;
  415. if (layout == LayoutType.LEFTMOST_UPPER && this.layouts[0].root != this)
  416. return this.layouts[0].root.getColor(layout);
  417. if (layout == LayoutType.LEFTMOST_UPPER)
  418. return this.layouts[0].color;
  419. if (layout == LayoutType.RIGHTMOST_UPPER && this.layouts[1].root == this && this.layouts[1].align == this)
  420. return Color.LIGHT_GRAY;
  421. if (layout == LayoutType.RIGHTMOST_UPPER && this.layouts[1].root != this)
  422. return this.layouts[1].root.getColor(layout);
  423. if (layout == LayoutType.RIGHTMOST_UPPER)
  424. return this.layouts[1].color;
  425. if (layout == LayoutType.LEFTMOST_LOWER && this.layouts[2].root == this && this.layouts[2].align == this)
  426. return Color.LIGHT_GRAY;
  427. if (layout == LayoutType.LEFTMOST_LOWER && this.layouts[2].root != this)
  428. return this.layouts[2].root.getColor(layout);
  429. if (layout == LayoutType.LEFTMOST_LOWER)
  430. return this.layouts[2].color;
  431. if (layout == LayoutType.RIGHTMOST_LOWER && this.layouts[3].root == this && this.layouts[3].align == this)
  432. return Color.LIGHT_GRAY;
  433. if( layout == LayoutType.RIGHTMOST_LOWER && this.layouts[ 3 ].root != this )
  434. return this.layouts[ 3 ].root.getColor( layout );
  435. if( layout == LayoutType.RIGHTMOST_LOWER )
  436. return this.layouts[ 3 ].color;
  437. if( layout == LayoutType.COMBINED )
  438. return Color.LIGHT_GRAY;
  439. return null;
  440. }
  441. @Override
  442. public void setName(String n) {
  443. name = n;
  444. }
  445. @Override
  446. public ElkNode getOriginalNode() {
  447. return original;
  448. }
  449. @Override
  450. public void remove() {
  451. parent.removeNode(this);
  452. }
  453. @Override
  454. public LayeredGraphNode parent() {
  455. return parent;
  456. }
  457. @Override
  458. public void setLayer(int index) {
  459. parent.setNodeLayer(this, index);
  460. }
  461. @Override
  462. public int getLayer() {
  463. return parent.getNodeLayer(this);
  464. }
  465. @Override
  466. public void setX(double x, boolean def, LayoutType layout) {
  467. if (layout == null) {
  468. layouts[0].x = x;
  469. layouts[1].x = x;
  470. layouts[2].x = x;
  471. layouts[3].x = x;
  472. combined.x = x;
  473. }
  474. if (layout == LayoutType.LEFTMOST_UPPER) {
  475. layouts[0].xUndef = !def;
  476. layouts[0].x = x;
  477. }
  478. if (layout == LayoutType.RIGHTMOST_UPPER) {
  479. layouts[1].xUndef = !def;
  480. layouts[1].x = x;
  481. }
  482. if (layout == LayoutType.LEFTMOST_LOWER) {
  483. layouts[2].xUndef = !def;
  484. layouts[2].x = x;
  485. }
  486. if (layout == LayoutType.RIGHTMOST_LOWER) {
  487. layouts[3].xUndef = !def;
  488. layouts[3].x = x;
  489. }
  490. if (layout == LayoutType.COMBINED)
  491. combined.x = x;
  492. }
  493. @Override
  494. public void setY(double y, LayoutType layout) {
  495. if (layout == null) {
  496. layouts[0].y = y;
  497. layouts[1].y = y;
  498. layouts[2].y = y;
  499. layouts[3].y = y;
  500. combined.y = y;
  501. }
  502. if (layout == LayoutType.LEFTMOST_UPPER)
  503. layouts[0].y = y;
  504. if (layout == LayoutType.RIGHTMOST_UPPER)
  505. layouts[1].y = y;
  506. if (layout == LayoutType.LEFTMOST_LOWER)
  507. layouts[2].y = y;
  508. if (layout == LayoutType.RIGHTMOST_LOWER)
  509. layouts[3].y = y;
  510. if (layout == LayoutType.COMBINED)
  511. combined.y = y;
  512. }
  513. @Override
  514. public double getX(LayoutType layout) {
  515. if (layout == LayoutType.LEFTMOST_UPPER)
  516. return this.layouts[0].x;
  517. if (layout == LayoutType.RIGHTMOST_UPPER)
  518. return this.layouts[1].x;
  519. if (layout == LayoutType.LEFTMOST_LOWER)
  520. return this.layouts[2].x;
  521. if (layout == LayoutType.RIGHTMOST_LOWER)
  522. return this.layouts[3].x;
  523. if (layout == LayoutType.COMBINED)
  524. return combined.x;
  525. return 0;
  526. }
  527. @Override
  528. public double getY(LayoutType layout) {
  529. if (layout == LayoutType.LEFTMOST_UPPER)
  530. return this.layouts[0].y;
  531. if (layout == LayoutType.RIGHTMOST_UPPER)
  532. return this.layouts[1].y;
  533. if (layout == LayoutType.LEFTMOST_LOWER)
  534. return this.layouts[2].y;
  535. if (layout == LayoutType.RIGHTMOST_LOWER)
  536. return this.layouts[3].y;
  537. if (layout == LayoutType.COMBINED)
  538. return combined.y;
  539. return 0;
  540. }
  541. @Override
  542. public double getWidth(LayoutType layout) {
  543. if (nodes.size() > 0) {
  544. double max = 0;
  545. double min = Double.POSITIVE_INFINITY;
  546. for( LayeredGraphNode n : nodes )
  547. {
  548. if( max < n.getX(layout) + n.getWidth(layout) )
  549. max = n.getX(layout) + n.getWidth(layout);
  550. min = Math.min( n.getX(layout), min);
  551. }
  552. if (layout == LayoutType.LEFTMOST_UPPER)
  553. return Math.max(max - min, layouts[0].w);
  554. if (layout == LayoutType.RIGHTMOST_UPPER)
  555. return Math.max(max - min, layouts[1].w);
  556. if (layout == LayoutType.LEFTMOST_LOWER)
  557. return Math.max(max - min, layouts[2].w);
  558. if (layout == LayoutType.RIGHTMOST_LOWER)
  559. return Math.max(max - min, layouts[3].w);
  560. if (layout == LayoutType.COMBINED)
  561. return Math.max(max - min, combined.w);
  562. }
  563. if (layout == LayoutType.LEFTMOST_UPPER)
  564. return layouts[0].w;
  565. if (layout == LayoutType.RIGHTMOST_UPPER)
  566. return layouts[1].w;
  567. if (layout == LayoutType.LEFTMOST_LOWER)
  568. return layouts[2].w;
  569. if (layout == LayoutType.RIGHTMOST_LOWER)
  570. return layouts[3].w;
  571. if (layout == LayoutType.COMBINED)
  572. return combined.w;
  573. return 0;
  574. }
  575. @Override
  576. public double getHeight( LayoutType layout ) {
  577. if( nodes.size() > 0 )
  578. {
  579. double max = 0;
  580. for( LayeredGraphNode n : nodes )
  581. {
  582. if( max < n.getY(layout) + n.getHeight(layout) )
  583. max = n.getY(layout) + n.getHeight(layout);
  584. }
  585. if( layout == LayoutType.LEFTMOST_UPPER )
  586. return Math.max( max, layouts[ 0 ].h );
  587. if( layout == LayoutType.RIGHTMOST_UPPER )
  588. return Math.max( max, layouts[ 1 ].h );
  589. if( layout == LayoutType.LEFTMOST_LOWER )
  590. return Math.max( max, layouts[ 2 ].h );
  591. if( layout == LayoutType.RIGHTMOST_LOWER )
  592. return Math.max( max, layouts[ 3 ].h );
  593. if( layout == LayoutType.COMBINED )
  594. return Math.max( max, combined.h );
  595. }
  596. if (layout == LayoutType.LEFTMOST_UPPER)
  597. return layouts[0].h;
  598. if (layout == LayoutType.RIGHTMOST_UPPER)
  599. return layouts[1].h;
  600. if (layout == LayoutType.LEFTMOST_LOWER)
  601. return layouts[2].h;
  602. if (layout == LayoutType.RIGHTMOST_LOWER)
  603. return layouts[3].h;
  604. if (layout == LayoutType.COMBINED)
  605. return combined.h;
  606. return 0;
  607. }
  608. @Override
  609. public void setWidth(double w, LayoutType layout) {
  610. if (layout == null) {
  611. this.layouts[0].w = w;
  612. this.layouts[1].w = w;
  613. this.layouts[2].w = w;
  614. this.layouts[3].w = w;
  615. combined.w = w;
  616. }
  617. if (layout == LayoutType.LEFTMOST_UPPER)
  618. this.layouts[0].w = w;
  619. if (layout == LayoutType.RIGHTMOST_UPPER)
  620. this.layouts[1].w = w;
  621. if (layout == LayoutType.LEFTMOST_LOWER)
  622. this.layouts[2].w = w;
  623. if (layout == LayoutType.RIGHTMOST_LOWER)
  624. this.layouts[3].w = w;
  625. if (layout == LayoutType.COMBINED)
  626. combined.w = w;
  627. }
  628. @Override
  629. public void setHeight(double h, LayoutType layout) {
  630. if (layout == null) {
  631. this.layouts[0].h = h;
  632. this.layouts[1].h = h;
  633. this.layouts[2].h = h;
  634. this.layouts[3].h = h;
  635. combined.h = h;
  636. }
  637. if (layout == LayoutType.LEFTMOST_UPPER)
  638. this.layouts[0].h = h;
  639. if (layout == LayoutType.RIGHTMOST_UPPER)
  640. this.layouts[1].h = h;
  641. if (layout == LayoutType.LEFTMOST_LOWER)
  642. this.layouts[2].h = h;
  643. if (layout == LayoutType.RIGHTMOST_LOWER)
  644. this.layouts[3].h = h;
  645. if (layout == LayoutType.COMBINED)
  646. combined.h = h;
  647. }
  648. @Override
  649. public void removeEdge(LayeredGraphEdge e) {
  650. edges.remove(e);
  651. }
  652. @Override
  653. public void removeNode(LayeredGraphNode n) {
  654. for (LayeredGraphEdge e : n.getIncomingEdges())
  655. e.remove();
  656. for (LayeredGraphEdge e : n.getOutgoingEdges())
  657. e.remove();
  658. nodes.remove(n);
  659. for (ArrayList<LayeredGraphNode> l : layers) {
  660. l.remove(n);
  661. }
  662. }
  663. @Override
  664. public void setNodeLayer(LayeredGraphNode n, int index) {
  665. while (index >= layers.size())
  666. layers.add(new ArrayList<>());
  667. int old = n.getLayer();
  668. if (old >= 0)
  669. layers.get(old).remove(n);
  670. layers.get(index).add(n);
  671. }
  672. @Override
  673. public void setOrderedLayer(ArrayList<Double> indizes, int layerIndex) {
  674. ArrayList<LayeredGraphNode> l2 = layers.get(layerIndex);
  675. ArrayList<LayeredGraphNode> result = new ArrayList<LayeredGraphNode>();
  676. while (indizes.size() > 0) {
  677. int mIndex = 0;
  678. double min = indizes.get(0);
  679. for (int i = 1; i < indizes.size(); i++) {
  680. if (min > indizes.get(i)) {
  681. mIndex = i;
  682. min = indizes.get(i);
  683. }
  684. }
  685. result.add(l2.get(mIndex));
  686. l2.remove(mIndex);
  687. indizes.remove(mIndex);
  688. }
  689. layers.set(layerIndex, result);
  690. }
  691. @Override
  692. public ArrayList<LayeredGraphEdge> getOutgoingEdges() {
  693. return parent.getOutgoingEdges(this);
  694. }
  695. @Override
  696. public ArrayList<LayeredGraphEdge> getSortedOutgoingEdges() {
  697. return parent.getSortedOutgoingEdges(this);
  698. }
  699. @Override
  700. public ArrayList<LayeredGraphEdge> getIncomingEdges() {
  701. return parent.getIncomingEdges(this);
  702. }
  703. @Override
  704. public ArrayList<LayeredGraphEdge> getSortedIncomingEdges() {
  705. return parent.getSortedIncomingEdges(this);
  706. }
  707. @Override
  708. public ArrayList<LayeredGraphEdge> getContainedEdges() {
  709. return edges;
  710. }
  711. @Override
  712. public ArrayList<LayeredGraphNode> getContainedNodes() {
  713. return nodes;
  714. }
  715. @Override
  716. public ArrayList<LayeredGraphNode> getSortedContainedNodes() {
  717. ArrayList<LayeredGraphNode> result = new ArrayList<>();
  718. for (ArrayList<LayeredGraphNode> l : layers) {
  719. result.addAll(l);
  720. }
  721. return result;
  722. }
  723. @Override
  724. public ArrayList<ArrayList<LayeredGraphNode>> getContainedLayers() {
  725. return layers;
  726. }
  727. @Override
  728. public int getNodeLayer(LayeredGraphNode n) {
  729. for (int i = 0; i < layers.size(); i++) {
  730. if (layers.get(i).contains(n))
  731. return i;
  732. }
  733. return -1;
  734. }
  735. @Override
  736. public ArrayList<LayeredGraphEdge> getOutgoingEdges(LayeredGraphNode n) {
  737. ArrayList<LayeredGraphEdge> result = new ArrayList<>();
  738. for( LayeredGraphEdge e : edges )
  739. {
  740. if( e.getSources().contains( n ) && !result.contains( e ) )
  741. result.add( e );
  742. }
  743. return result;
  744. }
  745. @Override
  746. public ArrayList<LayeredGraphEdge> getIncomingEdges(LayeredGraphNode n) {
  747. ArrayList<LayeredGraphEdge> result = new ArrayList<>();
  748. for( LayeredGraphEdge e : edges )
  749. {
  750. if( e.getTargets().contains( n ) && !result.contains( e ) )
  751. result.add( e );
  752. }
  753. return result;
  754. }
  755. @Override
  756. public ArrayList<LayeredGraphEdge> getSortedOutgoingEdges(LayeredGraphNode n) {
  757. ArrayList<LayeredGraphEdge> result = new ArrayList<>();
  758. if( n.getLayer() + 1 >= layers.size() )
  759. return result;
  760. ArrayList< LayeredGraphEdge > unsorted = getOutgoingEdges( n );
  761. for( LayeredGraphNode node : layers.get( n.getLayer() + 1 ) )
  762. {
  763. for( LayeredGraphEdge e : unsorted )
  764. {
  765. if( e.getTargets().contains( node ) && !result.contains( e ) )
  766. result.add( e );
  767. }
  768. }
  769. return result;
  770. }
  771. @Override
  772. public ArrayList<LayeredGraphEdge> getSortedIncomingEdges(LayeredGraphNode n) {
  773. ArrayList<LayeredGraphEdge> result = new ArrayList<>();
  774. if( n.getLayer() - 1 < 0 )
  775. return result;
  776. ArrayList< LayeredGraphEdge > unsorted = getIncomingEdges( n );
  777. for( LayeredGraphNode node : layers.get( n.getLayer() - 1 ) )
  778. {
  779. for( LayeredGraphEdge e : unsorted )
  780. {
  781. if( e.getSources().contains( node ) && !result.contains( e ) )
  782. result.add( e );
  783. }
  784. }
  785. return result;
  786. }
  787. @Override
  788. public LayeredGraphEdge findEdgeBetween( LayeredGraphNode source, LayeredGraphNode target )
  789. {
  790. for( LayeredGraphEdge e : edges )
  791. {
  792. if( e.getSources().contains( source ) && e.getTargets().contains( target ) )
  793. return e;
  794. }
  795. return null;
  796. }
  797. @Override
  798. public LayeredGraphNode createNode(ElkNode original) {
  799. LayeredGraphNode n = new LayeredNode(original, this);
  800. nodes.add(n);
  801. return n;
  802. }
  803. @Override
  804. public LayeredGraphEdge createEdge(ElkEdge original, ArrayList<LayeredGraphNode> sources,
  805. ArrayList<LayeredGraphNode> targets) {
  806. LayeredGraphEdge e = new LayeredEdge(original, sources, targets, this);
  807. edges.add(e);
  808. return e;
  809. }
  810. @Override
  811. public LayeredGraphEdge createSimpleEdge(ElkEdge original, LayeredGraphNode source, LayeredGraphNode target) {
  812. ArrayList<LayeredGraphNode> sources = new ArrayList<>();
  813. ArrayList<LayeredGraphNode> targets = new ArrayList<>();
  814. sources.add(source);
  815. targets.add(target);
  816. LayeredGraphEdge e = new LayeredEdge(original, sources, targets, this);
  817. edges.add(e);
  818. return e;
  819. }
  820. @Override
  821. public LayeredGraphEdge findEdgeFromOriginal(Object original) {
  822. for (LayeredGraphEdge e : edges) {
  823. if (e.getOriginalEdge() == original)
  824. return e;
  825. }
  826. return null;
  827. }
  828. @Override
  829. public LayeredGraphNode findNodeFromOriginal(Object original) {
  830. for (LayeredGraphNode n : nodes) {
  831. if (n.getOriginalNode() == original)
  832. return n;
  833. }
  834. return null;
  835. }
  836. @Override
  837. public LayeredGraphNode findNodeByName(String name) {
  838. for (LayeredGraphNode n : nodes) {
  839. if (name != null && n.toString().equals(name))
  840. return n;
  841. }
  842. return null;
  843. }
  844. @Override
  845. public void addNode(LayeredGraphNode n) {
  846. nodes.add(n);
  847. n.setParent(this);
  848. }
  849. @Override
  850. public void addEdge(LayeredGraphEdge e) {
  851. edges.add(e);
  852. e.setGraph(this);
  853. }
  854. @Override
  855. public void setParent(LayeredGraphNode parent) {
  856. this.parent = parent;
  857. }
  858. @Override
  859. public String toString() {
  860. if( name != null )
  861. return name;
  862. return "unnamed node";
  863. }
  864. }