Merge pull request #2209 from iced-rs/remove-associated-theme

`Themer` widget

5 files changed, 139 insertions, 107 deletions

diff --git a/widget/src/lazy.rs b/widget/src/lazy.rs
index e9edbb4c..dda6162b 100644
--- a/widget/src/lazy.rs
+++ b/widget/src/lazy.rs
@@ -29,19 +29,19 @@ use std::rc::Rc;
 
 /// A widget that only rebuilds its contents when necessary.
 #[allow(missing_debug_implementations)]
-pub struct Lazy<'a, Message, Renderer, Dependency, View> {
+pub struct Lazy<'a, Message, Theme, Renderer, Dependency, View> {
     dependency: Dependency,
     view: Box<dyn Fn(&Dependency) -> View + 'a>,
     element: RefCell<
-        Option<Rc<RefCell<Option<Element<'static, Message, Renderer>>>>>,
+        Option<Rc<RefCell<Option<Element<'static, Message, Theme, Renderer>>>>>,
     >,
 }
 
-impl<'a, Message, Renderer, Dependency, View>
-    Lazy<'a, Message, Renderer, Dependency, View>
+impl<'a, Message, Theme, Renderer, Dependency, View>
+    Lazy<'a, Message, Theme, Renderer, Dependency, View>
 where
     Dependency: Hash + 'a,
