Struct Colorization

pub struct Colorization { /* private fields */ }

Colorization sets a color for the whole table data (so it’s not include the borders).

You can colorize borders in a different round using BorderColor or Theme

Examples

use std::iter::FromIterator;

use tabled::builder::Builder;
use tabled::settings::{style::BorderColor, themes::Colorization, Color, Style};

let data = [["Hello", "World"], ["Hi", "World"], ["Halo", "World"]];

let color1 = Color::FG_BLACK | Color::BG_WHITE;
let color2 = Color::BG_BLACK | Color::FG_WHITE;
let color3 = Color::FG_RED | Color::BG_RED;

let mut table = Builder::from_iter(data).build();
table
    .with(Colorization::chess(color1, color2))
    .with(Style::modern())
    .with(BorderColor::filled(color3));

println!("{table}");

Implementations

impl Colorization

pub fn chess(white: Color, black: Color) -> Self

Creates a Colorization with a chess pattern.

use std::iter::FromIterator;

use tabled::builder::Builder;
use tabled::settings::{themes::Colorization, Color, Style};

let data = [["Hello", "World"], ["Hi", "World"], ["Halo", "World"]];

let color1 = Color::FG_BLACK | Color::BG_WHITE;
let color2 = Color::BG_BLACK | Color::FG_WHITE;

let mut table = Builder::from_iter(data).build();
table
    .with(Colorization::chess(color1, color2))
    .with(Style::empty());

println!("{table}");

pub fn exact<I, O>(colors: I, target: O) -> ExactColorization<O>

where I: IntoIterator, I::Item: Into<Color>,

Creates a Colorization with a target Object.

use std::iter::FromIterator;

use tabled::builder::Builder;
use tabled::settings::object::Rows;
use tabled::settings::{themes::Colorization, Color, Style};

let data = [["Hello", "World"], ["Hi", "World"], ["Halo", "World"]];

let color1 = Color::FG_BLACK | Color::BG_WHITE;
let color2 = Color::BG_BLACK | Color::FG_WHITE;

let mut table = Builder::from_iter(data).build();
table
    .with(Colorization::exact([color1, color2], Rows::first()))
    .with(Style::empty());

println!("{table}");

pub fn rows<I>(colors: I) -> Self

where I: IntoIterator, I::Item: Into<Color>,

Creates a Colorization with a pattern which changes row by row.

use std::iter::FromIterator;

use tabled::builder::Builder;
use tabled::settings::object::Rows;
use tabled::settings::{themes::Colorization, Color, Style};

let data = [["Hello", "World"], ["Hi", "World"], ["Halo", "World"]];

let color1 = Color::FG_BLACK | Color::BG_WHITE;
let color2 = Color::BG_BLACK | Color::FG_WHITE;

let mut table = Builder::from_iter(data).build();
table
    .with(Colorization::rows([color1, color2]))
    .with(Style::empty());

println!("{table}");

pub fn columns<I>(colors: I) -> Self

where I: IntoIterator, I::Item: Into<Color>,

Creates a Colorization with a pattern which changes column by column.

use std::iter::FromIterator;

use tabled::builder::Builder;
use tabled::settings::object::Rows;
use tabled::settings::{themes::Colorization, Color, Style};

let data = [["Hello", "World"], ["Hi", "World"], ["Halo", "World"]];

let color1 = Color::FG_BLACK | Color::BG_WHITE;
let color2 = Color::BG_BLACK | Color::FG_WHITE;

let mut table = Builder::from_iter(data).build();
table
    .with(Colorization::columns([color1, color2]))
    .with(Style::empty());

println!("{table}");

pub fn by_row<I>(colors: I) -> Self

where I: IntoIterator, I::Item: Into<Color>,

Creates a Colorization with a pattern which peaks cells one by one iterating over rows.

use std::iter::FromIterator;

use tabled::builder::Builder;
use tabled::settings::object::Rows;
use tabled::settings::{themes::Colorization, Color, Style};

let data = [["Hello", "World"], ["Hi", "World"], ["Halo", "World"]];

let color1 = Color::FG_BLACK | Color::BG_WHITE;
let color2 = Color::BG_BLACK | Color::FG_WHITE;

let mut table = Builder::from_iter(data).build();
table
    .with(Colorization::by_row([color1, color2]))
    .with(Style::empty());

println!("{table}");

pub fn by_column<I>(colors: I) -> Self

where I: IntoIterator, I::Item: Into<Color>,

Creates a Colorization with a pattern which peaks cells one by one iterating over columns.

use std::iter::FromIterator;

use tabled::builder::Builder;
use tabled::settings::object::Rows;
use tabled::settings::{themes::Colorization, Color, Style};

let data = [["Hello", "World"], ["Hi", "World"], ["Halo", "World"]];

let color1 = Color::FG_BLACK | Color::BG_WHITE;
let color2 = Color::BG_BLACK | Color::FG_WHITE;

let mut table = Builder::from_iter(data).build();
table
    .with(Colorization::by_column([color1, color2]))
    .with(Style::empty());

println!("{table}");

Trait Implementations

impl Clone for Colorization

fn clone(&self) -> Colorization

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Colorization

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

Formats the value using the given formatter.

impl PartialEq for Colorization

fn eq(&self, other: &Colorization) -> 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<R, D> TableOption<R, ColoredConfig, D> for Colorization

where R: Records + ExactRecords,

fn change(self, records: &mut R, cfg: &mut ColoredConfig, _: &mut D)

The function modificaties of records and a grid configuration.

fn hint_change(&self) -> Option<Entity>

A hint whether an TableOption is going to change table layout.

impl Eq for Colorization

impl StructuralPartialEq for Colorization