diff --git a/Cargo.toml b/Cargo.toml
index b0e303d..810c8a6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,4 +13,5 @@ repository = "https://github.com/shuoli84/tui-menu"
 ratatui = "0.26.1"
 
 [dev-dependencies]
+color-eyre = "0.6.3"
 crossterm = "0.27.0"
diff --git a/README.md b/README.md
index eddcad0..fd23f01 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,8 @@
 
 A menu widget for [Ratatui](https://crates.io/crates/ratatui).
 
+![Demo](https://vhs.charm.sh/vhs-3pN84WzBTmPTbU2SCtvUiV.gif)
+
 ## Features
 
 - Sub menu groups.
@@ -23,60 +25,85 @@ take a look at examples/basic.rs
 ```rust
 // menu should be draw at last, so it can stay on top of other content
 let menu = Menu::new();
-f.render_stateful_widget(menu, chunks[0], &mut app.menu);
+frame.render_stateful_widget(menu, chunks[0], &mut app.menu);
 ```
 
 ### Create nested menu tree
 
+Note: MenuItems can be created from any type that implements `Clone`. Using an enum is just one
+option which can work. You could use strings or your own state types.
+
 ```rust
+#[derive(Debug, Clone)]
+enum Action {
+    FileNew,
+    FileOpen,
+    FileOpenRecent(String),
+    FileSaveAs,
+    Exit,
+    EditCopy,
+    EditCut,
+    EditPaste,
+    AboutAuthor,
+    AboutHelp,
+}
+
 let menu = MenuState::new(vec![
     MenuItem::group(
         "File",
         vec![
-            MenuItem::item("New", "file.new".into()),
-            MenuItem::item("Open", "file.open".into()),
+            MenuItem::item("New", Action::FileNew),
+            MenuItem::item("Open", Action::FileOpen),
             MenuItem::group(
                 "Open recent",
-                vec!["file_1.txt", "file_2.txt"]
-                    .into_iter()
-                    .map(|f| MenuItem::item(f, format!("file.recent:{f}").into()))
+                ["file_1.txt", "file_2.txt"]
+                    .iter()
+                    .map(|&f| MenuItem::item(f, Action::FileOpenRecent(f.into())))
                     .collect(),
             ),
-            MenuItem::item("Save as", "file.save_as".into()),
-            MenuItem::item("Exit", "exit".into()),
+            MenuItem::item("Save as", Action::FileSaveAs),
+            MenuItem::item("Exit", Action::Exit),
         ],
     ),
     MenuItem::group(
         "Edit",
         vec![
-            MenuItem::item("Copy", "edit.new".into()),
-            MenuItem::item("Cut", "edit.cut".into()),
-            MenuItem::item("Paste", "edit.paste".into()),
+            MenuItem::item("Copy", Action::EditCopy),
+            MenuItem::item("Cut", Action::EditCut),
+            MenuItem::item("Paste", Action::EditPaste),
         ],
     ),
     MenuItem::group(
         "About",
         vec![
-            MenuItem::item("Author", "about.author".into()),
-            MenuItem::item("Help", "about.help".into()),
+            MenuItem::item("Author", Action::AboutAuthor),
+            MenuItem::item("Help", Action::AboutHelp),
         ],
     ),
-]);
+]),
 ```
 
 ### Consume events
 
 ``` rust
-for e in app.menu.drain_events() {
+for e in menu.drain_events() {
     match e {
-        tui_menu::MenuEvent::Selected(item) => match item.as_ref() {
-            "exit" => {
+        MenuEvent::Selected(item) => match item {
+            Action::Exit => {
                 return Ok(());
             }
-            _ => {
-                // println!("{} selected", item);
+            Action::FileNew => {
+                self.content.clear();
+            }
+            Action::FileOpenRecent(file) => {
+                self.content = format!("content of {file}");
+            }
+            action => {
+                self.content = format!("{action:?} not implemented");
             }
         },
     }
+    // close the menu once the event has been handled.
+    menu.reset();
 }
 ```
diff --git a/demo.tape b/demo.tape
new file mode 100644
index 0000000..045c583
--- /dev/null
+++ b/demo.tape
@@ -0,0 +1,88 @@
+# VHS documentation
+#
+# Output:
+#   Output <path>.gif               Create a GIF output at the given <path>
+#   Output <path>.mp4               Create an MP4 output at the given <path>
+#   Output <path>.webm              Create a WebM output at the given <path>
+#
+# Require:
+#   Require <string>                Ensure a program is on the $PATH to proceed
+#
+# Settings:
+#   Set FontSize <number>           Set the font size of the terminal
+#   Set FontFamily <string>         Set the font family of the terminal
+#   Set Height <number>             Set the height of the terminal
+#   Set Width <number>              Set the width of the terminal
+#   Set LetterSpacing <float>       Set the font letter spacing (tracking)
+#   Set LineHeight <float>          Set the font line height
+#   Set LoopOffset <float>%         Set the starting frame offset for the GIF loop
+#   Set Theme <json|string>         Set the theme of the terminal
+#   Set Padding <number>            Set the padding of the terminal
+#   Set Framerate <number>          Set the framerate of the recording
+#   Set PlaybackSpeed <float>       Set the playback speed of the recording
+#   Set MarginFill <file|#000000>   Set the file or color the margin will be filled with.
+#   Set Margin <number>             Set the size of the margin. Has no effect if MarginFill isn't set.
+#   Set BorderRadius <number>       Set terminal border radius, in pixels.
+#   Set WindowBar <string>          Set window bar type. (one of: Rings, RingsRight, Colorful, ColorfulRight)
+#   Set WindowBarSize <number>      Set window bar size, in pixels. Default is 40.
+#   Set TypingSpeed <time>          Set the typing speed of the terminal. Default is 50ms.
+#
+# Sleep:
+#   Sleep <time>                    Sleep for a set amount of <time> in seconds
+#
+# Type:
+#   Type[@<time>] "<characters>"    Type <characters> into the terminal with a
+#                                   <time> delay between each character
+#
+# Keys:
+#   Escape[@<time>] [number]        Press the Escape key
+#   Backspace[@<time>] [number]     Press the Backspace key
+#   Delete[@<time>] [number]        Press the Delete key
+#   Insert[@<time>] [number]        Press the Insert key
+#   Down[@<time>] [number]          Press the Down key
+#   Enter[@<time>] [number]         Press the Enter key
+#   Space[@<time>] [number]         Press the Space key
+#   Tab[@<time>] [number]           Press the Tab key
+#   Left[@<time>] [number]          Press the Left Arrow key
+#   Right[@<time>] [number]         Press the Right Arrow key
+#   Up[@<time>] [number]            Press the Up Arrow key
+#   Down[@<time>] [number]          Press the Down Arrow key
+#   PageUp[@<time>] [number]        Press the Page Up key
+#   PageDown[@<time>] [number]      Press the Page Down key
+#   Ctrl+<key>                      Press the Control key + <key> (e.g. Ctrl+C)
+#
+# Display:
+#   Hide                            Hide the subsequent commands from the output
+#   Show                            Show the subsequent commands in the output
+
+Output target/demo.gif
+
+Set Theme "Aardvark Blue"
+Set Width 1200
+Set Height 450
+
+Hide
+Type "cargo run --example basic" Enter
+Sleep 2s # allow some time for the build to complete
+Show
+Set TypingSpeed 500ms
+
+# File | Open recent | file_1.txt
+Right Down 3 Right
+# screenshot for ratatui.rs showcase
+Sleep 100ms Screenshot target/demo.png
+Enter Sleep 1s
+
+# File | Open recent | file_2.txt
+Right Down 3 Right Down Enter Sleep 1s
+
+# Show off other menus
+Right 3 Left 2
+
+# File | Exit
+Down 5 Enter
+
+# Show that the app exited before repeating the animation
+Sleep 1s
+Hide
+
diff --git a/examples/basic.rs b/examples/basic.rs
index 23b142a..0297567 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -1,55 +1,91 @@
+use color_eyre::config::HookBuilder;
 use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
+    event::{self, Event, KeyCode},
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
 use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    layout::{Constraint, Direction, Layout},
-    style::{Color, Style},
-    widgets::{Block, Borders},
-    Frame, Terminal,
+    prelude::*,
+    widgets::{Block, Paragraph},
 };
-use std::{borrow::Cow, error::Error, io};
-use tui_menu::{Menu, MenuItem, MenuState};
+use std::io::{self, stdout, Stdout};
+use tui_menu::{Menu, MenuEvent, MenuItem, MenuState};
+
+fn main() -> color_eyre::Result<()> {
+    let mut terminal = init_terminal()?;
+    App::new().run(&mut terminal)?;
+    restore_terminal()?;
+    Ok(())
+}
+
+/// Install panic and error hooks that restore the terminal before printing the error.
+pub fn init_hooks() -> color_eyre::Result<()> {
+    let (panic, error) = HookBuilder::default().into_hooks();
+    let panic = panic.into_panic_hook();
+    let error = error.into_eyre_hook();
+
+    std::panic::set_hook(Box::new(move |info| {
+        let _ = restore_terminal(); // ignore failure to restore terminal
+        panic(info);
+    }));
+    color_eyre::eyre::set_hook(Box::new(move |e| {
+        let _ = restore_terminal(); // ignore failure to restore terminal
+        error(e)
+    }))?;
+
+    Ok(())
+}
+
+fn init_terminal() -> io::Result<Terminal<CrosstermBackend<Stdout>>> {
+    enable_raw_mode()?;
+    execute!(stdout(), EnterAlternateScreen)?;
+    Terminal::new(CrosstermBackend::new(stdout()))
+}
+
+fn restore_terminal() -> io::Result<()> {
+    disable_raw_mode()?;
+    execute!(stdout(), LeaveAlternateScreen,)
+}
 
 struct App {
-    menu: tui_menu::MenuState<Cow<'static, str>>,
+    content: String,
+    menu: MenuState<Action>,
 }
 
 impl App {
-    fn new() -> App {
-        App {
+    fn new() -> Self {
+        Self {
+            content: String::new(),
             menu: MenuState::new(vec![
                 MenuItem::group(
                     "File",
                     vec![
-                        MenuItem::item("New", "file.new".into()),
-                        MenuItem::item("Open", "file.open".into()),
+                        MenuItem::item("New", Action::FileNew),
+                        MenuItem::item("Open", Action::FileOpen),
                         MenuItem::group(
                             "Open recent",
-                            vec!["file_1.txt", "file_2.txt"]
-                                .into_iter()
-                                .map(|f| MenuItem::item(f, format!("file.recent:{f}").into()))
+                            ["file_1.txt", "file_2.txt"]
+                                .iter()
+                                .map(|&f| MenuItem::item(f, Action::FileOpenRecent(f.into())))
                                 .collect(),
                         ),
-                        MenuItem::item("Save as", "file.save_as".into()),
-                        MenuItem::item("Exit", "exit".into()),
+                        MenuItem::item("Save as", Action::FileSaveAs),
+                        MenuItem::item("Exit", Action::Exit),
                     ],
                 ),
                 MenuItem::group(
                     "Edit",
                     vec![
-                        MenuItem::item("Copy", "edit.new".into()),
-                        MenuItem::item("Cut", "edit.cut".into()),
-                        MenuItem::item("Paste", "edit.paste".into()),
+                        MenuItem::item("Copy", Action::EditCopy),
+                        MenuItem::item("Cut", Action::EditCut),
+                        MenuItem::item("Paste", Action::EditPaste),
                     ],
                 ),
                 MenuItem::group(
                     "About",
                     vec![
-                        MenuItem::item("Author", "about.author".into()),
-                        MenuItem::item("Help", "about.help".into()),
+                        MenuItem::item("Author", Action::AboutAuthor),
+                        MenuItem::item("Help", Action::AboutHelp),
                     ],
                 ),
             ]),
@@ -57,82 +93,78 @@ impl App {
     }
 }
 
-fn main() -> Result<(), Box<dyn Error>> {
-    // setup terminal
-    enable_raw_mode()?;
-    let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-
-    // create app and run it
-    let app = App::new();
-    let res = run_app(&mut terminal, app);
+#[derive(Debug, Clone)]
+enum Action {
+    FileNew,
+    FileOpen,
+    FileOpenRecent(String),
+    FileSaveAs,
+    Exit,
+    EditCopy,
+    EditCut,
+    EditPaste,
+    AboutAuthor,
+    AboutHelp,
+}
 
-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
-
-    if let Err(err) = res {
-        println!("{:?}", err)
-    }
+impl App {
+    fn run<B: Backend>(mut self, terminal: &mut Terminal<B>) -> io::Result<()> {
+        loop {
+            terminal.draw(|frame| frame.render_widget(&mut self, frame.size()))?;
 
-    Ok(())
-}
+            if event::poll(std::time::Duration::from_millis(10))? {
+                if let Event::Key(key) = event::read()? {
+                    self.on_key_event(key);
+                }
+            }
 
-fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<()> {
-    loop {
-        terminal.draw(|f| ui(f, &mut app))?;
-
-        if event::poll(std::time::Duration::from_millis(10))? {
-            if let Event::Key(key) = event::read()? {
-                match key.code {
-                    KeyCode::Char('h') | KeyCode::Left => app.menu.left(),
-                    KeyCode::Char('l') | KeyCode::Right => app.menu.right(),
-                    KeyCode::Char('j') | KeyCode::Down => app.menu.down(),
-                    KeyCode::Char('k') | KeyCode::Up => app.menu.up(),
-                    KeyCode::Esc => app.menu.reset(),
-                    KeyCode::Enter => app.menu.select(),
-                    _ => {}
+            for e in self.menu.drain_events() {
+                match e {
+                    MenuEvent::Selected(item) => match item {
+                        Action::Exit => {
+                            return Ok(());
+                        }
+                        Action::FileNew => {
+                            self.content.clear();
+                        }
+                        Action::FileOpenRecent(file) => {
+                            self.content = format!("content of {file}");
+                        }
+                        action => {
+                            self.content = format!("{action:?} not implemented");
+                        }
+                    },
                 }
+                self.menu.reset();
             }
         }
+    }
 
-        for e in app.menu.drain_events() {
-            match e {
-                tui_menu::MenuEvent::Selected(item) => match item.as_ref() {
-                    "exit" => {
-                        return Ok(());
-                    }
-                    _ => {
-                        // println!("{} selected", item);
-                    }
-                },
-            }
+    fn on_key_event(&mut self, key: event::KeyEvent) {
+        match key.code {
+            KeyCode::Char('h') | KeyCode::Left => self.menu.left(),
+            KeyCode::Char('l') | KeyCode::Right => self.menu.right(),
+            KeyCode::Char('j') | KeyCode::Down => self.menu.down(),
+            KeyCode::Char('k') | KeyCode::Up => self.menu.up(),
+            KeyCode::Esc => self.menu.reset(),
+            KeyCode::Enter => self.menu.select(),
+            _ => {}
         }
     }
 }
 
-fn ui(f: &mut Frame, app: &mut App) {
-    let size = f.size();
+impl Widget for &mut App {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        use Constraint::*;
+        let [top, main] = Layout::vertical([Length(1), Fill(1)]).areas(area);
 
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(1), Constraint::Percentage(80)].as_ref())
-        .split(size);
+        Paragraph::new(self.content.as_str())
+            .block(Block::bordered().title("Content").on_black())
+            .render(main, buf);
 
-    let block = Block::default()
-        .title("Content")
-        .borders(Borders::ALL)
-        .style(Style::default().bg(Color::Black));
-    f.render_widget(block, chunks[1]);
+        "tui-menu".bold().blue().to_centered_line().render(top, buf);
 
-    // menu should be draw at last, so it can stay on top of other content
-    let menu = Menu::new();
-    f.render_stateful_widget(menu, chunks[0], &mut app.menu);
+        // draw menu last, so it renders on top of other content
+        Menu::new().render(top, buf, &mut self.menu);
+    }
 }