drop snapshots

Author: raphamorim

frontends/rioterm/src/application.rs

@@ -201,6 +201,17 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                             route.window.needs_render_after_occlusion = false;
                         }
 
+                        // Mark the renderable content as needing to render
+                        if let Some(ctx_item) =
+                            route.window.screen.ctx_mut().get_mut(route_id)
+                        {
+                            ctx_item
+                                .val
+                                .renderable_content
+                                .pending_update
+                                .set_dirty();
+                        }
+
                         // Check if we need to throttle based on timing
                         if let Some(wait_duration) = route.window.wait_until() {
                             // We need to wait before rendering again
@@ -226,45 +237,7 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                     }
                 }
             }
-            RioEventType::Rio(RioEvent::TerminalDamaged { route_id, damage }) => {
-                if self.config.renderer.strategy.is_event_based() {
-                    if let Some(route) = self.router.routes.get_mut(&window_id) {
-                        // Skip rendering for unfocused windows if configured
-                        if self.config.renderer.disable_unfocused_render
-                            && !route.window.is_focused
-                        {
-                            return;
-                        }
-
-                        // Skip rendering for occluded windows if configured
-                        if self.config.renderer.disable_occluded_render
-                            && route.window.is_occluded
-                            && !route.window.needs_render_after_occlusion
-                        {
-                            return;
-                        }
-
-                        // We received a damage event, so we should render
-                        // Don't second-guess the damage event by checking needs_render()
-
-                        // Clear the one-time render flag if it was set
-                        if route.window.needs_render_after_occlusion {
-                            route.window.needs_render_after_occlusion = false;
-                        }
 
-                        if let Some(ctx_item) =
-                            route.window.screen.ctx_mut().get_mut(route_id)
-                        {
-                            ctx_item
-                                .val
-                                .renderable_content
-                                .pending_update
-                                .invalidate(damage, &ctx_item.val.terminal);
-                            route.schedule_redraw(&mut self.scheduler, route_id);
-                        }
-                    }
-                }
-            }
             RioEventType::Rio(RioEvent::Wakeup(route_id)) => {
                 if self.config.renderer.strategy.is_event_based() {
                     if let Some(route) = self.router.routes.get_mut(&window_id) {
@@ -299,7 +272,7 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                                 .val
                                 .renderable_content
                                 .pending_update
-                                .mark_for_damage_check();
+                                .set_dirty();
                             route.schedule_redraw(&mut self.scheduler, route_id);
                         }
                     }
@@ -1302,16 +1275,12 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                     .pending_update
                     .is_dirty()
                 {
-                    route.request_redraw();
+                    route.schedule_redraw(
+                        &mut self.scheduler,
+                        route.window.screen.ctx().current_route(),
+                    );
                 }
 
-                // route.request_redraw();
-
-                // route.schedule_redraw(
-                //     &mut self.scheduler,
-                //     route.window.screen.ctx().current_route(),
-                // );
-
                 event_loop.set_control_flow(ControlFlow::Wait);
             }
             _ => {}

frontends/rioterm/src/context/mod.rs

@@ -69,26 +69,29 @@ impl<T: EventListener> Context<T> {
         let has_updated = self.renderable_content.selection_range != selection_range;
 
         if has_updated {
-            let mut terminal = self.terminal.lock();
-            let display_offset = terminal.display_offset();
-            terminal.update_selection_damage(selection_range, display_offset);
-            drop(terminal);
-
-            // Mark pending update as dirty so the selection change is rendered
+            // Selection is a UI-level change, so we use UI damage tracking
+            // Use full damage for selections since they can span multiple lines
+            // and change frequently (during dragging)
             self.renderable_content
                 .pending_update
-                .invalidate_full(&self.terminal);
+                .set_ui_damage(rio_backend::event::TerminalDamage::Full);
         }
 
         self.renderable_content.selection_range = selection_range;
     }
 
     #[inline]
     pub fn set_hyperlink_range(&mut self, hyperlink_range: Option<SelectionRange>) {
+        let old_hyperlink = self.renderable_content.hyperlink_range.clone();
+        
+        if old_hyperlink != hyperlink_range {
+            // For hyperlinks, use full damage as they're less frequent
+            self.renderable_content
+                .pending_update
+                .set_ui_damage(rio_backend::event::TerminalDamage::Full);
+        }
+        
         self.renderable_content.hyperlink_range = hyperlink_range;
-        self.renderable_content
-            .pending_update
-            .invalidate_full(&self.terminal);
     }
 
     #[inline]
@@ -283,8 +286,13 @@ impl<T: EventListener + Clone + std::marker::Send + 'static> ContextManager<T> {
             }
         }
 
-        let machine =
-            Machine::new(Arc::clone(&terminal), pty, event_proxy.clone(), window_id, route_id)?;
+        let machine = Machine::new(
+            Arc::clone(&terminal),
+            pty,
+            event_proxy.clone(),
+            window_id,
+            route_id,
+        )?;
         let channel = machine.channel();
         let io_thread = if config.spawn_performer {
             Some(machine.spawn())