← Back to branch summary

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

« back to all changes in this revision

Viewing changes to incr/model.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/model.c
 
1
#include <stdio.h>
 
2
#include <engine.h>
 
3
 
 
4
#ifdef DMALLOC
 
5
#include "dmalloc.h"
 
6
#endif
 
7
 
 
8
/* bind model nodes  and client IDs/descriptors */
 
9
 
 
10
char ILrec_name[] = "ILrec";
 
11
 
 
12
/* for mapping unsigned long IDs to model edges */
 
13
typedef struct {
 
14
        Dtdisc_t        base;
 
15
        engview_t       *view;
 
16
} edgemapdisc_t;
 
17
 
 
18
void ilfreemapsym(Dict_t *dict, void *obj, Dtdisc_t *argdisc)
 
19
{
 
20
        edgemapdisc_t   *disc;
 
21
 
 
22
        disc = (edgemapdisc_t*)argdisc;
 
23
        agfree(disc->view->model.main,obj);
 
24
}
 
25
 
 
26
void *ilmakeobjfn(Dict_t *dict, void *obj, Dtdisc_t *argdisc)
 
27
{
 
28
        return obj;
 
29
}
 
30
 
 
31
Dtdisc_t IL_dict_id_disc = {
 
32
    offsetof(Agedge_t,base.tag.id),     /* use id as key */
 
33
    sizeof(unsigned long),                              /* key size */
 
34
        -1,                                                     /* use holder objects */
 
35
    NIL(Dtmake_f),
 
36
    NIL(Dtfree_f),                              /*ilfreemapsym,*/
 
37
        NIL(Dtcompar_f),
 
38
    NIL(Dthash_f),
 
39
        NIL(Dtmemory_f),
 
40
        NIL(Dtevent_f)
 
41
};
 
42
 
 
43
/* trivial ID discipline */
 
44
static void     *idopen(Agraph_t *g) {return NIL(void*);}
 
45
static long idmap(void *state, int objtype, char *str, unsigned long *id, int createflag) {*id = (unsigned long)str; return TRUE;}
 
46
static long idalloc(void *state, int objtype, unsigned long id) {return TRUE;}
 
47
static void idfree(void *state, int objtype, unsigned long id){}
 
48
static char *idprint(void *state, int objtype, unsigned long id){return NILstr;}
 
49
static void     idclose(void *state) {}
 
50
static Agiddisc_t iddisc = { idopen,
 
51
idmap,
 
52
idalloc,
 
53
idfree,
 
54
idprint,
 
55
idclose};
 
56
 
 
57
Agdisc_t IL_graph_id_disc = {0, &iddisc, 0};
 
58
 
 
59
engview_t *il_open_view(ILengine_t *engine, ILview_t *client, Agdesc_t desc, unsigned int *recsize)
 
60
{
 
61
        engview_t                *rv;
 
62
        edgemapdisc_t   *disc;
 
63
        Agraph_t                *model;
 
64
        int                             i;
 
65
        unsigned long                   id = 1;
 
66
 
 
67
        model = agopen(NILstr, desc, &IL_graph_id_disc);
 
68
        rv = agalloc(model,recsize[IL_RECSIZE_VIEW]);
 
69
 
 
70
        rv->client = client;
 
71
        rv->engine = engine;
 
72
        for (i = 0; i < IL_RECSIZE_N; i++)
 
73
                rv->recsize[i] = recsize[i];
 
74
 
 
75
        rv->model.main = model;
 
76
        for (i = 0; i < IL_N_OPS; i++) {
 
77
                rv->model.v[i] = agidsubg(rv->model.main,id++,TRUE);
 
78
                rv->model.e[i] = agidsubg(rv->model.main,id++,TRUE);
 
79
        }
 
80
 
 
81
        disc = agalloc(model,sizeof(*disc));
 
82
        disc->base = IL_dict_id_disc;
 
83
        disc->view = rv;
 
84
        rv->model.e_dict = dtopen((Dtdisc_t*)disc,Dttree);
 
85
        client->pvt = rv;
 
86
        return rv;
 
87
}
 
88
 
 
89
void il_close_view(engview_t *view)
 
90
{
 
91
        Agraph_t        *G;
 
92
        Agnode_t        *n, *nn;
 
93
        Agedge_t        *e, *ne;
 
94
        Dtdisc_t        *edgemapdisc;
 
95
        ILedge_t        *espec;
 
96
        ILnode_t        *nspec;
 
97
 
 
98
        G = view->model.main;
 
99
 
 
100
        for (n = agfstnode(G); n; n = nn) {
 
101
                for (e = agfstout(n); e; e = ne) {
 
102
                        ne = agnxtout(e);
 
103
                        espec = il_edge(e);
 
104
                        /* this is done in clear_callbacks */
 
105
                        /* il_close_edge(view, espec); */
 
106
                        il_register_edge_callback(view, espec, IL_DEL);
 
107
                }
 
108
                nn = agnxtnode(n);
 
109
                nspec = il_node(n);
 
110
                il_register_node_callback(view, nspec, IL_DEL);
 
111
                /* il_close_node(view, il_node(n)); */
 
112
        }
 
113
        (void) il_issue_callbacks(view);
 
114
 
 
115
        view->client->pvt = NIL(void*);
 
116
        edgemapdisc = dtdisc(view->model.e_dict,NIL(Dtdisc_t*),0);
 
117
        dtclose(view->model.e_dict);
 
118
        agfree(G,edgemapdisc);
 
119
        agfree(G,view);
 
120
        agclose(G);
 
121
}
 
