Struct broot::image::ImageView

pub struct ImageView { /* private fields */ }

an imageview can display an image in the terminal with a ratio of one pixel per char in width.

Implementations

impl ImageView

pub fn new(path: &Path) -> Result<Self, ProgramError>

Examples found in repository

src/preview/preview.rs (line 45)

    pub fn new(
        path: &Path,
        prefered_mode: Option<PreviewMode>,
        con: &AppContext,
    ) -> Self {
        match prefered_mode {
            Some(PreviewMode::Hex) => Self::hex(path),
            Some(PreviewMode::Image) => Self::image(path),
            Some(PreviewMode::Text) => Self::unfiltered_text(path, con),
            None => {
                // automatic behavior: image, text, hex
                ImageView::new(path)
                    .map(Self::Image)
                    .unwrap_or_else(|_| Self::unfiltered_text(path, con))
            }
        }
    }
    /// try to build a preview with the designed mode, return an error
    /// if that wasn't possible
    pub fn with_mode(
        path: &Path,
        mode: PreviewMode,
        con: &AppContext,
    ) -> Result<Self, ProgramError> {
        match mode {
            PreviewMode::Hex => {
                Ok(HexView::new(path.to_path_buf()).map(Self::Hex)?)
            }
            PreviewMode::Image => {
                ImageView::new(path).map(Self::Image)
            }
            PreviewMode::Text => {
                Ok(
                    SyntacticView::new(path, InputPattern::none(), &mut Dam::unlimited(), con, false)
                        .transpose()
                        .expect("syntactic view without pattern shouldn't be none")
                        .map(Self::Syntactic)?,
                )
            }
        }
    }
    /// build an image view, unless the file can't be interpreted
    /// as an image, in which case a hex view is used
    pub fn image(path: &Path) -> Self {
        ImageView::new(path)
            .ok()
            .map(Self::Image)
            .unwrap_or_else(|| Self::hex(path))

    }

pub fn is_png(&self) -> bool

pub fn display(
    &mut self,
    w: &mut W,
    disc: &DisplayContext<'_>,
    area: &Area
) -> Result<(), ProgramError>

Examples found in repository

src/preview/preview.rs (line 255)

    pub fn display(
        &mut self,
        w: &mut W,
        disc: &DisplayContext,
        area: &Area,
    ) -> Result<(), ProgramError> {
        let panel_skin = &disc.panel_skin;
        let screen = disc.screen;
        let con = &disc.con;
        match self {
            Self::Image(iv) => iv.display(w, disc, area),
            Self::Syntactic(sv) => sv.display(w, screen, panel_skin, area, con),
            Self::ZeroLen(zlv) => zlv.display(w, screen, panel_skin, area),
            Self::Hex(hv) => hv.display(w, screen, panel_skin, area),
            Self::IoError(err) => {
                let mut y = area.top;
                w.queue(cursor::MoveTo(area.left, y))?;
                let mut cw = CropWriter::new(w, area.width as usize);
                cw.queue_str(&panel_skin.styles.default, "An error prevents the preview:")?;
                cw.fill(&panel_skin.styles.default, &SPACE_FILLING)?;
                y += 1;
                w.queue(cursor::MoveTo(area.left, y))?;
                let mut cw = CropWriter::new(w, area.width as usize);
                cw.queue_g_string(&panel_skin.styles.status_error, err.to_string())?;
                cw.fill(&panel_skin.styles.default, &SPACE_FILLING)?;
                y += 1;
                while y < area.top + area.height {
                    w.queue(cursor::MoveTo(area.left, y))?;
                    let mut cw = CropWriter::new(w, area.width as usize);
                    cw.fill(&panel_skin.styles.default, &SPACE_FILLING)?;
                    y += 1;
                }
                Ok(())
            }
        }
    }

pub fn display_info(
    &mut self,
    w: &mut W,
    _screen: Screen,
    panel_skin: &PanelSkin,
    area: &Area
) -> Result<(), ProgramError>

Examples found in repository

src/preview/preview.rs (line 289)

    pub fn display_info(
        &mut self,
        w: &mut W,
        screen: Screen,
        panel_skin: &PanelSkin,
        area: &Area,
    ) -> Result<(), ProgramError> {
        match self {
            Self::Image(iv) => iv.display_info(w, screen, panel_skin, area),
            Self::Syntactic(sv) => sv.display_info(w, screen, panel_skin, area),
            Self::Hex(hv) => hv.display_info(w, screen, panel_skin, area),
            _ => Ok(()),
        }
    }