diff --git a/Cargo.lock b/Cargo.lock
index 12ed69ae..2106e036 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -606,6 +606,14 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "context_menu"
+version = "0.1.0"
+dependencies = [
+ "iced",
+ "iced_aw",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
diff --git a/Cargo.toml b/Cargo.toml
index ef3f779e..da16acb0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -49,8 +49,8 @@ default = [
     "slide_bar",
     "wrap",
     "selection_list",
-    #"quad",
-    #"context_menu",
+    "quad",
+    "context_menu",
     "spinner",
     "drop_down",
     #"menu",
@@ -89,7 +89,7 @@ members = [
     "examples/sliderbar",
     "examples/wrap",
     "examples/selection_list",
-    #"examples/context_menu",
+    "examples/context_menu",
     "examples/spinner",
     "examples/WidgetIDReturn",
     "examples/drop_down",
diff --git a/examples/context_menu/src/main.rs b/examples/context_menu/src/main.rs
index 731d7750..eb7e7dbc 100644
--- a/examples/context_menu/src/main.rs
+++ b/examples/context_menu/src/main.rs
@@ -1,12 +1,17 @@
 use iced::{
     widget::{column, Button, Container, Row, Text},
-    Alignment, Element, Sandbox, Settings,
+    Alignment, Element,
 };
 
 use iced_aw::ContextMenu;
 
 fn main() -> iced::Result {
-    ContextMenuExample::run(Settings::default())
+    iced::application(
+        "ContextMenu example",
+        ContextMenuExample::update,
+        ContextMenuExample::view,
+    )
+    .run()
 }
 
 #[derive(Clone, Debug)]
@@ -23,22 +28,12 @@ struct ContextMenuExample {
     last_message: Option<Message>,
 }
 
-impl Sandbox for ContextMenuExample {
-    type Message = Message;
-
-    fn new() -> Self {
-        Self::default()
-    }
-
-    fn title(&self) -> String {
-        String::from("ContextMenu example")
-    }
-
-    fn update(&mut self, message: Self::Message) {
+impl ContextMenuExample {
+    fn update(&mut self, message: Message) {
         self.last_message = Some(message);
     }
 
-    fn view(&self) -> Element<'_, Self::Message> {
+    fn view(&self) -> Element<'_, Message> {
         let underlay = Container::new(
             Row::new()
                 .spacing(10)
diff --git a/src/lib.rs b/src/lib.rs
index b9a01e5b..d0d57860 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -138,9 +138,7 @@ mod platform {
 
     #[doc(no_inline)]
     #[cfg(feature = "context_menu")]
-    pub use {
-        crate::style::ContextMenuStyle, crate::widgets::context_menu, context_menu::ContextMenu,
-    };
+    pub use {crate::widgets::context_menu, context_menu::ContextMenu};
 
     #[doc(no_inline)]
     #[cfg(feature = "drop_down")]
diff --git a/src/style.rs b/src/style.rs
index 90bec0f7..5a53c257 100644
--- a/src/style.rs
+++ b/src/style.rs
@@ -37,5 +37,3 @@ pub use menu_bar::MenuBarStyle;
 
 #[cfg(feature = "context_menu")]
 pub mod context_menu;
-#[cfg(feature = "context_menu")]
-pub use context_menu::ContextMenuStyle;
diff --git a/src/style/context_menu.rs b/src/style/context_menu.rs
index fbfb90c1..f84e7dc0 100644
--- a/src/style/context_menu.rs
+++ b/src/style/context_menu.rs
@@ -1,20 +1,19 @@
 //! Use a badge for color highlighting important information.
 //!
 //! *This API requires the following crate features to be activated: badge*
-use std::rc::Rc;
-
+use super::{Status, StyleFn};
 use iced::{Background, Color, Theme};
 
-/// The appearance of a [`ContextMenu`](crate::widgets::ContextMenu).
+/// The style of a [`ContextMenu`](crate::widgets::ContextMenu).
 #[derive(Clone, Copy, Debug)]
-pub struct Appearance {
+pub struct Style {
     /// The background of the [`ContextMenu`](crate::widgets::ContextMenu).
     ///
     /// This is used to color the backdrop of the modal.
     pub background: Background,
 }
 
-impl Default for Appearance {
+impl Default for Style {
     fn default() -> Self {
         Self {
             background: Background::Color([0.87, 0.87, 0.87, 0.30].into()),
@@ -22,42 +21,39 @@ impl Default for Appearance {
     }
 }
 
-/// The appearance of a [`ContextMenu`](crate::widgets::ContextMenu).
-pub trait StyleSheet {
+/// The Catalog of a [`ContextMenu`](crate::widgets::ContextMenu).
+pub trait Catalog {
     ///Style for the trait to use.
-    type Style: Default + Clone;
-    /// The normal appearance of a [`ContextMenu`](crate::widgets::ContextMenu).
-    fn active(&self, style: &Self::Style) -> Appearance;
-}
+    type Class<'a>;
 
-/// The default appearance of a [`ContextMenu`](crate::widgets::ContextMenu).
-#[derive(Clone, Default)]
-#[allow(missing_docs, clippy::missing_docs_in_private_items)]
-pub enum ContextMenuStyle {
-    #[default]
-    Default,
-    Custom(Rc<dyn StyleSheet<Style = Theme>>),
+    /// The default class produced by the [`Catalog`].
+    fn default<'a>() -> Self::Class<'a>;
+
+    /// The [`Style`] of a class with the given status.
+    fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
 }
 
-impl ContextMenuStyle {
-    /// Creates a custom [`ContextMenuStyle`] style variant.
-    pub fn custom(style_sheet: impl StyleSheet<Style = Theme> + 'static) -> Self {
-        Self::Custom(Rc::new(style_sheet))
+impl Catalog for Theme {
+    type Class<'a> = StyleFn<'a, Self, Style>;
+
+    fn default<'a>() -> Self::Class<'a> {
+        Box::new(primary)
     }
-}
 
-impl StyleSheet for Theme {
-    type Style = ContextMenuStyle;
+    fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
+        class(self, status)
+    }
+}
 
-    fn active(&self, _style: &Self::Style) -> Appearance {
-        let palette = self.extended_palette();
+/// The primary theme of a [`ContextMenu`](crate::widgets::ContextMenu).
+#[must_use]
+pub fn primary(theme: &Theme, _status: Status) -> Style {
+    let palette = theme.extended_palette();
 
-        Appearance {
-            background: Color {
-                a: 0f32,
-                ..palette.background.base.color
-            }
-            .into(),
-        }
+    Style {
+        background: Background::Color(Color {
+            a: 0f32,
+            ..palette.background.base.color
+        }),
     }
 }
diff --git a/src/widgets/context_menu.rs b/src/widgets/context_menu.rs
index 37b5f01b..9219634a 100644
--- a/src/widgets/context_menu.rs
+++ b/src/widgets/context_menu.rs
@@ -12,7 +12,11 @@ use iced::{
     Element, Event, Length, Point, Rectangle, Vector,
 };
 
-pub use crate::style::context_menu::StyleSheet;
+pub use crate::style::{
+    context_menu::{Catalog, Style},
+    status::{Status, StyleFn},
+};
+
 use crate::widgets::overlay::ContextMenuOverlay;
 
 /// A context menu
@@ -41,14 +45,14 @@ where
     Overlay: Fn() -> Element<'a, Message, Theme, Renderer>,
     Message: Clone,
     Renderer: renderer::Renderer,
-    Theme: StyleSheet,
+    Theme: Catalog,
 {
     /// The underlying element.
     underlay: Element<'a, Message, Theme, Renderer>,
     /// The content of [`ContextMenuOverlay`].
     overlay: Overlay,
     /// The style of the [`ContextMenu`].
-    style: <Theme as StyleSheet>::Style,
+    class: Theme::Class<'a>,
 }
 
 impl<'a, Overlay, Message, Theme, Renderer> ContextMenu<'a, Overlay, Message, Theme, Renderer>
@@ -56,7 +60,7 @@ where
     Overlay: Fn() -> Element<'a, Message, Theme, Renderer>,
     Message: Clone,
     Renderer: renderer::Renderer,
-    Theme: StyleSheet,
+    Theme: Catalog,
 {
     /// Creates a new [`ContextMenu`]
     ///
@@ -70,14 +74,24 @@ where
         ContextMenu {
             underlay: underlay.into(),
             overlay,
-            style: <Theme as StyleSheet>::Style::default(),
+            class: Theme::default(),
         }
     }
 
     /// Sets the style of the [`ContextMenu`].
     #[must_use]
-    pub fn style(mut self, style: <Theme as StyleSheet>::Style) -> Self {
-        self.style = style;
+    pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> Self
+    where
+        Theme::Class<'a>: From<StyleFn<'a, Theme, Style>>,
+    {
+        self.class = (Box::new(style) as StyleFn<'a, Theme, Style>).into();
+        self
+    }
+
+    /// Sets the class of the input of the [`Badge`].
+    #[must_use]
+    pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
+        self.class = class.into();
         self
     }
 }
@@ -88,7 +102,7 @@ where
     Content: 'a + Fn() -> Element<'a, Message, Theme, Renderer>,
     Message: 'a + Clone,
     Renderer: 'a + renderer::Renderer,
-    Theme: StyleSheet,
+    Theme: Catalog,
 {
     fn size(&self) -> iced::Size<Length> {
         self.underlay.as_widget().size()
@@ -130,7 +144,7 @@ where
     }
 
     fn children(&self) -> Vec<Tree> {
-        vec![Tree::new(&self.underlay), Tree::new(&(self.overlay)())]
+        vec![Tree::new(&self.underlay), Tree::new((self.overlay)())]
     }
 
     fn diff(&self, tree: &mut Tree) {
@@ -142,7 +156,7 @@ where
         state: &'b mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<Message>,
+        operation: &mut dyn Operation<()>,
     ) {
         let s: &mut State = state.state.downcast_mut();
 
@@ -237,7 +251,7 @@ where
                 position + translation,
                 &mut state.children[1],
                 content,
-                self.style.clone(),
+                &self.class,
                 s,
             )
             .overlay(),
@@ -251,7 +265,7 @@ where
     Content: 'a + Fn() -> Self,
     Message: 'a + Clone,
     Renderer: 'a + renderer::Renderer,
-    Theme: 'a + StyleSheet,
+    Theme: 'a + Catalog,
 {
     fn from(modal: ContextMenu<'a, Content, Message, Theme, Renderer>) -> Self {
         Element::new(modal)
diff --git a/src/widgets/overlay/context_menu.rs b/src/widgets/overlay/context_menu.rs
index f07f7beb..c72375dd 100644
--- a/src/widgets/overlay/context_menu.rs
+++ b/src/widgets/overlay/context_menu.rs
@@ -2,7 +2,10 @@
 //!
 //! *This API requires the following crate features to be activated: ``context_menu``*
 use crate::context_menu;
-use crate::style::context_menu::StyleSheet;
+pub use crate::style::{
+    context_menu::{Catalog, Style},
+    status::{self, StyleFn},
+};
 
 use iced::{
     advanced::{
@@ -19,11 +22,12 @@ use iced::{
 
 /// The overlay of the [`ContextMenu`](crate::widgets::ContextMenu).
 #[allow(missing_debug_implementations)]
-pub struct ContextMenuOverlay<'a, Message, Theme = iced::Theme, Renderer = iced::Renderer>
+pub struct ContextMenuOverlay<'a, 'b, Message, Theme = iced::Theme, Renderer = iced::Renderer>
 where
     Message: 'a + Clone,
     Renderer: 'a + renderer::Renderer,
-    Theme: StyleSheet,
+    Theme: Catalog,
+    'b: 'a,
 {
     // The position of the element
     position: Point,
@@ -32,23 +36,24 @@ where
     /// The content of the [`ContextMenuOverlay`].
     content: Element<'a, Message, Theme, Renderer>,
     /// The style of the [`ContextMenuOverlay`].
-    style: <Theme as StyleSheet>::Style,
+    class: &'a Theme::Class<'b>,
     /// The state shared between [`ContextMenu`](crate::widgets::ContextMenu) and [`ContextMenuOverlay`].
     state: &'a mut context_menu::State,
 }
 
-impl<'a, Message, Theme, Renderer> ContextMenuOverlay<'a, Message, Theme, Renderer>
+impl<'a, 'b, Message, Theme, Renderer> ContextMenuOverlay<'a, 'b, Message, Theme, Renderer>
 where
     Message: Clone,
     Renderer: renderer::Renderer,
-    Theme: 'a + StyleSheet,
+    Theme: 'a + Catalog,
+    'b: 'a,
 {
     /// Creates a new [`ContextMenuOverlay`].
     pub(crate) fn new<C>(
         position: Point,
         tree: &'a mut Tree,
         content: C,
-        style: <Theme as StyleSheet>::Style,
+        class: &'a <Theme as Catalog>::Class<'b>,
         state: &'a mut context_menu::State,
     ) -> Self
     where
@@ -58,23 +63,25 @@ where
             position,
             tree,
             content: content.into(),
-            style,
+            class,
             state,
         }
     }
 
     /// Turn this [`ContextMenuOverlay`] into an overlay [`Element`](overlay::Element).
+    #[must_use]
     pub fn overlay(self) -> overlay::Element<'a, Message, Theme, Renderer> {
         overlay::Element::new(Box::new(self))
     }
 }
 
-impl<'a, Message, Theme, Renderer> overlay::Overlay<Message, Theme, Renderer>
-    for ContextMenuOverlay<'a, Message, Theme, Renderer>
+impl<'a, 'b, Message, Theme, Renderer> overlay::Overlay<Message, Theme, Renderer>
+    for ContextMenuOverlay<'a, 'b, Message, Theme, Renderer>
 where
     Message: 'a + Clone,
     Renderer: 'a + renderer::Renderer,
-    Theme: StyleSheet,
+    Theme: 'a + Catalog,
+    'b: 'a,
 {
     fn layout(&mut self, renderer: &Renderer, bounds: Size) -> Node {
         let limits = Limits::new(Size::ZERO, bounds);
@@ -109,7 +116,7 @@ where
     ) {
         let bounds = layout.bounds();
 
-        let style_sheet = theme.active(&self.style);
+        let style_sheet = theme.style(self.class, status::Status::Active);
 
         // Background
         if (bounds.width > 0.) && (bounds.height > 0.) {
@@ -188,7 +195,7 @@ where
                 Status::Captured
             }
 
-            Event::Window(_id, window::Event::Resized { .. }) => {
+            Event::Window(window::Event::Resized { .. }) => {
                 self.state.show = false;
                 forward_event_to_children = false;
                 Status::Captured