.map(|action::Binding { key, label, msg }| {
            if let Some(msg) = msg {
                action_button(key, label, Msg::Action(msg.clone()))
            } else {
                el(action_button_inner(key, label))
            }
        })

        .map(
            |action::Binding {
                 keys_str,
                 keys: _,
                 label,
                 msg,
             }| {
                if let Some(msg) = msg {
                    action_button(keys_str, label, Msg::Action(msg.clone()))
                } else {
                    el(action_button_inner(keys_str, label))
                }
            },
        )

#[derive(Debug, Clone, PartialEq, Eq)]

#[derive(Debug, Clone, PartialEq, Eq, Hash)]

#[derive(Debug, Clone, PartialEq)]

#[derive(Debug, Clone, PartialEq, Hash)]

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]

use iced::keyboard::key::Named;

#[derive(Debug)]

use iced::keyboard::{Key, Modifiers as Mods};
#[derive(Debug, Clone, Hash)]

    pub key: &'static str,

    // NOTE: This could be derived from keys, but preferrably at compile time
    pub keys_str: &'static str,
    pub keys: ModKeys,

}
#[derive(Debug, Clone, Hash)]
pub enum ModKeys {
    One(ModKey),
    Two(ModKey, ModKey),
}
#[derive(Debug, Clone, Hash)]
pub struct ModKey {
    pub key: Key,
    pub mods: Mods,

#[derive(Debug, Clone)]

#[derive(Debug, Clone, Hash)]

            key: "S-r",

            keys_str: "S-r",
            keys: ModKeys::One(ModKey {
                key: Key::Character("r".into()),
                mods: Mods::SHIFT,
            }),

                key: "S-C-c",

