← Back to branch summary

~ubuntu-branches/ubuntu/lucid/graphviz/lucid-security

« back to all changes in this revision

Viewing changes to contrib/lefty-grace/dotty_ui.lefty

  • Committer: Bazaar Package Importer
  • Author(s): Stephen M Moraco
  • Date: 2002-02-05 18:52:12 UTC
  • Revision ID: james.westby@ubuntu.com-20020205185212-8i04c70te00rc40y
Tags: upstream-1.7.16
Import upstream version 1.7.16

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/lefty-grace/dotty_ui.lefty
 
1
#
 
2
# dotty_ui: user interface functions and data structures
 
3
#
 
4
dotty.protogt.doaction = function (data, s) {
 
5
    local vt, gt;
 
6
 
 
7
    vt = dotty.views[data.widget];
 
8
    gt = dotty.graphs[vt.gtid];
 
9
    if (data.obj.nid >= 0) {
 
10
        if (gt.actions.node[s]) {
 
11
            gt.actions.node[s] (gt, vt, data.obj, data);
 
12
            return;
 
13
        }
 
14
    } else if (data.obj.eid >= 0) {
 
15
        if (gt.actions.edge[s]) {
 
16
            gt.actions.edge[s] (gt, vt, data.obj, data);
 
17
            return;
 
18
        }
 
19
    }
 
20
    if (gt.actions.general[s])
 
21
        gt.actions.general[s] (gt, vt, data);
 
22
};
 
