Enum youtube_tui::global::structs::KeyAction

pub enum KeyAction {
    MoveLeft,
    MoveRight,
    MoveUp,
    MoveDown,
    Select,
    Deselect,
    Exit,
    Back,
    ClearHistory,
    FirstHistory,
    Reload,
    StartCommandCapture,
    Paste,
    RemoveWord,
    ClearLine,
    PreviousWord,
    NextWord,
    First,
    End,
    PreviousEntry,
    NextEntry,
}

Part of the keybindings config

Variants

MoveLeft

Moves cursor to the left direction, or to the first item

MoveRight

Moves cursor to the right direction, or to the last item

MoveUp

Moves cursor up

MoveDown

Moves cursor dowm

Select

select the current item

Deselect

deselect the current item, reverts the cursor back to its hover state

Exit

exits/quits the entire app

Back

revert last history

ClearHistory

removes all history

FirstHistory

reverts back to first history (home page if it is not cleared)

Reload

reload the current page

StartCommandCapture

start command capture

Paste

paste text

RemoveWord

remove a word

ClearLine

removes all content in textfield

PreviousWord

move cursor to previous word in textfield

NextWord

move cursor to next word in textfield

First

move cursor to the first position

End

move cursor to the last position

PreviousEntry

Previous entry

NextEntry

Next entry

Trait Implementations

impl Clone for KeyAction

fn clone(&self) -> KeyAction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KeyAction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeyAction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<KeyAction> for KeyAction

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for KeyAction

impl Eq for KeyAction

impl StructuralEq for KeyAction

impl StructuralPartialEq for KeyAction