fix: Raise events when adding or removing nodes due to filtering on Unix

Author: DataTriny

platforms/atspi-common/src/adapter.rs

@@ -116,6 +116,77 @@ impl<'a> AdapterChangeHandler<'a> {
         self.remove_node(node);
     }
 
+    fn apply_filters(
+        &mut self,
+        old_node: &Node,
+        old_filter_result: FilterResult,
+        new_node: &Node,
+        new_filter_result: FilterResult,
+    ) {
+        let parent = new_node.filtered_parent(&filter);
+        if new_node.role() == Role::MenuListPopup {
+            println!("applying filter");
+        }
+        if new_filter_result == FilterResult::Include {
+            if new_node.role() == Role::MenuListPopup {
+                println!("adding node");
+            }
+            if old_filter_result == FilterResult::ExcludeSubtree {
+                self.add_subtree(new_node);
+                if new_node.role() == Role::MenuListPopup {
+                    println!("added node and descendents");
+                }
+            } else {
+                self.add_node(new_node);
+                if new_node.role() == Role::MenuListPopup {
+                    println!("added node");
+                }
+                if let Some(parent) = parent {
+                    if new_node.role() == Role::MenuListPopup {
+                        println!("has parent");
+                    }
+                    for child in old_node.filtered_children(&filter) {
+                        if new_node.role() == Role::MenuListPopup {
+                            println!("{:?}", child.id());
+                        }
+                        self.adapter
+                            .emit_object_event(parent.id(), ObjectEvent::ChildRemoved(child.id()));
+                    }
+                }
+            }
+
+            if let Some(parent) = parent {
+                let position = parent
+                    .filtered_children(&filter)
+                    .position(|c| c.id() == new_node.id())
+                    .unwrap();
+                self.adapter.emit_object_event(
+                    parent.id(),
+                    ObjectEvent::ChildAdded(position, new_node.id()),
+                );
+            }
+        } else if old_filter_result == FilterResult::Include {
+            if new_filter_result == FilterResult::ExcludeSubtree {
+                self.remove_subtree(old_node);
+            } else {
+                self.remove_node(old_node);
+                if let Some(parent) = parent {
+                    for (position, child) in new_node.filtered_children(&filter).enumerate() {
+                        self.adapter.emit_object_event(
+                            parent.id(),
+                            ObjectEvent::ChildAdded(position, child.id()),
+                        );
+                    }
+                }
+            }
+
+            if let Some(parent) = parent {
+                self.adapter
+                    .emit_object_event(parent.id(), ObjectEvent::ChildRemoved(old_node.id()));
+            }
+        }
+    }
+
     fn emit_text_change_if_needed_parent(&mut self, old_node: &Node, new_node: &Node) {
         if !new_node.supports_text_ranges() || !old_node.supports_text_ranges() {
             return;
@@ -286,20 +357,11 @@ impl TreeChangeHandler for AdapterChangeHandler<'_> {
         self.emit_text_change_if_needed(old_node, new_node);
         let filter_old = filter(old_node);
         let filter_new = filter(new_node);
+        if new_node.role() == Role::MenuListPopup {
+            println!("{:?} {:?}", filter_old, filter_new);
+        }
         if filter_new != filter_old {
-            if filter_new == FilterResult::Include {
-                if filter_old == FilterResult::ExcludeSubtree {
-                    self.add_subtree(new_node);
-                } else {
-                    self.add_node(new_node);
-                }
-            } else if filter_old == FilterResult::Include {
-                if filter_new == FilterResult::ExcludeSubtree {
-                    self.remove_subtree(old_node);
-                } else {
-                    self.remove_node(old_node);
-                }
-            }
+            self.apply_filters(old_node, filter_old, new_node, filter_new);
         } else if filter_new == FilterResult::Include {
             let old_wrapper = NodeWrapper(old_node);
             let new_wrapper = NodeWrapper(new_node);

platforms/atspi-common/src/node.rs

@@ -47,10 +47,6 @@ impl NodeWrapper<'_> {
         self.0.description()
     }
 
-    pub(crate) fn parent_id(&self) -> Option<NodeId> {
-        self.0.parent_id()
-    }
-
     pub(crate) fn id(&self) -> NodeId {
         self.0.id()
     }
@@ -540,17 +536,7 @@ impl NodeWrapper<'_> {
                 )),
             );
         }
-        let parent_id = self.parent_id();
-        if parent_id != old.parent_id() {
-            let parent = self
-                .0
-                .filtered_parent(&filter)
-                .map_or(NodeIdOrRoot::Root, |node| NodeIdOrRoot::Node(node.id()));
-            adapter.emit_object_event(
-                self.id(),
-                ObjectEvent::PropertyChanged(Property::Parent(parent)),
-            );
-        }
+        self.notify_parent_change(adapter, old);
         let role = self.role();
         if role != old.role() {
             adapter.emit_object_event(
@@ -568,6 +554,17 @@ impl NodeWrapper<'_> {
         }
     }
 
+    pub(crate) fn notify_parent_change(&self, adapter: &Adapter, old: &NodeWrapper) {
+        let parent = self.0.filtered_parent(&filter);
+        if parent.map(|p| p.id()) != old.0.filtered_parent(&filter).map(|p| p.id()) {
+            let parent = parent.map_or(NodeIdOrRoot::Root, |node| NodeIdOrRoot::Node(node.id()));
+            adapter.emit_object_event(
+                self.id(),
+                ObjectEvent::PropertyChanged(Property::Parent(parent)),
+            );
+        }
+    }
+
     fn notify_bounds_changes(
         &self,
         window_bounds: &WindowBounds,
@@ -581,7 +578,7 @@ impl NodeWrapper<'_> {
         }
     }
 
-    fn notify_children_changes(&self, adapter: &Adapter, old: &NodeWrapper<'_>) {
+    pub(crate) fn notify_children_changes(&self, adapter: &Adapter, old: &NodeWrapper<'_>) {
         let old_filtered_children = old.filtered_child_ids().collect::<Vec<NodeId>>();
         let new_filtered_children = self.filtered_child_ids().collect::<Vec<NodeId>>();
         for (index, child) in new_filtered_children.iter().enumerate() {