}
    }
}
component DiffEntry inherits Rectangle {
    VerticalBox {
        label := Text {
            text: "active diff";

    in-out property <bool> is-selected: false;
    in property <bool> has-hover;
    states [
        selected when root.is-selected: {
            root.background: Palette.selection-background;
            label.color: Palette.selection-foreground;
        }
        lowlighted when root.has-hover: {
            root.background: Palette.alternate-background;
            label.color: Palette.alternate-foreground;
        }
    ]

    in-out property <int> selected: -1;

    in-out property <int> selected: -2;
    public function deselect() {
        root.selected = -2;
    }

        diff-entry := DiffEntry {
            is-selected: root.selected == -1;
            has-hover: touch0.has-hover;

            touch0 := TouchArea {
                clicked => {
                    root.selected = -1;
                    root.selection-changed(-1);
                }
            }
        }

    callback request-diff-delta(string);
    function fill-diff-view() {
        if log.selected >= 0 && log.selected < log.changes_log.length {
            root.request-change-delta(changes_log[log.selected].hash)
        } else {
            root.request-diff-delta(chs.channels[chs.selected])
        }
    }

                if log.selected >= 0 {
                    root.request-change-delta(changes_log[log.selected].hash)
                } else {
                    delta = "";
                }

                fill-diff-view();

                    log.selected = -1;
                    delta = "";

                    log.deselect();
                    root.request-diff-delta(chs.channels[chs.selected])

                    if log.selected >= 0 {
                        root.request-change-delta(changes_log[log.selected].hash)
                    } else {
                        delta = "";
                    }

                    fill-diff-view();

                Ok(delta) => delta,
                Err(e) => {
                    println!("{:?}", e);
                    return;
                }
            };
            ui.set_delta((&String::from(delta)[..]).into());
        }
    });
    ui.on_request_diff_delta({
        let ui_handle = ui.as_weak();
        move |ch_name: SharedString| {
            let ch_name = ch_name.as_str();
            let ui = ui_handle.unwrap();
            let exe_path_string = ui.get_exe_path();
            let exe_path = Path::new(exe_path_string.as_str());
            let repo_path_string = ui.get_repo_path();
            let repo_path = Path::new(repo_path_string.as_str());
            let diff_output = cmds::diff(
                exe_path,
                repo_path,
                Some(ch_name).filter(|cn| !cn.is_empty()),
            );
            let delta = match diff_output {

    let output = cmd.output()?;
    check_exit_status(cmd, output.status)?;
    // TODO this will fail when diffing binary data
    Ok(String::from_utf8(output.stdout)?)
}
pub fn diff(
    exe: &std::path::Path,
    repo: &std::path::Path,
    ch_name_maybe: Option<&str>,
) -> Result<String, Error> {
    let mut cmd = Command::new(exe);
    let cmd = cmd
        .arg("diff")
        .arg("--no-prompt")
        .arg("--repository")
        .arg(repo);
    if let Some(ch_name) = ch_name_maybe {
        cmd.arg("--channel").arg(ch_name);
    }