23
dotty.protogt.actions.general = [
 
24
    "undo" = function (gt, vt, data) {
 
25
        gt.undo (gt, 1);
 
26
    };
 
27
    "paste" = function (gt, vt, data) {
 
28
        gt.paste (gt, data.pos, 1);
 
29
    };
 
30
    "do layout" = function (gt, vt, data) {
 
31
        gt.layoutgraph (gt);
 
32
    };
 
33
    "cancel layout" = function (gt, vt, data) {
 
34
        gt.cancellayout (gt);
 
35
    };
 
36
    "redraw" = function (gt, vt, data) {
 
37
        gt.redrawgraph (gt, [vt.vtid = vt;]);
 
38
    };
 
39
    "new graph" = function (gt, vt, data) {
 
40
        gt.erasegraph (gt, null, null);
 
41
    };
 
42
    "load graph" = function (gt, vt, data) {
 
43
        if ( gt.name ~= '') {
 
44
            gt.unfoldall (gt);
 
45
            gt.savegraph (gt, gt.name, 'file', 1);
 
46
        }
 
47
        gt.loadgraph (gt, null, 'file', dotty.protogt.graph, 1);
 
48
    };
 
49
    "load parent" = function (gt, vt, data) {
 
50
        local pname;
 
51
        pname = gt.graph['parent'];
 
52
 
 
53
        if ( ~pname | pname == '' )
 
54
            return;
 
55
     
 
56
        if ( gt.name ~= '') {
 
57
            gt.unfoldall (gt);
 
58
            gt.savegraph (gt, gt.name, gt.type, 1);
 
59
        }
 
60
 
 
61
        gt.loadgraph (gt, pname, 'file', dotty.protogt.graph, 1);
 
62
    };
 
63
    "reload graph" = function (gt, vt, data) {
 
64
        gt.loadgraph (gt, gt.name, gt.type, gt.graph, 1);
 
65
    };
 
66
    "save graph" = function (gt, vt, data) {
 
67
        gt.unfoldall (gt);
 
68
        gt.savegraph (gt, gt.name, gt.type, 1);
 
69
    };
 
70
    "save graph as" = function (gt, vt, data) {
 
71
        gt.unfoldall (gt);
 
72
        gt.savegraph (gt, null, 'file', 1);
 
73
    };
 
74
    "open view" = function (gt, vt, data) {
 
75
        gt = dotty.protogt.creategraph (null);
 
76
        gt.createview (gt, null);
 
77
    };
 
78
    "copy view" = function (gt, vt, data) {
 
79
        gt = gt.copygraph (gt);
 
80
        gt.createview (gt, vt);
 
81
    };
 
82
    "birdseye view" = function (gt, vt, data) {
 
83
        gt.createview (gt, dotty.protovt.birdseye);
 
84
    };
 
85
    "clone view" = function (gt, vt, data) {
 
86
        gt.createview (gt, vt);
 
87
    };
 
88
    "close view" = function (gt, vt, data) {
 
89
        gt.destroyview (gt, vt);
 
90
        if (tablesize (gt.views) == 0)
 
91
            gt.destroygraph (gt);
 
92
    };
 
93
    "set graph attr" = function (gt, vt, data) {
 
94
        gt.setattr (gt, ['attr' = gt.graph.graphattr;]);
 
95
    };
 
96
    "set node attr" = function (gt, vt, data) {
 
97
        gt.setattr (gt, ['attr' = gt.graph.nodeattr;]);
 
98
    };
 
99
    "set edge attr" = function (gt, vt, data) {
 
100
        gt.setattr (gt, ['attr' = gt.graph.edgeattr;]);
 
101
    };
 
102
    "zoom in" = function (gt, vt, data) {
 
103
        gt.zoom (gt, vt, 0.5, data.pos);
 
104
    };
 
105
    "zoom out" = function (gt, vt, data) {
 
106
        gt.zoom (gt, vt, 2, data.pos);
 
107
    };
 
108
    "zoom in slowly" = function (gt, vt, data) {
 
109
        gt.zoom (gt, vt, 0.9, data.pos);
 
110
    };
 
111
    "zoom out slowly" = function (gt, vt, data) {
 
112
        gt.zoom (gt, vt, 1.1, data.pos);
 
113
    };
 
114
    "move interactively" = function (gt, vt, data) {
 
115
        gt.setviewcenter ([vt.vtid = vt;], data.pos);
 
116
#        gt.redrawgraph (gt, [vt.vtid = vt;]);
 
117
    };      
 
118
    "fold subgraph" = function (gt, vt, data) {
 
119
        local grph;
 
120
 
 
121
        grph = ask( 'Name of subgraph to fold');
 
122
        if ( ~grph | grph == '' | grph == ' ' | ~gt.graph.graphdict[grph] ) {
 
123
            echo('No subgraph found');
 
124
            return;
 
125
        }
 
126
        gt.foldsgraph(gt, gt.views, grph );
 
127
    };
 
128
    "add node" = function( gt, vt, data) {
 
129
        local newname;
 
130
 
 
131
        newname = ask('Give new node name');
 
132
        if (newname == '' | newname == ' ')
 
133
            newname=0;
 
134
        gt.insertnode (gt, data.pos, null, newname, null, 1);
 
135
    };
 
136
    "add subgraph" = function (gt, vt, data) {
 
137
        local newname;
 
138
 
 
139
        newname = ask('Give new subgraph name');
 
140
        if (newname == '' | newname == ' ')
 
141
            newname=0;
 
142
        gt.insertsgraph (gt, newname, null, 1);
 
143
    };
 
144
 
 
145
    "find node" = function (gt, vt, data) {
 
146
        gt.findnode (gt, vt);
 
147
    };
 
148
    "print graph" = function (gt, vt, data) {
 
149
        gt.printorsave (gt, vt, null, null, null, null);
 
150
    };
 
151
    "text view" = function (gt, vt, data) {
 
152
        if (dotty.txtview == 'on')
 
153
            dotty.txtview = 'off';
 
154
        else
 
155
            dotty.txtview = 'on';
 
156
        txtview (dotty.txtview);
 
157
    };
 
158
    "quit" = function (gt, vt, data) {
 
159
        local reply;
 
160
 
 
161
        reply = ask ('Save graph', 'choice', 'Yes|No|Cancel');
 
162
        if (reply == "Cancel")
 
163
            return;
 
164
        else if ( reply == "Yes") {
 
165
            gt.unfoldall (gt);
 
166
            gt.savegraph (gt, gt.name, gt.type, 1);
 
167
        }
 
168
        exit ();
 
169
    };
 
170
];
 
