← Back to branch summary

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

« back to all changes in this revision

Viewing changes to incr/batch.c

  • 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:
incr/batch.c
 
1
#include <engine.h>
 
2
 
 
3
#ifdef DMALLOC
 
4
#include "dmalloc.h"
 
5
#endif
 
6
 
 
7
/* 
 
8
 * maintain buffers of pending requests (in callback subgraphs)
 
9
 * note that certain sequences of operations can reduce:
 
10
 * ins mod => ins
 
11
 * [ins mod] del => (empty)
 
12
 */
 
13
 
 
14
ilbool il_batch_delete_node(ILview_t *view, ILnode_t *spec);
 
15
ilbool il_batch_delete_edge(ILview_t *view, ILedge_t *spec);
 
16
 
 
17
ilbool il_batch_insert_node(ILview_t *view, ILnode_t *spec)
 
18
{
 
19
        engview_t       *ev;
 
20
        Agnode_t        *n;
 
21
        ilbool          rv;
 
22
 
 
23
        ev = (engview_t*)(view->pvt);
 
24
        if (il_find_node(ev,spec) == NILnode) {
 
25
                n = il_open_node(ev,spec);
 
26
                agsubnode(ev->model.v[IL_INS],n,TRUE);
 
27
                rv = TRUE; 
 
28
        }
 
29
        else rv = FALSE; /* can't insert pre-existing nodes */
 
30
        return rv;
 
31
}
 
32
 
 
33
ilbool il_batch_modify_node(ILview_t *view, ILnode_t *spec)
 
34
{
 
35
        engview_t       *ev;
 
36
        Agnode_t        *n, *subnode;
 
37
        ilbool          rv;
 
38
 
 
39
        ev = (engview_t*)(view->pvt);
 
40
        if ((n = il_find_node(ev,spec))) {
 
41
                if ((agsubnode(ev->model.v[IL_INS],n,FALSE)) == NILnode) {
 
42
                        subnode = agsubnode(ev->model.v[IL_MOD],n,TRUE);
 
43
                        if (spec->update & IL_UPD_SHAPE)
 
44
                                il_nd(subnode)->bb.valid = FALSE;
 
45
                }
 
46
                /* else fold  ins mode -> mod */
 
47
                rv = TRUE;
 
48
        }
 
49
        else rv = FALSE; /* can't modify non-existent nodes */
 
50
        return rv;
 
51
}
 
52
 
 
53
ilbool il_batch_delete_node(ILview_t *view, ILnode_t *spec)
 
54
{
 
55
        engview_t       *ev;
 
56
        Agnode_t        *n, *subnode;
 
57
        Agedge_t        *e;
 
58
        ilbool          rv;
 
59
 
 
60
        ev = (engview_t*)(view->pvt);
 
61
        if ((n = il_find_node(ev,spec))) {
 
62
                /* implies deletion of adjacent edges */
 
63
                for (e = agfstedge(n); e; e = agnxtedge(e,n))
 
64
                        il_batch_delete_edge(view, il_edge(e));
 
65
 
 
66
                if ((subnode = agsubnode(ev->model.v[IL_INS],n,FALSE))) {
 
67
                        /* fold  ins [mod] del => (empty), i.e. cancel in buffer */
 
68
                        il_close_node(ev, spec);
 
69
                }
 
70
                else {
 
71
                        /* fold  mod del => del */
 
72
                        if ((subnode = agsubnode(ev->model.v[IL_MOD],n,FALSE)))
 
73
                                agdelnode(subnode);
 
74
                        /* else no mods are pending */
 
75
                        agsubnode(ev->model.v[IL_DEL],n,TRUE);
 
76
                }
 
77
                rv = TRUE;
 
78
        }
 
79
        else rv = FALSE; /*can't delete non-existent nodes */
 
80
        return rv;
 
81
}
 
82
 
 
83
/* edges are the same.  if we adoped a cleaner/more functional
 
84
 * coding style, we could just merge all this code.
 
85
 */
 
86
ilbool il_batch_insert_edge(ILview_t *view, ILedge_t *spec)
 
