cargo fmt

Author: fschutt

core/src/callbacks.rs

@@ -146,7 +146,10 @@ impl_callback!(IFrameCallback, IFrameCallbackType);
 
 impl IFrameCallback {
     pub fn create(cb: IFrameCallbackType) -> Self {
-        Self { cb, ctx: OptionRefAny::None }
+        Self {
+            cb,
+            ctx: OptionRefAny::None,
+        }
     }
 }
 

core/src/debug.rs

@@ -181,7 +181,7 @@ impl DebugLogger {
         if level < self.min_level {
             return;
         }
-        
+
         // Check category filter
         if let Some(ref allowed) = self.category_filter {
             if !allowed.contains(&category) {

core/src/dom.rs

@@ -32,7 +32,6 @@ pub use crate::events::{
     NotEventFilter, WindowEventFilter,
 };
 pub use crate::id::{Node, NodeHierarchy, NodeId};
-pub use azul_css::dynamic_selector::{CssPropertyWithConditions, CssPropertyWithConditionsVec};
 use crate::{
     callbacks::{
         CoreCallback, CoreCallbackData, CoreCallbackDataVec, CoreCallbackType, IFrameCallback,
@@ -52,6 +51,7 @@ use crate::{
     },
     window::OptionVirtualKeyCodeCombo,
 };
+pub use azul_css::dynamic_selector::{CssPropertyWithConditions, CssPropertyWithConditionsVec};
 
 static TAG_ID: AtomicUsize = AtomicUsize::new(1);
 
@@ -955,7 +955,12 @@ pub enum IdOrClass {
     Class(AzString),
 }
 
-impl_vec!(IdOrClass, IdOrClassVec, IdOrClassVecDestructor, IdOrClassVecDestructorType);
+impl_vec!(
+    IdOrClass,
+    IdOrClassVec,
+    IdOrClassVecDestructor,
+    IdOrClassVecDestructorType
+);
 impl_vec_debug!(IdOrClass, IdOrClassVec);
 impl_vec_partialord!(IdOrClass, IdOrClassVec);
 impl_vec_ord!(IdOrClass, IdOrClassVec);
@@ -1089,7 +1094,12 @@ pub enum AttributeType {
     Custom(AttributeNameValue),
 }
 
-impl_vec!(AttributeType, AttributeVec, AttributeVecDestructor, AttributeVecDestructorType);
+impl_vec!(
+    AttributeType,
+    AttributeVec,
+    AttributeVecDestructor,
+    AttributeVecDestructorType
+);
 impl_vec_debug!(AttributeType, AttributeVec);
 impl_vec_partialord!(AttributeType, AttributeVec);
 impl_vec_ord!(AttributeType, AttributeVec);
@@ -2126,7 +2136,12 @@ impl Clone for NodeData {
 }
 
 // Clone, PartialEq, Eq, Hash, PartialOrd, Ord
-impl_vec!(NodeData, NodeDataVec, NodeDataVecDestructor, NodeDataVecDestructorType);
+impl_vec!(
+    NodeData,
+    NodeDataVec,
+    NodeDataVecDestructor,
+    NodeDataVecDestructorType
+);
 impl_vec_clone!(NodeData, NodeDataVec, NodeDataVecDestructor);
 impl_vec_mut!(NodeData, NodeDataVec);
 impl_vec_debug!(NodeData, NodeDataVec);
@@ -2476,7 +2491,12 @@ impl NodeData {
     }
 
     #[inline]
-    pub fn add_callback<C: Into<CoreCallback>>(&mut self, event: EventFilter, data: RefAny, callback: C) {
+    pub fn add_callback<C: Into<CoreCallback>>(
+        &mut self,
+        event: EventFilter,
+        data: RefAny,
+        callback: C,
+    ) {
         let callback = callback.into();
         let mut v: CoreCallbackDataVec = Vec::new().into();
         mem::swap(&mut v, &mut self.callbacks);
@@ -2505,7 +2525,7 @@ impl NodeData {
         v.push(IdOrClass::Class(s));
         self.ids_and_classes = v.into();
     }
-    
+
     /// Add an unconditional CSS property (always applies)
     #[inline]
     pub fn add_css_property(&mut self, p: CssProperty) {
@@ -2516,37 +2536,52 @@ impl NodeData {
         v.push(CssPropertyWithConditions::simple(p));
         self.css_props = v.into();
     }
-    
+
     /// Add a CSS property that applies only on hover
     #[inline]
     pub fn add_hover_css_property(&mut self, p: CssProperty) {
-        use azul_css::dynamic_selector::{CssPropertyWithConditions, DynamicSelector, PseudoStateType};
+        use azul_css::dynamic_selector::{
+            CssPropertyWithConditions, DynamicSelector, PseudoStateType,
+        };
         let mut v: CssPropertyWithConditionsVec = Vec::new().into();
         mem::swap(&mut v, &mut self.css_props);
         let mut v = v.into_library_owned_vec();
-        v.push(CssPropertyWithConditions::with_condition(p, DynamicSelector::PseudoState(PseudoStateType::Hover)));
+        v.push(CssPropertyWithConditions::with_condition(
+            p,
+            DynamicSelector::PseudoState(PseudoStateType::Hover),
+        ));
         self.css_props = v.into();
     }
-    
+
     /// Add a CSS property that applies only when active (clicked)
     #[inline]
     pub fn add_active_css_property(&mut self, p: CssProperty) {
-        use azul_css::dynamic_selector::{CssPropertyWithConditions, DynamicSelector, PseudoStateType};
+        use azul_css::dynamic_selector::{
+            CssPropertyWithConditions, DynamicSelector, PseudoStateType,
+        };
         let mut v: CssPropertyWithConditionsVec = Vec::new().into();
         mem::swap(&mut v, &mut self.css_props);
         let mut v = v.into_library_owned_vec();
-        v.push(CssPropertyWithConditions::with_condition(p, DynamicSelector::PseudoState(PseudoStateType::Active)));
+        v.push(CssPropertyWithConditions::with_condition(
+            p,
+            DynamicSelector::PseudoState(PseudoStateType::Active),
+        ));
         self.css_props = v.into();
     }
-    
+
     /// Add a CSS property that applies only when focused
     #[inline]
     pub fn add_focus_css_property(&mut self, p: CssProperty) {
-        use azul_css::dynamic_selector::{CssPropertyWithConditions, DynamicSelector, PseudoStateType};
+        use azul_css::dynamic_selector::{
+            CssPropertyWithConditions, DynamicSelector, PseudoStateType,
+        };
         let mut v: CssPropertyWithConditionsVec = Vec::new().into();
         mem::swap(&mut v, &mut self.css_props);
         let mut v = v.into_library_owned_vec();
-        v.push(CssPropertyWithConditions::with_condition(p, DynamicSelector::PseudoState(PseudoStateType::Focus)));
+        v.push(CssPropertyWithConditions::with_condition(
+            p,
+            DynamicSelector::PseudoState(PseudoStateType::Focus),
+        ));
         self.css_props = v.into();
     }
 
@@ -4241,7 +4276,8 @@ impl Dom {
     /// - `aria`: Accessibility information describing table purpose
     #[inline]
     pub fn table_with_aria<S: Into<AzString>>(caption: S, aria: SmallAriaInfo) -> Self {
-        let mut table = Self::create_table().with_child(Self::create_caption().with_child(Self::create_text(caption)));
+        let mut table = Self::create_table()
+            .with_child(Self::create_caption().with_child(Self::create_text(caption)));
         table.root.set_accessibility_info(aria.to_full_info());
         table
     }

core/src/events.rs

@@ -659,7 +659,13 @@ pub fn propagate_event(
     let mut result = PropagationResult::default();
 
     // Phase 1: Capture (root → target)
-    propagate_phase(event, ancestors.iter().copied(), EventPhase::Capture, callbacks, &mut result);
+    propagate_phase(
+        event,
+        ancestors.iter().copied(),
+        EventPhase::Capture,
+        callbacks,
+        &mut result,
+    );
 
     // Phase 2: Target
     if !event.stopped {
@@ -668,7 +674,13 @@ pub fn propagate_event(
 
     // Phase 3: Bubble (target → root)
     if !event.stopped {
-        propagate_phase(event, ancestors.iter().rev().copied(), EventPhase::Bubble, callbacks, &mut result);
+        propagate_phase(
+            event,
+            ancestors.iter().rev().copied(),
+            EventPhase::Bubble,
+            callbacks,
+            &mut result,
+        );
     }
 
     result.default_prevented = event.prevented_default;
@@ -1027,7 +1039,9 @@ pub fn detect_lifecycle_events(
     // Unmount events: nodes in old but not in new
     if let Some(layout) = old_layout {
         for &node_id in old_nodes.difference(&new_nodes) {
-            events.push(create_unmount_event(node_id, old_dom_id, layout, &timestamp));
+            events.push(create_unmount_event(
+                node_id, old_dom_id, layout, &timestamp,
+            ));
         }
     }
 
@@ -1811,7 +1825,7 @@ pub trait EventProvider {
     /// Get all pending events from this manager.
     ///
     /// Events should include:
-    /// 
+    ///
     /// - `target`: The DomNodeId that was affected
     /// - `event_type`: What happened (Input, Scroll, Focus, etc.)
     /// - `source`: EventSource::User for input, EventSource::Programmatic for API calls
@@ -1835,20 +1849,24 @@ pub fn deduplicate_synthetic_events(mut events: Vec<SyntheticEvent>) -> Vec<Synt
     // Coalesce consecutive events with same target and event_type
     let mut result = Vec::with_capacity(events.len());
     let mut iter = events.into_iter();
-    
+
     if let Some(mut prev) = iter.next() {
         for curr in iter {
             if prev.target == curr.target && prev.event_type == curr.event_type {
                 // Keep the one with later timestamp
-                prev = if curr.timestamp > prev.timestamp { curr } else { prev };
+                prev = if curr.timestamp > prev.timestamp {
+                    curr
+                } else {
+                    prev
+                };
             } else {
                 result.push(prev);
                 prev = curr;
             }
         }
         result.push(prev);
     }
-    
+
     result
 }
 
@@ -1872,22 +1890,22 @@ pub fn dispatch_synthetic_events(
 }
 
 /// Convert EventType to EventFilters (returns multiple filters for generic + specific events)
-/// 
+///
 /// For mouse button events, returns both generic (MouseUp) AND specific (LeftMouseUp).
 /// This allows callbacks registered for either filter to be triggered.
 fn event_type_to_filters(event_type: EventType) -> Vec<EventFilter> {
-    use EventType as E;
     use EventFilter as EF;
-    use HoverEventFilter as H;
+    use EventType as E;
     use FocusEventFilter as F;
+    use HoverEventFilter as H;
     use WindowEventFilter as W;
 
     match event_type {
         // Mouse button events - return BOTH generic and specific
         // Generic first, then specific (bubbling order)
         E::MouseDown => vec![EF::Hover(H::MouseDown), EF::Hover(H::LeftMouseDown)],
         E::MouseUp => vec![EF::Hover(H::MouseUp), EF::Hover(H::LeftMouseUp)],
-        
+
         // Other mouse events
         E::MouseOver => vec![EF::Hover(H::MouseOver)],
         E::MouseEnter => vec![EF::Hover(H::MouseEnter)],
@@ -1952,12 +1970,14 @@ fn get_callback_target(event: &SyntheticEvent) -> Option<CallbackTarget> {
         return Some(CallbackTarget::RootNodes);
     }
 
-    event.target.node.into_crate_internal().map(|node_id| {
-        CallbackTarget::Node {
+    event
+        .target
+        .node
+        .into_crate_internal()
+        .map(|node_id| CallbackTarget::Node {
             dom_id: event.target.dom,
             node_id,
-        }
-    })
+        })
 }
 
 /// Get hit test item for a node target
@@ -2123,9 +2143,9 @@ where
         selection_manager,
     };
 
-    let (internal_events, user_events) = events
-        .iter()
-        .fold((Vec::new(), Vec::new()), |(mut internal, mut user), event| {
+    let (internal_events, user_events) = events.iter().fold(
+        (Vec::new(), Vec::new()),
+        |(mut internal, mut user), event| {
             match process_event_for_internal(&ctx, event) {
                 Some(InternalEventAction::AddAndSkip(evt)) => {
                     internal.push(evt);
@@ -2139,9 +2159,13 @@ where
                 }
             }
             (internal, user)
-        });
+        },
+    );
 
-    PreCallbackFilterResult { internal_events, user_events }
+    PreCallbackFilterResult {
+        internal_events,
+        user_events,
+    }
 }
 
 /// Context for filtering internal events
@@ -2162,9 +2186,12 @@ fn process_event_for_internal<SM: SelectionManagerQuery>(
 ) -> Option<InternalEventAction> {
     match event.event_type {
         EventType::MouseDown => handle_mouse_down(event, ctx.hit_test, ctx.click_count),
-        EventType::MouseOver => {
-            handle_mouse_over(event, ctx.hit_test, ctx.mouse_state, ctx.drag_start_position)
-        }
+        EventType::MouseOver => handle_mouse_over(
+            event,
+            ctx.hit_test,
+            ctx.mouse_state,
+            ctx.drag_start_position,
+        ),
         EventType::KeyDown => handle_key_down(
             event,
             ctx.keyboard_state,
@@ -2354,8 +2381,7 @@ pub fn post_callback_filter_internal_events(
     new_focus: Option<DomNodeId>,
 ) -> PostCallbackFilterResult {
     if prevent_default {
-        let focus_event = (old_focus != new_focus)
-            .then_some(PostCallbackSystemEvent::FocusChanged);
+        let focus_event = (old_focus != new_focus).then_some(PostCallbackSystemEvent::FocusChanged);
         return PostCallbackFilterResult {
             system_events: focus_event.into_iter().collect(),
         };
@@ -2365,8 +2391,7 @@ pub fn post_callback_filter_internal_events(
         .iter()
         .filter_map(internal_event_to_system_event);
 
-    let focus_event = (old_focus != new_focus)
-        .then_some(PostCallbackSystemEvent::FocusChanged);
+    let focus_event = (old_focus != new_focus).then_some(PostCallbackSystemEvent::FocusChanged);
 
     let system_events = core::iter::once(PostCallbackSystemEvent::ApplyTextInput)
         .chain(event_actions)
@@ -2377,17 +2402,21 @@ pub fn post_callback_filter_internal_events(
 }
 
 /// Convert internal event to post-callback system event
-fn internal_event_to_system_event(event: &PreCallbackSystemEvent) -> Option<PostCallbackSystemEvent> {
-    use PreCallbackSystemEvent::*;
+fn internal_event_to_system_event(
+    event: &PreCallbackSystemEvent,
+) -> Option<PostCallbackSystemEvent> {
     use PostCallbackSystemEvent::*;
+    use PreCallbackSystemEvent::*;
 
     match event {
         TextClick { .. } | ArrowKeyNavigation { .. } | DeleteSelection { .. } => {
             Some(ScrollIntoView)
         }
-        TextDragSelection { is_dragging, .. } => {
-            Some(if *is_dragging { StartAutoScrollTimer } else { CancelAutoScrollTimer })
-        }
+        TextDragSelection { is_dragging, .. } => Some(if *is_dragging {
+            StartAutoScrollTimer
+        } else {
+            CancelAutoScrollTimer
+        }),
         KeyboardShortcut { shortcut, .. } => shortcut_to_system_event(*shortcut),
     }
 }
@@ -2861,4 +2890,4 @@ mod tests {
         // We can't test it directly without making the function public
         // but it's tested indirectly through propagate_event
     }
-}
+}