← Back to branch summary

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

« back to all changes in this revision

Viewing changes to dag/base.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:
dag/base.c
 
1
#include <dag.h>
 
2
 
 
3
#ifdef DMALLOC
 
4
#include "dmalloc.h"
 
5
#endif
 
6
 
 
7
/* data access - avoid direct access */
 
8
 
 
9
ddnode_t *dd_node(Agnode_t *n)
 
10
{
 
11
        return (ddnode_t*)(AGDATA(n));
 
12
}
 
13
 
 
14
ddedge_t *dd_edge(Agedge_t *e)
 
15
{
 
16
        return (ddedge_t*)(AGDATA(e));
 
17
}
 
18
 
 
19
ILnode_t *dd_nspec(Agnode_t *n) {
 
20
        return il_node(dd_node(n)->model);
 
21
}
 
22
 
 
23
ILnode_t *ddm_nspec(Agnode_t *mn)
 
24
{
 
25
        return ((ddmdlnode_t*)(AGDATA(mn)))->base.client;
 
26
}
 
27
 
 
28
ILedge_t *ddm_espec(Agedge_t *me)
 
29
{
 
30
        return ((ddmdledge_t*)(AGDATA(me)))->base.client;
 
31
}
 
32
 
 
33
ILedge_t *dd_espec(Agedge_t *e)
 
34
{
 
35
        return il_edge(dd_edge(e)->path->model);
 
36
}
 
37
 
 
38
ILedge_t *dd_pathspec(ddpath_t *path)
 
39
{
 
40
        return path->base.client;
 
41
}
 
42
 
 
43
Agnode_t *dd_rep(Agnode_t *mn)
 
44
{
 
45
        return ((ddmdlnode_t*)(AGDATA(mn)))->rep;
 
46
}
 
47
 
 
48
ddpath_t *dd_pathrep(Agedge_t *me)
 
49
{
 
50
        return (ddpath_t*)(AGDATA(me));
 
51
}
 
52
 
 
53
int dd_rank(Agnode_t *n)
 
54
{
 
55
        return dd_node(n)->rank;
 
56
}
 
57
 
 
58
int dd_order(Agnode_t *n)
 
59
{
 
60
        return dd_node(n)->order;
 
61
}
 
62
 
 
63
int dd_newrank(Agnode_t *n)
 
64
{
 
65
        return dd_node(n)->newrank;
 
66
}
 
67
 
 
68
int dd_oldrank(Agnode_t *n)
 
69
{
 
70
        return dd_node(n)->oldrank;
 
71
}
 
72
 
 
73
void dd_set_oldrank(Agnode_t *n)
 
74
{
 
75
        dd_node(n)->oldrank = dd_node(n)->rank;
 
76
}
 
77
 
 
78
void dd_set_newrank(Agnode_t *n, int r) 
 
79
{
 
80
        dd_node(n)->newrank = r;
 
81
}
 
82
 
 
83
void dd_fix_coord(Agnode_t *n, ilbool val)
 
84
{
 
85
        dd_node(n)->coord_fixed = val;
 
86
}
 
87
 
 
88
ilbool dd_coord_fixed(Agnode_t *n)
 
89
{
 
90
        return dd_node(n)->coord_fixed;
 
91
}
 
92
 
 
93
void dd_fix_order(Agnode_t *n, ilbool val)
 
94
{
 
95
        dd_node(n)->order_fixed = val;
 
96
}
 
97
 
 
98
ilbool dd_order_fixed(Agnode_t *n)
 
99
{
 
100
        return dd_node(n)->order_fixed;
 
101
}
 
102
 
 
103
void dd_set_old_coord(Agnode_t *n)
 
104
{
 
105
        ddnode_t        *spec;
 
106
 
 
107
        spec = dd_node(n);
 
108
        spec->prev = spec->cur;
 
109
}
 
110
 
 
111
void dd_set_ycoord(ddview_t *view, Agnode_t *n)
 
112
{
 
113
        double  y;
 
114
 
 
115
        y = dd_rankd(view,dd_rank(n))->y_base;
 
116
        dd_set_y(n,y);
 
117
}
 
118
 
 
119
double dd_ranksep(ddview_t *view)
 
120
{
 
121
        return il_nodesep(BASE(view)).y;
 
122
}
 
123
 
 
124
double dd_minlen(Agedge_t *e)
 
125
{
 
126
        return 1;
 
127
        return dd_espec(e)->length_hint;
 
128
}
 
129
 
 
130
double dd_efactor(Agedge_t *e)
 
