Struct Chart 

pub struct Chart { /* private fields */ }

The chart representation.

Anatomy of a Chart

A chart is a collection of different components, each of which is responsible for rendering a specific part of the chart. Below is a sample chart with a few components:

                   Sales Report
  |                                                        # coffee
30|                  x                                     x juice
  |      @           x             @                       @ milk
20|    # @           x@           x@          #
  |    #x@          #x@          #x@          #x
10|    #x@          #x@          #x@          #x@
  |    #x@          #x@          #x@          #x@
 0+-----------------------------------------------------
       Jan          Feb          Mar          Apr

The chart above has the following components: an x axis, an y axis, a title on the top center, and a legend on the top right.

The creation of charts in Charming is done in a builder-like fashion. Once you get a hang of this pattern, you will find that it is very easy to compose a chart. For instance, the following code snippet shows how to create the chart above:

use charming::Chart;
use charming::component::{Axis, Legend, Title};

let chart = Chart::new()
    .title(Title::new().text("Sales Report"))
    .x_axis(Axis::new().data(vec!["Jan", "Feb", "Mar", "Apr"]))
    .y_axis(Axis::new())
    .legend(Legend::new().data(vec!["coffee", "juice", "milk"]));

Components of a Chart

The following sections describe the components of a chart in detail.

Title

Title is the title of a chart, including main title and subtitle. A chart can have multiple titles, which is useful when you want to show multiple sub- charts in a single chart.

use charming::Chart;
use charming::component::Title;

let chart = Chart::new()
    .title(Title::new().text("Sales Report"));

Legend

Legend is the legend of a chart, which is used to show the meaning of the symbols and colors in the chart. A chart can have multiple legends.

use charming::Chart;
use charming::component::Legend;

let chart = Chart::new()
    .legend(Legend::new().data(vec!["coffee", "juice", "milk"]));

Grid

Grid is the background grid in a cartesian coordinate system. A chart can have multiple grids.

use charming::Chart;
use charming::component::Grid;

let chart = Chart::new()
    .grid(Grid::new());

X Axis and Y Axis

Axis is the axis in a cartesian coordinate system.

use charming::Chart;
use charming::component::Axis;

let chart = Chart::new()
    .x_axis(Axis::new().data(vec!["Jan", "Feb", "Mar", "Apr"]))
    .y_axis(Axis::new());

Polar Coordinate

PolarCoordinate is the polar coordinate system. Polar coordinate can be used in scatter and line charts. Every polar coordinate has an AngleAxis and a RadiusAxis.

Radar Coordinate

RadarCoordinate is the radar coordinate system. Radar coordinate can be in radar charts.

Data Zoom

DataZoom is used for zooming a specific area, which enables user to view data in different scales. A chart can have multiple data zooms.

Visual Map

VisualMap is a visual encoding component. It maps data to visual channels, such as color, symbol size or symbol shape. A chart can have multiple visual maps.

Tooltip

Tooltip is a floating box that appears when user hovers over a data item.

AxisPointer

AxisPointer is a tool for displaying reference line and axis value under mouse pointer.

Toolbox

Toolbox is a feature toolbox that includes data view, save as image, data zoom, restore, and reset.

Implementations

impl Chart

pub fn new() -> Chart

pub fn title<T: Into<Title>>(self, title: T) -> Self

pub fn animation<A: Into<bool>>(self, animation: A) -> Self

pub fn animation_duration<A: Into<AnimationTime>>( self, animation_duration: A, ) -> Self

pub fn animation_threshold<A: Into<f64>>(self, animation_threshold: A) -> Self

pub fn animation_easing<A: Into<Easing>>(self, animation_easing: A) -> Self

pub fn animation_delay<A: Into<AnimationTime>>(self, animation_delay: A) -> Self

pub fn animation_duration_update<A: Into<AnimationTime>>( self, animation_duration_update: A, ) -> Self

pub fn animation_easing_update<A: Into<Easing>>( self, animation_easing_update: A, ) -> Self

pub fn animation_delay_update<A: Into<AnimationTime>>( self, animation_delay_update: A, ) -> Self

pub fn tooltip<T: Into<Tooltip>>(self, tooltip: T) -> Self

pub fn legend<L: Into<LegendConfig>>(self, legend: L) -> Self

pub fn toolbox<T: Into<Toolbox>>(self, toolbox: T) -> Self

pub fn grid<G: Into<Grid>>(self, grid: G) -> Self

pub fn grid3d<G: Into<Grid3D>>(self, grid3d: G) -> Self

pub fn x_axis<X: Into<Axis>>(self, x_axis: X) -> Self

pub fn x_axis3d<X: Into<Axis3D>>(self, x_axis3d: X) -> Self

pub fn y_axis<Y: Into<Axis>>(self, y_axis: Y) -> Self

pub fn y_axis3d<Y: Into<Axis3D>>(self, y_axis3d: Y) -> Self

pub fn z_axis3d<Z: Into<Axis3D>>(self, z_axis3d: Z) -> Self

pub fn polar<P: Into<PolarCoordinate>>(self, polar: P) -> Self

pub fn angle_axis<A: Into<AngleAxis>>(self, angle_axis: A) -> Self

pub fn radius_axis<R: Into<RadiusAxis>>(self, radius_axis: R) -> Self

pub fn single_axis<S: Into<SingleAxis>>(self, single_axis: S) -> Self

pub fn parallel_axis<P: Into<ParallelAxis>>(self, parallel_axis: P) -> Self

pub fn axis_pointer<A: Into<AxisPointer>>(self, axis_pointer: A) -> Self

pub fn visual_map<V: Into<VisualMap>>(self, visual_map: V) -> Self

pub fn data_zoom<D: Into<DataZoom>>(self, data_zoom: D) -> Self

pub fn parallel<P: Into<ParallelCoordinate>>(self, parallel: P) -> Self

pub fn calendar<C: Into<Calendar>>(self, calendar: C) -> Self

pub fn dataset<D: Into<Dataset>>(self, dataset: D) -> Self

pub fn radar<R: Into<RadarCoordinate>>(self, radar: R) -> Self

pub fn color<C: Into<Color>>(self, color: Vec<C>) -> Self

pub fn background_color<B: Into<Color>>(self, background_color: B) -> Self

pub fn mark_line<M: Into<MarkLine>>(self, mark_line: M) -> Self

pub fn aria<A: Into<Aria>>(self, aria: A) -> Self

pub fn series<S: Into<Series>>(self, series: S) -> Self

pub fn geo_map<G: Into<GeoMap>>(self, geo_map: G) -> Self

impl Chart

pub fn save_as_image_type(&self) -> Option<&SaveAsImageType>

Trait Implementations

impl Clone for Chart

fn clone(&self) -> Chart

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Chart

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Chart

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Chart

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Chart

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Chart

fn eq(&self, other: &Chart) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Chart

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Chart