g->y = G_Y;
g->folding = G_FOLDING;
g->shrink = G_SHRINK;
- g->expand = G_EXPAND;
+ g->stretch = G_STRETCH;
g->textmode = G_TEXTMODE;
g->shape = G_SHAPE;
g->classname = G_CLASSNAME; /* No class name association. */
- g->layoutalgorithm = G_LAYOUTALGORITHM;
g->layout_downfactor = G_LAYOUT_DOWNFACTOR;
g->layout_upfactor = G_LAYOUT_UPFACTOR;
g->layout_nearfactor = G_LAYOUT_NEARFACTOR;
n->height = N_HEIGHT; /* Also. */
n->shrink = N_SHRINK;
- n->expand = N_EXPAND;
+ n->stretch = N_STRETCH;
n->folding = N_FOLDING; /* No explicit default value. */
}
}
-static const char *
-get_layoutalgorithm_str (enum layoutalgorithm layoutalgorithm)
-{
- switch (layoutalgorithm)
- {
- case normal: return "normal";
- case maxdepth: return "maxdepth";
- case mindepth: return "mindepth";
- case maxdepthslow: return "maxdepthslow";
- case mindepthslow: return "mindepthslow";
- case maxdegree: return "maxdegree";
- case mindegree: return "mindegree";
- case maxindegree: return "maxindegree";
- case minindegree: return "minindegree";
- case maxoutdegree: return "maxoutdegree";
- case minoutdegree: return "minoutdegree";
- case minbackward: return "minbackward";
- case dfs: return "dfs";
- case tree: return "tree";
- default: abort (); return NULL;
- }
-}
-
static const char *
get_decision_str (enum decision decision)
{
if (n->shrink != N_SHRINK)
fprintf (fout, "\t\tshrink:\t%d\n", n->shrink);
- if (n->expand != N_EXPAND)
- fprintf (fout, "\t\texpand:\t%d\n", n->expand);
+ if (n->stretch != N_STRETCH)
+ fprintf (fout, "\t\tstretch:\t%d\n", n->stretch);
if (n->folding != N_FOLDING)
fprintf (fout, "\t\tfolding:\t%d\n", n->folding);
if (g->shrink != G_SHRINK)
fprintf (fout, "\tshrink:\t%d\n", g->shrink);
- if (g->expand != G_EXPAND)
- fprintf (fout, "\texpand:\t%d\n", g->expand);
+ if (g->stretch != G_STRETCH)
+ fprintf (fout, "\tstretch:\t%d\n", g->stretch);
if (g->textmode != G_TEXTMODE)
fprintf (fout, "\ttextmode:\t%s\n",
}
}
- if (g->layoutalgorithm != G_LAYOUTALGORITHM)
- fprintf (fout, "\tlayoutalgorithm:\t%s\n",
- get_layoutalgorithm_str (g->layoutalgorithm));
-
if (g->layout_downfactor != G_LAYOUT_DOWNFACTOR)
fprintf (fout, "\tlayout_downfactor:\t%d\n", g->layout_downfactor);
if (g->layout_upfactor != G_LAYOUT_UPFACTOR)
struct infoname *next;
};
-/* Layout Algorithms which can be found in VCG.
- Details about each algoithm can be found below. */
-enum layoutalgorithm
-{
- normal,
- maxdepth,
- mindepth,
- maxdepthslow,
- mindepthslow,
- maxdegree,
- mindegree,
- maxindegree,
- minindegree,
- maxoutdegree,
- minoutdegree,
- minbackward,
- dfs,
- tree
-};
-
/* VCG decision yes/no. */
enum decision
{
int width;
int height;
- /* shrink, expand gives the shrinking and expanding factor of the
+ /* shrink, stretch gives the shrinking and stretching factor of the
node. The values of the attributes width, height, borderwidth and
- the size of the label text is scaled by ((expand=shrink) \Lambda
+ the size of the label text is scaled by ((stretch=shrink) \Lambda
100) percent. Note that the actual scale value is determined by the
scale value of a node relatively to a scale value of the graph,
- i.e. if (expand,shrink) = (2,1) for the graph and (expand,shrink)
+ i.e. if (stretch,shrink) = (2,1) for the graph and (stretch,shrink)
= (2,1) for the node of the graph, then the node is scaled by the
factor 4 compared to the normal size. The scale value can also be
specified by scaling: float.
Default are 1,1. */
int shrink;
- int expand;
+ int stretch;
/* folding specifies the default folding of the nodes. The folding k
(with k ? 0) means that the graph part that is reachable via edges
Default value is 0 */
int folding;
- /* Shrink, expand gives the shrinking and expanding factor for the
- graph's representation (default is 1, 1). ((expand=shrink) \Lambda
+ /* Shrink, stretch gives the shrinking and stretching factor for the
+ graph's representation (default is 1, 1). ((stretch=shrink) \Lambda
100) is the scaling of the graph in percentage, e.g.,
- (expand,shrink) = (1,1) or (2,2) or (3,3) : : : is normal size,
- (expand,shrink) = (1,2) is half size, (expand,shrink) = (2,1) is
+ (stretch,shrink) = (1,1) or (2,2) or (3,3) : : : is normal size,
+ (stretch,shrink) = (1,2) is half size, (stretch,shrink) = (2,1) is
double size. For subgraphs, it is also the scaling factor of the
summary node. The scaling factor can also be specified by scaling:
float (here, scaling 1.0 means normal size). */
int shrink;
- int expand;
+ int stretch;
/* textmode specifies the adjustment of the text within the border of a
summary node. The possibilities are center, left.justify and
Default id NULL. */
struct colorentry *colorentry;
- /* layoutalgorithm chooses different graph layout algorithms
- Possibilities are maxdepth, mindepth, maxdepthslow, mindepthslow,
- maxdegree, mindegree, maxindegree, minindegree, maxoutdegree,
- minoutdegree, minbackward, dfs and tree. The default algorithm tries
- to give all edges the same orientation and is based on the
- calculation of strongly connected components. The algorithms that
- are based on depth first search are faster. While the simple dfs
- does not enforce additionally constraints, the algorithm maxdepth
- tries to increase the depth of the layout and the algorithm mindepth
- tries to increase the wide of the layout. These algorithms are fast
- heuristics. If they are not appropriate, the algorithms maxdepthslow
- or mindepthslow also increase the depth or wide, but they are very
- slow. The algorithm maxindegree lays out the nodes by scheduling the
- nodes with the maximum of incoming edges first, and minindegree lays
- out the nodes by scheduling the nodes with the minimum of incoming
- edges first. In the same manner work the algorithms maxoutdegree and
- minoutdegree for outgoing edges, and maxdegree and mindegree for the
- sum of incoming and outgoing edges. These algorithms may have various
- effects, and can sometimes be used as replacements of maxdepthslow
- or mindepthslow.
-
- The algorithm minbackward can be used if the graph is acyclic.
- The algorithm tree is a specialized method for downward laid out
- trees. It is much faster on such tree-like graphs and results in a
- balanced layout.
- Default is normal. */
- enum layoutalgorithm layoutalgorithm;
-
/* Layout downfactor, layout upfactor, layout nearfactor The layout
algorithm partitions the set of edges into edges pointing upward,
edges pointing downward, and edges pointing sidewards. The last type
projects / bison.git / commitdiff