131
{
 
132
        return dd_espec(e)->cost;
 
133
}
 
134
 
 
135
unsigned char dd_dfsmark(Agnode_t *n)
 
136
{
 
137
        return dd_node(n)->dfsmark;
 
138
}
 
139
 
 
140
void dd_set_dfsmark(Agnode_t *n, unsigned char val)
 
141
{
 
142
        dd_node(n)->dfsmark = val;
 
143
}
 
144
 
 
145
double dd_uv_sep(ddview_t *view, Agnode_t *left, Agnode_t *right)
 
146
{
 
147
        double   s0,s1,rv;
 
148
        s0 = dd_nodesize(view,left).x;
 
149
        s1 = dd_nodesize(view,right).x;
 
150
        rv = (s0 + s1) / 2.0 + dd_nodesep(view).x;
 
151
        return rv;
 
152
}
 
153
 
 
154
ddpath_t *dd_path(Agedge_t *e) { return (ddpath_t*)AGDATA(dd_edge(e)->path->model); }
 
155
Agnode_t *dd_pathhead(Agedge_t *e) { return aghead(dd_path(e)->last); }
 
156
Agnode_t *dd_pathtail(Agedge_t *e) { return agtail(dd_path(e)->first); }
 
157
Agedge_t *dd_first_elt(Agedge_t *e) { return dd_path(e)->first; }
 
158
Agedge_t *dd_last_elt(Agedge_t *e) { return dd_path(e)->last; }
 
159
 
 
160
void dd_set_first(ddpath_t *p, Agedge_t *first) {
 
161
        p->first = first;
 
162
}
 
163
void dd_set_last(ddpath_t *p, Agedge_t *last) {
 
164
        p->last = last;
 
165
}
 
166
void dd_set_firstlast(ddpath_t *p, Agedge_t *first, Agedge_t *last) {
 
167
        p->first = first; p->last = last;
 
168
}
 
169
 
 
170
 
 
171
ilcoord_t dd_pos(Agnode_t *n) { return dd_node(n)->cur.pos; }
 
172
 
 
173
int dd_is_a_vnode(Agnode_t *n)
 
174
{
 
175
        return (dd_node(n)->model == NILnode);
 
176
}
 
177
 
 
178
ilcoord_t dd_nodesize(ddview_t *view, Agnode_t *node)
 
179
{
 
180
        ilcoord_t       rv;
 
181
 
 
182
        if (node == NILnode) rv.x = rv.y = 0;
 
183
        else if (dd_is_a_vnode(node)) { /* is a virtual node */
 
184
                rv.y = EPSILON;
 
185
                rv.x = 2.0 * il_nodesep(BASE(view)).x;
 
186
        }
 
187
        else {
 
188
                rv = il_nodesize(BASE(view),dd_node(node)->model);
 
189
                if (rv.x <= 0) rv.x = EPSILON;
 
190
                if (rv.y <= 0) rv.y = EPSILON;
 
191
        }
 
192
        return rv;
 
193
}
 
194
 
 
195
void dd_set_x(Agnode_t *n, double x)
 
196
{
 
197
        ddnode_t        *nd;
 
198
        ILnode_t        *spec;
 
199
 
 
200
        nd = dd_node(n);
 
201
        nd->cur.pos.x = x;
 
202
        nd->cur.valid = TRUE;   /* see below, sort of a cheat */
 
203
        if (nd->model) {
 
204
                spec = il_node(nd->model);
 
205
                spec->pos.x = x;
 
206
                spec->pos_valid = TRUE;
 
207
        }
 
208
}
 
209
 
 
210
void dd_set_y(Agnode_t *n, double y)
 
211
{
 
212
        ddnode_t        *nd;
 
213
        ILnode_t        *spec;
 
214
 
 
215
        nd = dd_node(n);
 
216
        nd->cur.pos.y = y;
 
217
        nd->cur.valid = TRUE;   /* see above, still sort of a cheat */
 
218
        if (nd->model) {
 
219
                spec = il_node(nd->model);
 
220
                spec->pos.y = y;
 
221
                spec->pos_valid = TRUE;
 
222
        }
 
223
}
 
224
 
 
225
static char DDrecname[] = "_dag";
 
226
 
 
227
Agedge_t *dd_open_edge(ddview_t *view, Agnode_t *u, Agnode_t *v, ddpath_t *path)
 
228
{
 
229
        Agedge_t        *rv;
 
230
        ddedge_t        *ed;
 
231
 
 
232
        rv = agidedge(u,v,AGID(path->model),TRUE);
 
233
        ed = agbindrec(rv,DDrecname,sizeof(ddedge_t),TRUE);
 
234
        ed->path = path;
 
235
        return rv;
 
236
}
 
