refactor: only hide those with overlaps

Author: blindFS

src/app_engine/drawing.rs

@@ -46,12 +46,6 @@ impl AppEngine {
         })
     }
 
-    pub(super) fn finalize_hints(&self) {
-        for hb in self.hint_boxes.iter() {
-            hb.refresh(0, &self.overlay_frame, &self.config.theme);
-        }
-    }
-
     /// Show/Hide hint_boxes/colored_frames, update hint text and positions.
     /// Returns indices of visible hint boxes
     pub(super) fn update_hints(&mut self) -> Vec<usize> {
@@ -73,7 +67,8 @@ impl AppEngine {
                 let matches_search_prefix = search_pattern
                     .as_ref()
                     .is_none_or(|p| self.search_targets.get(idx).is_some_and(|h| p.is_match(h)));
-                let visible = hb.label.starts_with(&self.hint_prefix)
+                let visible = !hb.disabled
+                    && hb.label.starts_with(&self.hint_prefix)
                     && matches_search_prefix
                     && !is_selected_side;
 

src/app_engine/lifecycle.rs

@@ -5,13 +5,13 @@ use crate::{
     config::{GlyphlowConfig, RoleOfInterest, VisibilityCheckingLevel},
     os_util::{AppWindowInfo, get_focused_window},
     user_interface::{HintBox, hint_label_from_index, resolve_collisions},
-    util::digits_by_length,
+    util::{Frame, digits_by_length},
 };
 use accessibility::AXUIElementAttributes;
 use log::Level;
 use objc2::rc::autoreleasepool;
 use objc2_quartz_core::CATransaction;
-use std::{path::PathBuf, sync::mpsc::Receiver, time::Duration};
+use std::{ops::Range, path::PathBuf, sync::mpsc::Receiver, time::Duration};
 use tokio::sync::mpsc::Sender;
 
 const SHORT_TIMEOUT: u64 = 1;
@@ -157,30 +157,51 @@ impl AppEngine {
         let result_rx = self.ui_element_traverse_on_activation(target);
 
         let mut color_idx = 0;
+        let mut popup_ranges: Vec<Range<usize>> = vec![];
+        let mut popup_frames: Vec<Frame> = vec![];
+        let mut popup_start_idx = 0;
         let mut popup_level = 0;
-        let mut no_popup = true;
 
         autoreleasepool(|_| {
             for (idx, signal) in result_rx.iter().enumerate() {
                 match signal {
-                    ElementSignal::ElementFound(Some(ele)) if no_popup || popup_level > 0 => {
+                    ElementSignal::ElementFound(Some(ele)) => {
                         let need_flush = (idx + 1) % Self::HINTBOX_FLUSH_BATCH_SIZE == 0;
                         self.handle_element_found(ele, &mut color_idx, need_flush);
                     }
                     ElementSignal::TraversalFinished(target) => {
+                        // Disable hints that are covered by popups
+                        if !popup_frames.is_empty()
+                            && matches!(target, Target::Clickable | Target::Text)
+                        {
+                            for (idx, hb) in self.hint_boxes.iter_mut().enumerate() {
+                                if popup_ranges.iter().any(|r| r.contains(&idx)) {
+                                    continue;
+                                }
+                                let frame = self.element_cache.cache[idx].frame;
+                                if popup_frames
+                                    .iter()
+                                    .any(|p_f| p_f.intersect(&frame).is_some())
+                                {
+                                    hb.disabled = true;
+                                    hb.set_visible(false);
+                                }
+                            }
+                        }
                         self.handle_traversal_finished(target);
                     }
-                    ElementSignal::StartPopup => {
-                        if no_popup {
-                            self.hint_boxes.iter().for_each(|hb| hb.free());
-                            self.hint_boxes.clear();
-                            self.element_cache.clear();
-                            no_popup = false;
+                    ElementSignal::StartPopup(frame) => {
+                        if popup_level == 0 {
+                            popup_frames.push(frame);
+                            popup_start_idx = self.hint_boxes.len();
                         }
                         popup_level += 1;
                     }
                     ElementSignal::EndPopup => {
                         popup_level -= 1;
+                        if popup_level == 0 {
+                            popup_ranges.push(popup_start_idx..self.hint_boxes.len());
+                        }
                     }
                     _ => (),
                 }
@@ -254,7 +275,7 @@ impl AppEngine {
         if !self.hint_boxes.is_empty() {
             resolve_collisions(&mut self.hint_boxes, self.hint_width, &self.config.theme);
             // Update layers to match final positions and labels without clearing (avoid flicker)
-            self.finalize_hints();
+            self.update_hints();
 
             if need_help_msg {
                 self.notify("Press Enter to act.", Level::Trace);

src/ax_element.rs

@@ -6,12 +6,11 @@ use accessibility::{AXAttribute, AXUIElement, AXUIElementAttributes};
 use accessibility_sys::{
     AXUIElementCopyMultipleAttributeValues, AXValueCreate, AXValueGetValue, AXValueRef,
     kAXButtonRole, kAXCellRole, kAXCheckBoxRole, kAXComboBoxRole, kAXContentListSubrole,
-    kAXErrorSuccess, kAXGroupRole, kAXHiddenAttribute, kAXImageRole, kAXListRole,
-    kAXMenuButtonRole, kAXMenuItemRole, kAXMenuRole, kAXPopUpButtonRole, kAXPositionAttribute,
-    kAXPressAction, kAXRoleAttribute, kAXRowRole, kAXScrollAreaRole, kAXScrollBarRole,
-    kAXSelectedTextRangeAttribute, kAXSizeAttribute, kAXStaticTextRole, kAXTextAreaRole,
-    kAXTextFieldRole, kAXTitleAttribute, kAXValueTypeCFRange, kAXValueTypeCGPoint,
-    kAXValueTypeCGSize, kAXWindowRole,
+    kAXErrorSuccess, kAXGroupRole, kAXHiddenAttribute, kAXImageRole, kAXListRole, kAXMenuItemRole,
+    kAXMenuRole, kAXPopUpButtonRole, kAXPositionAttribute, kAXPressAction, kAXRoleAttribute,
+    kAXRowRole, kAXScrollAreaRole, kAXScrollBarRole, kAXSelectedTextRangeAttribute,
+    kAXSizeAttribute, kAXStaticTextRole, kAXTextAreaRole, kAXTextFieldRole, kAXTitleAttribute,
+    kAXValueTypeCFRange, kAXValueTypeCGPoint, kAXValueTypeCGSize, kAXWindowRole,
 };
 use core_foundation::{
     array::{CFArray, CFArrayRef},
@@ -35,7 +34,7 @@ pub enum ElementSignal {
     // Traversal
     ElementFound(Option<ElementOfInterest>),
     TraversalFinished(Target),
-    StartPopup,
+    StartPopup(Frame),
     EndPopup,
 }
 
@@ -1028,8 +1027,10 @@ fn traverse_elements(
             }
         }
         kAXGroupRole if element.subrole().is_ok_and(|r| r == "AXApplicationDialog") => {
-            let _ = result_tx.send(ElementSignal::StartPopup);
-            is_popup = true;
+            if let Some(frame) = ele_fp.frame {
+                let _ = result_tx.send(ElementSignal::StartPopup(frame));
+                is_popup = true;
+            }
         }
         kAXGroupRole => match target {
             Target::Clickable if element.is_clickable() => {
@@ -1051,13 +1052,11 @@ fn traverse_elements(
             }
             _ => (),
         },
-        kAXMenuRole
-            if element.parent().and_then(|p| p.role()).is_ok_and(|r| {
-                r == kAXMenuButtonRole || r == kAXButtonRole || r == kAXCellRole
-            }) =>
-        {
-            let _ = result_tx.send(ElementSignal::StartPopup);
-            is_popup = true;
+        kAXMenuRole => {
+            if let Some(frame) = ele_fp.frame {
+                let _ = result_tx.send(ElementSignal::StartPopup(frame));
+                is_popup = true;
+            }
         }
         kAXMenuItemRole => match target {
             Target::Text => {

src/user_interface/hint_box.rs

@@ -39,6 +39,7 @@ pub struct HintBox {
     x: f64,
     y: f64,
     pub idx: usize,
+    pub disabled: bool,
     /// Moved distance to avoid collision
     delta: (f64, f64),
     frame: Option<Frame>,
@@ -82,6 +83,7 @@ impl HintBox {
             x,
             y,
             idx,
+            disabled: false,
             delta: (0.0, 0.0),
             frame,
             color,
@@ -369,10 +371,13 @@ fn resolve_collisions_reactive(boxes: &mut [HintBox], x_thres: f64, y_thres: f64
     let mut in_queue = vec![true; boxes.len()];
 
     // Initial setup
-    for i in 0..boxes.len() {
+    for (i, hb) in boxes.iter().enumerate() {
+        if hb.disabled {
+            continue;
+        }
         let coords = (
-            (boxes[i].x / x_thres).floor() as i32,
-            (boxes[i].y / y_thres).floor() as i32,
+            (hb.x / x_thres).floor() as i32,
+            (hb.y / y_thres).floor() as i32,
         );
         cell_coords[i] = coords;
         grid.entry(coords).or_default().push(i);