122
 
 
123
/* model nodes */
 
124
Agnode_t *il_open_node(engview_t *view, ILnode_t *client)
 
125
{
 
126
        Agraph_t        *model;
 
127
        Agnode_t        *n;
 
128
        engnode_t       *desc;
 
129
 
 
130
        model = view->model.main;
 
131
        n = agidnode(model,(unsigned long)client,TRUE);
 
132
        desc = (engnode_t *)agbindrec(n,ILrec_name,view->recsize[IL_RECSIZE_NODE],TRUE); 
 
133
        desc->client = client;
 
134
        return n;
 
135
}
 
136
 
 
137
Agnode_t *il_find_node(engview_t *view, ILnode_t *node)
 
138
{
 
139
        return agidnode(view->model.main,(unsigned long)node,FALSE);
 
140
}
 
141
 
 
142
void il_close_node(engview_t *view, ILnode_t *node)
 
143
{
 
144
        Agnode_t        *n;
 
145
 
 
146
        if ((n = il_find_node(view,node)))
 
147
                agdelete(view->model.main,n);
 
148
}
 
149
 
 
150
/* model edges */
 
151
Agedge_t *il_open_edge(engview_t *view, ILedge_t *client)
 
152
{
 
153
        Agraph_t        *model;
 
154
        Agnode_t        *u, *v;
 
155
        Agedge_t        *e;
 
156
        engedge_t       *desc;
 
157
 
 
158
        model = view->model.main;
 
159
        u = il_find_node(view,(ILnode_t*)(client->tail.term));
 
160
        v = il_find_node(view,(ILnode_t*)(client->head.term));
 
161
        if (u && v && ((e = agidedge(u,v,(unsigned long)client,TRUE)))) {
 
162
                assert (AGID(e) == (unsigned long)client);
 
163
                desc = (engedge_t *)agbindrec(e,ILrec_name,view->recsize[IL_RECSIZE_EDGE],TRUE); 
 
164
                desc->client = client;  /* shallow copy OK for most */
 
165
                dtinsert(view->model.e_dict,e);
 
166
#if 0 /* suspected of memory leak */
 
167
                        /* OLD DEBUG CODE TO REMOVE SOMEDAY */
 
168
                        { Agedge_t *f;
 
169
                        ILedge_t        *probe;
 
170
                        probe = 0;
 
171
                        il_find_edge(view,probe);
 
172
                        probe = (ILedge_t*) (~(unsigned long)0);
 
173
                        il_find_edge(view,probe);
 
174
                        probe = client;
 
175
                        f = il_find_edge(view,probe);
 
176
                        assert (e == f);
 
177
                        }
 
178
#endif
 
179
        }
 
180
        else e = NILedge;
 
181
        return e;
 
182
}
 
183
 
 
184
Agedge_t *il_find_edge(engview_t *view, ILedge_t *edge)
 
185
{
 
186
        static Agedge_t template;       /* static to avoid purify warnings */
 
187
 
 
188
        template.base.tag.id = (unsigned long) edge;
 
189
        return (Agedge_t*)dtsearch(view->model.e_dict,&template);
 
190
}
 
191
 
 
192
void il_close_edge(engview_t *view, ILedge_t *edge)
 
193
{
 
194
        Agedge_t        *e;
 
195
 
 
196
        if ((e = il_find_edge(view, edge))) {
 
197
                /* do not call il_freeshape on edge->pos because 
 
198
                 * it is the client's responsibility */
 
199
                /*
 
200
                il_freeshape(agheap(view->model.main),edge->pos);
 
201
                edge->pos = NIL(ilshape_t*);
 
202
                */
 
203
                dtdelete(view->model.e_dict,e);
 
204
                agdelete(view->model.main,e);
 
205
                assert(il_find_edge(view,edge) == NILedge);
 
206
        }
 
207
}
 
208
 
 
209
ILnode_t *ilnextnode(ILview_t *view, ILnode_t *spec)
 
210
{
 
211
        Agnode_t        *model_n;
 
212
        ILnode_t        *rv;
 
213
 
 
214
        if (spec) {
 
215
                model_n = il_find_node(view->pvt,spec);
 
216
                if (model_n) model_n = agnxtnode(model_n);
 
217
        }
 
218
        else model_n = agfstnode(ilmodel(view));
 
219
        if (model_n) rv = (ILnode_t*)ilmdlobj_to_spec(view,(Agobj_t*)model_n);
 
220
        else rv = NIL(ILnode_t*);
 
221
        return rv;
 
222
}
 
223
 
 
224
ILedge_t *ilnextedge(ILview_t *view, ILnode_t *endpoint, ILedge_t *spec)
 
225
{
 
226
        Agnode_t        *model_n;
 
227
        Agedge_t        *model_e;
 
228
        ILedge_t        *rv;
 
229
 
 
230
        model_n = il_find_node(view->pvt,endpoint);
 
231
        if (model_n == NILnode) rv = NIL(ILedge_t*);
 
232
        else {
 
233
                if (spec) {
 
234
                        model_e = il_find_edge(view->pvt,spec);
 
235
                        if (model_e) model_e = agnxtedge(model_e, model_n);
 
236
                }
 
237
                else model_e = agfstedge(model_n);
 
238
                if (model_e) rv = (ILedge_t*)ilmdlobj_to_spec(view,(Agobj_t*)model_e);
 
239
                else rv = NIL(ILedge_t*);
 
240
        }
 
241
        return rv;
 
242
}