Struct Rule

Source

pub struct Rule {
    pub gradient: Option<Box<dyn Gradient>>,
    pub symbol_set: Set,
    pub orientation: Orientation,
    pub padding: Padding,
    pub vertical_alignment: VerticalAlignment,
    pub horizontal_alignment: Alignment,
    pub extra_rep_1: usize,
    pub extra_rep_2: usize,
    pub bg: Bg,
    pub area_margin: Margin,
}

Expand description

§Allows:

- Vertical alignment
- Horizontal alignment
- Horizontal and vertical paddings
- Center symbols
- Horizontal and vertical orientation
- Colorgrad gradients
- Start and end symbols

Fields§

§gradient: Option<Box<dyn Gradient>>§symbol_set: Set§orientation: Orientation§padding: Padding§vertical_alignment: VerticalAlignment§horizontal_alignment: Alignment§extra_rep_1: usize§extra_rep_2: usize§bg: Bg§area_margin: Margin

Implementations§

Source §

impl Rule

Source

pub fn new() -> Self

generates a new rule that looks like ───────────── with no gradient and no padding centered horizontally and vertically by default

Source

pub fn area_margin(self, margin: Margin) -> Self

Source

pub fn bg_solid(self, c: Color) -> Self

makes the bg solid

Source

pub fn bg_same_gradient(self) -> Self

makes the bg use the same gradient as the fg

Source

pub fn bg_gradient<G: Gradient + 'static>(self, g: G) -> Self

makes the bg a custom gradient

Source

pub fn bg(self, bg: Bg) -> Self

Examples found in repository ?

examples/x.rs (line 17)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered().title_top(
8                    Line::from(generate_gradient_text!(
9                        "ASCII",
10                        colorgrad::preset::warm()
11                    ))
12                    .centered(),
13                );
14                let rule_hor = Rule::from_set(
15                    presets::horizontal::ASCII,
16                )
17                .bg(Bg::Solid(Color::Green))
18                .horizontal_padding(1)
19                .with_gradient(colorgrad::preset::warm());
20                f.render_widget(rule_hor, f.area());
21                f.render_widget(block, f.area());
22            })?;
23            let event = event::read()?;
24            if let Event::Key(key_event) = event {
25                if key_event.kind == KeyEventKind::Press {
26                    match key_event.code {
27                        KeyCode::Char('q') => {
28                            break Ok(());
29                        }
30                        _ => {}
31                    }
32                }
33            }
34        }
35    }

Source

pub fn new_vertical() -> Self

creates a new vertical rule

Source

pub fn from_set(set: Set) -> Self

Creates a new rule instance from a Set struct

let rule = Rule::from_set(presets::horizontal::ASCII);
// Has the start, end, center, right, and left symbols from the horizontal ASCII preset
frame.render_widget(rule, frame.area())

Examples found in repository ?

examples/hor_gradient_padding.rs (lines 8-10)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule = Rule::from_set(
9                    presets::test_sets::HORIZONTAL,
10                )
11                .with_gradient(colorgrad::preset::warm())
12                .horizontal_padding(4);
13                f.render_widget(rule, f.area());
14                f.render_widget(block, f.area());
15            })?;
16            let event = event::read()?;
17
18            if let Event::Key(key_event) = event {
19                if key_event.kind == KeyEventKind::Press {
20                    if let KeyCode::Char('q') =
21                        key_event.code
22                    {
23                        break Ok(());
24                    }
25                }
26            }
27        }
28    }

More examples

Hide additional examples

examples/vert_gradient_padding.rs (lines 8-10)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule = Rule::from_set(
9                    presets::test_sets::VERTICAL,
10                )
11                .with_gradient(colorgrad::preset::warm())
12                .vertical()
13                .vertical_padding(1);
14                f.render_widget(rule, f.area());
15                f.render_widget(block, f.area());
16            })?;
17            let event = event::read()?;
18
19            if let Event::Key(key_event) = event {
20                if key_event.kind == KeyEventKind::Press {
21                    if let KeyCode::Char('q') =
22                        key_event.code
23                    {
24                        break Ok(());
25                    }
26                }
27            }
28        }
29    }

