Enum PaletteStyle

pub enum PaletteStyle {
    Primary,
    Secondary,
    Tertiary,
    View,
    Background,
    TitlePrimary,
    TitleSecondary,
    Highlight,
    HighlightInactive,
    Shadow,
    EditableText,
    EditableTextCursor,
    EditableTextInactive,
}

Style entry in a palette.

This represents a color “role”. The palette will resolve this to a Style.

For example, PaletteStyle::Highlight should be used when drawing highlighted text. In the default palette, it will resolve to a Style made of:

• The Reverse effect (front and background will be swapped).
• A front color of PaletteColor::Highlight (but with the reverse effect, it will become the background color).
• A back color of PaletteColor::HighlightText (will become the front color).

From there, the PaletteColor::Highlight and PaletteColor::HighlightText will be resolved to concrete colors (or possibly to InheritParent, which will inherit the previous concrete color).

To override the look of highlighted text, you can either:

• Change the palette entries for PaletteColor::Highlight/PaletteColor::HighlightText.
• Change the palette entry for PaletteStyle::Highlight, possibly using different palette colors instead (or directly specifying a concrete color there).

Variants

Primary

Style used for regular text.

Secondary

Style used for secondary text.

Tertiary

Style used for tertiary text.

View

Style used for view background.

Background

Style used for application background (behind all views).

TitlePrimary

Style used for main titles.

TitleSecondary

Style used for secondary titles.

Highlight

Style used for highlighted text.

HighlightInactive

Style used for inactive highlighted text.

Shadow

Style used to draw the drop shadows (1-cell border to the bottom/right of views).

EditableText

Style used for editable text (TextArea, EditView).

EditableTextCursor

Style used for the selected character in editable text.

EditableTextInactive

Style used for editable text when inactive.

Implementations

impl PaletteStyle

pub fn resolve(self, palette: &Palette) -> Style

Given a style palette, resolve self to a concrete style.

pub fn all() -> impl Iterator<Item = Self>

Returns an iterator on all possible palette styles.

Trait Implementations

impl Clone for PaletteStyle

fn clone(&self) -> PaletteStyle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PaletteStyle

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

Formats the value using the given formatter.

impl Enum for PaletteStyle

const LENGTH: usize = 13usize

Length of the enum.

fn from_usize(value: usize) -> Self

Takes an usize, and returns an element matching into_usize function.

fn into_usize(self) -> usize

Returns an unique identifier for a value within range of 0..Array::LENGTH.

impl<V> EnumArray<V> for PaletteStyle

type Array = [V; 13]

Representation of an enum map for type V.

impl From<PaletteStyle> for StyleType

fn from(style: PaletteStyle) -> Self

Converts to this type from the input type.

impl FromStr for PaletteStyle

type Err = NoSuchColor

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, NoSuchColor>

Parses a string s to return a value of this type.

impl Hash for PaletteStyle

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<PaletteStyle> for Palette

type Output = Style

The returned type after indexing.

fn index(&self, palette_style: PaletteStyle) -> &Style

Performs the indexing (container[index]) operation.

impl IndexMut<PaletteStyle> for Palette

fn index_mut(&mut self, palette_style: PaletteStyle) -> &mut Style

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

impl PartialEq for PaletteStyle

fn eq(&self, other: &PaletteStyle) -> 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 Resolvable for PaletteStyle

fn from_config(config: &Config, context: &Context) -> Result<Self, Error>

where Self: Sized,

Build from a config (a JSON value).

fn from_any(any: Box<dyn Any>) -> Option<Self>

where Self: Sized + Any,

Build from an Any variable.

impl Copy for PaletteStyle

impl Eq for PaletteStyle

impl StructuralPartialEq for PaletteStyle