237
 
 
238
void dd_close_edge(ddview_t *view, Agedge_t *e)
 
239
{
 
240
        ddedge_t        *ed;
 
241
 
 
242
        ed = dd_edge(e);
 
243
        if (ed->cn) agdelete(view->con[XCON].g,ed->cn);
 
244
        agdelete(view->layout,e);
 
245
}
 
246
 
 
247
Agnode_t *dd_open_node(ddview_t *view, Agnode_t *model_n)
 
248
{
 
249
        Agnode_t        *n;
 
250
        ddnode_t        *nd;
 
251
        unsigned long   id;
 
252
        static unsigned long    anon_id = 1;
 
253
 
 
254
        if (model_n) id = (unsigned long)(model_n->base.tag.id);
 
255
        else {id = anon_id; anon_id += 2;}
 
256
 
 
257
        n = agidnode(view->layout,id,TRUE);
 
258
        nd = agbindrec(n,DDrecname,sizeof(ddnode_t),TRUE);
 
259
        if (model_n) {
 
260
                nd->model = agsubnode(BASE(view)->model.main,model_n,FALSE);
 
261
                ((ddmdlnode_t*)(AGDATA(model_n)))->rep = n;
 
262
        }
 
263
        return n;
 
264
}
 
265
 
 
266
Agnode_t *dd_find_node(ddview_t *view, ILnode_t *spec)
 
267
{
 
268
        return agidnode(view->layout,(unsigned long)spec,FALSE);
 
269
}
 
270
 
 
271
void dd_close_node(ddview_t *view, Agnode_t *n)
 
272
{
 
273
        /* must already be isolated in graph */
 
274
        assert(agfstedge(n) == NIL(Agedge_t*));
 
275
        if (dd_node_in_config(n))
 
276
                dd_rank_delete(view,n);
 
277
        agdelete(view->layout,n);
 
278
}
 
279
 
 
280
ddpath_t *dd_open_path(ddview_t *view, ILedge_t *spec)
 
281
{
 
282
        Agedge_t        *model_edge;
 
283
        ddpath_t        *path;
 
284
 
 
285
        model_edge = il_find_edge(BASE(view),spec);
 
286
        assert(il_find_edge(BASE(view),spec));
 
287
        path = (ddpath_t*)AGDATA(model_edge);
 
288
        path->model = model_edge;
 
289
        return path;
 
290
}
 
291
 
 
292
ddpath_t *dd_find_path(ddview_t *view, ILedge_t *spec)
 
293
{
 
294
        Agedge_t        *model_e;
 
295
 
 
296
        model_e = il_find_edge(BASE(view), spec);
 
297
        if (model_e) return (ddpath_t*)AGDATA(model_e);
 
298
        else return NIL(ddpath_t*);
 
299
}
 
300
 
 
301
void dd_close_path(ddview_t *view, ddpath_t *path)
 
302
{
 
303
        Agnode_t        *vn,*nv;
 
304
        Agedge_t        *ve;
 
305
 
 
306
        if (path->first) {
 
307
                if (path->first == path->last) {
 
308
                        dd_invalidate_mval(dd_pathtail(path->first),DOWN);
 
309
                        dd_invalidate_mval(dd_pathhead(path->last),UP);
 
310
                        dd_close_edge(view, path->first);
 
311
                }
 
312
                else for (vn = path->first->node; dd_is_a_vnode(vn); vn = nv) {
 
313
                        nv = agfstout(vn)->node;
 
314
                        for (ve = agfstedge(vn); ve; ve = agnxtedge(ve,vn))
 
315
                                dd_close_edge(view, ve);
 
316
                        dd_close_node(view, vn);
 
317
                }
 
318
        } 
 
319
        else { } /* no work for flat or self edge */
 
320
        if (path->unclipped_path)
 
321
                il_freecurve(vmregion(path->unclipped_path), path->unclipped_path);
 
322
        path->unclipped_path = NIL(ilcurve_t*);
 
323
        path->first = path->last = NILedge;
 
324
        /* note, do not close model edge until callback is cleared ! */
 
325
}
 
326
 
 
327
ilcoord_t dd_nodesep(ddview_t *view) {return il_nodesep((engview_t*)view);}
 
328
 
 
329
ilbool dd_constraint(Agedge_t *e)
 
330
{
 
331
        return dd_espec(e)->constraint;
 
332
}