1
28 package demo.layout.multipage;
29
30 import y.base.DataProvider;
31 import y.base.Edge;
32 import y.base.Graph;
33 import y.base.GraphFactory;
34 import y.base.Node;
35 import y.base.NodeMap;
36 import y.geom.YDimension;
37 import y.geom.YPoint;
38 import y.geom.YPointCursor;
39 import y.layout.EdgeLabelLayout;
40 import y.layout.LayoutGraph;
41 import y.layout.NodeLabelLayout;
42 import y.layout.multipage.EdgeInfo;
43 import y.layout.multipage.EdgeLabelInfo;
44 import y.layout.multipage.ElementInfoManager;
45 import y.layout.multipage.MultiPageLayout;
46 import y.layout.multipage.NodeInfo;
47 import y.layout.multipage.NodeLabelInfo;
48 import y.util.GraphCopier;
49 import y.util.Maps;
50 import y.view.EdgeLabel;
51 import y.view.EdgeRealizer;
52 import y.view.Graph2D;
53 import y.view.NodeLabel;
54 import y.view.NodeRealizer;
55 import y.view.ShapeNodeRealizer;
56 import y.view.hierarchy.DefaultHierarchyGraphFactory;
57 import y.view.hierarchy.HierarchyManager;
58
59 import java.awt.Color;
60 import java.util.Map;
61
62
67 public class MultiPageGraph2DBuilder {
68
73 private static final Object REFERENCING_NODE_ID_DPKEY =
74 "demo.layout.multipage.MultiPageGraph2DBuilder.REFERENCING_NODE_ID_DPKEY";
75
76 private static final Object NODE_INFO_DPKEY =
77 "demo.layout.multipage.MultiPageGraph2DBuilder.NODE_INFO_DPKEY";
78
79
80 private Graph2D model;
81 private MultiPageLayout layout;
82 private GraphCopier.CopyFactory copyFactory;
83
84
90 public MultiPageGraph2DBuilder(Graph2D model, MultiPageLayout layout) {
91 this.model = model;
92 this.layout = layout;
93 }
94
95 public void reset(Graph2D model, MultiPageLayout layout) {
96 this.model = model;
97 this.layout = layout;
98 this.copyFactory = null;
99 }
100
101
106 private GraphCopier.CopyFactory getCopyFactory() {
107 return copyFactory;
108 }
109
110
116 public MultiPageLayout getLayout() {
117 return layout;
118 }
119
120
125 public Graph2D getModel() {
126 return model;
127 }
128
129
137 public Object getNodeId( final Node node ) {
138 final Graph graph = node.getGraph();
139 if (graph != null) {
140 final DataProvider dp = graph.getDataProvider(NODE_INFO_DPKEY);
141 if (dp != null) {
142 final NodeInfo info = (NodeInfo) dp.get(node);
143 if (info != null) {
144 return info.getId();
145 }
146 }
147 }
148 return null;
149 }
150
151 public byte getNodeType( final Node node ) {
152 final Graph graph = node.getGraph();
153 if (graph != null) {
154 final DataProvider dp = graph.getDataProvider(NODE_INFO_DPKEY);
155 if (dp != null) {
156 final NodeInfo info = (NodeInfo) dp.get(node);
157 if (info != null) {
158 return info.getType();
159 }
160 }
161 }
162 return -1;
163 }
164
165 public int getPageNo( final Node node ) {
166 final Graph graph = node.getGraph();
167 if (graph != null) {
168 final DataProvider dp = graph.getDataProvider(NODE_INFO_DPKEY);
169 if (dp != null) {
170 final NodeInfo info = (NodeInfo) dp.get(node);
171 if (info != null) {
172 return info.getPageNo();
173 }
174 }
175 }
176 return -1;
177 }
178
179 public int getReferencedPageNo( final Node node ) {
180 final Graph graph = node.getGraph();
181 if (graph != null) {
182 final DataProvider dp = graph.getDataProvider(NODE_INFO_DPKEY);
183 if (dp != null) {
184 final NodeInfo info = (NodeInfo) dp.get(node);
185 if (info != null) {
186 final Node mpRef = info.getReferencingNode();
187 if (mpRef != null) {
188 final NodeInfo mpRefInfo = layout.getNodeInfo(mpRef);
189 return mpRefInfo.getPageNo();
190 }
191 }
192 }
193 }
194 return -1;
195 }
196
197 public Object getReferencingNodeId( final Node node ) {
198 final Graph graph = node.getGraph();
199 if (graph != null) {
200 final DataProvider dp = graph.getDataProvider(REFERENCING_NODE_ID_DPKEY);
201 if (dp != null) {
202 return dp.get(node);
203 }
204 }
205 return null;
206 }
207
208
215 public Graph2D createPageView( final Graph2D page, final int pageNo ) {
216 copyFactory = page.getGraphCopyFactory();
217 final GraphCopier graphCopier = new GraphCopier(new MyGraphCopyFactory());
218 graphCopier.copy(getLayout().getPage(pageNo), page);
219 return page;
220 }
221
222
233 protected Node createConnectorNode( final Node sourceNode, final Graph2D targetGraph ) {
234 final NodeInfo info = getLayout().getNodeInfo(sourceNode);
235 final Node connector = getCopyFactory().copyNode(targetGraph, sourceNode);
236 final YPoint center = targetGraph.getCenter(connector);
237 final YDimension size = targetGraph.getSize(connector);
238
239 targetGraph.setRealizer(connector, new ShapeNodeRealizer(ShapeNodeRealizer.ROUND_RECT));
240 targetGraph.getRealizer(connector).setFillColor(Color.YELLOW);
241 final Object referencingNodeID = getLayout().getNodeInfo(info.getReferencingNode()).getId();
242 ((NodeMap) targetGraph.getDataProvider(REFERENCING_NODE_ID_DPKEY)).set(connector, referencingNodeID);
243 addLabels(sourceNode, targetGraph.getRealizer(connector), getLayout());
244 targetGraph.setSize(connector, size);
245 targetGraph.setCenter(connector, center);
246
247 return connector;
248 }
249
250
264 protected Node createProxyReferenceNode( final Node sourceNode, final Graph2D targetGraph ) {
265 final NodeInfo info = getLayout().getNodeInfo(sourceNode);
266 final Node pageNode = getCopyFactory().copyNode(targetGraph, sourceNode);
267 final YPoint center = targetGraph.getCenter(pageNode);
268 final YDimension size = targetGraph.getSize(pageNode);
269
270 final NodeInfo referencingNodeInfo = getLayout().getNodeInfo(
271 info.getReferencingNode());
272 targetGraph.setRealizer(pageNode, new ShapeNodeRealizer(ShapeNodeRealizer.ELLIPSE));
273 targetGraph.getRealizer(pageNode).setFillColor(Color.GREEN);
274 targetGraph.setLabelText(pageNode, "p " + (referencingNodeInfo.getPageNo() + 1));
275 final Object referencingNodeID = getLayout().getNodeInfo(info.getReferencingNode()).getId();
276 ((NodeMap) targetGraph.getDataProvider(REFERENCING_NODE_ID_DPKEY)).set(pageNode, referencingNodeID);
277 targetGraph.setSize(pageNode, size);
278 targetGraph.setCenter(pageNode, center);
279
280 return pageNode;
281 }
282
283
296 protected Node createProxyNode( final Node sourceNode, final Graph2D targetGraph ) {
297 final NodeInfo info = getLayout().getNodeInfo(sourceNode);
298 final Node proxy = getCopyFactory().copyNode(targetGraph, sourceNode);
299 final YPoint center = targetGraph.getCenter(proxy);
300 final YDimension size = targetGraph.getSize(proxy);
301
302 targetGraph.setRealizer(proxy, new ShapeNodeRealizer(ShapeNodeRealizer.ROUND_RECT));
303 targetGraph.getRealizer(proxy).setFillColor(Color.LIGHT_GRAY);
304 final Object referencingNodeID = getLayout().getNodeInfo(info.getReferencingNode()).getId();
305 ((NodeMap) targetGraph.getDataProvider(REFERENCING_NODE_ID_DPKEY)).set(proxy, referencingNodeID);
306 addLabels(sourceNode, targetGraph.getRealizer(proxy), getLayout());
307 targetGraph.setSize(proxy, size);
308 targetGraph.setCenter(proxy, center);
309
310 return proxy;
311 }
312
313
323 protected Node createGroupNode(final Node sourceNode, final Graph2D targetGraph) {
324 final NodeInfo info = getLayout().getNodeInfo(sourceNode);
325 final Node groupNode = getCopyFactory().copyNode(targetGraph, sourceNode);
326 final YPoint center = targetGraph.getCenter(groupNode);
327 final YDimension size = targetGraph.getSize(groupNode);
328
329 final NodeInfo representingNodeInfo = getLayout().getNodeInfo(info.getRepresentedNode());
330 targetGraph.setRealizer(groupNode, getRealizer((Node) representingNodeInfo.getId()));
331 targetGraph.setSize(groupNode, size);
332 targetGraph.setCenter(groupNode, center);
333
334 return groupNode;
335 }
336
337
348 protected Node createNormalNode(final Node sourceNode, final Graph2D targetGraph) {
349 final NodeInfo info = getLayout().getNodeInfo(sourceNode);
350 final Node node = getCopyFactory().copyNode(targetGraph, sourceNode);
351 final YPoint center = targetGraph.getCenter(node);
352 final YDimension size = targetGraph.getSize(node);
353
354 final NodeInfo representingNodeInfo = getLayout().getNodeInfo(info.getRepresentedNode());
355 targetGraph.setRealizer(node, getRealizer((Node) representingNodeInfo.getId()));
356 addLabels(sourceNode, targetGraph.getRealizer(node), getLayout());
357 targetGraph.setSize(node, size);
358 targetGraph.setCenter(node, center);
359
360 return node;
361 }
362
363
376 protected Edge createNormalEdge(final Edge sourceEdge, final Node newSource, final Node newTarget,
377 final Graph2D targetGraph) {
378 final EdgeInfo edgeInfo = getLayout().getEdgeInfo(sourceEdge);
379 final Edge newEdge = getCopyFactory().copyEdge(targetGraph, newSource, newTarget, sourceEdge);
380
381 final EdgeRealizer realizer = createCopyOfRealizer((Edge) edgeInfo.getId());
382 if (realizer != null) {
383 addLabels(sourceEdge, realizer, getLayout());
384 applyRealizer(newEdge, targetGraph, realizer);
385 }
386
387 return newEdge;
388 }
389
390
404 protected Edge createProxyReferenceEdge( final Edge sourceEdge, final Node newSource, final Node newTarget,
405 final Graph2D targetGraph ) {
406 final EdgeInfo edgeInfo = getLayout().getEdgeInfo(sourceEdge);
407 final Edge newEdge = getCopyFactory().copyEdge(targetGraph, newSource, newTarget, sourceEdge);
408
409 final EdgeRealizer realizer = createCopyOfRealizer((Edge) edgeInfo.getId());
410 if (realizer != null) {
411 addLabels(sourceEdge, realizer, getLayout());
412 applyRealizer(newEdge, targetGraph, realizer);
413 }
414
415 return newEdge;
416 }
417
418
431 protected Edge createConnectorEdge(final Edge sourceEdge, final Node newSource, final Node newTarget,
432 final Graph2D targetGraph) {
433 final EdgeInfo edgeInfo = getLayout().getEdgeInfo(sourceEdge);
434 final Edge newEdge = getCopyFactory().copyEdge(targetGraph, newSource, newTarget, sourceEdge);
435
436 final Object representingEdgeId = getLayout().getEdgeInfo(edgeInfo.getRepresentedEdge()).getId();
437 final Edge origEdge = (Edge) representingEdgeId;
438 final EdgeRealizer origRealizerCopy = createCopyOfRealizer(origEdge);
439 addLabels(sourceEdge, origRealizerCopy, getLayout());
440 applyRealizer(newEdge, targetGraph, origRealizerCopy);
441 return newEdge;
442 }
443
444
457 protected Edge createProxyEdge( final Edge sourceEdge, final Node newSource, final Node newTarget,
458 final Graph2D targetGraph ) {
459 final EdgeInfo edgeInfo = getLayout().getEdgeInfo(sourceEdge);
460 final Edge newEdge = getCopyFactory().copyEdge(targetGraph, newSource, newTarget, sourceEdge);
461
462 final EdgeRealizer realizer = createCopyOfRealizer((Edge) edgeInfo.getId());
463 if (realizer != null) {
464 addLabels(sourceEdge, realizer, getLayout());
465 applyRealizer(newEdge, targetGraph, realizer);
466 }
467
468 return newEdge;
469 }
470
471 private static NodeRealizer getRealizer(final Node origNode) {
472 final Graph2D graph = (Graph2D) origNode.getGraph();
473 final NodeRealizer realizer = graph.getRealizer(origNode);
474 return realizer.createCopy();
475 }
476
477 private static void addLabels(final Node source, final NodeRealizer targetRealizer, final ElementInfoManager infoManager) {
478 for (int i = targetRealizer.labelCount(); i --> 0;) {
480 targetRealizer.removeLabel(i);
481 }
482
483 final LayoutGraph sourceGraph = (LayoutGraph) source.getGraph();
485 final NodeLabelLayout[] nll = sourceGraph.getNodeLabelLayout(source);
486 for (int i = 0; i < nll.length; i++) {
487 final NodeLabelInfo labelInfo = infoManager.getNodeLabelInfo(nll[i]);
488 final NodeLabel origLabel = (NodeLabel) labelInfo.getId();
489 final NodeLabel newLabel = (NodeLabel) origLabel.clone();
490 newLabel.setModelParameter(nll[i].getModelParameter());
491 targetRealizer.setLabel(newLabel);
492 }
493 }
494
495 private static void applyRealizer(final Edge e, final Graph2D g, final EdgeRealizer realizer) {
496 if (realizer == null) {
497 return;
498 }
499
500 realizer.clearPoints();
501 for (YPointCursor cur = g.getPoints(e).points(); cur.ok(); cur.next()) {
502 final YPoint p = cur.point();
503 realizer.addPoint(p.x, p.y);
504 }
505 realizer.setSourcePoint(g.getSourcePointRel(e));
506 realizer.setTargetPoint(g.getTargetPointRel(e));
507 g.setRealizer(e, realizer);
508 }
509
510 private static EdgeRealizer createCopyOfRealizer(Edge e) {
511 if (e.getGraph() != null && e.getGraph() instanceof Graph2D) {
512 final Graph2D origGraph = (Graph2D) e.getGraph();
513 final EdgeRealizer realizer = origGraph.getRealizer(e);
514 return realizer.createCopy();
515 } else {
516 return null;
517 }
518 }
519
520 private static void addLabels(final Edge source, final EdgeRealizer targetRealizer, final ElementInfoManager infoManager) {
521 while (targetRealizer.labelCount() > 0) {
523 targetRealizer.removeLabel(targetRealizer.getLabel());
524 }
525
526 final LayoutGraph sourceGraph = (LayoutGraph) source.getGraph();
528 final EdgeLabelLayout[] ell = sourceGraph.getEdgeLabelLayout(source);
529 for (int i = 0; i < ell.length; i++) {
530 final EdgeLabelInfo labelInfo = infoManager.getEdgeLabelInfo(ell[i]);
531 final EdgeLabel origLabel = (EdgeLabel) labelInfo.getId();
532 final EdgeLabel newLabel = (EdgeLabel) origLabel.clone();
533 newLabel.setModelParameter(ell[i].getModelParameter());
534 targetRealizer.addLabel(newLabel);
535 }
536 }
537
538 private class MyGraphCopyFactory implements GraphCopier.CopyFactory {
539 public Node copyNode(Graph targetGraph, Node originalNode) {
540 final NodeInfo info = getLayout().getNodeInfo(originalNode);
541 final Graph2D targetGraph2D = (Graph2D) targetGraph;
542
543 Node graph2DNode;
544 if (info.getType() == NodeInfo.TYPE_NORMAL) {
545 graph2DNode = createNormalNode(originalNode, targetGraph2D);
546 } else if (info.getType() == NodeInfo.TYPE_GROUP) {
547 graph2DNode = createGroupNode(originalNode, targetGraph2D);
548 } else if (info.getType() == NodeInfo.TYPE_CONNECTOR) {
549 graph2DNode = createConnectorNode(originalNode, targetGraph2D);
550 } else if (info.getType() == NodeInfo.TYPE_PROXY) {
551 graph2DNode = createProxyNode(originalNode, targetGraph2D);
552 } else {
553 graph2DNode = createProxyReferenceNode(originalNode, targetGraph2D);
554 }
555 ((NodeMap) targetGraph.getDataProvider(NODE_INFO_DPKEY)).set(graph2DNode, info);
556
557 return graph2DNode;
558 }
559
560 public Edge copyEdge(Graph targetGraph, Node newSource, Node newTarget, Edge sourceEdge) {
561 final EdgeInfo edgeInfo = getLayout().getEdgeInfo(sourceEdge);
562 final Graph2D targetGraph2D = (Graph2D) targetGraph;
563
564 Edge newEdge;
565 if (edgeInfo.getType() == EdgeInfo.TYPE_CONNECTOR) {
566 newEdge = createConnectorEdge(sourceEdge, newSource, newTarget, targetGraph2D);
567 } else if (edgeInfo.getType() == EdgeInfo.TYPE_PROXY_REFERENCE) {
568 newEdge = createProxyReferenceEdge(sourceEdge, newSource, newTarget, targetGraph2D);
569 } else if (edgeInfo.getType() == EdgeInfo.TYPE_PROXY) {
570 newEdge = createProxyEdge(sourceEdge, newSource, newTarget, targetGraph2D);
571 } else {
572 newEdge = createNormalEdge(sourceEdge, newSource, newTarget, targetGraph2D);
573 }
574
575 return newEdge;
576 }
577
578 public Graph createGraph() {
579 final Graph2D graph = (Graph2D) getCopyFactory().createGraph();
580 if (graph.getHierarchyManager() == null) {
581 final HierarchyManager hm = new HierarchyManager(graph);
582 final GraphFactory baseFactory = getModel().getHierarchyManager().getGraphFactory();
583 if (baseFactory instanceof DefaultHierarchyGraphFactory) {
584 hm.setGraphFactory(baseFactory);
585 }
586 }
587
588 return graph;
589 }
590
591 public void preCopyGraphData(Graph sourceGraph, Graph targetGraph) {
592 targetGraph.addDataProvider(NODE_INFO_DPKEY, Maps.createHashedNodeMap());
593 targetGraph.addDataProvider(REFERENCING_NODE_ID_DPKEY, Maps.createHashedNodeMap());
594 getCopyFactory().preCopyGraphData(sourceGraph, targetGraph);
595 }
596
597 public void postCopyGraphData(Graph sourceGraph, Graph targetGraph, Map nodeMap, Map edgeMap) {
598 getCopyFactory().postCopyGraphData(sourceGraph, targetGraph, nodeMap, edgeMap);
599 }
600 }
601 }
602