171
dotty.protogt.actions.node = [
 
172
    "cut" = function (gt, vt, obj, data) {
 
173
        gt.cut (gt, obj, 'one', 'support', 'cut');
 
174
        dotty.clipgt.layoutgraph (dotty.clipgt);
 
175
    };
 
176
    "Cut" = function (gt, vt, obj, data) {
 
177
        gt.cut (gt, obj, 'reachable', 'support', 'cut');
 
178
        dotty.clipgt.layoutgraph (dotty.clipgt);
 
179
    };
 
180
    "copy" = function (gt, vt, obj, data) {
 
181
        gt.cut (gt, obj, 'one', 'support', 'copy');
 
182
        dotty.clipgt.layoutgraph (dotty.clipgt);
 
183
    };
 
184
    "Copy" = function (gt, vt, obj, data) {
 
185
        gt.cut (gt, obj, 'reachable', 'support', 'copy');
 
186
        dotty.clipgt.layoutgraph (dotty.clipgt);
 
187
    };
 
188
    "group" = function (gt, vt, obj, data) {
 
189
        local kv;
 
190
 
 
191
        if ((kv = gt.getattr (gt, obj)))
 
192
            gt.groupnodesbyattr (gt, kv.key, kv.val, [
 
193
                'label' = kv.val; kv.key = kv.val;
 
194
            ], 1, 1);
 
195
    };
 
196
    "Group" = function (gt, vt, obj, data) {
 
197
        local kv;
 
198
 
 
199
        if ((kv = gt.getattr (gt, obj)))
 
200
            gt.groupnodesbyattr (gt, kv.key, kv.val, [
 
201
                'label' = kv.val; kv.key = kv.val;
 
202
            ], 0, 1);
 
203
    };
 
204
    "delete" = function (gt, vt, obj, data) {
 
205
        if (obj.eid >= 0)
 
206
            gt.removeedge (gt, obj);
 
207
        else
 
208
            gt.removenode (gt, obj);
 
209
    };
 
210
    "Delete" = function (gt, vt, obj, data) {
 
211
        gt.removesubtree (gt, obj);
 
212
    };
 
213
    "remove" = function (gt, vt, obj, data) {
 
214
        if (obj.nid >= 0)
 
215
            if ((kv = gt.getattr (gt, obj)))
 
216
                gt.removenodesbyattr (gt, kv.key, kv.val);
 
217
    };
 
218
    "Remove" = function (gt, vt, obj, data) {
 
219
        if (obj.nid >= 0)
 
220
            if ((kv = gt.getattr (gt, obj)))
 
221
                gt.removesubtreesbyattr (gt, kv.key, kv.val);
 
222
    };
 
223
    "fold/unfold subtree" = function (gt, vt, obj, data) {
 
224
        if ( obj.nid >= 0 ) {
 
225
            if ( obj.attr.folded == '0' ) {
 
226
                if ( gt.foldsubtree( gt, obj )) {        
 
227
#                    gt.layoutgraph (gt);
 
228
#                    gt.setviewcenter ([vt.vtid = vt;], obj.pos);
 
229
                    gt.drawgraph (gt, [vt.vtid = vt;]);
 
230
                }
 
231
            }       
 
232
            else if ( obj.attr.folded == '1' ) {
 
233
                gt.unfoldsubtree( gt, obj );
 
234
                gt.layoutgraph (gt);
 
235
#  Recentering on base node doesn't seem to work in every case...
 
236
#                gt.setviewcenter ([vt.vtid = vt;], obj.pos);
 
237
#                gt.redrawgraph (gt, [vt.vtid = vt;]);
 
238
            }
 
239
        }
 
240
        else
 
241
            echo('Not on a node');
 
242
    };
 
243
    "unfold subtree" = function (gt, vt, obj, data) {
 
244
        if ( obj.nid >= 0 ) {
 
245
            gt.unfoldsubtree( gt, obj );        
 
246
            gt.drawgraph (gt, [vt.vtid = vt;]);
 
247
        }
 
248
        else
 
249
            echo('Not on a node', obj.nid);
 
250
    };
 
251
    "set attr" = function (gt, vt, obj, data) {
 
252
        gt.setattr (gt, obj);
 
253
    };
 
254
    "print attr" = function (gt, vt, obj, data) {
 
255
        local attname;
 
256
        if (obj.nid >= 0) {
 
257
            attname = ask('What attribute?');
 
258
            echo (obj.attr[attname]);
 
259
        }
 
260
        dump (obj.attr);
 
261
    };
 
262
    "change label" = function (gt, vt, obj, data) {
 
263
        local newname;
 
264
        newname = ask('Enter new label name');
 
265
        if ( newname == 1 )
 
266
            return;
 
267
        if (newname == '' | newname == ' ')
 
268
            newname=0;
 
269
        if ( obj.nid >= 0 ) {
 
270
            gt.undrawnode (gt, gt.views, obj);
 
271
            obj.attr['label'] = newname;
 
272
            gt.unpacknodeattr (gt, obj);
 
273
            gt.drawnode (gt, gt.views, obj);
 
274
        }
 
275
        else if (obj.eid >= 0) {
 
276
            gt.undrawedge (gt, gt.views, obj);
 
277
            obj.attr['label'] = newname;
 
278
            gt.unpackedgeattr (gt, obj);
 
279
            gt.drawedge (gt, gt.views, obj);
 
280
        }
 
281
        gt.layoutgraph (gt);
 
282
    };
 
283
    "load subgraph" = function (gt, vt, obj, data) {
 
284
         local node, fname, pname, ngt, rtn, fd, graph;
 
285
 
 
286
         if ( obj.nid < 0) {
 
287
             echo('Invalid node');
 
288
             return;
 
289
         }
 
290
 
 
291
         gt.unfoldall (gt);
 
292
         gt.savegraph (gt, gt.name, gt.type, 1);
 
293
 
 
294
         pname = gt.name;
 
295
         fname = concat (obj.name, '.dot');
 
296
         ngt = dotty.protogt.creategraph (null);
 
297
         ngt.graphattr.parent = pname;
 
298
 
 
299
         if (~((fd = dotty.openio (fname, 'file', 'r')) >= 0)) {
 
300
             gt.erasegraph (gt, null, null);
 
301
             ngt.createview (ngt, null);
 
302
             gt.destroyview (gt, vt);
 
303
             ngt.redrawgraph (ngt, ngt.views);
 
304
             ngt.insertnode (ngt, ['x' = 30; 'y' = 0;], null, obj.name, null, 1);
 
305
             ngt.savegraph (ngt, fname, 'file', 1);
 
306
         }
 
307
         else 
 
308
             gt.loadgraph (gt, fname, 'file', ngt, 1);
 
309
     };
 
310
];
 