examples/x.rs (lines 14-16)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered().title_top(
8                    Line::from(generate_gradient_text!(
9                        "ASCII",
10                        colorgrad::preset::warm()
11                    ))
12                    .centered(),
13                );
14                let rule_hor = Rule::from_set(
15                    presets::horizontal::ASCII,
16                )
17                .bg(Bg::Solid(Color::Green))
18                .horizontal_padding(1)
19                .with_gradient(colorgrad::preset::warm());
20                f.render_widget(rule_hor, f.area());
21                f.render_widget(block, f.area());
22            })?;
23            let event = event::read()?;
24            if let Event::Key(key_event) = event {
25                if key_event.kind == KeyEventKind::Press {
26                    match key_event.code {
27                        KeyCode::Char('q') => {
28                            break Ok(());
29                        }
30                        _ => {}
31                    }
32                }
33            }
34        }
35    }

examples/no_gradient.rs (lines 8-10)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule_vert = Rule::from_set(
9                    presets::test_sets::VERTICAL,
10                )
11                .horizontal_alignment(Alignment::Left)
12                .vertical()
13                .horizontal_padding(4)
14                .vertical_padding(1);
15                let rule_hor = Rule::from_set(
16                    presets::test_sets::HORIZONTAL,
17                )
18                .horizontal_padding(6);
19                f.render_widget(rule_hor, f.area());
20                f.render_widget(rule_vert, f.area());
21                f.render_widget(block, f.area());
22            })?;
23            let event = event::read()?;
24            if let Event::Key(key_event) = event {
25                if key_event.kind == KeyEventKind::Press {
26                    match key_event.code {
27                        KeyCode::Char('q') => {
28                            break Ok(());
29                        }
30                        _ => {}
31                    }
32                }
33            }
34        }
35    }

examples/preset_examples.rs (lines 16-18)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered().title_top(
8                    Line::from(
9                        crate::generate_gradient_text!(
10                            "Vertical",
11                            colorgrad::preset::warm()
12                        ),
13                    )
14                    .centered(),
15                );
16                let rule_hor = Rule::from_set(
17                    presets::test_sets::VERTICAL,
18                ).vertical()
19                .vertical_padding(1)
20                .with_gradient(colorgrad::preset::warm());
21                f.render_widget(rule_hor, f.area());
22                f.render_widget(block, f.area());
23            })?;
24            let event = event::read()?;
25            if let Event::Key(key_event) = event {
26                if key_event.kind == KeyEventKind::Press {
27                    match key_event.code {
28                        KeyCode::Char('q') => {
29                            break Ok(());
30                        }
31                        _ => {}
32                    }
33                }
34            }
35        }
36    }

Source

pub fn new_with_gradient<G: Gradient + 'static>(gradient: G) -> Self

the new function and the with_gradient function combined

    // displays a new rule with a rainbow gradient
    Rule::new_with_gradient(colorgrad::preset::rainbow())

Source

pub fn with_gradient<G: Gradient + 'static>(self, gradient: G) -> Self

sets gradient for rule. uses colorgrad gradients

    // displays `+=====+=====+` with a rainbow gradient
    Rule::default().with_gradient(colorgrad::preset::rainbow())

Examples found in repository ?

examples/hor_gradient_padding.rs (line 11)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule = Rule::from_set(
9                    presets::test_sets::HORIZONTAL,
10                )
11                .with_gradient(colorgrad::preset::warm())
12                .horizontal_padding(4);
13                f.render_widget(rule, f.area());
14                f.render_widget(block, f.area());
15            })?;
16            let event = event::read()?;
17
18            if let Event::Key(key_event) = event {
19                if key_event.kind == KeyEventKind::Press {
20                    if let KeyCode::Char('q') =
21                        key_event.code
22                    {
23                        break Ok(());
24                    }
25                }
26            }
27        }
28    }

More examples

Hide additional examples

