},
    ResetFile {
        path: String,

        }
        MsgIn::ResetFile { path } => {
            let state: anyhow::Result<State>;
            (internal_state, state) = spawn_blocking(move || {
                let state = |internal_state: &mut InternalState| {
                    reset_file(internal_state, path)?;
                    get_state(internal_state)
                };
                let state = state(&mut internal_state);
                (internal_state, state)
            })
            .await
            .unwrap();
            let _ = msg_out_tx.send(MsgOut::Refreshed {
                state,
                invalidate_logs: false,
            });

fn reset_file(state: &mut InternalState, path: String) -> anyhow::Result<()> {
    let repo = &state.repo;
    let current_channel = current_channel(repo)?;
    let txn = repo.pristine.arc_txn_begin()?;
    let repo_path = CanonicalPathBuf::canonicalize(&repo.path)?;
    let channel = txn
        .read()
        .load_channel(&current_channel)?
        .context("Loading current channel")?;
    let mut conflicts = Vec::new();
    let root = std::fs::canonicalize(&path)?;
    let path = root.strip_prefix(&repo_path)?;
    use path_slash::PathExt;
    let path = path.to_slash_lossy();
    conflicts.extend(libpijul::output::output_repository_no_pending(
        &repo.working_copy,
        &repo.changes,
        &txn,
        &channel,
        &path,
        true,
        None,
        std::thread::available_parallelism()?.get(),
        0,
    )?);
    // TODO: handle conflicts - but why are there conflicts from file reset? Is
    // it for the case when reset removes conflict resolutions?
    // super::print_conflicts(&conflicts)?;
    txn.commit()?;
    Ok(())
}

    ResetChange,

    RmAddedFile,

    RmChange,

        (RmAddedFile, RmAddedFile) => true,

        (RmChange, RmChange) => true,

        (RmAddedFile, _) => false,

        (RmChange, _) => false,

            }
            model::SubMenu::ResetChange => {
                vec![confirm("confirm reset selection"), cancel()]

    };
    let reset_changed_file = || Binding {
        key: "x",
        label: "reset file",
        msg: Some(FilteredMsg::RmChange),
    };
    let reset_changed_hunk = || Binding {
        key: "x",
        label: "reset hunk",
        msg: Some(FilteredMsg::RmChange),

        msg: Some(FilteredMsg::RmAddedFile),

        msg: Some(FilteredMsg::RmChange),

                        ma.push(reset_changed_file());

            can_reset_hunk,

            // TODO support reset of selected hunk
            {
                let _ = (can_reset_hunk, reset_changed_hunk);
                // push_if(can_reset_hunk, reset_changed_hunk, ma);
            }

        can_reset_hunk: bool,

                            can_reset_hunk: false,

                            can_reset_hunk: true,

                                can_reset_hunk: false,

        Msg::View(view::Msg::Action(action::FilteredMsg::RmAddedFile)),

        Msg::View(view::Msg::Action(action::FilteredMsg::RmChange)),

                    model::SubMenu::ResetChange => reset_change(state),

        action::FilteredMsg::RmAddedFile => rm_added_file(state),

        action::FilteredMsg::RmChange => rm_change(state),

fn reset_change(state: &mut State) -> Task<Msg> {
    if let Some(ReadyState { selection, .. }) =
        model::is_ready_mut(&mut state.model)
        && let Some(selection::Status::ChangedFile {
            ix: _,
            path,
            diff_selected,
        }) = selection.status.as_ref()
    {
        if !diff_selected {
            state
                .repo_tx_in
                .send(repo::MsgIn::ResetFile {
                    path: path.raw.clone(),
                })
                .unwrap();
        } else {
            todo!("reset selected hunk")
        }
    } else {
        report::show_err(
            &mut state.model.report,
            "Cannot reset the current selection. This should never happen, please report it! State: {state:?}"
                .to_string(),
        );
    }
    state.model.sub_menu = None;
    Task::none()
}

fn rm_added_file(state: &mut State) -> Task<Msg> {

fn rm_change(state: &mut State) -> Task<Msg> {

        // See if the change is a previously untracked file

            return Task::none();

        } else {
            state.model.sub_menu = Some(model::SubMenu::ResetChange);

                    "x" => action(action::FilteredMsg::RmAddedFile),

                    "x" => action(action::FilteredMsg::RmChange),