311
dotty.protogt.actions.edge = dotty.protogt.actions.node;
 
312
dotty.protovt.normal.menus = [
 
313
    'general' = [
 
314
        0 = "undo";
 
315
        1 = "paste";
 
316
        2 = "do layout";
 
317
        3 = "cancel layout";
 
318
        4 = "redraw";
 
319
        5 = "new graph";
 
320
        6 = "load graph";
 
321
        7 = "reload graph";
 
322
        8 = "load parent";
 
323
        9 = "save graph";
 
324
        10 = "save graph as";
 
325
        11 = "open view";
 
326
        12 = "copy view";
 
327
        13 = "clone view";
 
328
        14 = "birdseye view";
 
329
        15 = "close view";
 
330
        16 = "set graph attr";
 
331
        17 = "set node attr";
 
332
        18 = "set edge attr";
 
333
        19 = "zoom in";
 
334
        20 = "zoom out";
 
335
        21 = "find node";
 
336
        22 = "print graph";
 
337
        23 = "text view";
 
338
        24 = "quit";
 
339
    ];
 
340
    'node' = [
 
341
        0 = "cut";
 
342
        1 = "Cut";
 
343
        2 = "copy";
 
344
        3 = "Copy";
 
345
        4 = "group";
 
346
        5 = "Group";
 
347
        6 = "delete";
 
348
        7 = "Delete";
 
349
        8 = "remove";
 
350
        9 = "Remove";
 
351
        10 = "set attr";
 
352
        11 = "print attr";
 
353
        12 = "change label";
 
354
        13 = "load subgraph";
 
355
    ];
 
356
    'edge' = [
 
357
        0 = "cut";
 
358
        1 = "Cut";
 
359
        2 = "copy";
 
360
        3 = "Copy";
 
361
        4 = "delete";
 
362
        5 = "Delete";
 
363
        6 = "set attr";
 
364
        7 = "print attr";
 
365
        8 = "change label";
 
366
    ];
 
367
];
 
