version = "2.5.0"

checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"

 "windows-targets 0.52.5",

version = "0.3.9"

checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"

 "bitflags 2.5.0",

 "bitflags 2.5.0",

 "bitflags 2.5.0",

 "rustix",

 "bitflags 2.5.0",

 "bitflags 2.5.0",

 "bitflags 2.5.0",

 "termion 2.0.3",

version = "0.2.155"

checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"

name = "libredox"

version = "0.0.2"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"

dependencies = [

 "bitflags 2.5.0",

 "libc",

 "redox_syscall",

]

[[package]]

name = "numtoa"

version = "0.1.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"

[[package]]

 "termion 3.0.0",

name = "redox_termios"

version = "0.1.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "20145670ba436b55d91fc92d25e71160fbfbdd57831631c8d7d36377a476f1cb"

[[package]]

 "bitflags 2.5.0",

 "linux-raw-sys",

 "rustix",

name = "termion"

version = "2.0.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "c4648c7def6f2043b2568617b9f9b75eae88ca185dbc1f1fda30e95a85d49d7d"

dependencies = [

 "libc",

 "libredox",

 "numtoa",

 "redox_termios",

]

[[package]]

name = "termion"

version = "3.0.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "417813675a504dfbbf21bfde32c03e5bf9f2413999962b479023c02848c1c7a5"

dependencies = [

 "libc",

 "libredox",

 "numtoa",

 "redox_termios",

]

[[package]]

 "windows-targets 0.52.5",

 "windows-targets 0.52.5",

version = "0.52.5"

checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"

 "windows_aarch64_gnullvm 0.52.5",

 "windows_aarch64_msvc 0.52.5",

 "windows_i686_gnu 0.52.5",

 "windows_i686_msvc 0.52.5",

 "windows_x86_64_gnu 0.52.5",

 "windows_x86_64_gnullvm 0.52.5",

 "windows_x86_64_msvc 0.52.5",

version = "0.52.5"

checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"

version = "0.52.5"

checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"

version = "0.52.5"

checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"

version = "0.52.5"

checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"

version = "0.52.5"

checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"

version = "0.52.5"

checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"

version = "0.52.5"

checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"

version = "0.52.5"

checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"

 "linux-raw-sys",

 "rustix",

    term::pager::page(pretty)?;

inquire = { version = "0.7.4", default-features = false, features = ["termion", "editor"] }