examples/vert_gradient_padding.rs (line 11)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule = Rule::from_set(
9                    presets::test_sets::VERTICAL,
10                )
11                .with_gradient(colorgrad::preset::warm())
12                .vertical()
13                .vertical_padding(1);
14                f.render_widget(rule, f.area());
15                f.render_widget(block, f.area());
16            })?;
17            let event = event::read()?;
18
19            if let Event::Key(key_event) = event {
20                if key_event.kind == KeyEventKind::Press {
21                    if let KeyCode::Char('q') =
22                        key_event.code
23                    {
24                        break Ok(());
25                    }
26                }
27            }
28        }
29    }

examples/x.rs (line 19)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered().title_top(
8                    Line::from(generate_gradient_text!(
9                        "ASCII",
10                        colorgrad::preset::warm()
11                    ))
12                    .centered(),
13                );
14                let rule_hor = Rule::from_set(
15                    presets::horizontal::ASCII,
16                )
17                .bg(Bg::Solid(Color::Green))
18                .horizontal_padding(1)
19                .with_gradient(colorgrad::preset::warm());
20                f.render_widget(rule_hor, f.area());
21                f.render_widget(block, f.area());
22            })?;
23            let event = event::read()?;
24            if let Event::Key(key_event) = event {
25                if key_event.kind == KeyEventKind::Press {
26                    match key_event.code {
27                        KeyCode::Char('q') => {
28                            break Ok(());
29                        }
30                        _ => {}
31                    }
32                }
33            }
34        }
35    }

examples/preset_examples.rs (line 20)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered().title_top(
8                    Line::from(
9                        crate::generate_gradient_text!(
10                            "Vertical",
11                            colorgrad::preset::warm()
12                        ),
13                    )
14                    .centered(),
15                );
16                let rule_hor = Rule::from_set(
17                    presets::test_sets::VERTICAL,
18                ).vertical()
19                .vertical_padding(1)
20                .with_gradient(colorgrad::preset::warm());
21                f.render_widget(rule_hor, f.area());
22                f.render_widget(block, f.area());
23            })?;
24            let event = event::read()?;
25            if let Event::Key(key_event) = event {
26                if key_event.kind == KeyEventKind::Press {
27                    match key_event.code {
28                        KeyCode::Char('q') => {
29                            break Ok(());
30                        }
31                        _ => {}
32                    }
33                }
34            }
35        }
36    }

Source

pub fn horizontal_padding(self, padding: u16) -> Self

sets the horizontal padding

Examples found in repository ?

examples/hor_gradient_padding.rs (line 12)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule = Rule::from_set(
9                    presets::test_sets::HORIZONTAL,
10                )
11                .with_gradient(colorgrad::preset::warm())
12                .horizontal_padding(4);
13                f.render_widget(rule, f.area());
14                f.render_widget(block, f.area());
15            })?;
16            let event = event::read()?;
17
18            if let Event::Key(key_event) = event {
19                if key_event.kind == KeyEventKind::Press {
20                    if let KeyCode::Char('q') =
21                        key_event.code
22                    {
23                        break Ok(());
24                    }
25                }
26            }
27        }
28    }

More examples

Hide additional examples

examples/x.rs (line 18)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered().title_top(
8                    Line::from(generate_gradient_text!(
9                        "ASCII",
10                        colorgrad::preset::warm()
11                    ))
12                    .centered(),
13                );
14                let rule_hor = Rule::from_set(
15                    presets::horizontal::ASCII,
16                )
17                .bg(Bg::Solid(Color::Green))
18                .horizontal_padding(1)
19                .with_gradient(colorgrad::preset::warm());
20                f.render_widget(rule_hor, f.area());
21                f.render_widget(block, f.area());
22            })?;
23            let event = event::read()?;
24            if let Event::Key(key_event) = event {
25                if key_event.kind == KeyEventKind::Press {
26                    match key_event.code {
27                        KeyCode::Char('q') => {
28                            break Ok(());
29                        }
30                        _ => {}
31                    }
32                }
33            }
34        }
35    }