368
dotty.protovt.normal.keys = [
 
369
    'general' = [
 
370
        'u' = "undo";
 
371
        'p' = "paste";
 
372
        'l' = "do layout";
 
373
        'k' = "cancel layout";
 
374
        ' ' = "redraw";
 
375
        'R' = "reload graph";
 
376
        'L' = "load graph";
 
377
        '+' = "load parent";
 
378
        's' = "save graph";
 
379
        'Z' = "zoom in";
 
380
        'z' = "zoom out";
 
381
        '.' = "zoom in slowly";
 
382
        ',' = "zoom out slowly";
 
383
        '       ' = "move interactively";
 
384
        'n' = "add node";
 
385
        'Q' = "quit";
 
386
    ];
 
387
    'node' = [
 
388
        'c' = "copy";
 
389
        'C' = "Copy";
 
390
        'g' = "group";
 
391
        'G' = "Group";
 
392
        'd' = "delete";
 
393
        'D' = "Delete";
 
394
        'r' = "remove";
 
395
        'R' = "Remove";
 
396
        'f' = "fold/unfold subtree";
 
397
        'a' = "set attr";
 
398
        '/'  = "change label";
 
399
        '-' = "load subgraph";
 
400
    ];
 
401
    'edge' = [
 
402
        'c' = "copy";
 
403
        'C' = "Copy";
 
404
        'd' = "delete";
 
405
        'D' = "Delete";
 
406
        'a' = "set attr";
 
407
        '/'  = "change label";
 
408
    ];
 
409
];
 
410
dotty.protovt.birdseye.menus = dotty.protovt.normal.menus;
 
411
dotty.protovt.birdseye.keys = dotty.protovt.normal.keys;
 
