Struct cursive_core::theme::Palette

pub struct Palette { /* private fields */ }

Color configuration for the application.

Assign each color role an actual color.

It implements Index and IndexMut to access and modify this mapping:

It also implements Extend to update a batch of colors at once.

Example

use cursive_core::theme::{BaseColor::*, Color::*, PaletteColor::*};

let mut palette = Palette::default();

assert_eq!(palette[Background], Dark(Blue));
palette[Shadow] = Light(Red);
assert_eq!(palette[Shadow], Light(Red));

let colors = vec![(Shadow, Dark(Green)), (Primary, Light(Blue))];
palette.extend(colors);
assert_eq!(palette[Shadow], Dark(Green));
assert_eq!(palette[Primary], Light(Blue));

Implementations

impl Palette

pub fn custom<'a>(&'a self, key: &str) -> Option<&'a Color>

Returns a custom color from this palette.

Returns None if the given key was not found.

pub fn merge(&self, namespace: &str) -> Self

Returns a new palette where the given namespace has been merged.

All values in the namespace will override previous values.

pub fn set_color(&mut self, key: &str, color: Color)

Sets the color for the given key.

This will update either the basic palette or the custom values.

pub fn set_basic_color(
    &mut self,
    key: &str,
    color: Color
) -> Result<(), NoSuchColor>

Sets a basic color from its name.

Returns Err(()) if key is not a known PaletteColor.

pub fn add_namespace(
    &mut self,
    key: &str,
    namespace: HashMap<String, PaletteNode, RandomState>
)

Adds a color namespace to this palette.

Trait Implementations

impl Clone for Palette

fn clone(&self) -> Palette

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Palette

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

Formats the value using the given formatter.

impl Default for Palette

Returns the default palette for a cursive application.

• Background => Dark(Blue)
• Shadow => Dark(Black)
• View => Dark(White)
• Primary => Dark(Black)
• Secondary => Dark(Blue)
• Tertiary => Light(White)
• TitlePrimary => Dark(Red)
• TitleSecondary => Dark(Yellow)
• Highlight => Dark(Red)
• HighlightInactive => Dark(Blue)
• HighlightText => Dark(White)

fn default() -> Palette

Returns the “default value” for a type.

impl Extend<(PaletteColor, Color)> for Palette

fn extend<T>(&mut self, iter: T)where
    T: IntoIterator<Item = (PaletteColor, Color)>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Index<PaletteColor> for Palette

type Output = Color

The returned type after indexing.

fn index(&self, palette_color: PaletteColor) -> &Color

Performs the indexing (container[index]) operation.

impl IndexMut<PaletteColor> for Palette

fn index_mut(&mut self, palette_color: PaletteColor) -> &mut Color

Performs the mutable indexing (container[index]) operation.

impl PartialEq<Palette> for Palette

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Palette

impl StructuralEq for Palette

impl StructuralPartialEq for Palette