examples/no_gradient.rs (line 13)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule_vert = Rule::from_set(
9                    presets::test_sets::VERTICAL,
10                )
11                .horizontal_alignment(Alignment::Left)
12                .vertical()
13                .horizontal_padding(4)
14                .vertical_padding(1);
15                let rule_hor = Rule::from_set(
16                    presets::test_sets::HORIZONTAL,
17                )
18                .horizontal_padding(6);
19                f.render_widget(rule_hor, f.area());
20                f.render_widget(rule_vert, f.area());
21                f.render_widget(block, f.area());
22            })?;
23            let event = event::read()?;
24            if let Event::Key(key_event) = event {
25                if key_event.kind == KeyEventKind::Press {
26                    match key_event.code {
27                        KeyCode::Char('q') => {
28                            break Ok(());
29                        }
30                        _ => {}
31                    }
32                }
33            }
34        }
35    }

Source

pub fn vertical_padding(self, padding: u16) -> Self

sets the vertical padding

Examples found in repository ?

examples/vert_gradient_padding.rs (line 13)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule = Rule::from_set(
9                    presets::test_sets::VERTICAL,
10                )
11                .with_gradient(colorgrad::preset::warm())
12                .vertical()
13                .vertical_padding(1);
14                f.render_widget(rule, f.area());
15                f.render_widget(block, f.area());
16            })?;
17            let event = event::read()?;
18
19            if let Event::Key(key_event) = event {
20                if key_event.kind == KeyEventKind::Press {
21                    if let KeyCode::Char('q') =
22                        key_event.code
23                    {
24                        break Ok(());
25                    }
26                }
27            }
28        }
29    }

More examples

Hide additional examples

examples/no_gradient.rs (line 14)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule_vert = Rule::from_set(
9                    presets::test_sets::VERTICAL,
10                )
11                .horizontal_alignment(Alignment::Left)
12                .vertical()
13                .horizontal_padding(4)
14                .vertical_padding(1);
15                let rule_hor = Rule::from_set(
16                    presets::test_sets::HORIZONTAL,
17                )
18                .horizontal_padding(6);
19                f.render_widget(rule_hor, f.area());
20                f.render_widget(rule_vert, f.area());
21                f.render_widget(block, f.area());
22            })?;
23            let event = event::read()?;
24            if let Event::Key(key_event) = event {
25                if key_event.kind == KeyEventKind::Press {
26                    match key_event.code {
27                        KeyCode::Char('q') => {
28                            break Ok(());
29                        }
30                        _ => {}
31                    }
32                }
33            }
34        }
35    }

examples/preset_examples.rs (line 19)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered().title_top(
8                    Line::from(
9                        crate::generate_gradient_text!(
10                            "Vertical",
11                            colorgrad::preset::warm()
12                        ),
13                    )
14                    .centered(),
15                );
16                let rule_hor = Rule::from_set(
17                    presets::test_sets::VERTICAL,
18                ).vertical()
19                .vertical_padding(1)
20                .with_gradient(colorgrad::preset::warm());
21                f.render_widget(rule_hor, f.area());
22                f.render_widget(block, f.area());
23            })?;
24            let event = event::read()?;
25            if let Event::Key(key_event) = event {
26                if key_event.kind == KeyEventKind::Press {
27                    match key_event.code {
28                        KeyCode::Char('q') => {
29                            break Ok(());
30                        }
31                        _ => {}
32                    }
33                }
34            }
35        }
36    }

Source

pub fn right_padding(self, padding: u16) -> Self

Sets the right padding

Source

pub fn left_padding(self, padding: u16) -> Self

Sets the left padding

Source

pub fn top_padding(self, padding: u16) -> Self

Sets the top padding

Source

pub fn bottom_padding(self, padding: u16) -> Self

Sets the bottom padding

Source

pub fn with_set(self, set: Set) -> Self

Sets the end, start, right, center, and left symbols from the Set struct

Source

pub fn horizontal(self) -> Self

makes the rule horizontal instead of vertical. Horizontal by default

Source

pub fn vertical(self) -> Self

