in progress

src/animate.rs

@@ -10,8 +10,8 @@ use crate::{
     ViewId,
 };
 
-use std::any::Any;
 use std::rc::Rc;
+use std::{any::Any, sync::Arc};
 
 use floem_reactive::{create_updater, RwSignal, SignalGet, Trigger};
 use smallvec::{smallvec, SmallVec};
@@ -24,7 +24,7 @@ use web_time::{Duration, Instant};
 #[derive(Clone, Debug)]
 pub struct KeyFrameProp {
     // the style prop value. This will either come from an animation frameor it will be pulled from the computed style
-    val: Rc<dyn Any>,
+    val: Arc<dyn Any>,
     // the frame id
     id: u16,
     /// This easing will be used while animating towards this keyframe. while this prop is the lower one this easing function will not be used.

src/app.rs

@@ -7,7 +7,7 @@ use raw_window_handle::HasDisplayHandle;
 use winit::{
     application::ApplicationHandler,
     event::WindowEvent,
-    event_loop::{ActiveEventLoop, ControlFlow, EventLoop, EventLoopBuilder, EventLoopProxy},
+    event_loop::{ActiveEventLoop, ControlFlow, EventLoop, EventLoopProxy},
     monitor::MonitorHandle,
     window::WindowId,
 };
@@ -157,12 +157,14 @@ impl Application {
     pub fn new() -> Self {
         let event_loop = EventLoop::new().expect("can't start the event loop");
         let event_loop_proxy = event_loop.create_proxy();
-        *EVENT_LOOP_PROXY.lock() = Some(event_loop_proxy.clone());
+        let (sender, receiver) = crossbeam_channel::unbounded();
+        *EVENT_LOOP_PROXY.lock() = Some((event_loop_proxy.clone(), sender));
         unsafe {
             Clipboard::init(event_loop.display_handle().unwrap().as_raw());
         }
         let handle = ApplicationHandle::new();
         Self {
+            receiver,
             handle: Some(handle),
             event_listener: None,
             event_loop: Some(event_loop),
@@ -187,8 +189,7 @@ impl Application {
         config: Option<WindowConfig>,
     ) -> Self {
         self.handle.as_mut().unwrap().new_window(
-            &self.event_loop,
-            self.event_loop.create_proxy(),
+            self.event_loop.as_ref().unwrap(),
             Box::new(|window_id| app_view(window_id).into_any()),
             config.unwrap_or_default(),
         );
@@ -237,12 +238,19 @@ impl Application {
         }
     }
 
+    pub(crate) fn send_proxy_event(event: UserEvent) {
+        if let Some((proxy, sender)) = EVENT_LOOP_PROXY.lock().as_ref() {
+            let _ = sender.send(event);
+            proxy.wake_up();
+        }
+    }
+
     pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
-        self.event_loop.available_monitors()
+        self.event_loop.as_ref().unwrap().available_monitors()
     }
 
     pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        self.event_loop.primary_monitor()
+        self.event_loop.as_ref().unwrap().primary_monitor()
     }
 }
 
@@ -251,7 +259,5 @@ impl Application {
 /// This function sends a `QuitApp` event to the application's event loop,
 /// triggering the application to close gracefully.
 pub fn quit_app() {
-    Application::with_event_loop_proxy(|proxy| {
-        let _ = proxy.send_event(UserEvent::QuitApp);
-    });
+    Application::send_proxy_event(UserEvent::QuitApp);
 }

src/app_handle.rs

@@ -43,7 +43,7 @@ impl ApplicationHandle {
 
     pub(crate) fn handle_user_event(
         &mut self,
-        event_loop: &EventLoopWindowTarget<UserEvent>,
+        event_loop: &ActiveEventLoop,
         event_proxy: EventLoopProxy<UserEvent>,
         event: UserEvent,
     ) {
@@ -274,7 +274,6 @@ impl ApplicationHandle {
     pub(crate) fn new_window(
         &mut self,
         event_loop: &dyn ActiveEventLoop,
-        event_proxy: EventLoopProxy,
         view_fn: Box<dyn FnOnce(WindowId) -> Box<dyn View>>,
         #[allow(unused_variables)] WindowConfig {
             size,
@@ -336,7 +335,7 @@ impl ApplicationHandle {
         }
 
         if let Some(logical_size) = logical_size {
-            window_attributes = window_attributes.with_inner_size(logical_size);
+            window_attributes = window_attributes.with_surface_size(logical_size);
         }
 
         #[cfg(not(target_os = "macos"))]
@@ -420,7 +419,6 @@ impl ApplicationHandle {
         let window_id = window.id();
         let window_handle = WindowHandle::new(
             window,
-            event_proxy,
             view_fn,
             transparent,
             apply_default_theme,

src/context.rs

@@ -7,6 +7,7 @@ use std::{
     rc::Rc,
     sync::Arc,
 };
+use winit::window::Window;
 
 #[cfg(not(target_arch = "wasm32"))]
 use std::time::{Duration, Instant};
@@ -1169,7 +1170,7 @@ impl<'a> PaintCx<'a> {
 pub enum PaintState {
     /// The renderer is not yet initialized. This state is used to wait for the GPU resources to be acquired.
     PendingGpuResources {
-        window: Arc<dyn wgpu::WindowHandle>,
+        window: Arc<dyn Window>,
         rx: crossbeam::channel::Receiver<Result<GpuResources, GpuResourceError>>,
         font_embolden: f32,
         /// This field holds an instance of `Renderer::Uninitialized` until the GPU resources are acquired,
@@ -1178,17 +1179,15 @@ pub enum PaintState {
         ///
         /// Previously, `PaintState::renderer` and `PaintState::renderer_mut` would panic if called when the renderer was uninitialized.
         /// However, this turned out to be hard to handle properly and led to panics, especially since the rest of the application code can't control when the renderer is initialized.
-        renderer: crate::renderer::Renderer<Arc<dyn wgpu::WindowHandle>>,
+        renderer: crate::renderer::Renderer,
     },
     /// The renderer is initialized and ready to paint.
-    Initialized {
-        renderer: crate::renderer::Renderer<Arc<dyn wgpu::WindowHandle>>,
-    },
+    Initialized { renderer: crate::renderer::Renderer },
 }
 
 impl PaintState {
     pub fn new(
-        window: Arc<dyn wgpu::WindowHandle>,
+        window: Arc<dyn Window>,
         rx: crossbeam::channel::Receiver<Result<GpuResources, GpuResourceError>>,
         scale: f64,
         size: Size,
@@ -1224,16 +1223,14 @@ impl PaintState {
         }
     }
 
-    pub(crate) fn renderer(&self) -> &crate::renderer::Renderer<Arc<dyn wgpu::WindowHandle>> {
+    pub(crate) fn renderer(&self) -> &crate::renderer::Renderer {
         match self {
             PaintState::PendingGpuResources { renderer, .. } => renderer,
             PaintState::Initialized { renderer } => renderer,
         }
     }
 
-    pub(crate) fn renderer_mut(
-        &mut self,
-    ) -> &mut crate::renderer::Renderer<Arc<dyn wgpu::WindowHandle>> {
+    pub(crate) fn renderer_mut(&mut self) -> &mut crate::renderer::Renderer {
         match self {
             PaintState::PendingGpuResources { renderer, .. } => renderer,
             PaintState::Initialized { renderer } => renderer,
@@ -1264,7 +1261,7 @@ impl<'a> UpdateCx<'a> {
 }
 
 impl Deref for PaintCx<'_> {
-    type Target = crate::renderer::Renderer<Arc<dyn wgpu::WindowHandle>>;
+    type Target = crate::renderer::Renderer;
 
     fn deref(&self) -> &Self::Target {
         self.paint_state.renderer()

src/inspector.rs

@@ -92,7 +92,7 @@ impl CapturedView {
             children: id
                 .children()
                 .into_iter()
-                .map(|view| Rc::new(CapturedView::capture(view, app_state, clipped)))
+                .map(|view| Arc::new(CapturedView::capture(view, app_state, clipped)))
                 .collect(),
         }
     }
@@ -1173,7 +1173,7 @@ pub fn capture(window_id: WindowId) {
     })
 }
 
-fn find_view(name: &str, views: &Rc<CapturedView>) -> Vec<ViewId> {
+fn find_view(name: &str, views: &Arc<CapturedView>) -> Vec<ViewId> {
     let mut ids = Vec::new();
     if name.is_empty() {
         return ids;
@@ -1205,7 +1205,7 @@ fn find_view(name: &str, views: &Rc<CapturedView>) -> Vec<ViewId> {
 
 fn find_relative_view_by_id_without_self(
     id: ViewId,
-    views: &Rc<CapturedView>,
+    views: &Arc<CapturedView>,
 ) -> Option<RelativeViewId> {
     let mut parent_id = None;
     let mut big_brother_id = None;
@@ -1246,7 +1246,7 @@ fn find_relative_view_by_id_without_self(
 
 fn find_relative_view_by_id_with_self(
     id: ViewId,
-    views: &Rc<CapturedView>,
+    views: &Arc<CapturedView>,
 ) -> Option<RelativeViewId> {
     if views.id == id {
         let first_child_id = views.children.first().map(|x| x.id);

src/renderer.rs

@@ -47,6 +47,8 @@
 //! - Only one view can be active at a time.
 //! - Only one view can be focused at a time.
 //!
+use std::sync::Arc;
+
 use crate::text::TextLayout;
 use floem_renderer::gpu_resources::GpuResources;
 use floem_renderer::Img;
@@ -57,14 +59,15 @@ use floem_vello_renderer::VelloRenderer;
 use floem_vger_renderer::VgerRenderer;
 use peniko::kurbo::{self, Affine, Rect, Shape, Size, Stroke};
 use peniko::BrushRef;
+use winit::window::Window;
 
 #[allow(clippy::large_enum_variant)]
-pub enum Renderer<W> {
+pub enum Renderer {
     #[cfg(feature = "vello")]
     Vello(VelloRenderer),
     #[cfg(not(feature = "vello"))]
     Vger(VgerRenderer),
-    TinySkia(TinySkiaRenderer<W>),
+    TinySkia(TinySkiaRenderer<Arc<dyn Window>>),
     /// Uninitialized renderer, used to allow the renderer to be created lazily
     /// All operations on this renderer are no-ops
     Uninitialized {
@@ -73,17 +76,14 @@ pub enum Renderer<W> {
     },
 }
 
-impl<W: wgpu::WindowHandle> Renderer<W> {
+impl Renderer {
     pub fn new(
-        window: W,
+        window: Arc<dyn Window>,
         gpu_resources: GpuResources,
         scale: f64,
         size: Size,
         font_embolden: f32,
-    ) -> Self
-    where
-        W: Clone + 'static,
-    {
+    ) -> Self {
         let size = Size::new(size.width.max(1.0), size.height.max(1.0));
 
         let force_tiny_skia = std::env::var("FLOEM_FORCE_TINY_SKIA")
@@ -191,7 +191,7 @@ impl<W: wgpu::WindowHandle> Renderer<W> {
     }
 }
 
-impl<W: wgpu::WindowHandle> floem_renderer::Renderer for Renderer<W> {
+impl floem_renderer::Renderer for Renderer {
     fn begin(&mut self, capture: bool) {
         match self {
             #[cfg(feature = "vello")]

src/screen_layout.rs

@@ -1,5 +1,7 @@
 //! Tools for computing screen locations from locations within a View and
 //! vice-versa.
+use std::sync::Arc;
+
 use crate::ViewId;
 use peniko::kurbo::{Point, Rect, Size};
 use winit::window::{Window, WindowId};
@@ -26,7 +28,7 @@ pub fn try_create_screen_layout(view: &ViewId) -> Option<ScreenLayout> {
                             .outer_position()
                             .map(|outer_position| {
                                 let monitor_bounds = monitor_bounds_for_monitor(window, &monitor);
-                                let inner_size = window.inner_size();
+                                let inner_size = window.surface_size();
                                 let outer_size = window.outer_size();
 
                                 let window_bounds = rect_from_physical_bounds_for_window(
@@ -63,7 +65,10 @@ pub fn try_create_screen_layout(view: &ViewId) -> Option<ScreenLayout> {
     .unwrap_or(None)
 }
 
-pub fn screen_layout_for_window(window_id: WindowId, window: &Window) -> Option<ScreenLayout> {
+pub fn screen_layout_for_window(
+    window_id: WindowId,
+    window: &Arc<dyn Window>,
+) -> Option<ScreenLayout> {
     window
         .current_monitor()
         .map(|monitor| {
@@ -74,7 +79,7 @@ pub fn screen_layout_for_window(window_id: WindowId, window: &Window) -> Option<
                         .outer_position()
                         .map(|outer_position| {
                             let monitor_bounds = monitor_bounds_for_monitor(window, &monitor);
-                            let inner_size = window.inner_size();
+                            let inner_size = window.surface_size();
                             let outer_size = window.outer_size();
 
                             let window_bounds = rect_from_physical_bounds_for_window(