Trait dotavious::attributes::EdgeAttributes[−][src]

pub trait EdgeAttributes<'a> {
    fn add_attribute<S: Into<String>>(
        &mut self, 
        key: S, 
        value: AttributeText<'a>
    ) -> &mut Self;

    fn get_attributes_mut(&mut self) -> &mut IndexMap<String, AttributeText<'a>>;

    fn add_validation_error(
        &mut self, 
        field: &'static str, 
        message: &'static str
    );

    fn arrow_head(&mut self, arrowhead: ArrowType) -> &mut Self { ... }

    fn arrow_size(&mut self, arrow_size: f32) -> &mut Self { ... }

    fn arrow_tail(&mut self, arrow_tail: ArrowType) -> &mut Self { ... }

    fn class(&mut self, class: String) -> &mut Self { ... }

    fn color(&mut self, color: Color<'a>) -> &mut Self { ... }

    fn color_with_colorlist(&mut self, color: ColorList<'a>) -> &mut Self { ... }

    fn color_scheme(&mut self, color_scheme: String) -> &mut Self { ... }

    fn comment(&mut self, comment: String) -> &mut Self { ... }

    fn constraint(&mut self, constraint: bool) -> &mut Self { ... }

    fn decorate(&mut self, decorate: bool) -> &mut Self { ... }

    fn dir(&mut self, dir: Direction) -> &mut Self { ... }

    fn edge_target(&mut self, edge_target: String) -> &mut Self { ... }

    fn edge_tooltip(&mut self, edge_tooltip: String) -> &mut Self { ... }

    fn edge_url(&mut self, edge_url: String) -> &mut Self { ... }

    fn fill_color(&mut self, fill_color: Color<'a>) -> &mut Self { ... }

    fn fill_color_with_colorlist(
        &mut self, 
        fill_color: ColorList<'a>
    ) -> &mut Self { ... }

    fn font_color(&mut self, font_color: Color<'a>) -> &mut Self { ... }

    fn font_name(&mut self, font_name: String) -> &mut Self { ... }

    fn font_size(&mut self, font_size: f32) -> &mut Self { ... }

    fn head_lp(&mut self, head_lp: Point) -> &mut Self { ... }

    fn head_clip(&mut self, head_clip: bool) -> &mut Self { ... }

    fn head_label(&mut self, head_label: String) -> &mut Self { ... }

    fn head_port(&mut self, head_port: PortPosition) -> &mut Self { ... }

    fn head_target(&mut self, head_target: String) -> &mut Self { ... }

    fn head_tooltip(&mut self, head_tooltip: String) -> &mut Self { ... }

    fn head_url(&mut self, head_url: String) -> &mut Self { ... }

    fn label(&mut self, label: String) -> &mut Self { ... }

    fn label_angle(&mut self, label_angle: f32) -> &mut Self { ... }

    fn label_distance(&mut self, label_distance: f32) -> &mut Self { ... }

    fn label_float(&mut self, label_float: bool) -> &mut Self { ... }

    fn label_font_color(&mut self, label_font_color: Color<'a>) -> &mut Self { ... }

    fn label_font_name(&mut self, label_font_name: String) -> &mut Self { ... }

    fn label_font_size(&mut self, label_font_size: f32) -> &mut Self { ... }

    fn label_target(&mut self, label_target: String) -> &mut Self { ... }

    fn label_tooltip(&mut self, label_tooltip: String) -> &mut Self { ... }

    fn label_url(&mut self, label_url: String) -> &mut Self { ... }

    fn layer(&mut self, layer: String) -> &mut Self { ... }

    fn lhead(&mut self, lhead: String) -> &mut Self { ... }

    fn label_position(&mut self, lp: Point) -> &mut Self { ... }

    fn ltail(&mut self, ltail: String) -> &mut Self { ... }

    fn min_len(&mut self, min_len: u32) -> &mut Self { ... }

    fn no_justify(&mut self, no_justify: bool) -> &mut Self { ... }

    fn pen_width(&mut self, pen_width: f32) -> &mut Self { ... }

    fn pos(&mut self, pos: Point) -> &mut Self { ... }

    fn same_head(&mut self, same_head: String) -> &mut Self { ... }

    fn same_tail(&mut self, same_tail: String) -> &mut Self { ... }

    fn show_boxes(&mut self, show_boxes: u32) -> &mut Self { ... }

    fn style(&mut self, style: EdgeStyle) -> &mut Self { ... }

    fn tail_lp(&mut self, tail_lp: Point) -> &mut Self { ... }

    fn tail_clip(&mut self, tail_clip: bool) -> &mut Self { ... }

    fn tail_label(&mut self, tail_label: String) -> &mut Self { ... }

    fn tail_port(&mut self, tail_port: PortPosition) -> &mut Self { ... }

    fn tail_target(&mut self, tail_target: String) -> &mut Self { ... }

    fn tail_tooltip(&mut self, tail_tooltip: String) -> &mut Self { ... }

    fn tail_url(&mut self, tail_url: String) -> &mut Self { ... }

    fn target(&mut self, target: String) -> &mut Self { ... }

    fn tooltip(&mut self, tooltip: String) -> &mut Self { ... }

    fn url(&mut self, url: String) -> &mut Self { ... }

    fn weight(&mut self, weight: u32) -> &mut Self { ... }

    fn xlabel(&mut self, xlabel: String) -> &mut Self { ... }

    fn xlp(&mut self, xlp: Point) -> &mut Self { ... }
}

Required methods

fn add_attribute<S: Into<String>>(
    &mut self,
    key: S,
    value: AttributeText<'a>
) -> &mut Self[src]

fn get_attributes_mut(&mut self) -> &mut IndexMap<String, AttributeText<'a>>[src]

fn add_validation_error(&mut self, field: &'static str, message: &'static str)[src]

Loading content...

Provided methods

fn arrow_head(&mut self, arrowhead: ArrowType) -> &mut Self[src]

Style of arrowhead on the head node of an edge. This will only appear if the dir attribute is forward or both.

fn arrow_size(&mut self, arrow_size: f32) -> &mut Self[src]

Multiplicative scale factor for arrowheads. default: 1.0, minimum: 0.0

fn arrow_tail(&mut self, arrow_tail: ArrowType) -> &mut Self[src]

Style of arrowhead on the tail node of an edge. This will only appear if the dir attribute is back or both.

fn class(&mut self, class: String) -> &mut Self[src]

Classnames to attach to the edge’s SVG element. Combine with stylesheet for styling SVG output using CSS classnames. Multiple space-separated classes are supported.

fn color(&mut self, color: Color<'a>) -> &mut Self[src]

Basic drawing color for graphics, not text. For the latter, use the fontcolor attribute. If any fraction is used, the colors are drawn in series, with each color being given roughly its specified fraction of the edge.

fn color_with_colorlist(&mut self, color: ColorList<'a>) -> &mut Self[src]

Basic drawing color for graphics, not text. For the latter, use the fontcolor attribute. if colorList has no fractions, the edge is drawn using parallel splines or lines, one for each color in the list, in the order given. The head arrow, if any, is drawn using the first color in the list, and the tail arrow, if any, the second color. This supports the common case of drawing opposing edges, but using parallel splines instead of separately routed multiedges. If any fraction is used, the colors are drawn in series, with each color being given roughly its specified fraction of the edge.

fn color_scheme(&mut self, color_scheme: String) -> &mut Self[src]

This attribute specifies a color scheme namespace: the context for interpreting color names. In particular, if a color value has form “xxx” or “//xxx”, then the color xxx will be evaluated according to the current color scheme. If no color scheme is set, the standard X11 naming is used. For example, if colorscheme=bugn9, then color=7 is interpreted as color=“/bugn9/7”.

fn comment(&mut self, comment: String) -> &mut Self[src]

Comments are inserted into output. Device-dependent

fn constraint(&mut self, constraint: bool) -> &mut Self[src]

If false, the edge is not used in ranking the nodes.

fn decorate(&mut self, decorate: bool) -> &mut Self[src]

If true, attach edge label to edge by a 2-segment polyline, underlining the label, then going to the closest point of spline.

fn dir(&mut self, dir: Direction) -> &mut Self[src]

Edge type for drawing arrowheads. Indicates which ends of the edge should be decorated with an arrowhead. The actual style of the arrowhead can be specified using the arrowhead and arrowtail attributes.

fn edge_target(&mut self, edge_target: String) -> &mut Self[src]

If the edge has a URL or edgeURL attribute, edgetarget determines which window of the browser is used for the URL attached to the non-label part of the edge. Setting edgetarget=_graphviz will open a new window if it doesn’t already exist, or reuse it if it does.

fn edge_tooltip(&mut self, edge_tooltip: String) -> &mut Self[src]

Tooltip annotation attached to the non-label part of an edge. Used only if the edge has a URL or edgeURL attribute.

fn edge_url(&mut self, edge_url: String) -> &mut Self[src]

The link for the non-label parts of an edge. edgeURL overrides any URL defined for the edge. Also, edgeURL is used near the head or tail node unless overridden by headURL or tailURL, respectively.

fn fill_color(&mut self, fill_color: Color<'a>) -> &mut Self[src]

Color used to fill the background of a node or cluster assuming style=filled, or a filled arrowhead.

fn fill_color_with_colorlist(&mut self, fill_color: ColorList<'a>) -> &mut Self[src]

Color used to fill the background of a node or cluster assuming style=filled, or a filled arrowhead. A gradient fill is used. By default, this is a linear fill; setting style=radial will cause a radial fill. At present, only two colors are used. If the second color (after a colon) is missing, the default color is used for it.

fn font_color(&mut self, font_color: Color<'a>) -> &mut Self[src]

Color used for text.

fn font_name(&mut self, font_name: String) -> &mut Self[src]

Font used for text.

fn font_size(&mut self, font_size: f32) -> &mut Self[src]

Font size, in points, used for text. default: 14.0, minimum: 1.0

fn head_lp(&mut self, head_lp: Point) -> &mut Self[src]

Position of an edge’s head label, in points. The position indicates the center of the label.

fn head_clip(&mut self, head_clip: bool) -> &mut Self[src]

If true, the head of an edge is clipped to the boundary of the head node; otherwise, the end of the edge goes to the center of the node, or the center of a port, if applicable.

fn head_label(&mut self, head_label: String) -> &mut Self[src]

Text label to be placed near head of edge.

fn head_port(&mut self, head_port: PortPosition) -> &mut Self[src]

Indicates where on the head node to attach the head of the edge. In the default case, the edge is aimed towards the center of the node, and then clipped at the node boundary.

fn head_target(&mut self, head_target: String) -> &mut Self[src]

If the edge has a headURL, headtarget determines which window of the browser is used for the URL. Setting headURL=_graphviz will open a new window if the window doesn’t already exist, or reuse the window if it does. If undefined, the value of the target is used.

fn head_tooltip(&mut self, head_tooltip: String) -> &mut Self[src]

Tooltip annotation attached to the head of an edge. Used only if the edge has a headURL attribute.

fn head_url(&mut self, head_url: String) -> &mut Self[src]

If defined, headURL is output as part of the head label of the edge. Also, this value is used near the head node, overriding any URL value.

fn label(&mut self, label: String) -> &mut Self[src]

An escString or an HTML label.

fn label_angle(&mut self, label_angle: f32) -> &mut Self[src]

Determines, along with labeldistance, where the headlabel / taillabel are placed with respect to the head / tail in polar coordinates. The origin in the coordinate system is the point where the edge touches the node. The ray of 0 degrees goes from the origin back along the edge, parallel to the edge at the origin. The angle, in degrees, specifies the rotation from the 0 degree ray, with positive angles moving counterclockwise and negative angles moving clockwise. default: -25.0, minimum: -180.0

fn label_distance(&mut self, label_distance: f32) -> &mut Self[src]

Multiplicative scaling factor adjusting the distance that the headlabel / taillabel is from the head / tail node. default: 1.0, minimum: 0.0

fn label_float(&mut self, label_float: bool) -> &mut Self[src]

If true, allows edge labels to be less constrained in position. In particular, it may appear on top of other edges.

fn label_font_color(&mut self, label_font_color: Color<'a>) -> &mut Self[src]

Color used for headlabel and taillabel.

fn label_font_name(&mut self, label_font_name: String) -> &mut Self[src]

Font used for headlabel and taillabel. If not set, defaults to edge’s fontname.

fn label_font_size(&mut self, label_font_size: f32) -> &mut Self[src]

Font size, in points, used for headlabel and taillabel. If not set, defaults to edge’s fontsize. default: 14.0, minimum: 1.0

fn label_target(&mut self, label_target: String) -> &mut Self[src]

If the edge has a URL or labelURL attribute, this attribute determines which window of the browser is used for the URL attached to the label.

fn label_tooltip(&mut self, label_tooltip: String) -> &mut Self[src]

Tooltip annotation attached to label of an edge. Used only if the edge has a URL or labelURL attribute.

fn label_url(&mut self, label_url: String) -> &mut Self[src]

If defined, labelURL is the link used for the label of an edge. labelURL overrides any URL defined for the edge.

fn layer(&mut self, layer: String) -> &mut Self[src]

fn lhead(&mut self, lhead: String) -> &mut Self[src]

fn label_position(&mut self, lp: Point) -> &mut Self[src]

Label position The position indicates the center of the label.

fn ltail(&mut self, ltail: String) -> &mut Self[src]

Logical tail of an edge. When compound=true, if ltail is defined and is the name of a cluster containing the real tail, the edge is clipped to the boundary of the cluster.

fn min_len(&mut self, min_len: u32) -> &mut Self[src]

Minimum edge length (rank difference between head and tail).

fn no_justify(&mut self, no_justify: bool) -> &mut Self[src]

fn pen_width(&mut self, pen_width: f32) -> &mut Self[src]

fn pos(&mut self, pos: Point) -> &mut Self[src]

Position of node, or spline control points. the position indicates the center of the node. On output, the coordinates are in points.

fn same_head(&mut self, same_head: String) -> &mut Self[src]

Edges with the same head and the same samehead value are aimed at the same point on the head.

fn same_tail(&mut self, same_tail: String) -> &mut Self[src]

Edges with the same tail and the same sametail value are aimed at the same point on the tail.

fn show_boxes(&mut self, show_boxes: u32) -> &mut Self[src]

Print guide boxes in PostScript at the beginning of routesplines if showboxes=1, or at the end if showboxes=2. (Debugging, TB mode only!) default: 0, minimum: 0

fn style(&mut self, style: EdgeStyle) -> &mut Self[src]

Set style information for components of the graph.

fn tail_lp(&mut self, tail_lp: Point) -> &mut Self[src]

Position of an edge’s tail label, in points. The position indicates the center of the label.

fn tail_clip(&mut self, tail_clip: bool) -> &mut Self[src]

If true, the tail of an edge is clipped to the boundary of the tail node; otherwise, the end of the edge goes to the center of the node, or the center of a port, if applicable.

fn tail_label(&mut self, tail_label: String) -> &mut Self[src]

Text label to be placed near tail of edge.

fn tail_port(&mut self, tail_port: PortPosition) -> &mut Self[src]

Indicates where on the tail node to attach the tail of the edge.

fn tail_target(&mut self, tail_target: String) -> &mut Self[src]

If the edge has a tailURL, tailtarget determines which window of the browser is used for the URL.

fn tail_tooltip(&mut self, tail_tooltip: String) -> &mut Self[src]

Tooltip annotation attached to the tail of an edge.

fn tail_url(&mut self, tail_url: String) -> &mut Self[src]

If defined, tailURL is output as part of the tail label of the edge. Also, this value is used near the tail node, overriding any URL value.

fn target(&mut self, target: String) -> &mut Self[src]

If the object has a URL, this attribute determines which window of the browser is used for the URL.

fn tooltip(&mut self, tooltip: String) -> &mut Self[src]

Tooltip annotation attached to the node or edge. If unset, Graphviz will use the object’s label if defined. Note that if the label is a record specification or an HTML-like label, the resulting tooltip may be unhelpful. In this case, if tooltips will be generated, the user should set a tooltip attribute explicitly.

fn url(&mut self, url: String) -> &mut Self[src]

Hyperlinks incorporated into device-dependent output.

fn weight(&mut self, weight: u32) -> &mut Self[src]

Weight of edge. The heavier the weight, the shorter, straighter and more vertical the edge is. default: 1, minimum: 0

fn xlabel(&mut self, xlabel: String) -> &mut Self[src]

External label for a node or edge. The label will be placed outside of the node but near it. These labels are added after all nodes and edges have been placed. The labels will be placed so that they do not overlap any node or label. This means it may not be possible to place all of them. To force placing all of them, set forcelabels=true.

fn xlp(&mut self, xlp: Point) -> &mut Self[src]

Position of an exterior label, in points. The position indicates the center of the label.

Loading content...

Implementors

impl<'a> EdgeAttributes<'a> for EdgeAttributeStatementBuilder<'a>[src]

impl<'a> EdgeAttributes<'a> for EdgeBuilder<'a>[src]

Loading content...