makes the rule a vertical rule instead of horizontal

Examples found in repository ?

examples/vert_gradient_padding.rs (line 12)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule = Rule::from_set(
9                    presets::test_sets::VERTICAL,
10                )
11                .with_gradient(colorgrad::preset::warm())
12                .vertical()
13                .vertical_padding(1);
14                f.render_widget(rule, f.area());
15                f.render_widget(block, f.area());
16            })?;
17            let event = event::read()?;
18
19            if let Event::Key(key_event) = event {
20                if key_event.kind == KeyEventKind::Press {
21                    if let KeyCode::Char('q') =
22                        key_event.code
23                    {
24                        break Ok(());
25                    }
26                }
27            }
28        }
29    }

More examples

Hide additional examples

examples/no_gradient.rs (line 12)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule_vert = Rule::from_set(
9                    presets::test_sets::VERTICAL,
10                )
11                .horizontal_alignment(Alignment::Left)
12                .vertical()
13                .horizontal_padding(4)
14                .vertical_padding(1);
15                let rule_hor = Rule::from_set(
16                    presets::test_sets::HORIZONTAL,
17                )
18                .horizontal_padding(6);
19                f.render_widget(rule_hor, f.area());
20                f.render_widget(rule_vert, f.area());
21                f.render_widget(block, f.area());
22            })?;
23            let event = event::read()?;
24            if let Event::Key(key_event) = event {
25                if key_event.kind == KeyEventKind::Press {
26                    match key_event.code {
27                        KeyCode::Char('q') => {
28                            break Ok(());
29                        }
30                        _ => {}
31                    }
32                }
33            }
34        }
35    }

examples/preset_examples.rs (line 18)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered().title_top(
8                    Line::from(
9                        crate::generate_gradient_text!(
10                            "Vertical",
11                            colorgrad::preset::warm()
12                        ),
13                    )
14                    .centered(),
15                );
16                let rule_hor = Rule::from_set(
17                    presets::test_sets::VERTICAL,
18                ).vertical()
19                .vertical_padding(1)
20                .with_gradient(colorgrad::preset::warm());
21                f.render_widget(rule_hor, f.area());
22                f.render_widget(block, f.area());
23            })?;
24            let event = event::read()?;
25            if let Event::Key(key_event) = event {
26                if key_event.kind == KeyEventKind::Press {
27                    match key_event.code {
28                        KeyCode::Char('q') => {
29                            break Ok(());
30                        }
31                        _ => {}
32                    }
33                }
34            }
35        }
36    }

Source

pub fn rep_2(self, symb: char) -> Self

repeated symbol for right side

    Rule::default().rep_2('-')

+=====+-----+

Source

pub fn rep_1(self, symb: char) -> Self

repeated symbol for left side

    Rule::default().rep_1('-')

+-----+=====+

Source

pub fn start(self, symb: char) -> Self

first symbol

    Rule::default().start('%')

%=====+=====+

Source

pub fn end(self, symb: char) -> Self

last symbol

     Rule::default().end('%');

+=====+=====%

Source

pub fn center(self, symb: char) -> Self

center symbol

     Rule::default().center('%')

+=====%=====+

Source

pub fn main_symbol(self, symb: char) -> Self

the rep_1 and the rep_2 functions in one

Source

pub fn padding(self, padding: Padding) -> Self

Source

pub fn orientation(self, orientation: Orientation) -> Self

sets rule orientation

    // creates a vertical rule
    Rule::default().orientation(Orientation::Vertical)

/// using the .horizontal() and .vertical() methods instead is recommended for simplicity

Source

pub fn vertical_alignment(self, alignment: VerticalAlignment) -> Self

sets vertical alignment centered by default

    // creates a rule thats vertically aligned to the top
    Rule::default().vertical_alignment(VerticalAlignment::Top)

Source

pub fn horizontal_alignment(self, alignment: Alignment) -> Self

Examples found in repository ?

examples/no_gradient.rs (line 11)

