Enum ProtocolType 

pub enum ProtocolType {
    Halfblocks,
    Sixel,
    Kitty,
    Iterm2,
}

Serde-friendly protocol-type enum for Picker.

Variants

Halfblocks

Sixel

Kitty

Iterm2

Implementations

impl ProtocolType

pub fn next(&self) -> ProtocolType

Examples found in repository

examples/demo/main.rs (line 175)

    pub fn on_key(&mut self, c: char) -> bool {
        match c {
            'q' => {
                self.should_quit = true;
            }
            't' => {
                self.show_images = match self.show_images {
                    ShowImages::All => ShowImages::Fixed,
                    ShowImages::Fixed => ShowImages::Resized,
                    ShowImages::Resized => ShowImages::All,
                }
            }
            'i' => {
                // Normally, we *never* would want to switch the detected protocol.
                // This is for some debug session, where you want to test some other protocol than
                // the detected.
                // Changing "live" is also quite hazardous, as this will render some artifacts in
                // between, or even trigger error messages, or crashes.
                // If you need to "downgrade" e.g. to Halfblocks, then do it before any renders.
                let next = self.picker.protocol_type().next();
                self.picker.set_protocol_type(next);
                self.reset_images();
            }
            'o' => {
                let path = match self.image_source_path.to_str() {
                    Some("./assets/Ada.png") => "./assets/Jenkins.png",
                    Some("./assets/Jenkins.png") => "./assets/NixOS.png",
                    _ => "./assets/Ada.png",
                };
                self.image_source = image::ImageReader::open(path).unwrap().decode().unwrap();
                self.image_source_path = path.into();
                self.reset_images();
            }
            'H' => {
                if self.split_percent >= 10 {
                    self.split_percent -= 10;
                }
            }
            'L' => {
                if self.split_percent <= 90 {
                    self.split_percent += 10;
                }
            }
            'h' => {
                let (pos, _, _) = &mut self.image_sliced_position;
                if pos.x > 0 {
                    pos.x -= 1;
                }
            }
            'j' => {
                let (pos, _, _) = &mut self.image_sliced_position;
                if let Some(viewport) = self.image_sliced_viewport
                    && (pos.y < 0 || (pos.y as u16) < viewport.height.saturating_sub(1))
                {
                    pos.y += 1;
                }
            }
            'k' => {
                let (pos, _, _) = &mut self.image_sliced_position;
                if pos.y > 0
                    || pos.y.unsigned_abs() < self.image_sliced.size().height.saturating_sub(1)
                {
                    pos.y -= 1;
                }
            }
            'l' => {
                let (pos, _, _) = &mut self.image_sliced_position;
                if let Some(viewport) = self.image_sliced_viewport
                    && pos.x
                        < (viewport
                            .width
                            .saturating_sub(self.image_sliced.size().width)
                            as i16)
                {
                    pos.x += 1;
                }
            }
            'a' => {
                self.image_sliced_position.2 = !self.image_sliced_position.2;
            }
            _ => {
                return false;
            }
        }
        true
    }

Trait Implementations

impl Clone for ProtocolType

fn clone(&self) -> ProtocolType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProtocolType

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

Formats the value using the given formatter.

impl PartialEq for ProtocolType

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

impl StructuralPartialEq for ProtocolType