ClipboardCopyErrorReports,

        (ClipboardCopyErrorReports, ClipboardCopyErrorReports) => true,

        (ClipboardCopyErrorReports, _) => false,

            "Hide errors"

            "hide errors"

            "Show errors"

            "show errors"

        if !report.hidden {
            bindings.push(Binding {
                key: "S-C-c",
                label: "copy errors",
                msg: Some(FilteredMsg::ClipboardCopyErrorReports),
            });
        }

        Msg::View(msg) => update_from_app(state, msg),

        Msg::View(msg) => update_from_view(state, msg),

fn update_from_app(state: &mut State, msg: view::Msg) -> Task<Msg> {

fn update_from_view(state: &mut State, msg: view::Msg) -> Task<Msg> {

            if !state.model.report.hidden {
                // Mark all entries as seen
                state
                    .model
                    .report
                    .entries
                    .iter_mut()
                    .for_each(|entry| entry.is_read = true);
            }

        }
        action::FilteredMsg::ClipboardCopyErrorReports => {
            let to_copy = report::entries_to_string(&state.model.report);
            task::clipboard_write(to_copy)

                    "c" if mods == Modifiers::SHIFT | Modifiers::CTRL => {
                        action(action::FilteredMsg::ClipboardCopyErrorReports)
                    }

pub fn entries_to_string(report: &Container) -> String {
    use std::fmt::Write;
    let mut output = "".to_string();
    report.entries.iter().for_each(
        |Entry {
             level,
             msg,
             time,
             is_read: _,
         }| {
            let level = match level {
                Level::Warning => "WARNING",
                Level::Error => "ERROR",
            };
            writeln!(&mut output, "{time} - {level}: {msg}").unwrap();
        },
    );
    output
}