Struct EntryRenderData

pub struct EntryRenderData<'a> {
    pub illegal_char_for_hotkey: Option<char>,
    pub kind: &'a EntryKind,
    pub key_combo_sequence: Option<Vec<KeyCombo>>,
    /* private fields */
}

This struct represents the data that will be used to render an entry in the list. It is used in conjunction with the search query to determine how to render the entry.

It holds the prefix, search hit and suffix of the entry name, the next character after the search hit, the kind of the entry and the shortcut assigned to the entry.

This allows us to render the entry in the UI with the search hit underlined and the shortcut displayed next to the entry.

For example, if the entry name is “Cargo.toml” and the search query is “ar”, the prefix will be “C”, the search hit will be “ar”, the suffix will be “go.toml”, the next character will be “g” (the character immediately after the search hit)

The shortcut is assigned at a later stage and is used to quickly jump to the entry.

Fields

illegal_char_for_hotkey: Option<char>

The character that shouldn’t appear in a hotkey sequence for the entry. That’s normally the first character of the name or first character after the search hit. The idea is to allow the user to be able finish writing out the entry name without jumping to the entry itself.

NOTE: that the character is converted to lowercase before being stored, since our search is case insensitive.

kind: &'a EntryKind

The kind of the entry, we need to keep track of this because we render directories differently than files.

key_combo_sequence: Option<Vec<KeyCombo>>

The key combo sequence assigned to the entry, it’s an optional sequence of key combos.

Implementations

impl EntryRenderData<'_>

pub fn from_entry<T: AsRef<str>>( entry: &Entry, search_query: T, ) -> EntryRenderData<'_>

Trait Implementations

impl<'a> Debug for EntryRenderData<'a>

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

Formats the value using the given formatter.

impl<'a> From<EntryRenderData<'a>> for ListItem<'a>

fn from(value: EntryRenderData<'a>) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for EntryRenderData<'a>

fn eq(&self, other: &EntryRenderData<'a>) -> 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<'a> StructuralPartialEq for EntryRenderData<'a>