                keys_str: "S-C-c",
                keys: ModKeys::One(ModKey {
                    key: Key::Character("c".into()),
                    mods: Mods::SHIFT.union(Mods::CTRL),
                }),

impl ModKeys {
    pub fn iter(&self) -> ModKeysIter<'_> {
        ModKeysIter { keys: self, ix: 0 }
    }
}
pub struct ModKeysIter<'a> {
    keys: &'a ModKeys,
    ix: usize,
}
impl<'a> Iterator for ModKeysIter<'a> {
    type Item = &'a ModKey;
    fn next(&mut self) -> Option<Self::Item> {
        let Self { keys, ix } = self;
        match keys {
            ModKeys::One(mod_key) => {
                if *ix == 0 {
                    *ix += 1;
                    Some(mod_key)
                } else {
                    None
                }
            }
            ModKeys::Two(mod_key_0, mod_key_1) => {
                if *ix == 0 {
                    *ix += 1;
                    Some(mod_key_0)
                } else if *ix == 1 {
                    *ix += 1;
                    Some(mod_key_1)
                } else {
                    None
                }
            }
        }
    }
}

        key: "←| h",

        keys_str: "←| h",
        keys: ModKeys::Two(
            ModKey {
                key: Key::Named(Named::ArrowLeft),
                mods: Mods::NONE,
            },
            ModKey {
                key: Key::Character("h".into()),
                mods: Mods::NONE,
            },
        ),

        key: "→| l",

        keys_str: "→| l",
        keys: ModKeys::Two(
            ModKey {
                key: Key::Named(Named::ArrowRight),
                mods: Mods::NONE,
            },
            ModKey {
                key: Key::Character("l".into()),
                mods: Mods::NONE,
            },
        ),

        key: "S-(↓| j)",

        keys_str: "S-(↓| j)",
        keys: ModKeys::Two(
            ModKey {
                key: Key::Named(Named::ArrowDown),
                mods: Mods::SHIFT,
            },
            ModKey {
                key: Key::Character("j".into()),
                mods: Mods::SHIFT,
            },
        ),

        key: "S-(↑| k)",

        keys_str: "S-(↑| k)",
        keys: ModKeys::Two(
            ModKey {
                key: Key::Named(Named::ArrowUp),
                mods: Mods::SHIFT,
            },
            ModKey {
                key: Key::Character("k".into()),
                mods: Mods::SHIFT,
            },
        ),

        key: "a",

        keys_str: "a",
        keys: ModKeys::One(ModKey {
            key: Key::Character("a".into()),
            mods: Mods::NONE,
        }),

        key: "x",

        keys_str: "x",
        keys: ModKeys::One(ModKey {
            key: Key::Character("x".into()),
            mods: Mods::NONE,
        }),

        key: "x",

        keys_str: "x",
        keys: ModKeys::One(ModKey {
            key: Key::Character("x".into()),
            mods: Mods::NONE,
        }),

        key: "x",

        keys_str: "x",
        keys: ModKeys::One(ModKey {
            key: Key::Character("x".into()),
            mods: Mods::NONE,
        }),

        key: "r",

        keys_str: "r",
        keys: ModKeys::One(ModKey {
            key: Key::Character("r".into()),
            mods: Mods::NONE,
        }),

        key: "C-s",

        keys_str: "C-s",
        keys: ModKeys::One(ModKey {
            key: Key::Character("s".into()),
            mods: Mods::CTRL,
        }),

        key: "C-p",

        keys_str: "C-p",
        keys: ModKeys::One(ModKey {
            key: Key::Character("p".into()),
            mods: Mods::CTRL,
        }),

        key: "C-d",

        keys_str: "C-d",
        keys: ModKeys::One(ModKey {
            key: Key::Character("d".into()),
            mods: Mods::CTRL,
        }),

        key: "TAB",

        keys_str: "Tab",
        keys: ModKeys::One(ModKey {
            key: Key::Named(Named::Tab),
            mods: Mods::NONE,
        }),

        key: "S-TAB",

        keys_str: "S-Tab",
        keys: ModKeys::One(ModKey {
            key: Key::Named(Named::Tab),
            mods: Mods::SHIFT,
        }),

        key: "c",

        keys_str: "c",
        keys: ModKeys::One(ModKey {
            key: Key::Character("c".into()),
            mods: Mods::NONE,
        }),

        key: "f",

        keys_str: "f",
        keys: ModKeys::One(ModKey {
            key: Key::Character("f".into()),
            mods: Mods::NONE,
        }),

        key: "C-r",

        keys_str: "C-r",
        keys: ModKeys::One(ModKey {
            key: Key::Character("r".into()),
            mods: Mods::CTRL,
        }),

        key: "Enter",

        keys_str: "Enter",
        keys: ModKeys::One(ModKey {
            key: Key::Character("r".into()),
            mods: Mods::CTRL,
        }),

        key: "Esc",

        keys_str: "Esc",
        keys: ModKeys::One(ModKey {
            key: Key::Named(Named::Escape),
            mods: Mods::NONE,
        }),

        key: "Esc",

        keys_str: "Esc",
        keys: ModKeys::One(ModKey {
            key: Key::Named(Named::Escape),
            mods: Mods::NONE,
        }),

        key: "e",

        keys_str: "e",
        keys: ModKeys::One(ModKey {
            key: Key::Character("e".into()),
            mods: Mods::NONE,
        }),

        key: "C-c",

        keys_str: "C-c",
        keys: ModKeys::One(ModKey {
            key: Key::Character("c".into()),
            mods: Mods::CTRL,
        }),

            key: "T",

            keys_str: "S-t",
            keys: ModKeys::One(ModKey {
                key: Key::Character("t".into()),
                mods: Mods::SHIFT,
            }),

            key: "t",

            keys_str: "t",
            keys: ModKeys::One(ModKey {
                key: Key::Character("t".into()),
                mods: Mods::NONE,
            }),

            key: "t",

            keys_str: "t",
            keys: ModKeys::One(ModKey {
                key: Key::Character("t".into()),
                mods: Mods::NONE,
            }),

        key: "S-p",

        keys_str: "S-p",
        keys: ModKeys::One(ModKey {
            key: Key::Character("p".into()),
            mods: Mods::SHIFT,
        }),

        key: "S-f",

        keys_str: "S-f",
        keys: ModKeys::One(ModKey {
            key: Key::Character("f".into()),
            mods: Mods::SHIFT,
        }),

        key: "↓| j",

        keys_str: "↓| j",
        keys: ModKeys::Two(
            ModKey {
                key: Key::Named(Named::ArrowDown),
                mods: Mods::NONE,
            },
            ModKey {
                key: Key::Character("j".into()),
                mods: Mods::NONE,
            },
        ),

        key: "↑| k",

        keys_str: "↑| k",
        keys: ModKeys::Two(
            ModKey {
                key: Key::Named(Named::ArrowUp),
                mods: Mods::NONE,
            },
            ModKey {
                key: Key::Character("k".into()),
                mods: Mods::NONE,
            },
        ),

        key: "Enter",

        keys_str: "Enter",
        keys: ModKeys::One(ModKey {
            key: Key::Named(Named::Enter),
            mods: Mods::NONE,
        }),

        key: "Esc",

        keys_str: "Esc",
        keys: ModKeys::One(ModKey {
            key: Key::Named(Named::Escape),
            mods: Mods::NONE,
        }),

    let key_subs = match &state.model.sub {
        model::SubState::PickingRepoDir(_model) => {
            Subscription::none()
            // dir_picker::subs(&picking_repo.picker)
            //     .map(view::Msg::PickingRepo)
            //     .map(Msg::View)
        }
        model::SubState::ManagingRepo(model) => subs_managing_repo(model),
        model::SubState::PickingProject(_model) => Subscription::none(),
    };
    let window_subs = window::events().map(|(_id, event)| Msg::Window(event));
    Subscription::batch([key_subs, window_subs])
}
fn subs_managing_repo(_model: &model::ManagingRepo) -> Subscription<Msg> {
    use iced::keyboard::{self, key, Key, Modifiers};

    use iced::keyboard::{self, key, Key};

    keyboard::listen().filter_map(|event| {
        let action = |msg| Some(Msg::View(view::Msg::Action(msg)));
        let selection =
            |selection| action(action::FilteredMsg::Selection(selection));
        let unfiltered = |selection| {
            Some(Msg::View(view::Msg::UnfilteredSelection(selection)))
        };

    let allowed_actions = state.model.allowed_actions.clone();
    let key_subs = keyboard::listen().with(allowed_actions).filter_map(
        |(allowed_actions, event)| {
            let unfiltered = |selection| {
                Some(Msg::View(view::Msg::UnfilteredSelection(selection)))
            };

        match event {
            keyboard::Event::KeyPressed {
                key,
                modifiers: mods,

            match event {
                keyboard::Event::KeyPressed { key, modifiers, .. } => {
                    allowed_actions
                        .iter()
                        .find_map(|binding| {
                            binding.msg.as_ref().and_then(|msg| {
                                if binding.keys.iter().any(|binding| {
                                    binding.key == key
                                        && binding.mods == modifiers
                                }) {
                                    Some(msg.clone())
                                } else {
                                    None
                                }
                            })
                        })
                        .map(view::Msg::Action)
                        .map(Msg::View)
                }
                keyboard::Event::KeyReleased {
                    key,
                    modifiers: mods,

            } => {
                if mods.is_empty() {
                    match key {
                        Key::Character(c) => match c.as_str() {
                            // _____________________________________________
                            // Directions
                            "j" => selection(selection::Msg::PressDir(
                                selection::Dir::Down,
                            )),
                            "k" => {
                                selection(selection::Msg::PressDir(selection::Dir::Up))
                            }
                            "h" => selection(selection::Msg::PressDir(
                                selection::Dir::Left,
                            )),
                            "l" => selection(selection::Msg::PressDir(
                                selection::Dir::Right,
                            )),
                            // _____________________________________________
                            // Other keys (sort alphabetically)
                            "a" => action(action::FilteredMsg::AddUntrackedFile),
                            "c" => action(action::FilteredMsg::SelectChannel),
                            "e" => action(action::FilteredMsg::ShowEntireLog),
                            "f" => action(action::FilteredMsg::ForkChannel),
                            "t" => action(
                                action::FilteredMsg::ToRecordToggleSelectedFileOrChange,
                            ),
                            "r" => action(action::FilteredMsg::StartRecord),
                            "x" => action(action::FilteredMsg::RmChange),
                            _ => None,
                        },
                        Key::Named(key::Named::Enter) => {
                            action(action::FilteredMsg::Confirm)
                        }
                        Key::Named(key::Named::Escape) => {
                            action(action::FilteredMsg::Cancel)
                        }
                        Key::Named(key::Named::ArrowDown) => {
                            selection(selection::Msg::PressDir(selection::Dir::Down))
                        }
                        Key::Named(key::Named::ArrowUp) => {
                            selection(selection::Msg::PressDir(selection::Dir::Up))
                        }
                        Key::Named(key::Named::ArrowLeft) => {
                            selection(selection::Msg::PressDir(selection::Dir::Left))
                        }
                        Key::Named(key::Named::ArrowRight) => {
                            selection(selection::Msg::PressDir(selection::Dir::Right))
                        }
                        Key::Named(key::Named::Tab) => {
                            action(action::FilteredMsg::FocusNext)
                        }
                        Key::Named(_) | Key::Unidentified => None,
                    }
                } else {
                    match key {
                        Key::Character(c) => match c.as_str() {
                            "c" if mods == Modifiers::CTRL => {
                                action(action::FilteredMsg::ClipboardCopy)
                            }
                            "c" if mods == Modifiers::SHIFT | Modifiers::CTRL => {
                                action(action::FilteredMsg::ClipboardCopyReports)
                            }
                            "d" if mods == Modifiers::CTRL => {
                                action(action::FilteredMsg::DiscardRecord)
                            }
                            "p" if mods == Modifiers::CTRL => {
                                action(action::FilteredMsg::PostponeRecord)
                            }
                            "r" if mods == Modifiers::CTRL => {
                                action(action::FilteredMsg::RefreshRepo)
                            }
                            "r" if mods == Modifiers::SHIFT => {
                                action(action::FilteredMsg::ToggleReports)
                            }
                            "s" if mods == Modifiers::CTRL => {
                                action(action::FilteredMsg::SaveRecord)
                            }
                            "f" if mods == Modifiers::SHIFT => action(
                                action::FilteredMsg::EnterSubMenu(model::SubMenu::Pull),
                            ),
                            "j" if mods == Modifiers::SHIFT => selection(
                                selection::Msg::AltPressDir(selection::Dir::Down),
                            ),
                            "k" if mods == Modifiers::SHIFT => selection(
                                selection::Msg::AltPressDir(selection::Dir::Up),
                            ),
                            "h" if mods == Modifiers::SHIFT => selection(
                                selection::Msg::AltPressDir(selection::Dir::Left),
                            ),
                            "l" if mods == Modifiers::SHIFT => selection(
                                selection::Msg::AltPressDir(selection::Dir::Right),
                            ),
                            "p" if mods == Modifiers::SHIFT => action(
                                action::FilteredMsg::EnterSubMenu(model::SubMenu::Push),
                            ),
                            "t" if mods == Modifiers::SHIFT => {
                                action(action::FilteredMsg::ToRecord(
                                    to_record::Msg::ToggleOverall,
                                ))
                            }
                            _ => None,
                        },
                        Key::Named(key::Named::ArrowDown)
                            if mods == Modifiers::SHIFT =>
                        {
                            selection(selection::Msg::AltPressDir(selection::Dir::Down))
                        }
                        Key::Named(key::Named::ArrowUp) if mods == Modifiers::SHIFT => {
                            selection(selection::Msg::AltPressDir(selection::Dir::Up))
                        }
                        Key::Named(key::Named::ArrowLeft)
                            if mods == Modifiers::SHIFT =>
                        {
                            selection(selection::Msg::AltPressDir(selection::Dir::Left))
                        }
                        Key::Named(key::Named::ArrowRight)
                            if mods == Modifiers::SHIFT =>
                        {
                            selection(selection::Msg::AltPressDir(
                                selection::Dir::Right,
                            ))
                        }
                        Key::Named(key::Named::Tab) if mods == Modifiers::SHIFT => {
                            action(action::FilteredMsg::FocusPrev)
                        }
                        Key::Named(_) | Key::Unidentified => None,
                    }
                }
            }
            keyboard::Event::KeyReleased {
                key,
                modifiers: mods,
                ..
            } => {
                if mods.is_empty() {
                    match key {
                        Key::Character(c) => match c.as_str() {
                            "j" =>
                            unfiltered(

                } => {
                    if mods.is_empty() {
                        match key {
                            Key::Character(c) => match c.as_str() {
                                "j" => unfiltered(

                            "k" =>
                            unfiltered(

                                "k" => unfiltered(

                            "h" =>
                            unfiltered(

                                "h" => unfiltered(

                            "l" =>
                            unfiltered(

                                "l" => unfiltered(

                            _ => None,
                        },
                        Key::Named(key::Named::ArrowDown) => {
                            unfiltered(

                                _ => None,
                            },
                            Key::Named(key::Named::ArrowDown) => unfiltered(

                            )
                        }
                        Key::Named(key::Named::ArrowUp) => {
                            unfiltered(

                            ),
                            Key::Named(key::Named::ArrowUp) => unfiltered(

                            )
                        }
                        Key::Named(key::Named::ArrowLeft) => {
                            unfiltered(

                            ),
                            Key::Named(key::Named::ArrowLeft) => unfiltered(

                            )
                        }
                        Key::Named(key::Named::ArrowRight) => {
                            unfiltered(

                            ),
                            Key::Named(key::Named::ArrowRight) => unfiltered(

                            )

                            ),
                            Key::Named(_) | Key::Unidentified => None,

                        Key::Named(_) | Key::Unidentified => None,

                    } else {
                        None

                } else {
                    None

                keyboard::Event::ModifiersChanged(_) => None,

            keyboard::Event::ModifiersChanged(_) => None,
        }
    })

        },
    );
    let window_subs = window::events().map(|(_id, event)| Msg::Window(event));
    Subscription::batch([key_subs, window_subs])