412
dotty.protovt.normal.uifuncs = [
 
413
    'leftdown' = function (data) {
 
414
        local gt;
 
415
 
 
416
        gt = dotty.graphs[vt.gtid];
 
417
        vt = dotty.views[data.widget];
 
418
        if (dotty.node2move) {
 
419
# &        (dotty.rp2.x ~= data.pos.x | dotty.rp2.y ~= data.pos.y)) {
 
420
            gt.movenode (gt, dotty.node2move, data.pos);
 
421
            gt.redrawgraph (gt, [vt.vtid = vt;]);
 
422
#            gt.redrawgraph (gt, gt.views);
 
423
            dotty.rp2 = data.pos;
 
424
        }
 
425
        else if (data.obj.nid >= 0) {
 
426
            dotty.node2move = data.obj;
 
427
            dotty.movewidget = data.widget;
 
428
            dotty.rp2 = data.pos;
 
429
        }
 
430
    };
 
431
    'leftmove' = function (data) {
 
432
        local vt,gt;
 
433
 
 
434
        gt = dotty.graphs[vt.gtid];
 
435
        vt = dotty.views[data.widget];
 
436
        dotty.node2move = data.obj;
 
437
        dotty.movewidget = data.widget;
 
438
        dotty.rp2 = data.pos;
 
439
 
 
440
        if (dotty.node2move ) {
 
441
# &      (dotty.rp2.x ~= data.pos.x | dotty.rp2.y ~= data.pos.y)) {
 
442
            gt.movenode (gt, dotty.node2move, dotty.rp2);
 
443
            gt.setviewscale ([vt.vtid = vt;], 1);
 
444
            gt.redrawgraph (gt, [vt.vtid = vt;]);
 
445
#            gt.redrawgraph (gt, gt.views);
 
446
            dotty.rp2 = data.pos;
 
447
        }
 
448
    };
 
449
    'leftup' = function (data) {
 
450
        local gt;
 
451
 
 
452
        gt = dotty.graphs[dotty.views[data.widget].gtid];
 
453
        if (dotty.node2move) {
 
454
            if (dotty.movewidget == data.widget)
 
455
                gt.movenode (gt, dotty.node2move, data.pos);
 
456
            dotty.node2move = 0;
 
457
        }
 
458
# Use 'n' key to create new node
 
459
# else if (~data.obj)
 
460
#            gt.insertnode (gt, data.pos, null, null, null, 1);
 
461
    };
 
462
    'middledown' = function (data) {
 
463
        if (~(data.obj.nid >= 0))
 
464
            return;
 
465
        dotty.rubberband = 1;
 
466
        dotty.movewidget = data.widget;
 
467
        setgfxattr (data.widget, ['mode' = 'xor';]);
 
468
#        setgfxattr (data.widget, ['mode' = 'src';]);
 
469
        dotty.rp1 = data.pos;
 
470
        dotty.rp2 = data.pos;
 
471
        line (data.widget, null, dotty.rp1, dotty.rp2, ['color' = 1;]);
 
472
    };
 
473
    'middlemove' = function (data) {
 
474
        if (dotty.rubberband ~= 1 |
 
475
                (dotty.rp2.x == data.pos.x & dotty.rp2.y == data.pos.y))
 
476
            return;
 
477
        line (data.widget, null, dotty.rp1, dotty.rp2, ['color' = 1;]);
 
478
        dotty.rp2 = data.pos;
 
479
        line (data.widget, null, dotty.rp1, dotty.rp2, ['color' = 1;]);
 
480
    };
 
481
    'middleup' = function (data) {
 
482
        local gt;
 
483
 
 
484
        gt = dotty.graphs[dotty.views[data.widget].gtid];
 
485
        if (dotty.rubberband ~= 1)
 
486
            return;
 
487
        dotty.rubberband = 0;
 
488
        line (dotty.movewidget, null, dotty.rp1, dotty.rp2, ['color' = 1;]);
 
489
        setgfxattr (dotty.movewidget, ['mode' = 'src';]);
 
490
        if (dotty.movewidget ~= data.widget |
 
491
                ~(data.pobj.nid >= 0) | ~(data.obj.nid >= 0))
 
492
            return;
 
493
        if (data.pobj.attr.support)
 
494
            gt.groupnodes (gt, [
 
495
                data.obj.nid = data.obj;
 
496
                data.pobj.nid = data.pobj;
 
497
            ], data.obj, null, null, null, 1, 1);
 
498
        else if (data.obj.attr.support)
 
499
            gt.groupnodes (gt, [
 
500
                data.obj.nid = data.obj;
 
501
                data.pobj.nid = data.pobj;
 
502
            ], data.pobj, null, null, null, 1, 1);
 
503
        else
 
504
            gt.insertedge (gt, data.pobj, null, data.obj, null, null, 1);
 
505
    };
 
506
    'rightdown' = function (data) {
 
507
        local vt, gt, menu, i;
 
508
 
 
509
        vt = dotty.views[data.widget];
 
510
        gt = dotty.graphs[vt.gtid];
 
511
        if (~data.obj)
 
512
            menu = vt.menus.general;
 
513
        else if (data.obj.nid >= 0)
 
514
            menu = vt.menus.node;
 
515
        else if (data.obj.eid >= 0)
 
516
            menu = vt.menus.edge;
 
517
        if ((i = displaymenu (data.widget, menu)) >= 0)
 
518
            gt.doaction (data, menu[i]);
 
519
    };
 
520
    'keyup' = function (data) {
 
521
        local vt, gt, action;
 
522
 
 
523
        vt = dotty.views[data.widget];
 
524
        gt = dotty.graphs[vt.gtid];
 
525
        if (data.obj.nid >= 0) {
 
526
            if (vt.keys.node[data.key])
 
527
                action = vt.keys.node[data.key];
 
528
        } else if (data.obj.eid >= 0) {
 
529
            if (vt.keys.edge[data.key])
 
530
                action = vt.keys.edge[data.key];
 
531
        }
 
532
        if (~action)
 
533
            if (vt.keys.general[data.key])
 
534
                action = vt.keys.general[data.key];
 
535
        if (action)
 
536
            gt.doaction (data, action);
 
537
    };
 
538
    'redraw' = function (data) {
 
539
        local vt, gt;
 
540
 
 
541
        vt = dotty.views[data.widget];
 
542
        gt = dotty.graphs[vt.gtid];
 
543
        gt.drawgraph (gt, [vt.vtid = vt;]);
 
544
    };
 
545
    'closeview' = function (data) {
 
546
        local vt, gt;
 
547
 
 
548
        vt = dotty.views[data.widget];
 
549
        gt = dotty.graphs[vt.gtid];
 
550
        gt.destroyview (gt, vt);
 
551
        if (tablesize (gt.views) == 0)
 
552
            gt.destroygraph (gt);
 
553
    };
 
554
];
 
