AJ Kelly
584 lines
18 KiB
Plaintext
584 lines
18 KiB
Plaintext
#
|
|
# dotty_edit: editing functions and data structures
|
|
#
|
|
dotty.protogt.getnodesbyattr = function (gt, key, val) {
|
|
local nid, node, nlist;
|
|
|
|
nlist = [];
|
|
for (nid in gt.graph.nodes) {
|
|
node = gt.graph.nodes[nid];
|
|
if (node.attr[key] == val)
|
|
nlist[nid] = node;
|
|
}
|
|
return nlist;
|
|
};
|
|
dotty.protogt.reachablenodes = function (gt, node) {
|
|
local nlist, stack, eid, edge, i;
|
|
|
|
stack[0] = node;
|
|
i = 1;
|
|
while (i > 0) {
|
|
node = stack[i - 1];
|
|
i = i - 1;
|
|
nlist[node.nid] = node;
|
|
for (eid in node.edges) {
|
|
edge = node.edges[eid];
|
|
if (~nlist[edge.head.nid]) {
|
|
nlist[edge.head.nid] = edge.head;
|
|
stack[i] = edge.head;
|
|
i = i + 1;
|
|
}
|
|
}
|
|
}
|
|
return nlist;
|
|
};
|
|
dotty.protogt.mergegraph = function (gt, graph, show) {
|
|
local nameid, onode, pos, size, eid, eid2, tnode, hnode, oedge;
|
|
|
|
if (~gt.noundo)
|
|
gt.startadd2undo (gt);
|
|
for (nameid in graph.nodedict) {
|
|
pos = null;
|
|
size = null;
|
|
onode = graph.nodes[graph.nodedict[nameid]];
|
|
if (onode.pos)
|
|
pos = node.pos;
|
|
if (onode.size)
|
|
size = node.size;
|
|
if (~(gt.graph.nodedict[nameid] >= 0)) {
|
|
pos = null;
|
|
size = null;
|
|
if (onode.pos)
|
|
pos = node.pos;
|
|
if (onode.size)
|
|
size = node.size;
|
|
gt.insertnode (gt, pos, size, nameid, onode.attr, show);
|
|
}
|
|
}
|
|
for (eid in graph.edges) {
|
|
oedge = graph.edges[eid];
|
|
tnode = gt.graph.nodes[gt.graph.nodedict[oedge.tail.name]];
|
|
hnode = gt.graph.nodes[gt.graph.nodedict[oedge.head.name]];
|
|
for (eid2 in tnode.edges)
|
|
if (tnode.edges[eid2].tail == tnode &
|
|
tnode.edges[eid2].head == hnode) {
|
|
oedge = null;
|
|
break;
|
|
}
|
|
if (oedge)
|
|
gt.insertedge (gt, tnode, null, hnode, null, oedge.attr, show);
|
|
}
|
|
if (~gt.noundo)
|
|
gt.endadd2undo (gt);
|
|
};
|
|
dotty.protogt.insertsgraph = function (gt, name, attr, show) {
|
|
local gid, sgraph, aid;
|
|
|
|
if (~gt)
|
|
return null;
|
|
gid = gt.graph.maxgid;
|
|
if (~name) {
|
|
while (gt.graph.graphdict[(name = concat ('g', gid))] >= 0)
|
|
gid = gid + 1;
|
|
} else if (gt.graph.graphdict[name]) {
|
|
dotty.message (0, concat ('graph: ', name, ' exists'));
|
|
return null;
|
|
}
|
|
gt.graph.graphdict[name] = gid;
|
|
gt.graph.maxgid = gid + 1;
|
|
gt.graph.graphs[gid] = [
|
|
dotty.keys.gid = gid;
|
|
dotty.keys.name = name;
|
|
dotty.keys.gattr = copy (gt.graph.graphattr);
|
|
dotty.keys.nattr = copy (gt.graph.nodeattr);
|
|
dotty.keys.eattr = copy (gt.graph.edgeattr);
|
|
];
|
|
sgraph = gt.graph.graphs[gid];
|
|
if (~attr)
|
|
attr = [];
|
|
if (~attr.label)
|
|
attr.label = '\N';
|
|
for (aid in attr)
|
|
sgraph.graphattr[aid] = attr[aid];
|
|
gt.unpacksgraphattr (gt, sgraph);
|
|
if (show)
|
|
gt.drawsgraph (gt, gt.views, sgraph);
|
|
return sgraph;
|
|
};
|
|
dotty.protogt.removesgraph = function (gt, sgraph) {
|
|
gt.undrawsgraph (gt, gt.views, sgraph);
|
|
remove (sgraph.name, gt.graph.graphdict);
|
|
remove (sgraph.gid, gt.graph.graphs);
|
|
};
|
|
dotty.protogt.insertnode = function (gt, pos, size, name, attr, show) {
|
|
local nid, node, aid;
|
|
|
|
nid = gt.graph.maxnid;
|
|
if (~name) {
|
|
while (gt.graph.nodedict[(name = concat ('n', nid))] >= 0)
|
|
nid = nid + 1;
|
|
} else if (gt.graph.nodedict[name] >= 0) {
|
|
dotty.message (0, concat ('node: ', name, ' exists'));
|
|
return null;
|
|
}
|
|
gt.graph.nodedict[name] = nid;
|
|
gt.graph.maxnid = nid + 1;
|
|
gt.graph.nodes[nid] = [
|
|
dotty.keys.nid = nid;
|
|
dotty.keys.name = name;
|
|
dotty.keys.attr = copy (gt.graph.nodeattr);
|
|
dotty.keys.edges = [];
|
|
];
|
|
node = gt.graph.nodes[nid];
|
|
if (~attr)
|
|
attr = [];
|
|
if (~attr.label)
|
|
attr.label = '\N';
|
|
for (aid in attr)
|
|
node.attr[aid] = attr[aid];
|
|
gt.unpacknodeattr (gt, node);
|
|
if (~pos)
|
|
pos = ['x' = 10; 'y' = 10;];
|
|
node[dotty.keys.pos] = copy (pos);
|
|
if (~size)
|
|
size = ['x' = strlen (attr.label) * 30; 'y' = 30;];
|
|
if (size.x == 0)
|
|
size.x = 30;
|
|
node[dotty.keys.size] = copy (size);
|
|
if (show)
|
|
gt.drawnode (gt, gt.views, node);
|
|
if (~gt.noundo) {
|
|
gt.startadd2undo (gt);
|
|
gt.currundo.inserted.nodes[nid] = node;
|
|
gt.endadd2undo (gt);
|
|
}
|
|
return node;
|
|
};
|
|
dotty.protogt.removenode = function (gt, node) {
|
|
local eid, list, edge, gid;
|
|
|
|
if (~gt.noundo)
|
|
gt.startadd2undo (gt);
|
|
for (eid in node.edges)
|
|
list[eid] = node.edges[eid];
|
|
for (eid in list)
|
|
gt.removeedge (gt, list[eid]);
|
|
gt.undrawnode (gt, gt.views, node);
|
|
for (gid in gt.graph.graphs)
|
|
remove (node.nid, gt.graph.graphs[gid].nodes);
|
|
remove (node.name, gt.graph.nodedict);
|
|
remove (node.nid, gt.graph.nodes);
|
|
if (~gt.noundo) {
|
|
gt.currundo.deleted.nodes[node.nid] = node;
|
|
gt.endadd2undo (gt);
|
|
}
|
|
};
|
|
dotty.protogt.insertedge =
|
|
function (gt, nodea, porta, nodeb, portb, attr, show) {
|
|
local eid, edge, aid, tport, hport;
|
|
|
|
if (~nodea | ~nodeb)
|
|
return null;
|
|
if (porta)
|
|
tport = porta;
|
|
if (portb)
|
|
hport = portb;
|
|
eid = gt.graph.maxeid;
|
|
while (gt.graph.edges[eid])
|
|
eid = eid + 1;
|
|
gt.graph.maxeid = eid + 1;
|
|
gt.graph.edges[eid] = [
|
|
dotty.keys.eid = eid;
|
|
dotty.keys.tail = nodea;
|
|
dotty.keys.tport = porta;
|
|
dotty.keys.head = nodeb;
|
|
dotty.keys.hport = portb;
|
|
dotty.keys.attr = copy (gt.graph.edgeattr);
|
|
];
|
|
edge = gt.graph.edges[eid];
|
|
if (~attr)
|
|
attr = [];
|
|
for (aid in attr)
|
|
edge.attr[aid] = attr[aid];
|
|
nodea.edges[eid] = edge;
|
|
nodeb.edges[eid] = edge;
|
|
edge[dotty.keys.points] = [
|
|
0 = copy (nodea.pos);
|
|
1 = copy (nodea.pos);
|
|
2 = copy (nodeb.pos);
|
|
3 = copy (nodeb.pos);
|
|
];
|
|
gt.unpackedgeattr (gt, edge);
|
|
if (show)
|
|
gt.drawedge (gt, gt.views, edge);
|
|
if (~gt.noundo) {
|
|
gt.startadd2undo (gt);
|
|
gt.currundo.inserted.edges[eid] = edge;
|
|
gt.endadd2undo (gt);
|
|
}
|
|
return edge;
|
|
};
|
|
dotty.protogt.removeedge = function (gt, edge) {
|
|
local head, tail;
|
|
|
|
if (~gt.noundo)
|
|
gt.startadd2undo (gt);
|
|
if (edge.head.attr.support == 1)
|
|
head = edge.head;
|
|
if (edge.tail.attr.support == 1)
|
|
if (head ~= edge.tail)
|
|
tail = edge.tail;
|
|
gt.undrawedge (gt, gt.views, edge);
|
|
remove (edge.eid, edge.head.edges);
|
|
remove (edge.eid, edge.tail.edges);
|
|
remove (edge.eid, gt.graph.edges);
|
|
if (head & tablesize (head.edges) == 0)
|
|
gt.removenode (gt, head);
|
|
if (tail & tablesize (tail.edges) == 0)
|
|
gt.removenode (gt, tail);
|
|
if (~gt.noundo) {
|
|
gt.currundo.deleted.edges[edge.eid] = edge;
|
|
gt.endadd2undo (gt);
|
|
}
|
|
};
|
|
dotty.protogt.swapedgeids = function (gt, edge1, edge2) {
|
|
local eid1, eid2;
|
|
|
|
if (edge1.eid == edge2.eid)
|
|
return;
|
|
if (~gt.noundo)
|
|
gt.startadd2undo (gt);
|
|
eid1 = edge1.eid;
|
|
eid2 = edge2.eid;
|
|
gt.graph.edges[eid1] = edge2;
|
|
gt.graph.edges[eid2] = edge1;
|
|
remove (eid1, edge1.tail.edges);
|
|
remove (eid1, edge1.head.edges);
|
|
remove (eid2, edge2.tail.edges);
|
|
remove (eid2, edge2.head.edges);
|
|
edge1.tail.edges[eid2] = edge1;
|
|
edge1.head.edges[eid2] = edge1;
|
|
edge2.tail.edges[eid1] = edge2;
|
|
edge2.head.edges[eid1] = edge2;
|
|
edge1.eid = eid2;
|
|
edge2.eid = eid1;
|
|
if (~gt.noundo) {
|
|
gt.currundo.swapped.edges[eid1] = edge1;
|
|
gt.currundo.swapped.edges[eid2] = edge2;
|
|
gt.endadd2undo (gt);
|
|
}
|
|
};
|
|
dotty.protogt.removesubtree = function (gt, obj) {
|
|
local nlist, node, head, nid, edge, eid;
|
|
|
|
if (~gt.noundo)
|
|
gt.startadd2undo (gt);
|
|
if (obj.nid >= 0)
|
|
node = obj;
|
|
else if (obj.eid >= 0) {
|
|
node = obj.head;
|
|
gt.removeedge (gt, obj);
|
|
if (~gt.graph.nodes[node.nid]) {
|
|
if (~gt.noundo)
|
|
gt.endadd2undo (gt);
|
|
return;
|
|
}
|
|
for (eid in node.edges) {
|
|
edge = node.edges[eid];
|
|
if (edge.head == node & edge.tail ~= node) {
|
|
if (~gt.noundo)
|
|
gt.endadd2undo (gt);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
dotty.message (0, 'bad object type in gt.removesubtree');
|
|
return;
|
|
}
|
|
nlist = [node.nid = node;];
|
|
while (node) {
|
|
for (eid in node.edges) {
|
|
head = node.edges[eid].head;
|
|
if (head ~= node)
|
|
nlist[head.nid] = head;
|
|
}
|
|
gt.removenode (gt, node);
|
|
remove (node.nid, nlist);
|
|
node = null;
|
|
for (nid in nlist) {
|
|
node = nlist[nid];
|
|
for (eid in node.edges) {
|
|
edge = node.edges[eid];
|
|
if (edge.head == node & edge.tail ~= node) {
|
|
node = null;
|
|
break;
|
|
}
|
|
}
|
|
if (node)
|
|
break;
|
|
}
|
|
}
|
|
if (~gt.noundo)
|
|
gt.endadd2undo (gt);
|
|
};
|
|
dotty.protogt.removenodesbyattr = function (gt, key, val) {
|
|
local nlist, nid;
|
|
|
|
if (~gt.noundo)
|
|
gt.startadd2undo (gt);
|
|
nlist = gt.getnodesbyattr (gt, key, val);
|
|
for (nid in nlist)
|
|
gt.removenode (gt, nlist[nid]);
|
|
if (~gt.noundo)
|
|
gt.endadd2undo (gt);
|
|
};
|
|
dotty.protogt.removesubtreesbyattr = function (gt, key, val) {
|
|
local nlist, nid;
|
|
|
|
if (~gt.noundo)
|
|
gt.startadd2undo (gt);
|
|
nlist = gt.getnodesbyattr (gt, key, val);
|
|
for (nid in nlist)
|
|
if (gt.graph.nodes[nid])
|
|
gt.removesubtree (gt, nlist[nid]);
|
|
if (~gt.noundo)
|
|
gt.endadd2undo (gt);
|
|
};
|
|
dotty.protogt.groupnodes = function (gt, nlist, gnode, pos, size, attr,
|
|
keepmulti, show) {
|
|
local nid, node, elist, eid, edge, nodea, nodeb, inlist, outlist;
|
|
|
|
if (~nlist | tablesize (nlist) == 0)
|
|
return;
|
|
if (gnode.attr.support) {
|
|
dotty.message (0, 'cannot group nodes in a support node');
|
|
return;
|
|
}
|
|
if (~gt.noundo)
|
|
gt.startadd2undo (gt);
|
|
if (~gnode)
|
|
gnode = gt.insertnode (gt, pos, size, null, attr, show);
|
|
inlist = [];
|
|
outlist = [];
|
|
for (nid in nlist) {
|
|
if ((node = nlist[nid]) == gnode)
|
|
continue;
|
|
elist = [];
|
|
for (eid in node.edges)
|
|
elist[eid] = node.edges[eid];
|
|
for (eid in elist) {
|
|
edge = elist[eid];
|
|
if (edge.head == node) {
|
|
nodea = edge.tail;
|
|
nodeb = gnode;
|
|
if (~keepmulti) {
|
|
if (inlist[nodea.nid])
|
|
continue;
|
|
inlist[nodea.nid] = nodea;
|
|
if (nodea == gnode)
|
|
outlist[nodea.nid] = nodea;
|
|
}
|
|
} else {
|
|
nodea = gnode;
|
|
nodeb = edge.head;
|
|
if (~keepmulti) {
|
|
if (outlist[nodeb.nid])
|
|
continue;
|
|
outlist[nodeb.nid] = nodeb;
|
|
if (nodeb == gnode)
|
|
inlist[nodeb.nid] = nodeb;
|
|
}
|
|
}
|
|
gt.insertedge (gt, nodea, null, nodeb, null, edge.attr, show);
|
|
}
|
|
gt.removenode (gt, node);
|
|
}
|
|
if (~gt.noundo)
|
|
gt.endadd2undo (gt);
|
|
return gnode;
|
|
};
|
|
dotty.protogt.groupnodesbyattr =
|
|
function (gt, key, val, attr, keepmulti, show) {
|
|
local nlist, nid, pos, size;
|
|
|
|
pos = null;
|
|
size = null;
|
|
nlist = gt.getnodesbyattr (gt, key, val);
|
|
if (show)
|
|
for (nid in nlist) {
|
|
pos = nlist[nid].pos;
|
|
size = nlist[nid].size;
|
|
break;
|
|
}
|
|
return gt.groupnodes (gt, nlist, null, pos, size, attr, keepmulti, show);
|
|
};
|
|
dotty.protogt.cut = function (gt, obj, set, mode, op) {
|
|
local clipgt, list, node, nid, edge, eid, clipnode;
|
|
|
|
clipgt = dotty.clipgt;
|
|
clipgt.graph = copy (dotty.protogt.graph);
|
|
if (obj.eid >= 0) { # it's an edge
|
|
list.edges[obj.eid] = obj;
|
|
node = obj.head;
|
|
} else if (obj.nid >= 0) {
|
|
list.nodes[obj.nid] = obj;
|
|
node = obj;
|
|
for (eid in node.edges)
|
|
list.edges[eid] = node.edges[eid];
|
|
} else {
|
|
dotty.message (0, 'unknown object type in gt.cut');
|
|
return;
|
|
}
|
|
if (set == 'reachable') {
|
|
list.nodes = gt.reachablenodes (gt, node);
|
|
for (nid in list.nodes) {
|
|
node = list.nodes[nid];
|
|
for (eid in node.edges) {
|
|
edge = node.edges[eid];
|
|
list.edges[edge.eid] = edge;
|
|
}
|
|
}
|
|
}
|
|
if (mode == 'support') {
|
|
for (eid in list.edges) {
|
|
edge = list.edges[eid];
|
|
if (~list.nodes[edge.tail.nid]) {
|
|
list.support[edge.tail.nid] = edge.tail;
|
|
list.nodes[edge.tail.nid] = edge.tail;
|
|
}
|
|
if (~list.nodes[edge.head.nid]) {
|
|
list.support[edge.head.nid] = edge.head;
|
|
list.nodes[edge.head.nid] = edge.head;
|
|
}
|
|
}
|
|
}
|
|
for (nid = 0; nid < gt.graph.maxnid; nid = nid + 1) {
|
|
if (~list.nodes[nid])
|
|
continue;
|
|
node = list.nodes[nid];
|
|
clipnode = gt.insertnode (clipgt, null, null, node.name, node.attr, 0);
|
|
if (list.support[nid])
|
|
clipnode.support = 1;
|
|
list.clipnodes[nid] = clipnode;
|
|
}
|
|
for (eid = 0; eid < gt.graph.maxeid; eid = eid + 1) {
|
|
if (~list.edges[eid])
|
|
continue;
|
|
edge = list.edges[eid];
|
|
if (~list.nodes[edge.tail.nid] | ~list.nodes[edge.head.nid])
|
|
continue;
|
|
gt.insertedge (clipgt, list.clipnodes[edge.tail.nid], null,
|
|
list.clipnodes[edge.head.nid], null, edge.attr, 0);
|
|
}
|
|
if (op ~= 'cut')
|
|
return;
|
|
if (~gt.noundo)
|
|
gt.startadd2undo (gt);
|
|
for (eid in list.edges)
|
|
gt.removeedge (gt, list.edges[eid]);
|
|
for (nid in list.nodes)
|
|
if (~list.support[nid] & gt.graph.nodes[nid])
|
|
gt.removenode (gt, list.nodes[nid]);
|
|
if (~gt.noundo)
|
|
gt.endadd2undo (gt);
|
|
};
|
|
dotty.protogt.paste = function (gt, pos, show) {
|
|
local clipgt, offset, center, nid, node, eid, edge, nodes;
|
|
|
|
if (~gt.noundo)
|
|
gt.startadd2undo (gt);
|
|
clipgt = dotty.clipgt;
|
|
if (clipgt.graph.rect)
|
|
center = [
|
|
'x' = (clipgt.graph.rect[1].x + clipgt.graph.rect[0].x) / 2;
|
|
'y' = (clipgt.graph.rect[1].y + clipgt.graph.rect[0].y) / 2;
|
|
];
|
|
else
|
|
center = pos;
|
|
offset = [
|
|
'x' = center.x - pos.x;
|
|
'y' = center.y - pos.y;
|
|
];
|
|
for (nid = 0; clipgt.graph.nodes[nid]; nid = nid + 1) {
|
|
node = clipgt.graph.nodes[nid];
|
|
if (node.attr.label == '\N' | ~node.attr.label)
|
|
node.attr.label = node.name;
|
|
if (node.support == 1)
|
|
nodes[nid] = gt.insertnode (gt, [
|
|
'x' = node.pos.x - offset.x;
|
|
'y' = node.pos.y - offset.y;
|
|
], null, null, [
|
|
'support' = 1; 'shape' = 'circle';
|
|
'label' = ''; 'width' = 0.2;
|
|
], show);
|
|
else
|
|
nodes[nid] = gt.insertnode (gt, [
|
|
'x' = node.pos.x - offset.x;
|
|
'y' = node.pos.y - offset.y;
|
|
], node.size, null, node.attr, show);
|
|
}
|
|
for (eid = 0; clipgt.graph.edges[eid]; eid = eid + 1) {
|
|
edge = clipgt.graph.edges[eid];
|
|
gt.insertedge (gt, nodes[edge.tail.nid], null,
|
|
nodes[edge.head.nid], null, edge.attr, show);
|
|
}
|
|
if (~gt.noundo)
|
|
gt.endadd2undo (gt);
|
|
};
|
|
dotty.protogt.startadd2undo = function (gt) {
|
|
if (~gt.undoarray.level)
|
|
gt.currundo =
|
|
(gt.undoarray.entries[tablesize (gt.undoarray.entries)] = []);
|
|
gt.undoarray.level = gt.undoarray.level + 1;
|
|
};
|
|
dotty.protogt.endadd2undo = function (gt) {
|
|
gt.undoarray.level = gt.undoarray.level - 1;
|
|
};
|
|
dotty.protogt.undo = function (gt, show) {
|
|
local entry, n, eid, edge, nid, node, edges;
|
|
|
|
if ((n = tablesize (gt.undoarray.entries)) < 1)
|
|
return;
|
|
entry = gt.undoarray.entries[n - 1];
|
|
remove (n - 1, gt.undoarray.entries);
|
|
remove ('currundo', gt);
|
|
gt.noundo = 1;
|
|
# hardwire nodes and edges back with the same id's as the originals
|
|
for (nid in entry.deleted.nodes) {
|
|
node = entry.deleted.nodes[nid];
|
|
gt.graph.nodedict[node.name] = node.nid;
|
|
gt.graph.nodes[node.nid] = node;
|
|
node.edges = [];
|
|
if (show)
|
|
gt.drawnode (gt, gt.views, node);
|
|
}
|
|
for (eid in entry.deleted.edges) {
|
|
edge = entry.deleted.edges[eid];
|
|
gt.graph.edges[edge.eid] = edge;
|
|
edge.head.edges[edge.eid] = edge;
|
|
edge.tail.edges[edge.eid] = edge;
|
|
if (show)
|
|
gt.drawedge (gt, gt.views, edge);
|
|
}
|
|
if (entry.swapped.edges) {
|
|
if (tablesize (entry.swapped.edges) == 2) {
|
|
n = 0;
|
|
for (eid in entry.swapped.edges) {
|
|
edges[n] = entry.swapped.edges[eid];
|
|
n = n + 1;
|
|
}
|
|
gt.swapedgeids (gt, edges[0], edges[1]);
|
|
} else
|
|
dotty.message (0, 'cannot handle undoing swap of > 2 edges');
|
|
}
|
|
for (eid in entry.inserted.edges) {
|
|
edge = entry.inserted.edges[eid];
|
|
gt.removeedge (gt, edge);
|
|
}
|
|
for (nid in entry.inserted.nodes) {
|
|
node = entry.inserted.nodes[nid];
|
|
gt.removenode (gt, node);
|
|
}
|
|
gt.noundo = 0;
|
|
};
|