Convert Renderer::Theme to generic Widget type

examples/clock/src/main.rs

@@ -82,7 +82,7 @@ impl Application for Clock {
     }
 }
 
-impl<Message> canvas::Program<Message, Renderer> for Clock {
+impl<Message> canvas::Program<Message> for Clock {
     type State = ();
 
     fn draw(

examples/color_palette/src/main.rs

@@ -298,7 +298,7 @@ impl<C: ColorSpace + Copy> ColorPicker<C> {
             range: RangeInclusive<f64>,
             component: f32,
             update: impl Fn(f32) -> C + 'a,
-        ) -> Slider<'a, f64, C, iced::Renderer> {
+        ) -> Slider<'a, f64, C> {
             Slider::new(range, f64::from(component), move |v| update(v as f32))
                 .step(0.01)
         }

examples/component/src/main.rs

@@ -48,7 +48,7 @@ impl Sandbox for Component {
 mod numeric_input {
     use iced::alignment::{self, Alignment};
     use iced::widget::{button, component, row, text, text_input, Component};
-    use iced::{Element, Length, Renderer};
+    use iced::{Element, Length};
 
     pub struct NumericInput<Message> {
         value: Option<u32>,
@@ -81,7 +81,7 @@ mod numeric_input {
         }
     }
 
-    impl<Message> Component<Message, Renderer> for NumericInput<Message> {
+    impl<Message> Component<Message> for NumericInput<Message> {
         type State = ();
         type Event = Event;
 
@@ -111,7 +111,7 @@ mod numeric_input {
             }
         }
 
-        fn view(&self, _state: &Self::State) -> Element<Event, Renderer> {
+        fn view(&self, _state: &Self::State) -> Element<Event> {
             let button = |label, on_press| {
                 button(
                     text(label)
@@ -145,7 +145,7 @@ mod numeric_input {
         }
     }
 
-    impl<'a, Message> From<NumericInput<Message>> for Element<'a, Message, Renderer>
+    impl<'a, Message> From<NumericInput<Message>> for Element<'a, Message>
     where
         Message: 'a,
     {

examples/custom_quad/src/main.rs

@@ -29,7 +29,7 @@ mod quad {
         }
     }
 
-    impl<Message, Renderer> Widget<Message, Renderer> for CustomQuad
+    impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer> for CustomQuad
     where
         Renderer: renderer::Renderer,
     {
@@ -53,7 +53,7 @@ mod quad {
             &self,
             _state: &widget::Tree,
             renderer: &mut Renderer,
-            _theme: &Renderer::Theme,
+            _theme: &Theme,
             _style: &renderer::Style,
             layout: Layout<'_>,
             _cursor: mouse::Cursor,
@@ -74,10 +74,7 @@ mod quad {
         }
     }
 
-    impl<'a, Message, Renderer> From<CustomQuad> for Element<'a, Message, Renderer>
-    where
-        Renderer: renderer::Renderer,
-    {
+    impl<'a, Message> From<CustomQuad> for Element<'a, Message> {
         fn from(circle: CustomQuad) -> Self {
             Self::new(circle)
         }

examples/custom_shader/src/main.rs

@@ -8,8 +8,8 @@ use iced::widget::shader::wgpu;
 use iced::widget::{checkbox, column, container, row, shader, slider, text};
 use iced::window;
 use iced::{
-    Alignment, Application, Color, Command, Element, Length, Renderer,
-    Subscription, Theme,
+    Alignment, Application, Color, Command, Element, Length, Subscription,
+    Theme,
 };
 
 fn main() -> iced::Result {
@@ -72,7 +72,7 @@ impl Application for IcedCubes {
         Command::none()
     }
 
-    fn view(&self) -> Element<'_, Self::Message, Renderer<Self::Theme>> {
+    fn view(&self) -> Element<'_, Self::Message> {
         let top_controls = row![
             control(
                 "Amount",

examples/custom_widget/src/main.rs

@@ -29,7 +29,7 @@ mod circle {
         Circle::new(radius)
     }
 
-    impl<Message, Renderer> Widget<Message, Renderer> for Circle
+    impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer> for Circle
     where
         Renderer: renderer::Renderer,
     {
@@ -53,7 +53,7 @@ mod circle {
             &self,
             _state: &widget::Tree,
             renderer: &mut Renderer,
-            _theme: &Renderer::Theme,
+            _theme: &Theme,
             _style: &renderer::Style,
             layout: Layout<'_>,
             _cursor: mouse::Cursor,
@@ -70,7 +70,8 @@ mod circle {
         }
     }
 
-    impl<'a, Message, Renderer> From<Circle> for Element<'a, Message, Renderer>
+    impl<'a, Message, Theme, Renderer> From<Circle>
+        for Element<'a, Message, Theme, Renderer>
     where
         Renderer: renderer::Renderer,
     {

examples/geometry/src/main.rs

@@ -15,7 +15,7 @@ mod rainbow {
         Rainbow
     }
 
-    impl<Message> Widget<Message, Renderer> for Rainbow {
+    impl<Message> Widget<Message, Theme, Renderer> for Rainbow {
         fn size(&self) -> Size<Length> {
             Size {
                 width: Length::Fill,
@@ -139,7 +139,7 @@ mod rainbow {
         }
     }
 
-    impl<'a, Message> From<Rainbow> for Element<'a, Message, Renderer> {
+    impl<'a, Message> From<Rainbow> for Element<'a, Message> {
         fn from(rainbow: Rainbow) -> Self {
             Self::new(rainbow)
         }

examples/integration/src/controls.rs

@@ -29,8 +29,9 @@ impl Controls {
 }
 
 impl Program for Controls {
-    type Renderer = Renderer<Theme>;
+    type Theme = Theme;
     type Message = Message;
+    type Renderer = Renderer;
 
     fn update(&mut self, message: Message) -> Command<Message> {
         match message {
@@ -45,7 +46,7 @@ impl Program for Controls {
         Command::none()
     }
 
-    fn view(&self) -> Element<Message, Renderer<Theme>> {
+    fn view(&self) -> Element<Message, Theme, Renderer> {
         let background_color = self.background_color;
         let text = &self.text;
 

examples/loading_spinners/src/circular.rs

@@ -2,14 +2,15 @@
 use iced::advanced::layout;
 use iced::advanced::renderer;
 use iced::advanced::widget::tree::{self, Tree};
-use iced::advanced::{Clipboard, Layout, Renderer, Shell, Widget};
+use iced::advanced::{self, Clipboard, Layout, Shell, Widget};
 use iced::event;
 use iced::mouse;
 use iced::time::Instant;
 use iced::widget::canvas;
 use iced::window::{self, RedrawRequest};
 use iced::{
-    Background, Color, Element, Event, Length, Rectangle, Size, Vector,
+    Background, Color, Element, Event, Length, Rectangle, Renderer, Size,
+    Vector,
 };
 
 use super::easing::{self, Easing};
@@ -230,7 +231,7 @@ struct State {
     cache: canvas::Cache,
 }
 
-impl<'a, Message, Theme> Widget<Message, iced::Renderer<Theme>>
+impl<'a, Message, Theme> Widget<Message, Theme, Renderer>
     for Circular<'a, Theme>
 where
     Message: 'a + Clone,
@@ -254,7 +255,7 @@ where
     fn layout(
         &self,
         _tree: &mut Tree,
-        _renderer: &iced::Renderer<Theme>,
+        _renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
         layout::atomic(limits, self.size, self.size)
@@ -266,7 +267,7 @@ where
         event: Event,
         _layout: Layout<'_>,
         _cursor: mouse::Cursor,
-        _renderer: &iced::Renderer<Theme>,
+        _renderer: &Renderer,
         _clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         _viewport: &Rectangle,
@@ -290,13 +291,15 @@ where
     fn draw(
         &self,
         tree: &Tree,
-        renderer: &mut iced::Renderer<Theme>,
+        renderer: &mut Renderer,
         theme: &Theme,
         _style: &renderer::Style,
         layout: Layout<'_>,
         _cursor: mouse::Cursor,
         _viewport: &Rectangle,
     ) {
+        use advanced::Renderer as _;
+
         let state = tree.state.downcast_ref::<State>();
         let bounds = layout.bounds();
         let custom_style =
@@ -361,7 +364,7 @@ where
 }
 
 impl<'a, Message, Theme> From<Circular<'a, Theme>>
-    for Element<'a, Message, iced::Renderer<Theme>>
+    for Element<'a, Message, Theme, Renderer>
 where
     Message: Clone + 'a,
     Theme: StyleSheet + 'a,

examples/loading_spinners/src/linear.rs

@@ -2,7 +2,7 @@
 use iced::advanced::layout;
 use iced::advanced::renderer::{self, Quad};
 use iced::advanced::widget::tree::{self, Tree};
-use iced::advanced::{Clipboard, Layout, Shell, Widget};
+use iced::advanced::{self, Clipboard, Layout, Shell, Widget};
 use iced::event;
 use iced::mouse;
 use iced::time::Instant;
@@ -14,29 +14,27 @@ use super::easing::{self, Easing};
 use std::time::Duration;
 
 #[allow(missing_debug_implementations)]
-pub struct Linear<'a, Renderer>
+pub struct Linear<'a, Theme>
 where
-    Renderer: iced::advanced::Renderer,
-    Renderer::Theme: StyleSheet,
+    Theme: StyleSheet,
 {
     width: Length,
     height: Length,
-    style: <Renderer::Theme as StyleSheet>::Style,
+    style: Theme::Style,
     easing: &'a Easing,
     cycle_duration: Duration,
 }
 
-impl<'a, Renderer> Linear<'a, Renderer>
+impl<'a, Theme> Linear<'a, Theme>
 where
-    Renderer: iced::advanced::Renderer,
-    Renderer::Theme: StyleSheet,
+    Theme: StyleSheet,
 {
     /// Creates a new [`Linear`] with the given content.
     pub fn new() -> Self {
         Linear {
             width: Length::Fixed(100.0),
             height: Length::Fixed(4.0),
-            style: <Renderer::Theme as StyleSheet>::Style::default(),
+            style: Theme::Style::default(),
             easing: &easing::STANDARD,
             cycle_duration: Duration::from_millis(600),
         }
@@ -55,11 +53,8 @@ where
     }
 
     /// Sets the style variant of this [`Linear`].
-    pub fn style(
-        mut self,
-        style: <Renderer::Theme as StyleSheet>::Style,
-    ) -> Self {
-        self.style = style;
+    pub fn style(mut self, style: impl Into<Theme::Style>) -> Self {
+        self.style = style.into();
         self
     }
 
@@ -76,10 +71,9 @@ where
     }
 }
 
-impl<'a, Renderer> Default for Linear<'a, Renderer>
+impl<'a, Theme> Default for Linear<'a, Theme>
 where
-    Renderer: iced::advanced::Renderer,
-    Renderer::Theme: StyleSheet,
+    Theme: StyleSheet,
 {
     fn default() -> Self {
         Self::new()
@@ -151,11 +145,12 @@ impl State {
     }
 }
 
-impl<'a, Message, Renderer> Widget<Message, Renderer> for Linear<'a, Renderer>
+impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
+    for Linear<'a, Theme>
 where
-    Message: 'a + Clone,
-    Renderer: 'a + iced::advanced::Renderer,
-    Renderer::Theme: StyleSheet,
+    Message: Clone + 'a,
+    Theme: StyleSheet + 'a,
+    Renderer: advanced::Renderer + 'a,
 {
     fn tag(&self) -> tree::Tag {
         tree::Tag::of::<State>()
@@ -207,7 +202,7 @@ where
         &self,
         tree: &Tree,
         renderer: &mut Renderer,
-        theme: &Renderer::Theme,
+        theme: &Theme,
         _style: &renderer::Style,
         layout: Layout<'_>,
         _cursor: mouse::Cursor,
@@ -262,14 +257,14 @@ where
     }
 }
 
-impl<'a, Message, Renderer> From<Linear<'a, Renderer>>
-    for Element<'a, Message, Renderer>
+impl<'a, Message, Theme, Renderer> From<Linear<'a, Theme>>
+    for Element<'a, Message, Theme, Renderer>
 where
     Message: Clone + 'a,
+    Theme: StyleSheet + 'a,
     Renderer: iced::advanced::Renderer + 'a,
-    Renderer::Theme: StyleSheet,
 {
-    fn from(linear: Linear<'a, Renderer>) -> Self {
+    fn from(linear: Linear<'a, Theme>) -> Self {
         Self::new(linear)
     }
 }

examples/modal/src/main.rs

@@ -234,17 +234,17 @@ mod modal {
     use iced::{Color, Element, Event, Length, Point, Rectangle, Size, Vector};
 
     /// A widget that centers a modal element over some base element
-    pub struct Modal<'a, Message, Renderer> {
-        base: Element<'a, Message, Renderer>,
-        modal: Element<'a, Message, Renderer>,
+    pub struct Modal<'a, Message, Theme, Renderer> {
+        base: Element<'a, Message, Theme, Renderer>,
+        modal: Element<'a, Message, Theme, Renderer>,
         on_blur: Option<Message>,
     }
 
-    impl<'a, Message, Renderer> Modal<'a, Message, Renderer> {
+    impl<'a, Message, Theme, Renderer> Modal<'a, Message, Theme, Renderer> {
         /// Returns a new [`Modal`]
         pub fn new(
-            base: impl Into<Element<'a, Message, Renderer>>,
-            modal: impl Into<Element<'a, Message, Renderer>>,
+            base: impl Into<Element<'a, Message, Theme, Renderer>>,
+            modal: impl Into<Element<'a, Message, Theme, Renderer>>,
         ) -> Self {
             Self {
                 base: base.into(),
@@ -263,8 +263,8 @@ mod modal {
         }
     }
 
-    impl<'a, Message, Renderer> Widget<Message, Renderer>
-        for Modal<'a, Message, Renderer>
+    impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
+        for Modal<'a, Message, Theme, Renderer>
     where
         Renderer: advanced::Renderer,
         Message: Clone,
@@ -324,7 +324,7 @@ mod modal {
             &self,
             state: &widget::Tree,
             renderer: &mut Renderer,
-            theme: &<Renderer as advanced::Renderer>::Theme,
+            theme: &Theme,
             style: &renderer::Style,
             layout: Layout<'_>,
             cursor: mouse::Cursor,
@@ -346,7 +346,7 @@ mod modal {
             state: &'b mut widget::Tree,
             layout: Layout<'_>,
             _renderer: &Renderer,
-        ) -> Option<overlay::Element<'b, Message, Renderer>> {
+        ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
             Some(overlay::Element::new(
                 layout.position(),
                 Box::new(Overlay {
@@ -391,15 +391,16 @@ mod modal {
         }
     }
 
-    struct Overlay<'a, 'b, Message, Renderer> {
-        content: &'b mut Element<'a, Message, Renderer>,
+    struct Overlay<'a, 'b, Message, Theme, Renderer> {
+        content: &'b mut Element<'a, Message, Theme, Renderer>,
         tree: &'b mut widget::Tree,
         size: Size,
         on_blur: Option<Message>,
     }
 
-    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: advanced::Renderer,
         Message: Clone,
@@ -463,7 +464,7 @@ mod modal {
         fn draw(
             &self,
             renderer: &mut Renderer,
-            theme: &Renderer::Theme,
+            theme: &Theme,
             style: &renderer::Style,
             layout: Layout<'_>,
             cursor: mouse::Cursor,
@@ -524,7 +525,7 @@ mod modal {
             &'c mut self,
             layout: Layout<'_>,
             renderer: &Renderer,
-        ) -> Option<overlay::Element<'c, Message, Renderer>> {
+        ) -> Option<overlay::Element<'c, Message, Theme, Renderer>> {
             self.content.as_widget_mut().overlay(
                 self.tree,
                 layout.children().next().unwrap(),
@@ -533,13 +534,14 @@ mod modal {
         }
     }
 
-    impl<'a, Message, Renderer> From<Modal<'a, Message, Renderer>>
-        for Element<'a, Message, Renderer>
+    impl<'a, Message, Theme, Renderer> From<Modal<'a, Message, Theme, Renderer>>
+        for Element<'a, Message, Theme, Renderer>
     where
-        Renderer: 'a + advanced::Renderer,
+        Theme: 'a,
         Message: 'a + Clone,
+        Renderer: 'a + advanced::Renderer,
     {
-        fn from(modal: Modal<'a, Message, Renderer>) -> Self {
+        fn from(modal: Modal<'a, Message, Theme, Renderer>) -> Self {
             Element::new(modal)
         }
     }

examples/multitouch/src/main.rs

@@ -96,7 +96,7 @@ impl Application for Multitouch {
     }
 }
 
-impl canvas::Program<Message, Renderer> for State {
+impl canvas::Program<Message> for State {
     type State = ();
 
     fn update(

examples/screenshot/src/main.rs

@@ -7,7 +7,7 @@ use iced::window;
 use iced::window::screenshot::{self, Screenshot};
 use iced::{
     Alignment, Application, Command, ContentFit, Element, Length, Rectangle,
-    Renderer, Subscription, Theme,
+    Subscription, Theme,
 };
 
 use ::image as img;
@@ -131,7 +131,7 @@ impl Application for Example {
         Command::none()
     }
 
-    fn view(&self) -> Element<'_, Self::Message, Renderer<Self::Theme>> {
+    fn view(&self) -> Element<'_, Self::Message> {
         let image: Element<Message> = if let Some(screenshot) = &self.screenshot
         {
             image(image::Handle::from_pixels(

examples/toast/src/main.rs

@@ -177,7 +177,6 @@ mod toast {
     use std::fmt;
     use std::time::{Duration, Instant};
 
-    use iced::advanced;
     use iced::advanced::layout::{self, Layout};
     use iced::advanced::overlay;
     use iced::advanced::renderer;
@@ -314,7 +313,7 @@ mod toast {
         }
     }
 
-    impl<'a, Message> Widget<Message, Renderer> for Manager<'a, Message> {
+    impl<'a, Message> Widget<Message, Theme, Renderer> for Manager<'a, Message> {
         fn size(&self) -> Size<Length> {
             self.content.as_widget().size()
         }
@@ -457,7 +456,7 @@ mod toast {
             state: &'b mut Tree,
             layout: Layout<'_>,
             renderer: &Renderer,
-        ) -> Option<overlay::Element<'b, Message, Renderer>> {
+        ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
             let instants = state.state.downcast_mut::<Vec<Option<Instant>>>();
 
             let (content_state, toasts_state) = state.children.split_at_mut(1);
@@ -496,7 +495,7 @@ mod toast {
         timeout_secs: u64,
     }
 
-    impl<'a, 'b, Message> overlay::Overlay<Message, Renderer>
+    impl<'a, 'b, Message> overlay::Overlay<Message, Theme, Renderer>
         for Overlay<'a, 'b, Message>
     {
         fn layout(
@@ -601,7 +600,7 @@ mod toast {
         fn draw(
             &self,
             renderer: &mut Renderer,
-            theme: &<Renderer as advanced::Renderer>::Theme,
+            theme: &Theme,
             style: &renderer::Style,
             layout: Layout<'_>,
             cursor: mouse::Cursor,

examples/tour/src/main.rs

@@ -5,7 +5,7 @@ use iced::widget::{
     scrollable, slider, text, text_input, toggler, vertical_space,
 };
 use iced::widget::{Button, Column, Container, Slider};
-use iced::{Color, Element, Font, Length, Pixels, Renderer, Sandbox, Settings};
+use iced::{Color, Element, Font, Length, Pixels, Sandbox, Settings};
 
 pub fn main() -> iced::Result {
     #[cfg(target_arch = "wasm32")]
@@ -697,7 +697,7 @@ fn button<'a, Message: Clone>(label: &str) -> Button<'a, Message> {
 fn color_slider<'a>(
     component: f32,
     update: impl Fn(f32) -> Color + 'a,
-) -> Slider<'a, f64, StepMessage, Renderer> {
+) -> Slider<'a, f64, StepMessage> {
     slider(0.0..=1.0, f64::from(component), move |c| {
         StepMessage::TextColorChanged(update(c as f32))
     })