555
dotty.protovt.birdseye.uifuncs = [
 
556
    'leftdown' = function (data) {
 
557
        local gt, vid;
 
558
 
 
559
        gt = dotty.graphs[dotty.views[data.widget].gtid];
 
560
        for (vid in gt.views) {
 
561
            vt = gt.views[vid];
 
562
            if (vt.type ~= 'birdseye')
 
563
                gt.setviewcenter ([vid = vt;], data.pos);
 
564
        }
 
565
    };
 
566
    'leftmove' = function (data) {
 
567
        local gt, vid;
 
568
 
 
569
        gt = dotty.graphs[dotty.views[data.widget].gtid];
 
570
        for (vid in gt.views) {
 
571
            vt = gt.views[vid];
 
572
            if (vt.type ~= 'birdseye')
 
573
                gt.setviewcenter ([vid = vt;], data.pos);
 
574
        }
 
575
    };
 
576
    'leftup' = function (data) {
 
577
        local gt, vid;
 
578
 
 
579
        gt = dotty.graphs[dotty.views[data.widget].gtid];
 
580
        for (vid in gt.views) {
 
581
            vt = gt.views[vid];
 
582
            if (vt.type ~= 'birdseye')
 
583
                gt.setviewcenter ([vid = vt;], data.pos);
 
584
        }
 
585
    };
 
586
    'middledown' = dotty.protovt.normal.uifuncs.middledown;
 
587
    'middlemove' = dotty.protovt.normal.uifuncs.middlemove;
 
588
    'middleup' = dotty.protovt.normal.uifuncs.middleup;
 
589
    'rightdown' = dotty.protovt.normal.uifuncs.rightdown;
 
590
    'keyup' = dotty.protovt.normal.uifuncs.keyup;
 
591
    'redraw' = dotty.protovt.normal.uifuncs.redraw;
 
592
    'closeview' = dotty.protovt.normal.uifuncs.closeview;
 
593
];
 
594
dotty.monitorfile = function (data) {
 
595
    local gtid, gt, lpt;
 
596
 
 
597
    for (gtid in dotty.layoutpending) {
 
598
        lpt = dotty.layoutpending[gtid];
 
599
        if (lpt.fd == data.fd) {
 
600
            gt = dotty.graphs[lpt.gtid];
 
601
            gt.haveinput = 1;
 
602
            gt.layoutgraph (gt);
 
603
            return 1;
 
604
        }
 
605
    }
 
606
    return 0;
 
607
};