87
{
 
88
        engview_t       *ev;
 
89
        Agedge_t        *e;
 
90
        ilbool          rv;
 
91
 
 
92
        ev = (engview_t*)(view->pvt);
 
93
        if (il_find_edge(ev,spec) == NILedge) {
 
94
                e = il_open_edge(ev,spec);
 
95
                if (e) {
 
96
                        agsubedge(ev->model.e[IL_INS],e,TRUE);
 
97
                        assert(agnedges(ev->model.e[IL_INS]) > 0);
 
98
                        rv = TRUE;
 
99
                }
 
100
                else rv = FALSE;
 
101
        }
 
102
        else rv = FALSE; /* can't insert pre-existing edges */
 
103
        return rv;
 
104
}
 
105
 
 
106
ilbool il_batch_modify_edge(ILview_t *view, ILedge_t *spec)
 
107
{
 
108
        engview_t       *ev;
 
109
        Agedge_t        *e, *subedge;
 
110
        ilbool          rv;
 
111
 
 
112
        ev = (engview_t*)(view->pvt);
 
113
        if ((e = il_find_edge(ev,spec))) {
 
114
                if (agsubedge(ev->model.e[IL_INS],e,FALSE) == NILedge)
 
115
                        subedge = agsubedge(ev->model.e[IL_MOD],e,TRUE);
 
116
                /* else fold  ins mod => ins  */
 
117
                rv = TRUE;
 
118
        }
 
119
        else rv = FALSE; /* can't modify non-existent edges */
 
120
        return rv;
 
121
}
 
122
 
 
123
ilbool il_batch_delete_edge(ILview_t *view, ILedge_t *spec)
 
124
{
 
125
        engview_t       *ev;
 
126
        Agedge_t        *e, *subedge;
 
127
        ilbool          rv;
 
128
 
 
129
        ev = (engview_t*)(view->pvt);
 
130
        if ((e = il_find_edge(ev,spec))) {
 
131
                if ((subedge = agsubedge(ev->model.e[IL_INS],e,FALSE))) {
 
132
                        /* fold  ins [mod] del => (empty), i.e. cancel in buffer */
 
133
                        il_close_edge(ev, spec);
 
134
                }
 
135
                else {
 
136
                        /* fold  mod del => del */
 
137
                        if ((subedge = agsubedge(ev->model.e[IL_MOD],e,FALSE)))
 
138
                                agdeledge(subedge);
 
139
                        /* else no mods are pending */
 
140
                        agsubedge(ev->model.e[IL_DEL],e,TRUE);
 
141
                }
 
142
                rv = TRUE;
 
143
        }
 
144
        else rv = FALSE; /* can't delete non-existent edges */
 
145
        return rv;
 
146
}
 
147
 
 
148
static void cbcheck(ILview_t *view)
 
149
{
 
150
        if (view->enable_immediate_callbacks)
 
151
                ((engview_t*)(view->pvt))->engine->callback(view);
 
152
}
 
153
 
 
154
ilbool il_batch_ins(ILview_t *view, ILobj_t *spec)
 
155
{
 
156
        static ILfnlist_t f = {
 
157
                (ILnodefn_t)il_batch_insert_node,
 
158
                (ILedgefn_t)il_batch_insert_edge,
 
159
                NIL(ILhyperfn_t),
 
160
                NIL(ILviewfn_t)
 
161
        };
 
162
        ilbool  rv;
 
163
        rv = ildispatch(view,spec,&f);
 
164
        cbcheck(view);
 
165
        return rv;
 
166
}
 
167
 
 
168
ilbool il_batch_mod(ILview_t *view, ILobj_t *spec)
 
169
{
 
170
        static ILfnlist_t f = {
 
171
                (ILnodefn_t)il_batch_modify_node,
 
172
                (ILedgefn_t)il_batch_modify_edge,
 
173
                NIL(ILhyperfn_t),
 
174
                NIL(ILviewfn_t)
 
175
        };
 
176
        ilbool  rv;
 
177
        rv = ildispatch(view,spec,&f);
 
178
        cbcheck(view);
 
179
        return rv;
 
180
}
 
181
 
 
182
ilbool il_batch_del(ILview_t *view, ILobj_t *spec)
 
183
{
 
184
        static ILfnlist_t f = {
 
185
                (ILnodefn_t)il_batch_delete_node,
 
186
                (ILedgefn_t)il_batch_delete_edge,
 
187
                NIL(ILhyperfn_t),
 
188
                NIL(ILviewfn_t)
 
189
        };
 
190
        ilbool  rv;
 
191
        rv = ildispatch(view,spec,&f);
 
192
        cbcheck(view);
 
193
        return rv;
 
194
}