termion = "3"

        } else {

            let tty = termion::get_tty()?;

    termion::terminal_size().map(|(cols, _)| cols as usize).ok()

    termion::terminal_size().map(|(_, rows)| rows as usize).ok()

    termion::terminal_size()

pub mod pager;

use std::io::{IsTerminal, Write};

use std::{io, thread};

use crate::element::Size;

use crate::{Constraint, Element, Line, Paint};

use crossbeam_channel as chan;

use radicle_signals as signals;

use termion::event::{Event, Key, MouseButton, MouseEvent};

use termion::{input::TermRead, raw::IntoRawMode, screen::IntoAlternateScreen};

/// How many lines to scroll when the mouse wheel is used.

const MOUSE_SCROLL_LINES: usize = 3;

/// Pager error.

#[derive(Debug, thiserror::Error)]

pub enum Error {

    #[error(transparent)]

    Io(#[from] io::Error),

    #[error(transparent)]

    Channel(#[from] chan::RecvError),

}

/// A pager for the given element. Re-renders the element when the terminal is resized so that

/// it doesn't wrap. If the output device is not a TTY, just prints the element via

/// [`Element::print`].

///

/// # Signal Handling

///

/// This will install handlers for the pager until finished by the user, with there

/// being only one element handling signals at a time. If the pager cannot install

/// handlers, then it will return with an error.

pub fn page<E: Element + Send + 'static>(element: E) -> Result<(), Error> {

    let (events_tx, events_rx) = chan::unbounded();

    let (signals_tx, signals_rx) = chan::unbounded();

    signals::install(signals_tx)?;

    thread::spawn(move || {

        for e in io::stdin().events() {

            events_tx.send(e).ok();

        }

    });

    let result = thread::spawn(move || main(element, signals_rx, events_rx))

        .join()

        .unwrap();

    signals::uninstall()?;

    result

}

fn main<E: Element>(

    element: E,

    signals_rx: chan::Receiver<signals::Signal>,

    events_rx: chan::Receiver<Result<Event, io::Error>>,

) -> Result<(), Error> {

    let stdout = io::stdout();

    if !stdout.is_terminal() {

        element.print();

        return Ok(());

    }

    let raw = stdout.into_raw_mode()?;

    let mut stdout = termion::input::MouseTerminal::from(raw).into_alternate_screen()?;

    let (mut width, mut height) = termion::terminal_size()?;

    let mut lines = element.render(Constraint::max(Size::new(width as usize, height as usize)));

    let mut line = 0;

    render(&mut stdout, lines.as_slice(), line, (width, height))?;

    loop {

        chan::select! {

            recv(signals_rx) -> signal => {

                match signal? {

                    signals::Signal::WindowChanged => {

                        let (w, h) = termion::terminal_size()?;

                        lines = element.render(Constraint::max(Size::new(w as usize, h as usize)));

                        width = w;

                        height = h;

                    }

                    signals::Signal::Interrupt | signals::Signal::Terminate => {

                        break;

                    }

                    _ => continue,

                }

            }

            recv(events_rx) -> event => {

                let event = event??;

                let page = height as usize - 1; // Don't count the status bar.

                let end = if page > lines.len() { 0 } else { lines.len() - page };

                let prev = line;

                match event {

                    Event::Key(key) => match key {

                        Key::Up | Key::Char('k') => {

                            line = line.saturating_sub(1);

                        }

                        Key::Home => {

                            line = 0;

                        }

                        Key::End | Key::Char('G') => {

                            line = end;

                        }

                        Key::PageUp | Key::Char('b') => {

                            line = line.saturating_sub(page);

                        }

                        Key::PageDown | Key::Char(' ') => {

                            line = (line + page).min(end);

                        }

                        Key::Down | Key::Char('j') => {

                            if line < end {

                                line += 1;

                            }

                        }

                        Key::Char('q') => break,

                        _ => continue,

                    }

                    Event::Mouse(MouseEvent::Press(MouseButton::WheelDown, _, _)) => {

                        if line < end {

                            line += MOUSE_SCROLL_LINES;

                        }

                    }

                    Event::Mouse(MouseEvent::Press(MouseButton::WheelUp, _, _)) => {

                        line = line.saturating_sub(MOUSE_SCROLL_LINES);

                    }

                    _ => continue,

                }

                // Don't re-render if there's no change in line.

                if line == prev {

                    continue;

                }

            }

        }

        render(&mut stdout, &lines, line, (width, height))?;

    }

    Ok(())

}

fn render<W: Write>(

    out: &mut W,

    lines: &[Line],

    start_line: usize,

    (width, height): (u16, u16),

) -> io::Result<()> {

    write!(

        out,

        "{}{}",

        termion::clear::All,

        termion::cursor::Goto(1, 1)

    )?;

    let content_length = lines.len();

    let window_size = height as usize - 1;

    let end_line = if start_line + window_size > content_length {

        content_length

    } else {

        start_line + window_size

    };

    // Render content.

    for (ix, line) in lines[start_line..end_line].iter().enumerate() {

        write!(out, "{}{}", termion::cursor::Goto(1, ix as u16 + 1), line)?;

    }

    // Render progress meter.

    write!(

        out,

        "{}{}",

        termion::cursor::Goto(width - 3, height),

        Paint::new(format!(

            "{:.0}%",

            end_line as f64 / lines.len() as f64 * 100.

        ))

        .dim()

    )?;

    // Render cursor input area.

    write!(

        out,

        "{}{}",

        termion::cursor::Goto(1, height),

        Paint::new(":").dim()

    )?;

    out.flush()?;

    Ok(())

}

use std::io::{IsTerminal, Write};

    animation: impl io::Write + Send + 'static,

                let mut animation = termion::cursor::HideCursor::from(animation);

                                write!(animation, "\r{}", termion::clear::UntilNewline).ok();

                            write!(

                                animation,

                                "\r{}{spinner} {message}",

                                termion::clear::UntilNewline,

                            )

                            .ok();

                            write!(animation, "\r{}", termion::clear::UntilNewline).ok();

                            write!(animation, "\r{}", termion::clear::UntilNewline).ok();

                            write!(animation, "\r{}", termion::clear::UntilNewline).ok();

                            write!(animation, "\r{}", termion::clear::UntilNewline).ok();