Log viewer

use iced::{Element, Task};
use iced_cube::data::log_viewer::{self, Event, Level, Output, State, entry, log_viewer};

use crate::bridge;

#[derive(Debug, Clone)]
pub enum Message {
    Logs(Event),
}

#[derive(Debug)]
pub struct Example {
    logs: State,
}

impl Default for Example {
    fn default() -> Self {
        // Trace and debug lines are hidden, and the search marks every
        // line that mentions a timeout, starting at the first.
        let mut logs = State::new()
            .with_levels([Level::Info, Level::Warn, Level::Error])
            .with_wrap(true);
        logs.extend((0..240).map(|n| {
            let (level, message) = match n % 8 {
                0 => (Level::Info, format!("job {n} started")),
                1 => (Level::Debug, format!("job {n} read 3 inputs")),
                2 => (Level::Trace, format!("job {n} polled the queue")),
                3 => (
                    Level::Info,
                    format!("job {n} finished in {}ms", 40 + n % 50),
                ),
                4 => (
                    Level::Warn,
                    format!(
                        "job {n} is retrying after a timeout talking to the storage \
                         service, attempt 2 of 5, backing off for 800ms"
                    ),
                ),
                5 => (Level::Info, format!("uploaded report {n}")),
                6 => (
                    Level::Error,
                    format!("job {n} failed: timeout waiting for a lock"),
                ),
                _ => (Level::Info, format!("job {n} cleaned up")),
            };
            entry(level, message).target("scheduler")
        }));
        let _ = logs.update(Event::Search("timeout".into()));
        let _ = logs.update(Event::NextMatch);

        Self { logs }
    }
}

impl Example {
    pub fn update(&mut self, message: Message) -> Task<Message> {
        let Message::Logs(event) = message;
        match self.logs.update(event) {
            Some(Output::Copy(text)) => bridge::copy(text),
            Some(Output::FocusSearch) => log_viewer::focus_search(&self.logs),
            _ => Task::none(),
        }
    }

    pub fn view(&self) -> Element<'_, Message> {
        log_viewer(&self.logs)
            .height(380)
            .on_event(Message::Logs)
            .into()
    }
}

crates/gallery/src/stories/log_viewer/filtering.rs

use iced::widget::{column, text};
use iced::{Element, Task};
use iced_cube::context_menu;
use iced_cube::data::log_viewer::{
    self, Action, Event, Level, LineId, MenuItem, Output, State, entry, log_viewer,
};
use iced_cube::dropdown_menu;
use iced_cube::keys::{Chord, Keymap};
use iced_cube::theme::text_size;

use crate::bridge;

#[derive(Debug, Clone)]
pub enum Message {
    Logs(Event),
    Menu(context_menu::Event<MenuItem, LineId>),
}

#[derive(Debug)]
pub struct Example {
    logs: State,
    menu: context_menu::State<MenuItem, LineId>,
    keymap: Keymap<Action>,
    copied: String,
}

impl Default for Example {
    fn default() -> Self {
        let mut logs = State::new();
        logs.extend((0..120).map(|n| {
            let level = Level::ALL[n % Level::ALL.len()];
            entry(level, format!("step {n} of the nightly backup")).timestamp(format!(
                "02:{:02}:{:02}.000",
                n / 60,
                n % 60
            ))
        }));

        // The defaults, plus J and K.
        let keymap = log_viewer::default_keymap()
            .bind(Chord::character('j'), Action::Next)
            .bind(Chord::character('k'), Action::Previous);

        Self {
            logs,
            menu: log_viewer::menu(),
            keymap,
            copied: "Nothing copied yet".into(),
        }
    }
}

impl Example {
    pub fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::Logs(event) => self.logs(event),
            Message::Menu(event) => {
                let chosen = self.menu.update(event);
                match (chosen, self.menu.target()) {
                    (Some(dropdown_menu::Output::Activated(item)), Some(&id)) => {
                        self.logs(item.event(id))
                    }
                    _ => Task::none(),
                }
            }
        }
    }

    fn logs(&mut self, event: Event) -> Task<Message> {
        match self.logs.update(event) {
            Some(Output::Copy(lines)) => {
                self.copied = format!("Copied {} line(s)", lines.lines().count());
                bridge::copy(lines)
            }
            Some(Output::FocusSearch) => log_viewer::focus_search(&self.logs),
            _ => Task::none(),
        }
    }

    pub fn view(&self) -> Element<'_, Message> {
        column![
            text(
                "Click a line, then use the arrows or J and K. Space and Shift+arrows select, \
                 Ctrl+C copies, Ctrl+F searches and F3 steps through matches. Right-click, \
                 press and hold, or Shift+F10 opens a line's menu."
            )
            .size(text_size::SM),
            log_viewer(&self.logs)
                .keymap(self.keymap.clone())
                .context_menu(&self.menu, Message::Menu)
                .height(320)
                .on_event(Message::Logs),
            text(&self.copied).size(text_size::SM),
        ]
        .spacing(12)
        .into()
    }
}

crates/gallery/src/stories/log_viewer/keyboard.rs