-    View: Into<Element<'static, Message, Renderer>>,
+    View: Into<Element<'static, Message, Theme, Renderer>>,
 {
     /// Creates a new [`Lazy`] widget with the given data `Dependency` and a
     /// closure that can turn this data into a widget tree.
@@ -58,7 +58,7 @@ where
 
     fn with_element<T>(
         &self,
-        f: impl FnOnce(&Element<'_, Message, Renderer>) -> T,
+        f: impl FnOnce(&Element<'_, Message, Theme, Renderer>) -> T,
     ) -> T {
         f(self
             .element
@@ -72,7 +72,7 @@ where
 
     fn with_element_mut<T>(
         &self,
-        f: impl FnOnce(&mut Element<'_, Message, Renderer>) -> T,
+        f: impl FnOnce(&mut Element<'_, Message, Theme, Renderer>) -> T,
     ) -> T {
         f(self
             .element
@@ -85,17 +85,19 @@ where
     }
 }
 
-struct Internal<Message, Renderer> {
-    element: Rc<RefCell<Option<Element<'static, Message, Renderer>>>>,
+struct Internal<Message, Theme, Renderer> {
+    element: Rc<RefCell<Option<Element<'static, Message, Theme, Renderer>>>>,
     hash: u64,
 }
 
-impl<'a, Message, Renderer, Dependency, View> Widget<Message, Renderer>
-    for Lazy<'a, Message, Renderer, Dependency, View>
+impl<'a, Message, Theme, Renderer, Dependency, View>
+    Widget<Message, Theme, Renderer>
+    for Lazy<'a, Message, Theme, Renderer, Dependency, View>
 where
-    View: Into<Element<'static, Message, Renderer>> + 'static,
+    View: Into<Element<'static, Message, Theme, Renderer>> + 'static,
     Dependency: Hash + 'a,
     Message: 'static,
+    Theme: 'static,
     Renderer: core::Renderer + 'static,
 {
     fn tag(&self) -> tree::Tag {
@@ -121,7 +123,9 @@ where
     }
 
     fn diff(&self, tree: &mut Tree) {
-        let current = tree.state.downcast_mut::<Internal<Message, Renderer>>();
+        let current = tree
+            .state
+            .downcast_mut::<Internal<Message, Theme, Renderer>>();
 
         let mut hasher = Hasher::default();
         self.dependency.hash(&mut hasher);
@@ -231,7 +235,7 @@ where
         &self,
         tree: &Tree,
         renderer: &mut Renderer,
-        theme: &Renderer::Theme,
+        theme: &Theme,
         style: &renderer::Style,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
@@ -255,7 +259,7 @@ where
         tree: &'b mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-    ) -> Option<overlay::Element<'_, Message, Renderer>> {
+    ) -> Option<overlay::Element<'_, Message, Theme, Renderer>> {
         let overlay = Overlay(Some(
             InnerBuilder {
                 cell: self.element.borrow().as_ref().unwrap().clone(),
@@ -287,29 +291,33 @@ where
 }
 
 #[self_referencing]
-struct Inner<'a, Message: 'a, Renderer: 'a> {
-    cell: Rc<RefCell<Option<Element<'static, Message, Renderer>>>>,
-    element: Element<'static, Message, Renderer>,
+struct Inner<'a, Message: 'a, Theme: 'a, Renderer: 'a> {
+    cell: Rc<RefCell<Option<Element<'static, Message, Theme, Renderer>>>>,
+    element: Element<'static, Message, Theme, Renderer>,
     tree: &'a mut Tree,
 
     #[borrows(mut element, mut tree)]
     #[not_covariant]
-    overlay: Option<RefCell<Nested<'this, Message, Renderer>>>,
+    overlay: Option<RefCell<Nested<'this, Message, Theme, Renderer>>>,
 }
 
-struct Overlay<'a, Message, Renderer>(Option<Inner<'a, Message, Renderer>>);
+struct Overlay<'a, Message, Theme, Renderer>(
+    Option<Inner<'a, Message, Theme, Renderer>>,
+);
 
-impl<'a, Message, Renderer> Drop for Overlay<'a, Message, Renderer> {
+impl<'a, Message, Theme, Renderer> Drop
+    for Overlay<'a, Message, Theme, Renderer>
+{
     fn drop(&mut self) {
         let heads = self.0.take().unwrap().into_heads();
         (*heads.cell.borrow_mut()) = Some(heads.element);
     }
 }
 
-impl<'a, Message, Renderer> Overlay<'a, Message, Renderer> {
+impl<'a, Message, Theme, Renderer> Overlay<'a, Message, Theme, Renderer> {
     fn with_overlay_maybe<T>(
         &self,
-        f: impl FnOnce(&mut Nested<'_, Message, Renderer>) -> T,
+        f: impl FnOnce(&mut Nested<'_, Message, Theme, Renderer>) -> T,
     ) -> Option<T> {
         self.0.as_ref().unwrap().with_overlay(|overlay| {
             overlay.as_ref().map(|nested| (f)(&mut nested.borrow_mut()))
@@ -318,7 +326,7 @@ impl<'a, Message, Renderer> Overlay<'a, Message, Renderer> {
 
     fn with_overlay_mut_maybe<T>(
         &mut self,
-        f: impl FnOnce(&mut Nested<'_, Message, Renderer>) -> T,
+        f: impl FnOnce(&mut Nested<'_, Message, Theme, Renderer>) -> T,
     ) -> Option<T> {
         self.0.as_mut().unwrap().with_overlay_mut(|overlay| {
             overlay.as_mut().map(|nested| (f)(nested.get_mut()))
@@ -326,8 +334,8 @@ impl<'a, Message, Renderer> Overlay<'a, Message, Renderer> {
     }
 }
 
-impl<'a, Message, Renderer> overlay::Overlay<Message, Renderer>
-    for Overlay<'a, Message, Renderer>
+impl<'a, Message, Theme, Renderer> overlay::Overlay<Message, Theme, Renderer>
+    for Overlay<'a, Message, Theme, Renderer>
 where
     Renderer: core::Renderer,
 {
@@ -347,7 +355,7 @@ where
     fn draw(
         &self,
         renderer: &mut Renderer,
-        theme: &Renderer::Theme,
+        theme: &Theme,
         style: &renderer::Style,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
@@ -398,16 +406,19 @@ where
     }
 }
 
-impl<'a, Message, Renderer, Dependency, View>
-    From<Lazy<'a, Message, Renderer, Dependency, View>>
-    for Element<'a, Message, Renderer>
+impl<'a, Message, Theme, Renderer, Dependency, View>
+    From<Lazy<'a, Message, Theme, Renderer, Dependency, View>>
+    for Element<'a, Message, Theme, Renderer>
 where
-    View: Into<Element<'static, Message, Renderer>> + 'static,
+    View: Into<Element<'static, Message, Theme, Renderer>> + 'static,
     Renderer: core::Renderer + 'static,
     Message: 'static,
+    Theme: 'static,
     Dependency: Hash + 'a,
 {
-    fn from(lazy: Lazy<'a, Message, Renderer, Dependency, View>) -> Self {
+    fn from(
+        lazy: Lazy<'a, Message, Theme, Renderer, Dependency, View>,
+    ) -> Self {
         Self::new(lazy)
     }
 }
diff --git a/widget/src/lazy/cache.rs b/widget/src/lazy/cache.rs
index e7b87614..f922fd19 100644
--- a/widget/src/lazy/cache.rs
+++ b/widget/src/lazy/cache.rs
@@ -4,10 +4,10 @@ use crate::core::Element;
 use ouroboros::self_referencing;
 
 #[self_referencing(pub_extras)]
-pub struct Cache<'a, Message: 'a, Renderer: 'a> {
-    pub element: Element<'a, Message, Renderer>,
+pub struct Cache<'a, Message: 'a, Theme: 'a, Renderer: 'a> {
+    pub element: Element<'a, Message, Theme, Renderer>,
 
     #[borrows(mut element)]
     #[covariant]
-    overlay: Option<overlay::Element<'this, Message, Renderer>>,
+    overlay: Option<overlay::Element<'this, Message, Theme, Renderer>>,
 }
diff --git a/widget/src/lazy/component.rs b/widget/src/lazy/component.rs
index 3684e0c9..30b1efed 100644
--- a/widget/src/lazy/component.rs
+++ b/widget/src/lazy/component.rs
@@ -30,7 +30,7 @@ use std::rc::Rc;
 ///
 /// Additionally, a [`Component`] is capable of producing a `Message` to notify
 /// the parent application of any relevant interactions.
-pub trait Component<Message, Renderer> {
+pub trait Component<Message, Theme = crate::Theme, Renderer = crate::Renderer> {
     /// The internal state of this [`Component`].
     type State: Default;
 
@@ -48,7 +48,10 @@ pub trait Component<Message, Renderer> {
 
     /// Produces the widgets of the [`Component`], which may trigger an [`Event`](Component::Event)
     /// on user interaction.
-    fn view(&self, state: &Self::State) -> Element<'_, Self::Event, Renderer>;
+    fn view(
+        &self,
+        state: &Self::State,
+    ) -> Element<'_, Self::Event, Theme, Renderer>;
 
     /// Update the [`Component`] state based on the provided [`Operation`](widget::Operation)
     ///
@@ -65,13 +68,14 @@ struct Tag<T>(T);
 
 /// Turns an implementor of [`Component`] into an [`Element`] that can be
 /// embedded in any application.
-pub fn view<'a, C, Message, Renderer>(
+pub fn view<'a, C, Message, Theme, Renderer>(
     component: C,
-) -> Element<'a, Message, Renderer>
+) -> Element<'a, Message, Theme, Renderer>
 where
-    C: Component<Message, Renderer> + 'a,
+    C: Component<Message, Theme, Renderer> + 'a,
     C::State: 'static,
     Message: 'a,
+    Theme: 'a,
     Renderer: core::Renderer + 'a,
 {
     Element::new(Instance {
@@ -88,24 +92,26 @@ where
     })
 }
 
-struct Instance<'a, Message, Renderer, Event, S> {
-    state: RefCell<Option<State<'a, Message, Renderer, Event, S>>>,
+struct Instance<'a, Message, Theme, Renderer, Event, S> {
+    state: RefCell<Option<State<'a, Message, Theme, Renderer, Event, S>>>,
     tree: RefCell<Rc<RefCell<Option<Tree>>>>,
 }
 
 #[self_referencing]
-struct State<'a, Message: 'a, Renderer: 'a, Event: 'a, S: 'a> {
-    component:
-        Box<dyn Component<Message, Renderer, Event = Event, State = S> + 'a>,
+struct State<'a, Message: 'a, Theme: 'a, Renderer: 'a, Event: 'a, S: 'a> {
+    component: Box<
+        dyn Component<Message, Theme, Renderer, Event = Event, State = S> + 'a,
+    >,
     message: PhantomData<Message>,
     state: PhantomData<S>,
 
     #[borrows(component)]
     #[covariant]
-    element: Option<Element<'this, Event, Renderer>>,
+    element: Option<Element<'this, Event, Theme, Renderer>>,
 }
 
-impl<'a, Message, Renderer, Event, S> Instance<'a, Message, Renderer, Event, S>
+impl<'a, Message, Theme, Renderer, Event, S>
+    Instance<'a, Message, Theme, Renderer, Event, S>
 where
     S: Default + 'static,
     Renderer: renderer::Renderer,
@@ -196,14 +202,14 @@ where
 
     fn with_element<T>(
         &self,
-        f: impl FnOnce(&Element<'_, Event, Renderer>) -> T,
+        f: impl FnOnce(&Element<'_, Event, Theme, Renderer>) -> T,
     ) -> T {
         self.with_element_mut(|element| f(element))
     }
 
     fn with_element_mut<T>(
         &self,
-        f: impl FnOnce(&mut Element<'_, Event, Renderer>) -> T,
+        f: impl FnOnce(&mut Element<'_, Event, Theme, Renderer>) -> T,
     ) -> T {
         self.rebuild_element_if_necessary();
         self.state
@@ -214,8 +220,8 @@ where
     }
 }
 
-impl<'a, Message, Renderer, Event, S> Widget<Message, Renderer>
-    for Instance<'a, Message, Renderer, Event, S>
+impl<'a, Message, Theme, Renderer, Event, S> Widget<Message, Theme, Renderer>
+    for Instance<'a, Message, Theme, Renderer, Event, S>
 where
     S: 'static + Default,
     Renderer: core::Renderer,
@@ -411,7 +417,7 @@ where
         &self,
         tree: &Tree,
         renderer: &mut Renderer,
-        theme: &Renderer::Theme,
+        theme: &Theme,
         style: &renderer::Style,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
@@ -456,7 +462,7 @@ where
         tree: &'b mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-    ) -> Option<overlay::Element<'b, Message, Renderer>> {
+    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
         self.rebuild_element_if_necessary();
         let tree = tree
             .state
@@ -506,12 +512,12 @@ where
     }
 }
 
-struct Overlay<'a, 'b, Message, Renderer, Event, S>(
-    Option<Inner<'a, 'b, Message, Renderer, Event, S>>,
+struct Overlay<'a, 'b, Message, Theme, Renderer, Event, S>(
+    Option<Inner<'a, 'b, Message, Theme, Renderer, Event, S>>,
 );
 
-impl<'a, 'b, Message, Renderer, Event, S> Drop
-    for Overlay<'a, 'b, Message, Renderer, Event, S>
+impl<'a, 'b, Message, Theme, Renderer, Event, S> Drop
+    for Overlay<'a, 'b, Message, Theme, Renderer, Event, S>
 {
     fn drop(&mut self) {
         if let Some(heads) = self.0.take().map(Inner::into_heads) {
@@ -521,26 +527,26 @@ impl<'a, 'b, Message, Renderer, Event, S> Drop
 }
 
 #[self_referencing]
-struct Inner<'a, 'b, Message, Renderer, Event, S> {
-    instance: &'a mut Instance<'b, Message, Renderer, Event, S>,
+struct Inner<'a, 'b, Message, Theme, Renderer, Event, S> {
+    instance: &'a mut Instance<'b, Message, Theme, Renderer, Event, S>,
     tree: Tree,
     types: PhantomData<(Message, Event, S)>,
 
     #[borrows(mut instance, mut tree)]
     #[not_covariant]
-    overlay: Option<RefCell<Nested<'this, Event, Renderer>>>,
+    overlay: Option<RefCell<Nested<'this, Event, Theme, Renderer>>>,
 }
 
-struct OverlayInstance<'a, 'b, Message, Renderer, Event, S> {
-    overlay: Option<Overlay<'a, 'b, Message, Renderer, Event, S>>,
+struct OverlayInstance<'a, 'b, Message, Theme, Renderer, Event, S> {
+    overlay: Option<Overlay<'a, 'b, Message, Theme, Renderer, Event, S>>,
 }
 
-impl<'a, 'b, Message, Renderer, Event, S>
-    OverlayInstance<'a, 'b, Message, Renderer, Event, S>
+impl<'a, 'b, Message, Theme, Renderer, Event, S>
+    OverlayInstance<'a, 'b, Message, Theme, Renderer, Event, S>
 {
     fn with_overlay_maybe<T>(
         &self,
-        f: impl FnOnce(&mut Nested<'_, Event, Renderer>) -> T,
+        f: impl FnOnce(&mut Nested<'_, Event, Theme, Renderer>) -> T,
     ) -> Option<T> {
         self.overlay
             .as_ref()
@@ -555,7 +561,7 @@ impl<'a, 'b, Message, Renderer, Event, S>
 
     fn with_overlay_mut_maybe<T>(
         &mut self,
-        f: impl FnOnce(&mut Nested<'_, Event, Renderer>) -> T,
+        f: impl FnOnce(&mut Nested<'_, Event, Theme, Renderer>) -> T,
     ) -> Option<T> {
         self.overlay
             .as_mut()
@@ -569,8 +575,9 @@ impl<'a, 'b, Message, Renderer, Event, S>
     }
 }
 
-impl<'a, 'b, Message, Renderer, Event, S> overlay::Overlay<Message, Renderer>
-    for OverlayInstance<'a, 'b, Message, Renderer, Event, S>
+impl<'a, 'b, Message, Theme, Renderer, Event, S>
+    overlay::Overlay<Message, Theme, Renderer>
+    for OverlayInstance<'a, 'b, Message, Theme, Renderer, Event, S>
 where
     Renderer: core::Renderer,
     S: 'static + Default,
@@ -591,7 +598,7 @@ where
     fn draw(
         &self,
         renderer: &mut Renderer,
-        theme: &Renderer::Theme,
+        theme: &Theme,
         style: &renderer::Style,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
diff --git a/widget/src/lazy/helpers.rs b/widget/src/lazy/helpers.rs
index 5dc60d52..4d0776ca 100644
--- a/widget/src/lazy/helpers.rs
+++ b/widget/src/lazy/helpers.rs
@@ -7,13 +7,13 @@ use std::hash::Hash;
 /// Creates a new [`Lazy`] widget with the given data `Dependency` and a
 /// closure that can turn this data into a widget tree.
 #[cfg(feature = "lazy")]
-pub fn lazy<'a, Message, Renderer, Dependency, View>(
+pub fn lazy<'a, Message, Theme, Renderer, Dependency, View>(
     dependency: Dependency,
     view: impl Fn(&Dependency) -> View + 'a,
-) -> Lazy<'a, Message, Renderer, Dependency, View>
+) -> Lazy<'a, Message, Theme, Renderer, Dependency, View>
 where
     Dependency: Hash + 'a,
-    View: Into<Element<'static, Message, Renderer>>,
+    View: Into<Element<'static, Message, Theme, Renderer>>,
 {
     Lazy::new(dependency, view)
 }
@@ -21,13 +21,14 @@ where
 /// Turns an implementor of [`Component`] into an [`Element`] that can be
 /// embedded in any application.
 #[cfg(feature = "lazy")]
-pub fn component<'a, C, Message, Renderer>(
+pub fn component<'a, C, Message, Theme, Renderer>(
     component: C,
-) -> Element<'a, Message, Renderer>
+) -> Element<'a, Message, Theme, Renderer>
 where
-    C: Component<Message, Renderer> + 'a,
+    C: Component<Message, Theme, Renderer> + 'a,
     C::State: 'static,
     Message: 'a,
+    Theme: 'a,
     Renderer: core::Renderer + 'a,
 {
     component::view(component)
@@ -40,9 +41,9 @@ where
 /// the [`Responsive`] widget and, therefore, can be used to build the
 /// contents of the widget in a responsive way.
 #[cfg(feature = "lazy")]
-pub fn responsive<'a, Message, Renderer>(
-    f: impl Fn(Size) -> Element<'a, Message, Renderer> + 'a,
-) -> Responsive<'a, Message, Renderer>
+pub fn responsive<'a, Message, Theme, Renderer>(
+    f: impl Fn(Size) -> Element<'a, Message, Theme, Renderer> + 'a,
+) -> Responsive<'a, Message, Theme, Renderer>
 where
     Renderer: core::Renderer,
 {
diff --git a/widget/src/lazy/responsive.rs b/widget/src/lazy/responsive.rs
index 1df0866f..9875b24e 100644
--- a/widget/src/lazy/responsive.rs
+++ b/widget/src/lazy/responsive.rs
@@ -22,12 +22,17 @@ use std::ops::Deref;
 /// A [`Responsive`] widget will always try to fill all the available space of
 /// its parent.
 #[allow(missing_debug_implementations)]
-pub struct Responsive<'a, Message, Renderer = crate::Renderer> {
-    view: Box<dyn Fn(Size) -> Element<'a, Message, Renderer> + 'a>,
-    content: RefCell<Content<'a, Message, Renderer>>,
+pub struct Responsive<
+    'a,
+    Message,
+    Theme = crate::Theme,
+    Renderer = crate::Renderer,
+> {
+    view: Box<dyn Fn(Size) -> Element<'a, Message, Theme, Renderer> + 'a>,
+    content: RefCell<Content<'a, Message, Theme, Renderer>>,
 }
 
-impl<'a, Message, Renderer> Responsive<'a, Message, Renderer>
+impl<'a, Message, Theme, Renderer> Responsive<'a, Message, Theme, Renderer>
 where
     Renderer: core::Renderer,
 {
@@ -38,7 +43,7 @@ where
     /// the [`Responsive`] widget and, therefore, can be used to build the
     /// contents of the widget in a responsive way.
     pub fn new(
-        view: impl Fn(Size) -> Element<'a, Message, Renderer> + 'a,
+        view: impl Fn(Size) -> Element<'a, Message, Theme, Renderer> + 'a,
     ) -> Self {
         Self {
             view: Box::new(view),
@@ -51,13 +56,13 @@ where
     }
 }
 
-struct Content<'a, Message, Renderer> {
+struct Content<'a, Message, Theme, Renderer> {
     size: Size,
     layout: Option<layout::Node>,
-    element: Element<'a, Message, Renderer>,
+    element: Element<'a, Message, Theme, Renderer>,
 }
 
-impl<'a, Message, Renderer> Content<'a, Message, Renderer>
+impl<'a, Message, Theme, Renderer> Content<'a, Message, Theme, Renderer>
 where
     Renderer: core::Renderer,
 {
@@ -75,7 +80,7 @@ where
         &mut self,
         tree: &mut Tree,
         new_size: Size,
-        view: &dyn Fn(Size) -> Element<'a, Message, Renderer>,
+        view: &dyn Fn(Size) -> Element<'a, Message, Theme, Renderer>,
     ) {
         if self.size == new_size {
             return;
@@ -93,12 +98,12 @@ where
         tree: &mut Tree,
         renderer: R,
         layout: Layout<'_>,
-        view: &dyn Fn(Size) -> Element<'a, Message, Renderer>,
+        view: &dyn Fn(Size) -> Element<'a, Message, Theme, Renderer>,
         f: impl FnOnce(
             &mut Tree,
             R,
             Layout<'_>,
-            &mut Element<'a, Message, Renderer>,
+            &mut Element<'a, Message, Theme, Renderer>,
         ) -> T,
     ) -> T
     where
@@ -120,8 +125,8 @@ struct State {
     tree: RefCell<Tree>,
 }
 
-impl<'a, Message, Renderer> Widget<Message, Renderer>
-    for Responsive<'a, Message, Renderer>
+impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
+    for Responsive<'a, Message, Theme, Renderer>
 where
     Renderer: core::Renderer,
 {
@@ -223,7 +228,7 @@ where
         &self,
         tree: &Tree,
         renderer: &mut Renderer,
-        theme: &Renderer::Theme,
+        theme: &Theme,
         style: &renderer::Style,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
@@ -274,7 +279,7 @@ where
         tree: &'b mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-    ) -> Option<overlay::Element<'b, Message, Renderer>> {
+    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
         use std::ops::DerefMut;
 
         let state = tree.state.downcast_ref::<State>();
@@ -283,7 +288,10 @@ where
             content: self.content.borrow_mut(),
             tree: state.tree.borrow_mut(),
             types: PhantomData,
-            overlay_builder: |content: &mut RefMut<'_, Content<'_, _, _>>,
+            overlay_builder: |content: &mut RefMut<
+                '_,
+                Content<'_, _, _, _>,
+            >,
                               tree| {
                 content.update(tree, layout.bounds().size(), &self.view);
                 content.layout(tree, renderer);
@@ -315,32 +323,36 @@ where
     }
 }
 
-impl<'a, Message, Renderer> From<Responsive<'a, Message, Renderer>>
-    for Element<'a, Message, Renderer>
+impl<'a, Message, Theme, Renderer>
+    From<Responsive<'a, Message, Theme, Renderer>>
+    for Element<'a, Message, Theme, Renderer>
 where
-    Renderer: core::Renderer + 'a,
     Message: 'a,
+    Theme: 'a,
+    Renderer: core::Renderer + 'a,
 {
-    fn from(responsive: Responsive<'a, Message, Renderer>) -> Self {
+    fn from(responsive: Responsive<'a, Message, Theme, Renderer>) -> Self {
         Self::new(responsive)
     }
 }
 
 #[self_referencing]
-struct Overlay<'a, 'b, Message, Renderer> {
-    content: RefMut<'a, Content<'b, Message, Renderer>>,
+struct Overlay<'a, 'b, Message, Theme, Renderer> {
+    content: RefMut<'a, Content<'b, Message, Theme, Renderer>>,
     tree: RefMut<'a, Tree>,
     types: PhantomData<Message>,
 
     #[borrows(mut content, mut tree)]
     #[not_covariant]
-    overlay: Option<RefCell<Nested<'this, Message, Renderer>>>,
+    overlay: Option<RefCell<Nested<'this, Message, Theme, Renderer>>>,
 }
 
-impl<'a, 'b, Message, Renderer> Overlay<'a, 'b, Message, Renderer> {
+impl<'a, 'b, Message, Theme, Renderer>
+    Overlay<'a, 'b, Message, Theme, Renderer>
+{
     fn with_overlay_maybe<T>(
         &self,
-        f: impl FnOnce(&mut Nested<'_, Message, Renderer>) -> T,
+        f: impl FnOnce(&mut Nested<'_, Message, Theme, Renderer>) -> T,
     ) -> Option<T> {
         self.with_overlay(|overlay| {
             overlay.as_ref().map(|nested| (f)(&mut nested.borrow_mut()))
@@ -349,7 +361,7 @@ impl<'a, 'b, Message, Renderer> Overlay<'a, 'b, Message, Renderer> {
 
     fn with_overlay_mut_maybe<T>(
         &mut self,
-        f: impl FnOnce(&mut Nested<'_, Message, Renderer>) -> T,
+        f: impl FnOnce(&mut Nested<'_, Message, Theme, Renderer>) -> T,
     ) -> Option<T> {
         self.with_overlay_mut(|overlay| {
             overlay.as_mut().map(|nested| (f)(nested.get_mut()))
@@ -357,8 +369,9 @@ impl<'a, 'b, Message, Renderer> Overlay<'a, 'b, Message, Renderer> {
     }
 }
 
-impl<'a, 'b, Message, Renderer> overlay::Overlay<Message, Renderer>
-    for Overlay<'a, 'b, Message, Renderer>
+impl<'a, 'b, Message, Theme, Renderer>
+    overlay::Overlay<Message, Theme, Renderer>
+    for Overlay<'a, 'b, Message, Theme, Renderer>
 where
     Renderer: core::Renderer,
 {
@@ -378,7 +391,7 @@ where
     fn draw(
         &self,
         renderer: &mut Renderer,
-        theme: &Renderer::Theme,
+        theme: &Theme,
         style: &renderer::Style,
         layout: Layout<'_>,
         cursor: mouse::Cursor,