]> git.saurik.com Git - bison.git/blame_incremental - src/vcg.h
(nonterminals_reduce): Use warn_at rather than rolling our own.
[bison.git] / src / vcg.h
... / ...
CommitLineData
1/* VCG description handler for Bison.
2 Copyright 2001 Free Software Foundation, Inc.
3
4 This file is part of Bison, the GNU Compiler Compiler.
5
6 Bison is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 Bison is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with Bison; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
20
21#ifndef VCG_H_
22# define VCG_H_
23
24/* VCG color map. The 32 prime predefined colors. */
25enum color_e
26{
27 white = 0,
28 blue,
29 red,
30 green = 3,
31 yellow,
32 magenta,
33 cyan = 6,
34 darkgrey,
35 darkblue,
36 darkred = 9,
37 darkgreen,
38 darkyellow,
39 darkmagenta = 12,
40 darkcyan,
41 gold,
42 lightgrey = 15,
43 lightblue,
44 lightred,
45 lightgreen = 18,
46 lightyellow,
47 lightmagenta,
48 lightcyan = 21,
49 lilac,
50 turquoise,
51 aquamarine = 24,
52 khaki,
53 purple,
54 yellowgreen = 27,
55 pink,
56 orange,
57 orchid,
58 black = 31
59};
60
61/* VCG textmode. Specify the adjustement of the text within the border of a summary node. */
62enum textmode_e
63{
64 centered,
65 left_justify,
66 right_justify
67};
68
69/* VCG shapes. Used for nodes shapes. */
70enum shape_e
71{
72 box,
73 rhomb,
74 ellipse,
75 triangle
76};
77
78/* Structure for colorentries. */
79struct colorentry_s
80{
81 int color_index;
82 int red_cp;
83 int green_cp;
84 int blue_cp;
85 struct colorentry_s *next;
86};
87
88/* Structure to construct lists of classnames. */
89struct classname_s
90{
91 int no; /* Class number */
92 const char *name; /* Name associated to the class no. */
93 struct classname_s *next; /* next name class association. */
94};
95
96/* Structure is in infoname. */
97struct infoname_s
98{
99 int integer;
100 const char *string;
101 struct infoname_s *next;
102};
103
104/* Layout Algorithms which can be found in VCG.
105 Details about each algoithm can be found below. */
106enum layoutalgorithm_e
107{
108 normal,
109 maxdepth,
110 mindepth,
111 maxdepthslow,
112 mindepthslow,
113 maxdegree,
114 mindegree,
115 maxindegree,
116 minindegree,
117 maxoutdegree,
118 minoutdegree,
119 minbackward,
120 dfs,
121 tree
122};
123
124/* VCG decision yes/no. */
125enum decision_e
126{
127 yes,
128 no
129};
130
131/* VCG graph orientation. */
132enum orientation_e
133{
134 top_to_bottom,
135 bottom_to_top,
136 left_to_right,
137 right_to_left
138};
139
140/* VCG alignement for node alignement. */
141enum alignement_e
142{
143 center,
144 top,
145 bottom
146};
147
148/* VCG arrow mode. */
149enum arrow_mode_e
150{
151 fixed,
152 free_a
153};
154
155/* VCG crossing weight type. */
156enum crossing_type_e
157{
158 bary,
159 median,
160 barymedian,
161 medianbary
162};
163
164/* VCG views. */
165enum view_e
166{
167 normal_view,
168 cfish,
169 pfish,
170 fcfish,
171 fpfish
172};
173
174/*------------------------------------------------------.
175| Node attributs list. structure that describes a node. |
176`------------------------------------------------------*/
177
178struct node_s
179{
180 /* Title the unique string identifying the node. This attribute is
181 mandatory. */
182 const char *title;
183
184 /* Label the text displayed inside the node. If no label is specified
185 then the title of the node will be used. Note that this text may
186 contain control characters like NEWLINE that influences the size of
187 the node. */
188 const char *label;
189
190 /* loc is the location as x, y position relatively to the system of
191 coordinates of the graph. Locations are specified in the form
192 loc: - x: xpos y: ypos "". The locations of nodes are only valid,
193 if the whole graph is fully specified with locations and no part is
194 folded. The layout algorithm of the tool calculates appropriate x, y
195 positions, if at least one node that must be drawn (i.e., is not
196 hidden by folding or edge classes) does not have fixed specified
197 locations.
198 Default is none. */
199 int locx;
200 int locy;
201
202 /* vertical order is the level position (rank) of the node. We can also
203 specify level: int. Level specifications are only valid, if the
204 layout is calculated, i.e. if at least one node does not have a
205 fixed location specification. The layout algorithm partitioned all
206 nodes into levels 0...maxlevel. Nodes at the level 0 are on the
207 upper corner. The algorithm is able to calculate appropriate levels
208 for the nodes automatically, if no fixed levels are given.
209 Specifications of levels are additional constraints, that may be
210 ignored, if they are in conflict with near edge specifications.
211 Default values are unspecified. */
212 int vertical_order;
213
214 /* horizontal order is the horizontal position of the node within a
215 level. The nodes which are specified with horizontal positions are
216 ordered according to these positions within the levels. The nodes
217 which do not have this attribute are inserted into this ordering by
218 the crossing reduction mechanism. Note that connected components are
219 handled separately, thus it is not possible to intermix such
220 components by specifying a horizontal order. If the algorithm for
221 downward laid out trees is used, the horizontal order influences
222 only the order of the child nodes at a node, but not the order of
223 the whole level.
224 Default is unspecified. */
225 int horizontal_order;
226
227 /* width, height is the width and height of a node including the border.
228 If no value (in pixels) is given then width and height are
229 calculated from the size of the label.
230 Default are width and height of the label. */
231 int width;
232 int height;
233
234 /* shrink, stretch gives the shrinking and stretching factor of the
235 node. The values of the attributes width, height, borderwidth and
236 the size of the label text is scaled by ((stretch=shrink) \Lambda
237 100) percent. Note that the actual scale value is determined by the
238 scale value of a node relatively to a scale value of the graph,
239 i.e. if (stretch,shrink) = (2,1) for the graph and (stretch,shrink)
240 = (2,1) for the node of the graph, then the node is scaled by the
241 factor 4 compared to the normal size. The scale value can also be
242 specified by scaling: float.
243 Default are 1,1. */
244 int shrink;
245 int stretch;
246
247 /* folding specifies the default folding of the nodes. The folding k
248 (with k ? 0) means that the graph part that is reachable via edges
249 of a class less or equal to k is folded and displayed as one node.
250 There are commands to unfold such summary nodes, see section 5. If
251 no folding is specified for a node, then the node may be folded if
252 it is in the region of another node that starts the folding. If
253 folding 0 is specified, then the node is never folded. In this case
254 the folding stops at the predecessors of this node, if it is
255 reachable from another folding node. The summary node inherits some
256 attributes from the original node which starts the folding (all
257 color attributes, textmode and label, but not the location). A
258 folded region may contain folded regions with smaller folding class
259 values (nested foldings). If there is more than one node that start
260 the folding of the same region (this implies that the folding class
261 values are equal) then the attributes are inherited by one of these
262 nodes nondeterministically. If foldnode attributes are specified,
263 then the summary node attributes are inherited from these attributes.
264 Default is none. */
265 int folding;
266
267 /* shape specifies the visual appearance of a node: box, rhomb, ellipse,
268 and triangle. The drawing of ellipses is much slower than the drawing
269 of the other shapes.
270 Default is box. */
271 enum shape_e shape;
272
273 /* textmode specifies the adjustment of the text within the border of a
274 node. The possibilities are center, left.justify and right.justify.
275 Default is center. */
276 enum textmode_e textmode;
277
278 /* borderwidth specifies the thickness of the node's border in pixels.
279 color is the background color of the node. If none is given, the
280 node is white. For the possibilities, see the attribute color for
281 graphs.
282 Default is 2. */
283 int borderwidth;
284
285 /* node color.
286 Default is white or transparent, */
287 enum color_e color;
288
289 /* textcolor is the color for the label text. bordercolor is the color
290 of the border. Default color is the textcolor. info1, info2, info3
291 combines additional text labels with a node or a folded graph. info1,
292 Default is black. */
293 enum color_e textcolor;
294
295 /* info2, info3 can be selected from the menu. The corresponding text
296 labels can be shown by mouse clicks on nodes.\f
297 Default are null strings. */
298 const char *infos[3];
299
300 /* Node border color.
301 Default is textcolor. */
302 enum color_e bordercolor;
303
304 /* Next node node... */
305 struct node_s *next;
306};
307
308/* typedef alias. */
309typedef struct node_s node_t;
310
311/*-------------------------------------------------------.
312| Edge attributs list. Structure that describes an edge. |
313`-------------------------------------------------------*/
314
315/* VCG Edge type. */
316enum edge_type
317{
318 normal_edge,
319 back_edge,
320 near_edge,
321 bent_near_edge
322};
323
324/* Structs enum definitions for edges. */
325enum linestyle_e
326{
327 continuous,
328 dashed,
329 dotted,
330 invisible
331};
332
333enum arrowstyle_e
334{
335 solid,
336 line,
337 none
338};
339
340/* The struct edge_s itself. */
341struct edge_s
342{
343
344 /* Edge type.
345 Default is normal edge. */
346 enum edge_type type;
347
348 /* Sourcename is the title of the source node of the edge.
349 Default: none. */
350 const char *sourcename; /* Mandatory. */
351
352 /* Targetname is the title of the target node of the edge.
353 Default: none. */
354 const char *targetname; /* Mandatory. */
355
356 /* Label specifies the label of the edge. It is drawn if
357 display.edge.labels is set to yes.
358 Default: no label. */
359 const char *label;
360
361 /* Linestyle specifies the style the edge is drawn. Possibilities are:
362 ffl continuous a solid line is drawn ( -- ) ffl dashed the edge
363 consists of single dashes ( - - - ) ffl dotted the edge is made of
364 single dots ( \Delta \Delta \Delta ) ffl invisible the edge is not
365 drawn. The attributes of its shape (color, thickness) are ignored.
366 To draw a dashed or dotted line needs more time than solid lines.
367 Default is continuous. */
368 enum linestyle_e linestyle;
369
370 /* Thickness is the thickness of an edge.
371 Default is 2. */
372 int thickness;
373
374 /* Class specifies the folding class of the edge. Nodes reachable by
375 edges of a class less or equal to a constant k specify folding
376 regions of k. See the node attribute folding and the folding commands.
377 Default is 1. */
378 int class;
379
380 /* color is the color of the edge.
381 Default is black. */
382 enum color_e color;
383
384 /* textcolor is the color of the label of the edge. arrowcolor,
385 backarrowcolor is the color of the arrow head and of the backarrow
386 head. priority The positions of the nodes are mainly determined by
387 the incoming and outgoing edges. One can think of rubberbands instead
388 of edges that pull a node into its position. The priority of an edges
389 corresponds to the strength of the rubberband.
390 Default is color. */
391 enum color_e textcolor;
392
393 /* Arrow color.
394 Default is color. */
395 enum color_e arrowcolor;
396
397 /* BackArrow color.
398 Default is color. */
399 enum color_e backarrowcolor;
400
401 /* arrowsize, backarrowsize The arrow head is a right-angled, isosceles
402 triangle and the cathetuses have length arrowsize.
403 Default is 10. */
404 int arrowsize;
405
406 /* Backarrow size
407 Default is 0. */
408 int backarrowsize;
409
410 /* arrowstyle, backarrowstyle Each edge has two arrow heads: the one
411 appears at the target node (the normal arrow head), the other appears
412 at the source node (the backarrow head). Normal edges only have the
413 normal solid arrow head, while the backarrow head is not drawn, i.e.
414 it is none. Arrowstyle is the style of the normal arrow head, and
415 backarrowstyle is the style of the backarrow head. Styles are none,
416 i.e. no arrow head, solid, and line.
417 Default is solid. */
418 enum arrowstyle_e arrowstyle;
419
420 /* Default is none. */
421 enum arrowstyle_e backarrowstyle;
422
423 /* Default is 1. */
424 int priority;
425
426 /* Anchor. An anchor point describes the vertical position in a node
427 where an edge goes out. This is useful, if node labels are several
428 lines long, and outgoing edges are related to label lines. (E.g.,
429 this allows a nice visualization of structs containing pointers as
430 fields.).
431 Default is none. */
432 int anchor;
433
434 /* Horizontal order is the horizontal position the edge. This is of
435 interest only if the edge crosses several levels because it specifies
436 the point where the edge crosses the level. within a level. The nodes
437 which are specified with horizontal positions are ordered according
438 to these positions within a level. The horizontal position of a long
439 edge that crosses the level specifies between which two node of that
440 level the edge has to be drawn. Other edges which do not have this
441 attribute are inserted into this ordering by the crossing reduction
442 mechanism. Note that connected components are handled separately,
443 thus it is not possible to intermix such components by specifying a
444 horizontal order.
445 Default is unspcified. */
446 int horizontal_order;
447
448 /*
449 ** Next edge node...
450 */
451 struct edge_s *next;
452
453};
454
455/*
456** typedef alias.
457*/
458typedef struct edge_s edge_t;
459
460/*--------------------------------------------------------.
461| Graph attributs list. Structure that describes a graph. |
462`--------------------------------------------------------*/
463
464struct graph_s
465{
466 /* Graph title or name.
467 Title specifies the name (a string) associated with the graph. The
468 default name of a subgraph is the name of the outer graph, and the
469 name of the outmost graph is the name of the specification input
470 file. The name of a graph is used to identify this graph, e.g., if
471 we want to express that an edge points to a subgraph. Such edges
472 point to the root of the graph, i.e. the first node of the graph or
473 the root of the first subgraph in the graph, if the subgraph is
474 visualized explicitly.
475 By default, it's the name of the vcg graph file description. */
476 const char *title;
477
478 /* Graph label.
479 Label the text displayed inside the node, when the graph is folded
480 to a node. If no label is specified then the title of the graph will
481 be used. Note that this text may contain control characters like
482 NEWLINE that influences the size of the node.
483 By default, it takes the title value */
484 const char *label;
485
486 /* Any informations.
487 Info1, info2, info3 combines additional text labels with a node or a
488 folded graph. info1, info2, info3 can be selected from the menu
489 interactively. The corresponding text labels can be shown by mouse
490 clicks on nodes.
491 Defalut values are empty strings (here NULL pointers) */
492 const char *infos[3];
493
494 /* Background color and summary node colors
495 Color specifies the background color for the outermost graph, or the
496 color of the summary node for subgraphs. Colors are given in the enum
497 declared above. If more than these default colors are needed, a
498 color map with maximal 256 entries can be used. The first 32 entries
499 correspond to the colors just listed. A color of the color map can
500 selected by the color map index, an integer, for instance red has
501 index 2, green has index 3, etc.
502 Default is white for background and white or transparent for summary
503 nodes. */
504 enum color_e color;
505
506 /* Textcolor.
507 need explainations ???
508 defalut is black for summary nodes. */
509 enum color_e textcolor;
510
511 /* Bordercolor is the color of the summary node's border. Default color
512 is the textcolor. width, height are width and height of the
513 displayed part of the window of the outermost graph in pixels, or
514 width and height of the summary node of inner subgraphs.
515 Default is the defalut of the textcolor. */
516 enum color_e bordercolor;
517
518 /* Width, height are width and height of the displayed part of the
519 window of the outermost graph in pixels, or width and height of the
520 summary node of inner subgraphs.
521 Defalut value is 100. */
522 int width;
523 int height;
524
525 /* Specify the thickness if summary node's border in pixels.
526 defalut value is 2. */
527 int borderwidth;
528
529 /* x, y are the x-position and y-position of the graph's window in
530 pixels, relatively to the root screen, if it is the outermost graph.
531 The origin of the window is upper, left hand. For inner subgraphs,
532 it is the position of the folded summary node. The position can also
533 be specified in the form loc: fx:int y:intg.
534 The default value is 0. */
535 int x;
536 int y;
537
538 /* folding of a subgraph is 1, if the subgraph is fused, and 0, if the
539 subgraph is visualized explicitly. There are commands to unfold such
540 summary nodes.
541 Defalut value is 0 */
542 int folding;
543
544 /* Shrink, stretch gives the shrinking and stretching factor for the
545 graph's representation (default is 1, 1). ((stretch=shrink) \Lambda
546 100) is the scaling of the graph in percentage, e.g.,
547 (stretch,shrink) = (1,1) or (2,2) or (3,3) : : : is normal size,
548 (stretch,shrink) = (1,2) is half size, (stretch,shrink) = (2,1) is
549 double size. For subgraphs, it is also the scaling factor of the
550 summary node. The scaling factor can also be specified by scaling:
551 float (here, scaling 1.0 means normal size). */
552 int shrink;
553 int stretch;
554
555 /* textmode specifies the adjustment of the text within the border of a
556 summary node. The possibilities are center, left.justify and
557 right.justify.
558 Default value is center.*/
559 enum textmode_e textmode;
560
561 /* Shape can be specified for subgraphs only. It is the shape of the
562 subgraph summary node that appears if the subgraph is folded: box,
563 rhomb, ellipse, and triangle. vertical order is the level position
564 (rank) of the summary node of an inner subgraph, if this subgraph is
565 folded. We can also specify level: int. The level is only
566 recognized, if an automatical layout is calculated. horizontal order
567 is the horizontal position of the summary node within a level. The
568 nodes which are specified with horizontal positions are ordered
569 according to these positions within the levels. The nodes which do
570 not have this attribute are inserted into this ordering by the
571 crossing reduction mechanism. Note that connected
572 components are handled separately, thus it is not possible to
573 intermix such components by specifying a horizontal order. If the
574 algorithm for downward laid out trees is used, the horizontal order
575 influences only the order of the child nodes at a node, but not the
576 order of the whole level.
577 Defalut is box, other: rhomb, ellipse, triangle. */
578 enum shape_e shape;
579
580 /* Vertical order is the level position (rank) of the summary node of an
581 inner subgraph, if this subgraph is folded. We can also specify
582 level: int. The level is only recognized, if an automatical layout is
583 calculated. */
584 int vertical_order;
585
586 /* Horizontal order is the horizontal position of the summary node within
587 a level. The nodes which are specified with horizontal positions are
588 ordered according to these positions within the levels. The nodes which
589 do not have this attribute are inserted into this ordering by the
590 crossing reduction mechanism. Note that connected components are
591 handled separately, thus it is not possible to intermix such components
592 by specifying a horizontal order. If the algorithm for downward laid
593 out trees is used, the horizontal order influences only the order of
594 the child nodes at a node, but not the order of the whole level. */
595 int horizontal_order;
596
597 /* xmax, ymax specify the maximal size of the virtual window that is
598 used to display the graph. This is usually larger than the displayed
599 part, thus the width and height of the displayed part cannot be
600 greater than xmax and ymax. Only those parts of the graph are drawn
601 that are inside the virtual window. The virtual window can be moved
602 over the potential infinite system of coordinates by special
603 positioning commands.
604 Defaults are 90 and 90. */
605 int xmax;
606 int ymax;
607
608 /* xy-base: specify the upper left corner coordonates of the graph
609 relatively to the root window.
610 Defaults are 5, 5. */
611 int xbase;
612 int ybase;
613
614 /* xspace, yspace the minimum horizontal and vertical distance between
615 nodes. xlspace is the horizontal distance between lines at the
616 points where they cross the levels. (At these points, dummy nodes
617 are used. In fact, this is the horizontal distance between dummy
618 nodes.) It is recommended to set xlspace to a larger value, if
619 splines are used to draw edges, to prevent sharp bendings.
620 Default are 20 and 70. */
621 int xspace;
622 int yspace;
623
624 /* The horizontal space between lines at the point where they cross
625 the levels.
626 defaults value is 1/2 xspace (polygone) and 4/5 xspace (splines)*/
627 int xlspace;
628
629 /* xraster, yraster specifies the raster distance for the position of
630 the nodes. The center of a node is aligned to this raster. xlraster
631 is the horizontal raster for the positions of the line control
632 points (the dummy nodes). It should be a divisor of xraster.
633 defaluts are 1,1. */
634 int xraster;
635 int yraster;
636
637 /* xlraster is the horizontal raster for the positions of the line
638 control points (the dummy nodes). It should be a divisor of xraster.
639 defaults is 1. */
640 int xlraster;
641
642 /* hidden specifies the classes of edges that are hidden.
643 Edges that are within such a class are not laid out nor drawn.
644 Nodes that are only reachable (forward or backward) by edges of an
645 hidden class are not drawn. However, nodes that are not reachable
646 at all are drawn. (But see attribute ignore.singles.) Specification
647 of classes of hidden edges allows to hide parts of a graph, e.g.,
648 annotations of a syntax tree. This attribute is only allowed at the
649 outermost level. More than one settings are possible to specify
650 exactly the set of classes that are hidden. Note the important
651 difference between hiding of edges and the edge line style invisible.
652 Hidden edges are not existent in the layout. Edges with line style
653 invisible are existent in the layout; they need space and may
654 produce crossings and influence the layout, but you cannot see
655 them.
656 No default value. */
657 int hidden;
658
659 /* Classname allows to introduce names for the edge classes. The names
660 are used in the menus. infoname allows to introduce names for the
661 additional text labels. The names are used in the menus.
662 defaults are 1,2,3...
663 By default, no class names. */
664 struct classname_s *classname;
665
666 /* Infoname allows to introduce names for the additional text labels.
667 The names are used in the menus.
668 Infoname is given by an integer and a string.
669 The default value is NULL. */
670 struct infoname_s *infoname;
671
672 /* Colorentry allows to fill the color map. A color is a triplet of integer
673 values for the red/green/blue-part. Each integer is between 0 (off) and
674 255 (on), e.g., 0 0 0 is black and 255 255 255 is white. For instance
675 colorentry 75 : 70 130 180 sets the map entry 75 to steel blue. This
676 color can be used by specifying just the number 75.
677 Default id NULL. */
678 struct colorentry_s *colorentry;
679
680 /* layoutalgorithm chooses different graph layout algorithms
681 Possibilities are maxdepth, mindepth, maxdepthslow, mindepthslow,
682 maxdegree, mindegree, maxindegree, minindegree, maxoutdegree,
683 minoutdegree, minbackward, dfs and tree. The default algorithm tries
684 to give all edges the same orientation and is based on the
685 calculation of strongly connected components. The algorithms that
686 are based on depth first search are faster. While the simple dfs
687 does not enforce additionally constraints, the algorithm maxdepth
688 tries to increase the depth of the layout and the algorithm mindepth
689 tries to increase the wide of the layout. These algorithms are fast
690 heuristics. If they are not appropriate, the algorithms maxdepthslow
691 or mindepthslow also increase the depth or wide, but they are very
692 slow. The algorithm maxindegree lays out the nodes by scheduling the
693 nodes with the maximum of incoming edges first, and minindegree lays
694 out the nodes by scheduling the nodes with the minimum of incoming
695 edges first. In the same manner work the algorithms maxoutdegree and
696 minoutdegree for outgoing edges, and maxdegree and mindegree for the
697 sum of incoming and outgoing edges. These algorithms may have various
698 effects, and can sometimes be used as replacements of maxdepthslow
699 or mindepthslow.
700
701 The algorithm minbackward can be used if the graph is acyclic.
702 The algorithm tree is a specialized method for downward laid out
703 trees. It is much faster on such tree-like graphs and results in a
704 balanced layout.
705 Default is normal. */
706 enum layoutalgorithm_e layoutalgorithm;
707
708 /* Layout downfactor, layout upfactor, layout nearfactor The layout
709 algorithm partitions the set of edges into edges pointing upward,
710 edges pointing downward, and edges pointing sidewards. The last type
711 of edges is also called near edges. If the layout.downfactor is
712 large compared to the layout.upfactor and the layout.nearfactor,
713 then the positions of the nodes is mainly determined by the edges
714 pointing downwards. If the layout.upfactor is large compared to the
715 layout.downfactor and the layout.nearfactor, then the positions of
716 the nodes is mainly determined by the edges pointing upwards. If the
717 layout.nearfactor is large, then the positions of the nodes is
718 mainly determined by the edges pointing sidewards. These attributes
719 have no effect, if the method for downward laid out trees is used.
720 Defalut is normal. */
721 int layout_downfactor;
722 int layout_upfactor;
723 int layout_nearfactor;
724 /* Layout splinefactor determines the bending at splines. The factor
725 100 indicates a very sharp bending, a factor 1 indicates a very flat
726 bending. Useful values are 30 : : : 80. */
727 int layout_splinefactor;
728
729 /* Late edge labels yes means that the graph is first partitioned and
730 then, labels are introduced. The default algorithm first creates
731 labels and then partitions the graph, which yield a more compact
732 layout, but may have more crossings.
733 Default is no. */
734 enum decision_e late_edge_labels;
735
736 /* Display edge labels yes means display labels and no means don't
737 display edge labels.
738 Default vaule is no. */
739 enum decision_e display_edge_labels;
740
741 /* Dirty edge labels yes enforces a fast layout of edge labels, which
742 may very ugly because several labels may be drawn at the same place.
743 Dirty edge labels cannot be used if splines are used.
744 Default is no.
745 */
746 enum decision_e dirty_edge_labels;
747
748 /* Finetuning no switches the fine tuning phase of the graph layout
749 algorithm off, while it is on as default. The fine tuning phase
750 tries to give all edges the same length.
751 Default is yes. */
752 enum decision_e finetuning;
753
754 /* Ignore singles yes hides all nodes which would appear single and
755 unconnected from the remaining graph. Such nodes have no edge at all
756 and are sometimes very ugly. Default is to show all nodes.
757 Default is no. */
758 enum decision_e ignore_singles;
759
760 /* Straight phase yes initiates an additional phase that tries to avoid
761 bendings in long edges.
762 Long edges are laid out by long straight vertical lines with
763 gradient 90 degree. Thus, this phase is not very appropriate for
764 normal layout, but it is recommended, if an orthogonal layout is
765 selected (see manhattan.edges).
766 Default is no. */
767 enum decision_e straight_phase;
768
769 /* priority phase yes replaces the normal pendulum method by a
770 specialized method: It forces straight long edges with 90 degree,
771 just as the straight phase. In fact, the straight phase is a fine
772 tune phase of the priority method. This phase is also recommended,
773 if an orthogonal layout is selected (see manhattan.edges).
774 Default is no. */
775 enum decision_e priority_phase;
776
777 /* manhattan edges yes switches the orthogonal layout on. Orthogonal
778 layout (or manhattan layout) means that all edges consist of line
779 segments with gradient 0 or 90 degree. Vertical edge segments might
780 by shared by several edges, while horizontal edge segments are never
781 shared. This results in very aesthetical layouts just for flowcharts.
782 If the orthogonal layout is used, then the priority phase and
783 straight phase should be used. Thus, these both phases are switched
784 on, too, unless priority layout and straight line tuning are
785 switched off explicitly.
786 Default is no. */
787 enum decision_e manhattan_edges;
788
789 /* Smanhattan edges yes switches a specialized orthogonal layout on:
790 Here, all horizontal edge segments between two levels share the same
791 horizontal line, i.e. not only vertical edge segments are shared,
792 but horizontal edge segments are shared by several edges, too. This
793 looks nice for trees but might be too confusing in general, because
794 the location of an edge might be ambiguously.
795 Default is no. */
796 enum decision_e smanhattan_edges;
797
798 /* Near edges no suppresses near edges and bent near edges in the
799 graph layout.
800 Default is yes. */
801 enum decision_e near_edges;
802
803 /* Orientation specifies the orientation of the graph: top.to.bottom,
804 bottom.to.top, left.to.right or right.to.left. Note: the normal
805 orientation is top.to.bottom. All explanations here are given
806 relatively to the normal orientation, i.e., e.g., if the orientation
807 is left to right, the attribute xlspace is not the horizontal but
808 the vertical distance between lines, etc.
809 Default is to_to_bottom. */
810 enum orientation_e orientation;
811
812 /* Node alignment specified the vertical alignment of nodes at the
813 horizontal reference line of the levels. If top is specified, the
814 tops of all nodes of a level have the same y-coordinate; on bottom,
815 the bottoms have the same y-coordinate, on center the nodes are
816 centered at the levels.
817 Default is center. */
818 enum alignement_e node_alignement;
819
820 /* Port sharing no suppresses the sharing of ports of edges at the
821 nodes. Normally, if multiple edges are adjacent to the same node,
822 and the arrow head of all these edges has the same visual appearance
823 (color, size, etc.), then these edges may share a port at a node,
824 i.e. only one arrow head is draw, and all edges are incoming into
825 this arrow head. This allows to have many edges adjacent to one node
826 without getting confused by too many arrow heads. If no port sharing
827 is used, each edge has its own port, i.e. its own place where it is
828 adjacent to the node.
829 Default is yes. */
830 enum decision_e port_sharing;
831
832 /* Arrow mode fixed (default) should be used, if port sharing is used,
833 because then, only a fixed set of rotations for the arrow heads are
834 used. If the arrow mode is free, then each arrow head is rotated
835 individually to each edge. But this can yield to a black spot, where
836 nothing is recognizable, if port sharing is used, since all these
837 qdifferently rotated arrow heads are drawn at the same place. If the
838 arrow mode is fixed, then the arrow head is rotated only in steps of
839 45 degree, and only one arrow head occurs at each port.
840 Default is fixed. */
841 enum arrow_mode_e arrow_mode;
842
843 /* Treefactor The algorithm tree for downward laid out trees tries to
844 produce a medium dense, balanced tree-like layout. If the tree
845 factor is greater than 0.5, the tree edges are spread, i.e. they
846 get a larger gradient. This may improve the readability of the tree.
847 Note: it is not obvious whether spreading results in a more dense or
848 wide layout. For a tree, there is a tree factor such that the whole
849 tree is minimal wide.
850 Default is 0.5. */
851 float treefactor;
852
853 /* Spreadlevel This parameter only influences the algorithm tree, too.
854 For large, balanced trees, spreading of the uppermost nodes would
855 enlarge the width of the tree too much, such that the tree does not
856 fit anymore in a window. Thus, the spreadlevel specifies the minimal
857 level (rank) where nodes are spread. Nodes of levels upper than
858 spreadlevel are not spread.
859 Default is 1. */
860 int spreadlevel;
861
862 /* Crossing weight specifies the weight that is used for the crossing
863 reduction: bary (default), median, barymedian or medianbary. We
864 cannot give a general recommendation, which is the best method. For
865 graphs with very large average degree of edges (number of incoming
866 and outgoing edges at a node), the weight bary is the fastest
867 method. With the weights barymedian and medianbary, equal weights of
868 different nodes are not very probable, thus the crossing reduction
869 phase 2 might be very fast.
870 Default is bary. */
871 enum crossing_type_e crossing_weight;
872
873 /* Crossing phase2 is the most time consuming phase of the crossing
874 reduction. In this phase, the nodes that happen to have equal
875 crossing weights are permuted. By specifying no, this phase is
876 suppressed.
877 Default is yes. */
878 enum decision_e crossing_phase2;
879
880 /* Crossing optimization is a postprocessing phase after the normal
881 crossing reduction: we try to optimize locally, by exchanging pairs
882 of nodes to reduce the crossings. Although this phase is not very
883 time consuming, it can be suppressed by specifying no.
884 Default is yes. */
885 enum decision_e crossing_optimization;
886
887 /* View allows to select the fisheye views. Because
888 of the fixed size of the window that shows the graph, we normally
889 can only see a small amount of a large graph. If we shrink the graph
890 such that it fits into the window, we cannot recognize any detail
891 anymore. Fisheye views are coordinate transformations: the view onto
892 the graph is distort, to overcome this usage deficiency. The polar
893 fisheye is easy to explain: assume a projection of the plane that
894 contains the graph picture onto a spheric ball. If we now look onto
895 this ball in 3 D, we have a polar fisheye view. There is a focus
896 point which is magnified such that we see all details. Parts of the
897 plane that are far away from the focus point are demagnified very
898 much. Cartesian fisheye have a similar effect; only the formula for
899 the coordinate transformation is different. Selecting cfish means
900 the cartesian fisheye is used which demagnifies such that the whole
901 graph is visible (self adaptable cartesian fisheye). With fcfish,
902 the cartesian fisheye shows the region of a fixed radius around the
903 focus point (fixed radius cartesian fisheye). This region might be
904 smaller than the whole graph, but the demagnification needed to show
905 this region in the window is also not so large, thus more details
906 are recognizable. With pfish the self adaptable polar fisheye is
907 selected that shows the whole graph, and with fpfish the fixed
908 radius polar fisheye is selected.
909 Defalut is normal view. */
910 enum view_e view;
911
912 /* Edges no suppresses the drawing of edges.
913 Default is yes. */
914 enum decision_e edges;
915
916 /* Nodes no suppresses the drawing of nodes.
917 Default is yes. */
918 enum decision_e nodes;
919
920 /* Splines specifies whether splines are used to draw edges (yes or no).
921 As default, polygon segments are used to draw edges, because this is
922 much faster. Note that the spline drawing routine is not fully
923 validated, and is very slow. Its use is mainly to prepare high
924 quality PostScript output for very small graphs.
925 Default is no. */
926 enum decision_e splines;
927
928 /* Bmax set the maximal number of iterations that are done for the
929 reduction of edge bendings.
930 Default is 100. */
931 int bmax;
932
933 /* Cmin set the minimal number of iterations that are done for the
934 crossing reduction with the crossing weights. The normal method
935 stops if two consecutive checks does not reduce the number of
936 crossings anymore. However, this increasing of the number of
937 crossings might be locally, such that after some more iterations,
938 the crossing number might decrease much more.
939 Default is 0. */
940 int cmin;
941
942 /* Cmax set the maximal number of interactions for crossing reduction.
943 This is helpful for speedup the layout process.
944 Default is infinite. */
945 int cmax;
946
947 /* Pmin set the minimal number of iterations that is done with the
948 pendulum method. Similar to the crossing reduction, this method
949 stops if the `imbalancement weight' does not decreases anymore.
950 However, the increasing of the imbalancement weight might be locally,
951 such that after some more iterations, the imbalancement weight might
952 decrease much more.
953 Default is 0. */
954 int pmin;
955
956 /* Pmax set the maximal number of iterations of the pendulum method.
957 This is helpful for speedup the layout process.
958 Default is 100. */
959 int pmax;
960
961 /* Rmin set the minimal number of iterations that is done with the
962 rubberband method. This is similar as for the pendulum method.
963 Default is 0. */
964 int rmin;
965
966 /* Rmax set the maximal number of iterations of the rubberband method.
967 This is helpful for speedup the layout process.
968 Default is 100. */
969 int rmax;
970
971 /* Smax set the maximal number of iterations of the straight line
972 recognition phase (useful only, if the straight line recognition
973 phase is switched on, see attribute straight.phase).
974 Default is 100. */
975 int smax;
976
977 /* Generic values.
978 */
979 node_t node;
980 edge_t edge;
981
982 /* List of nodes declared.
983 Pointer. */
984 node_t *node_list;
985
986 /* List of edges declared.
987 Pointer. */
988 edge_t *edge_list;
989
990};
991
992/* Graph typedefs. */
993typedef struct graph_s graph_t;
994
995void new_graph (graph_t *g);
996void new_node (node_t *node);
997void new_edge (edge_t *edge);
998
999void add_node (graph_t *graph, node_t *node);
1000void add_edge (graph_t *graph, edge_t *edge);
1001
1002void add_colorentry (graph_t *g, int color_idx, int red_cp,
1003 int green_cp, int blue_cp);
1004void add_classname (graph_t *g, int val, const char *name);
1005void add_infoname (graph_t *g, int val, const char *name);
1006
1007void open_node (FILE *fout);
1008void output_node (node_t *node, FILE *fout);
1009void close_node (FILE *fout);
1010
1011void open_edge (edge_t *edge, FILE *fout);
1012void output_edge (edge_t *edge, FILE *fout);
1013void close_edge (FILE *fout);
1014
1015void open_graph (FILE *fout);
1016void output_graph (graph_t *graph, FILE *fout);
1017void close_graph (graph_t *graph, FILE *fout);
1018
1019#endif /* VCG_H_ */