2    fn run(
3        terminal: &mut DefaultTerminal,
4    ) -> io::Result<()> {
5        loop {
6            terminal.draw(|f| {
7                let block = Block::bordered();
8                let rule_vert = Rule::from_set(
9                    presets::test_sets::VERTICAL,
10                )
11                .horizontal_alignment(Alignment::Left)
12                .vertical()
13                .horizontal_padding(4)
14                .vertical_padding(1);
15                let rule_hor = Rule::from_set(
16                    presets::test_sets::HORIZONTAL,
17                )
18                .horizontal_padding(6);
19                f.render_widget(rule_hor, f.area());
20                f.render_widget(rule_vert, f.area());
21                f.render_widget(block, f.area());
22            })?;
23            let event = event::read()?;
24            if let Event::Key(key_event) = event {
25                if key_event.kind == KeyEventKind::Press {
26                    match key_event.code {
27                        KeyCode::Char('q') => {
28                            break Ok(());
29                        }
30                        _ => {}
31                    }
32                }
33            }
34        }
35    }

Trait Implementations§

Source §

impl Default for Rule

Source §

fn default() -> Self

Returns the “default value” for a type. Read more

Source §

fn render(self, area_old: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.

Source §

impl WidgetRef for Rule

Source §

fn render_ref(&self, area_old: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.

Auto Trait Implementations§

§

impl Freeze for Rule

§

impl !RefUnwindSafe for Rule

§

impl !Send for Rule

§

impl !Sync for Rule

§

impl Unpin for Rule

§

impl !UnwindSafe for Rule

Blanket Implementations§

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> IntoEither for T

Source §

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

impl<T, U> TryFrom for T
where U: Into<T>,

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct RuleCopy item path

§The Rule widget

§Allows:

Fields§

Implementations§

impl Rule

pub fn new() -> Self

pub fn area_margin(self, margin: Margin) -> Self

pub fn bg_solid(self, c: Color) -> Self

pub fn bg_same_gradient(self) -> Self

pub fn extra_rep_1(self, rep: usize) -> Self

pub fn extra_rep_2(self, rep: usize) -> Self

pub fn extra_rep(self, rep_1: usize, rep_2: usize) -> Self

pub fn bg_gradient<G: Gradient + 'static>(self, g: G) -> Self

pub fn bg(self, bg: Bg) -> Self

pub fn new_vertical() -> Self

pub fn from_set(set: Set) -> Self

pub fn new_with_gradient<G: Gradient + 'static>(gradient: G) -> Self

pub fn with_gradient<G: Gradient + 'static>(self, gradient: G) -> Self

pub fn horizontal_padding(self, padding: u16) -> Self

pub fn vertical_padding(self, padding: u16) -> Self

pub fn right_padding(self, padding: u16) -> Self

pub fn left_padding(self, padding: u16) -> Self

pub fn top_padding(self, padding: u16) -> Self

pub fn bottom_padding(self, padding: u16) -> Self

pub fn with_set(self, set: Set) -> Self

pub fn horizontal(self) -> Self

pub fn vertical(self) -> Self

pub fn rep_2(self, symb: char) -> Self

pub fn rep_1(self, symb: char) -> Self

pub fn start(self, symb: char) -> Self

pub fn end(self, symb: char) -> Self

pub fn center(self, symb: char) -> Self

pub fn main_symbol(self, symb: char) -> Self

pub fn padding(self, padding: Padding) -> Self

pub fn orientation(self, orientation: Orientation) -> Self

pub fn vertical_alignment(self, alignment: VerticalAlignment) -> Self

pub fn horizontal_alignment(self, alignment: Alignment) -> Self

Trait Implementations§

impl Default for Rule

fn default() -> Self

impl Widget for Rule

fn render(self, area_old: Rect, buf: &mut Buffer)

impl WidgetRef for Rule

fn render_ref(&self, area_old: Rect, buf: &mut Buffer)

Auto Trait Implementations§

impl Freeze for Rule

impl !RefUnwindSafe for Rule

impl !Send for Rule

impl !Sync for Rule

impl Unpin for Rule

impl !UnwindSafe for Rule

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Struct Rule

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,