#
# DOTTY
#
dotty = [
'keys' = [
'nid' = 'nid';
'eid' = 'eid';
'gid' = 'gid';
'name' = 'name';
'attr' = 'attr';
'gattr' = 'graphattr';
'eattr' = 'edgeattr';
'nattr' = 'nodeattr';
'edges' = 'edges';
'tail' = 'tail';
'tport' = 'tport';
'head' = 'head';
'hport' = 'hport';
'pos' = 'pos';
'size' = 'size';
'points' = 'points';
'fname' = 'fontname';
'fsize' = 'fontsize';
'fcolor' = 'fontcolor';
'color' = 'color';
];
'maps' = [
'X11' = [
'fontmap' = [
'Times-Roman' =
'-*-times-medium-r-*--%d-*-*-*-*-*-*-1';
'Times-Italic' =
'-*-times-medium-i-*--%d-*-*-*-*-*-*-1';
'Times-Bold' =
'-*-times-bold-r-*--%d-*-*-*-*-*-*-1';
'Courier' =
'-*-courier-bold-r-*--%d-*-*-*-*-*-*-1';
'Courier-Bold' =
'-*-courier-bold-r-*--%d-*-*-*-*-*-*-1';
'Helvetica' =
'-*-helvetica-medium-r-normal--%d-*-*-*-p-*-iso8859-1';
'Helvetica-Bold' =
'-*-helvetica-bold-r-normal--%d-*-*-*-p-*-iso8859-1';
];
'psfontmap' = [
'Times-Roman' = 'Times-Roman';
'Times-Italic' = 'Times-Italic';
'Times-Bold' = 'Times-Bold';
'Courier' = 'Courier';
'Courier-Bold' = 'Courier-Bold';
'Helvetica' = 'Helvetica';
'Helvetica-Bold' = 'Helvetica-Bold';
];
];
'mswin' = [
'fontmap' = [
'Times-Roman' = 'Times New Roman';
'Times-Italic' = 'Times New Roman Italic';
'Times-Bold' = 'Times New Roman Bold';
'Courier' = 'Courier New';
'Courier-Bold' = 'Courier New Bold';
'Helvetica' = 'Arial';
'Helvetica-Bold' = 'Arial Bold';
];
'psfontmap' = [
'Times-Roman' = 'Times New Roman';
'Times-Italic' = 'Times New Roman Italic';
'Times-Bold' = 'Times New Roman Bold';
'Courier' = 'Courier New';
'Courier-Bold' = 'Courier New Bold';
'Helvetica' = 'Arial';
'Helvetica-Bold' = 'Arial Bold';
];
];
];
'protogt' = [
'graph' = [
'graphattr' = [
'fontsize' = '14';
'fontname' = 'Times-Roman';
'fontcolor' = 'black';
'color' = 'black';
];
'nodeattr' = [
'shape' = 'ellipse';
'fontsize' = '14';
'fontname' = 'Times-Roman';
'fontcolor' = 'black';
'color' = 'black';
];
'edgeattr' = [
'fontsize' = '14';
'fontname' = 'Times-Roman';
'fontcolor' = 'black';
'color' = 'black';
];
'graphdict' = [];
'nodedict' = [];
'graphs' = [];
'nodes' = [];
'edges' = [];
'maxgid' = 0;
'maxnid' = 0;
'maxeid' = 0;
'type' = 'digraph';
];
'layoutmode' = 'sync';
'lserver' = 'dot';
'edgehandles' = 1;
'noundo' = 0;
];
'lservers' = [];
'mlevel' = 0;
'graphs' = [];
'views' = [];
'protovt' = [
'normal' = [
'name' = 'DOTTY';
'orig' = ['x' = 1; 'y' = 1;];
'size' = ['x' = 420; 'y' = 520;];
'wrect' = [
0 = ['x' = 0; 'y' = 0;];
1 = ['x' = 400; 'y' = 500;];
];
'vsize' = ['x' = 400; 'y' = 500;];
'w2v' = 1;
];
'birdseye' = [
'type' = 'birdseye';
'name' = 'DOTTY birdseye view';
'orig' = ['x' = 1; 'y' = 1;];
'size' = ['x' = 220; 'y' = 260;];
'wrect' = [
0 = ['x' = 0; 'y' = 0;];
1 = ['x' = 200; 'y' = 250;];
];
'vsize' = ['x' = 200; 'y' = 250;];
'w2v' = 1;
];
];
'pagesizes' = [
'8.5x11' = ['x' = 8; 'y' = 10.5;];
'11x17' = ['x' = 10.5; 'y' = 16.5;];
'36x50' = ['x' = 35.5; 'y' = 49.5;];
];
];
load ('dotty_draw.lefty');
load ('dotty_edit.lefty');
load ('dotty_layout.lefty');
load ('dotty_ui.lefty');
#
# initialization functions
#
dotty.init = function () {
dotty.outlinecolor = 1;
dotty.fontmap = dotty.maps[getenv ('LEFTYWINSYS')].fontmap;
dotty.clipgt = dotty.protogt.creategraph (['noundo' = 1;]);
dotty.inited = 1;
};
dotty.simple = function (file) {
if (dotty.inited ~= 1)
dotty.init ();
dotty.createviewandgraph (file, 'file', null, null);
txtview ('off');
};
#
# main operations
#
dotty.protogt.creategraph = function (protogt) {
local gt, id, gtid;
if (~protogt)
protogt = dotty.protogt;
for (gtid = 0; dotty.graphs[gtid]; gtid = gtid + 1)
;
gt = (dotty.graphs[gtid] = []);
if (protogt.mode ~= 'replace') {
for (id in dotty.protogt)
gt[id] = copy (dotty.protogt[id]);
}
for (id in protogt)
gt[id] = copy (protogt[id]);
gt.gtid = gtid;
gt.views = [];
gt.undoarray = ['level' = 0; 'entries' = [];];
gt.busy = 0;
return gt;
};
dotty.protogt.copygraph = function (ogt) {
local gt, gtid, id;
for (gtid = 0; dotty.graphs[gtid]; gtid = gtid + 1)
;
gt = (dotty.graphs[gtid] = []);
for (id in ogt)
gt[id] = copy (ogt[id]);
gt.gtid = gtid;
gt.views = [];
gt.undoarray = ['level' = 0; 'entries' = [];];
gt.busy = 0;
return gt;
};
dotty.protogt.destroygraph = function (gt) {
local vid, vlist;
if (gt.layoutpending > 0)
gt.cancellayout (gt);
for (vid in gt.views)
vlist[vid] = gt.views[vid];
for (vid in gt.views)
gt.destroyview (gt, vlist[vid]);
remove (gt.gtid, dotty.graphs);
};
dotty.protogt.loadgraph = function (gt, name, type, protograph, layoutflag) {
local vid, vt, fd, graph, nid, eid, gid;
if (gt.layoutpending > 0)
gt.cancellayout (gt);
if (~name)
if (~(name = ask ('file name:', 'file', '')))
return;
dotty.pushbusy (gt, gt.views);
dotty.message (1, 'loading');
if (~protograph)
protograph = dotty.protogt.graph;
if (~((fd = dotty.openio (name, type, 'r')) >= 0) |
~(graph = readgraph (fd, protograph))) {
dotty.message (0, 'cannot load graph');
dotty.popbusy (gt, gt.views);
return;
}
for (vid in gt.views) {
vt = gt.views[vid];
vt.colors = [];
vt.colorn = 2;
}
gt.graph = graph;
gt.name = name;
gt.type = type;
gt.undoarray = ['level' = 0; 'entries' = [];];
if (~(type == 'file' & name == '-'))
closeio (fd);
graph.maxgid = tablesize (graph.graphs);
graph.maxnid = tablesize (graph.nodes);
graph.maxeid = tablesize (graph.edges);
for (nid in graph.nodes)
graph.nodes[nid][dotty.keys.nid] = nid;
for (eid in graph.edges)
graph.edges[eid][dotty.keys.eid] = eid;
for (gid in graph.graphs)
graph.graphs[gid][dotty.keys.gid] = gid;
gt.unpackattr (gt);
if (layoutflag) {
dotty.message (1, 'generating layout');
gt.layoutgraph (gt);
}
dotty.popbusy (gt, gt.views);
return gt.graph;
};
dotty.protogt.savegraph = function (gt, name, type, savecoord) {
local fd, graph, gid, sgraph, nid, node, eid, edge, pointi, attr;
if (~name)
if (~(name = ask ('file name:', 'file', '')))
return;
if (savecoord) {
graph = copy (gt.graph);
for (gid in graph.graphs) {
sgraph = graph.graphs[gid];
if (sgraph.rect)
sgraph.graphattr.bb = concat (sgraph.rect[0].x, ',',
sgraph.rect[0].y, ',', sgraph.rect[1].x, ',',
sgraph.rect[1].y);
if (sgraph.lp & tablesize (sgraph.lp) > 0)
sgraph.graphattr.lp = concat (sgraph.lp.x, ',', sgraph.lp.y);
else if (sgraph.lp)
sgraph.graphattr.lp = "";
}
for (nid in graph.nodes) {
node = graph.nodes[nid];
if (~node.attr.label)
node.attr.label = '\N';
if (node.pos)
node.attr.pos = concat (node.pos.x, ',', node.pos.y);
if (node.size) {
node.attr.width = node.size.x / 72;
node.attr.height = node.size.y / 72;
}
if (node.fields)
node.attr.rects = gt.packrecordfields (gt, node.fields);
}
for (eid in graph.edges) {
edge = graph.edges[eid];
if (edge.points) {
attr = '';
if (edge.sp)
attr = concat ('s,', edge.sp.x, ',', edge.sp.y, ' ');
if (edge.ep)
attr = concat (attr, 'e,', edge.ep.x, ',', edge.ep.y, ' ');
for (pointi = 0; edge.points[pointi]; pointi = pointi + 1)
attr = concat (attr, ' ', edge.points[pointi].x, ',',
edge.points[pointi].y);
edge.attr.pos = attr;
}
if (edge.lp)
edge.attr.lp = concat (edge.lp.x, ',', edge.lp.y);
}
if (~graph.rect) {
graph.rect = [
0 = ['x' = 0; 'y' = 0; ]; 1 = ['x' = 1; 'y' = 1; ];
];
for (nid in graph.nodes) {
node = graph.nodes[nid];
if (graph.rect[1].x < node.pos.x + node.size.x / 2)
graph.rect[1].x = node.pos.x + node.size.x / 2;
if (graph.rect[1].y < node.pos.y + node.size.y / 2)
graph.rect[1].y = node.pos.y + node.size.y / 2;
}
}
graph.graphattr.bb = concat (graph.rect[0].x, ',',
graph.rect[0].y, ',', graph.rect[1].x, ',',
graph.rect[1].y);
if (graph.lp & tablesize (graph.lp) > 0)
graph.graphattr.lp = concat (graph.lp.x, ',', graph.lp.y);
} else
graph = gt.graph;
if (~((fd = dotty.openio (name, type, 'w')) >= 0) |
~writegraph (fd, graph, 0)) {
dotty.message (0, 'cannot save graph');
return;
}
if (~(type == 'file' & name == '-'))
closeio (fd);
};
dotty.protogt.packrecordfields = function (gt, fields) {
local attrs, attr, fid, field;
for (fid = 0; fields[fid]; fid = fid + 1) {
field = fields[fid];
if (field.fields)
attr = gt.packrecordfields (gt, field.fields);
else
attr = concat (field.rect[0].x, ',', field.rect[0].y,
',', field.rect[1].x, ',', field.rect[1].y);
if (attrs)
attrs = concat (attrs, ' ', attr);
else
attrs = attr;
}
return attrs;
};
dotty.protogt.setgraph = function (gt, graph) {
local vid, vt, nid, eid, gid;
if (gt.layoutpending > 0)
gt.cancellayout (gt);
for (vid in gt.views) {
vt = gt.views[vid];
vt.colors = [];
vt.colorn = 2;
}
gt.graph = copy (graph);
gt.undoarray = ['level' = 0; 'entries' = [];];
gt.unpackattr (gt);
gt.graph.maxgid = tablesize (graph.graphs);
gt.graph.maxnid = tablesize (graph.nodes);
gt.graph.maxeid = tablesize (graph.edges);
for (nid in gt.graph.nodes)
gt.graph.nodes[nid][dotty.keys.nid] = nid;
for (eid in gt.graph.edges)
gt.graph.edges[eid][dotty.keys.eid] = eid;
for (gid in gt.graph.graphs)
gt.graph.graphs[gid][dotty.keys.gid] = gid;
gt.unpackattr (gt);
dotty.message (1, 'generating layout');
gt.layoutgraph (gt);
return gt.graph;
};
dotty.protogt.erasegraph = function (gt, protogt, protovt) {
local vid, vt;
if (gt.layoutpending > 0)
gt.cancellayout (gt);
for (vid in gt.views) {
vt = gt.views[vid];
vt.colors = [];
vt.colorn = 2;
clear (vt.canvas);
}
if (~protogt)
protogt = dotty.protogt;
gt.graph = copy (protogt.graph);
gt.undoarray = ['level' = 0; 'entries' = [];];
};
dotty.protogt.layoutgraph = function (gt) {
if (gt.graph.graphattr.bb) {
gt.unpacklayout (gt, gt.graph);
gt.setviewsize (gt.views, gt.graph.rect);
gt.redrawgraph (gt, gt.views);
return;
}
if (gt.layoutmode == 'async') {
if (~gt.haveinput) {
gt.startlayout (gt);
return;
}
if (~gt.finishlayout (gt))
return;
gt.setviewsize (gt.views, gt.graph.rect);
gt.redrawgraph (gt, gt.views);
} else {
if (~gt.startlayout (gt))
return;
else
while (~gt.finishlayout (gt))
;
gt.setviewsize (gt.views, gt.graph.rect);
gt.redrawgraph (gt, gt.views);
}
};
dotty.protogt.createview = function (gt, protovt) {
local vt, ovt, id, t;
vt = [];
vt.colors = [];
vt.colorn = 2;
if (~protovt)
protovt = dotty.protovt.normal;
if (protovt.mode ~= 'replace') {
for (id in dotty.protovt[protovt.type])
vt[id] = copy (dotty.protovt[protovt.type][id]);
}
for (id in protovt)
vt[id] = copy (protovt[id]);
if (~(vt.parent >= 0)) {
vt.view = createwidget (-1, [
'type' = 'view';
'name' = vt.name;
'origin' = vt.orig;
'size' = vt.size;
]);
vt.scroll = createwidget (vt.view, ['type' = 'scroll';]);
} else {
vt.view = -1;
vt.scroll = createwidget (vt.parent, [
'type' = 'scroll';
'size' = vt.size;
]);
}
vt.canvas = createwidget (vt.scroll, [
'type' = 'canvas';
'color' = [0 = protovt.bgcolor; 1 = protovt.fgcolor;];
]);
setwidgetattr (vt.canvas, [
'window' = vt.wrect;
'viewport' = vt.vsize;
]);
clear (vt.canvas);
dotty.views[vt.canvas] = vt;
vt.vtid = vt.canvas;
vt.gtid = gt.gtid;
gt.views[vt.vtid] = vt;
dotty.views[vt.scroll] = vt;
if (vt.view ~= -1)
dotty.views[vt.view] = vt;
if (protovt.colors & tablesize (protovt.colors) > 0) {
for (id in protovt.colors)
if (setwidgetattr (vt.canvas, ['color' = [
protovt.colors[id] = id;
];]) ~= 1) {
t = split (id, ' ');
if (tablesize (t) ~= 3 | setwidgetattr (vt.canvas, [
'color' = [protovt.colors[id] = [
'h' = ston (t[0]); 's' = ston (t[1]); 'v' = ston (t[2]);
];];
]) ~= 1) {
dotty.message (0,
concat ('unknown color ', id, ' using #1'));
}
}
vt.colors = copy (protovt.colors);
vt.colorn = protovt.colorn;
} else if (tablesize (gt.views) > 1) {
for (id in gt.views)
if (gt.views[id] ~= vt)
break;
ovt = gt.views[id];
for (id in ovt.colors)
if (setwidgetattr (vt.canvas, ['color' = [
ovt.colors[id] = id;
];]) ~= 1) {
t = split (id, ' ');
if (tablesize (t) ~= 3 | setwidgetattr (vt.canvas, [
'color' = [ovt.colors[id] = [
'h' = ston (t[0]); 's' = ston (t[1]); 'v' = ston (t[2]);
];];
]) ~= 1) {
dotty.message (0,
concat ('unknown color ', id, ' using #1'));
}
}
vt.colors = copy (ovt.colors);
vt.colorn = ovt.colorn;
}
if (gt.graph.rect)
gt.setviewsize ([vt.vtid = vt;], gt.graph.rect);
gt.drawgraph (gt, [vt.vtid = vt;]);
for (id in vt.uifuncs)
if (id == 'closeview')
widgets[vt.view][id] = vt.uifuncs[id];
else
widgets[vt.canvas][id] = vt.uifuncs[id];
return vt;
};
dotty.protogt.destroyview = function (gt, vt) {
destroywidget (vt.canvas);
destroywidget (vt.scroll);
if (vt.view ~= -1) {
destroywidget (vt.view);
remove (vt.view, dotty.views);
}
remove (vt.scroll, dotty.views);
remove (vt.canvas, dotty.views);
if (vt.gtid >= 0)
remove (vt.vtid, gt.views);
if (tablesize (dotty.views) == 0)
exit ();
};
dotty.protogt.zoom = function (gt, vt, factor, pos) {
gt.setviewscale ([vt.vtid = vt;], factor);
if (pos)
gt.setviewcenter ([vt.vtid = vt;], pos);
gt.redrawgraph (gt, [vt.vtid = vt;]);
};
dotty.protogt.findnode = function (gt, vt) {
local key, node, node1, nid;
if (~(key = ask ('give node name or label')))
return;
if (gt.graph.nodedict[key] >= 0)
node = gt.graph.nodes[gt.graph.nodedict[key]];
else if (gt.graph.nodedict[ston (key)] >= 0)
node = gt.graph.nodes[gt.graph.nodedict[ston (key)]];
else {
for (nid in gt.graph.nodes) {
node1 = gt.graph.nodes[nid];
if (node1.attr.label == key | node1.attr.label == ston (key)) {
node = node1;
break;
}
}
}
if (~node) {
dotty.message (0, concat ('cannot find node: ', key));
return;
}
gt.setviewcenter ([vt.vtid = vt;], node.pos);
};
dotty.protogt.setattr = function (gt, obj) {
local kv, t, attr, value;
if (~(kv = ask ('give attr/value, eg. color=blue')))
return;
t = split (kv, '=');
attr = t[0];
value = t[1];
if (
obj.attr == gt.graph.graphattr |
obj.attr == gt.graph.edgeattr |
obj.attr == gt.graph.nodeattr
) {
obj.attr[attr] = value;
return;
}
if (obj.nid >= 0) {
gt.undrawnode (gt, gt.views, obj);
obj.attr[attr] = value;
gt.unpacknodeattr (gt, obj);
gt.drawnode (gt, gt.views, obj);
} else if (obj.eid >= 0) {
gt.undrawedge (gt, gt.views, obj);
obj.attr[attr] = value;
gt.unpackedgeattr (gt, obj);
gt.drawedge (gt, gt.views, obj);
}
};
dotty.protogt.getattr = function (gt, node) {
local kv;
if (~(kv.key = ask ('give attr name')))
return null;
if ((kv.val = node.attr[kv.key]))
return kv;
return null;
};
#
# utilities
#
dotty.createviewandgraph = function (name, type, protogt, protovt) {
local vt, gt;
if (~protogt)
protogt = dotty.protogt;
if (protogt.creategraph)
gt = protogt.creategraph (protogt);
else
gt = dotty.protogt.creategraph (protogt);
vt = gt.createview (gt, protovt);
if (~protogt.graph)
protogt.graph = copy (dotty.protogt.graph);
if (name)
gt.loadgraph (gt, name, type, protogt.graph, 1);
return ['gt' = gt; 'vt' = vt;];
};
dotty.openio = function (name, type, mode) {
local fd;
if (~name)
return null;
if (type == 'file') {
if (name == '-') {
if (mode == 'r' | mode == 'r+')
fd = 0;
else
fd = 1;
} else if (~((fd = openio ('file', name, mode)) >= 0)) {
dotty.message (0, concat ('cannot open file: ', name));
return null;
}
} else if (type == 'pipe') {
if (~((fd = openio ('pipe', 'ksh', mode,
concat ("%e ", name))) >= 0)) {
dotty.message (0, concat ('cannot run command: ', name));
return null;
}
} else
return null;
return fd;
};
dotty.pushbusy = function (gt, views) {
local vid;
if (gt.busy == 0)
for (vid in gt.views)
setwidgetattr (vid, ['cursor' = 'watch';]);
gt.busy = gt.busy + 1;
};
dotty.popbusy = function (gt, views) {
local vid;
gt.busy = gt.busy - 1;
if (gt.busy == 0)
for (vid in gt.views)
setwidgetattr (vid, ['cursor' = 'default';]);
};
dotty.message = function (level, text) {
if (level <= dotty.mlevel)
echo ('dotty.lefty: ', text);
};
#
# printing or saving to file
#
dotty.protogt.printorsave = function (gt, vt, otype, name, mode, ptype) {
local pr, wrect, vsize, xy, psize, canvas, pscanvas, cid, cname, t;
local graph, edgehandles, fontmap, eid, edge, nid, node, gid, sgraph;
if (~otype)
if (~(otype = ask ('print to', 'choice', 'file|printer')))
return;
if (otype == 'printer') {
name = '/tmp/dottyout.ps';
if (getenv ('LEFTYWINSYS') ~= 'mswin' & ~pr)
if (~(pr = ask ('printer command', 'string', 'lpr')))
return;
}
if (~name)
if (~(name = ask ('postscript file', 'file', 'out.ps')))
return;
if (~ptype)
if (~(ptype = ask ('page size', 'choice', '8.5x11|11x17|36x50')))
return;
if (~mode)
if (~(mode = ask ('mode', 'choice', 'portrait|landscape|best fit')))
return;
wrect = copy (vt.wrect);
wrect[0].x = wrect[0].x - 1;
wrect[1].x = wrect[1].x + 1;
wrect[0].y = wrect[0].y - 1;
wrect[1].y = wrect[1].y + 1;
vsize = copy (vt.vsize);
if (vsize.x == 0)
vsize.x = 1;
if (vsize.y == 0)
vsize.y = 1;
xy = vsize.x / vsize.y;
if (mode == 'best fit') {
if (xy < 1)
mode = 'portrait';
else
mode = 'landscape';
}
psize = dotty.pagesizes[ptype];
if (mode == 'portrait') {
if (xy < psize.x / psize.y) {
vsize.y = psize.y * 300;
vsize.x = vsize.y * xy;
} else {
vsize.x = psize.x * 300;
vsize.y = vsize.x / xy;
}
} else {
if (xy < psize.y / psize.x) {
vsize.y = psize.x * 300;
vsize.x = vsize.y * xy;
} else {
vsize.x = psize.y * 300;
vsize.y = vsize.x / xy;
}
}
if (~((pscanvas = createwidget (-1, [
'type' = 'ps';
'origin' = ['x' = 0; 'y' = 0;];
'size' = vsize;
'mode' = mode;
'name' = name;
])) >= 0)) {
dotty.message (0, 'cannot open printer device');
return;
}
for (cname in vt.colors) {
cid = vt.colors[cname];
if (setwidgetattr (pscanvas, ['color' = [cid = cname;];]) ~= 1) {
t = split (cname, ' ');
if (tablesize (t) ~= 3 |
setwidgetattr (pscanvas, ['color' = [cid = [
'h' = ston (t[0]); 's' = ston (t[1]); 'v' = ston (t[2]);
];];]) ~= 1) {
dotty.message (0, concat ('unknown color ',
cname, ' using #1'));
}
}
}
setwidgetattr (pscanvas, ['window' = wrect;]);
graph = copy (gt.graph);
canvas = vt.canvas;
vt.canvas = pscanvas;
edgehandles = gt.edgehandles;
gt.edgehandles = 0;
fontmap = dotty.maps[getenv ('LEFTYWINSYS')].psfontmap;
for (eid in graph.edges) {
edge = graph.edges[eid];
edge.fontname = fontmap[edge.attr.fontname];
gt.drawedge (gt, [0 = vt;], edge);
}
for (nid in graph.nodes) {
node = graph.nodes[nid];
node.fontname = fontmap[node.attr.fontname];
gt.drawnode (gt, [0 = vt;], node);
}
for (gid in graph.graphs) {
sgraph = graph.graphs[gid];
sgraph.fontname = fontmap[sgraph.graphattr.fontname];
gt.drawsgraph (gt, [0 = vt;], sgraph);
}
graph.fontname = fontmap[graph.graphattr.fontname];
gt.drawsgraph (gt, [0 = vt;], graph);
gt.edgehandles = edgehandles;
vt.canvas = canvas;
destroywidget (pscanvas);
if (otype == 'printer' & getenv ('LEFTYWINSYS') ~= 'mswin')
system (concat (pr, ' /tmp/dottyout.ps; rm /tmp/dottyout.ps'));
};