Reflect non-callback components and resources in bevy_core_widgets and bevy_feathers (#20339)

# Objective

- Reflecting public components and resources is essential to allow them
to be saved to scenes and function properly in inspectors
- Fixes #20040.

## Solution

- Derive reflect for all of the public components and resources that
didn't have it
- Various components that store a `Callback`, like `CoreButton`, are a
notable exception
- Because Callbacks are not type-erased, and the reflect derive only
works when all generics are reflect, I could not get this to work nicely
- If you can get this working, please let me know and we can do this in
follow-up!
- I also slapped a missing Debug derive on the theme resource because it
seems extremely useful and I noticed it

## Notes to reviewers

- this is not feature-gated: see #20337 for the steps needed to
meaningfully do so. Fixing that is out of scope for the 0.17 release.
- I've opted to separate the Reflect derive from the other derives
wherever rustfmt would let me. While this looks dumb right now, it will
reduce the diff noise when fixing #20337.
- I could add reflection to the callback-containing components with an
ignore for the callback fields, but I don't think this is particularly
useful

Author: alice-i-cecile

crates/bevy_core_widgets/Cargo.toml

@@ -18,6 +18,7 @@ bevy_input_focus = { path = "../bevy_input_focus", version = "0.17.0-dev" }
 bevy_log = { path = "../bevy_log", version = "0.17.0-dev" }
 bevy_math = { path = "../bevy_math", version = "0.17.0-dev" }
 bevy_picking = { path = "../bevy_picking", version = "0.17.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.17.0-dev" }
 bevy_ui = { path = "../bevy_ui", version = "0.17.0-dev" }
 
 # other

crates/bevy_core_widgets/src/callback.rs

@@ -1,5 +1,6 @@
 use bevy_ecs::system::{Commands, SystemId, SystemInput};
 use bevy_ecs::world::{DeferredWorld, World};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
 
 /// A callback defines how we want to be notified when a widget changes state. Unlike an event
 /// or observer, callbacks are intended for "point-to-point" communication that cuts across the
@@ -27,7 +28,8 @@ use bevy_ecs::world::{DeferredWorld, World};
 /// // Later, when we want to execute the callback:
 /// app.world_mut().commands().notify(&callback);
 /// ```
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Reflect)]
+#[reflect(Default)]
 pub enum Callback<I: SystemInput = ()> {
     /// Invoke a one-shot system
     System(SystemId<I>),

crates/bevy_core_widgets/src/core_radio.rs

@@ -8,12 +8,14 @@ use bevy_ecs::{
     component::Component,
     observer::On,
     query::With,
+    reflect::ReflectComponent,
     system::{Commands, Query},
 };
 use bevy_input::keyboard::{KeyCode, KeyboardInput};
 use bevy_input::ButtonState;
 use bevy_input_focus::FocusedInput;
 use bevy_picking::events::{Click, Pointer};
+use bevy_reflect::Reflect;
 use bevy_ui::{Checkable, Checked, InteractionDisabled};
 
 use crate::{Activate, Callback, Notify};
@@ -48,6 +50,8 @@ pub struct CoreRadioGroup {
 /// See <https://www.w3.org/WAI/ARIA/apg/patterns/radio>/
 #[derive(Component, Debug)]
 #[require(AccessibilityNode(accesskit::Node::new(Role::RadioButton)), Checkable)]
+#[derive(Reflect)]
+#[reflect(Component)]
 pub struct CoreRadio;
 
 fn radio_group_on_key_input(

crates/bevy_core_widgets/src/core_scrollbar.rs

@@ -5,17 +5,20 @@ use bevy_ecs::{
     hierarchy::{ChildOf, Children},
     observer::On,
     query::{With, Without},
+    reflect::ReflectComponent,
     system::{Query, Res},
 };
 use bevy_math::Vec2;
 use bevy_picking::events::{Cancel, Drag, DragEnd, DragStart, Pointer, Press};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
 use bevy_ui::{
     ComputedNode, ComputedNodeTarget, Node, ScrollPosition, UiGlobalTransform, UiScale, Val,
 };
 
 /// Used to select the orientation of a scrollbar, slider, or other oriented control.
 // TODO: Move this to a more central place.
-#[derive(Debug, Default, Clone, Copy, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Reflect)]
+#[reflect(PartialEq, Clone, Default)]
 pub enum ControlOrientation {
     /// Horizontal orientation (stretching from left to right)
     Horizontal,
@@ -45,7 +48,8 @@ pub enum ControlOrientation {
 /// The application is free to position the scrollbars relative to the scrolling container however
 /// it wants: it can overlay them on top of the scrolling content, or use a grid layout to displace
 /// the content to make room for the scrollbars.
-#[derive(Component, Debug)]
+#[derive(Component, Debug, Reflect)]
+#[reflect(Component)]
 pub struct CoreScrollbar {
     /// Entity being scrolled.
     pub target: Entity,
@@ -62,6 +66,8 @@ pub struct CoreScrollbar {
 /// the scrollbar). This should be a child of the scrollbar entity.
 #[derive(Component, Debug)]
 #[require(CoreScrollbarDragState)]
+#[derive(Reflect)]
+#[reflect(Component)]
 pub struct CoreScrollbarThumb;
 
 impl CoreScrollbar {
@@ -83,7 +89,8 @@ impl CoreScrollbar {
 
 /// Component used to manage the state of a scrollbar during dragging. This component is
 /// inserted on the thumb entity.
-#[derive(Component, Default)]
+#[derive(Component, Default, Reflect)]
+#[reflect(Component, Default)]
 pub struct CoreScrollbarDragState {
     /// Whether the scrollbar is currently being dragged.
     pub dragging: bool,

crates/bevy_core_widgets/src/core_slider.rs

@@ -13,6 +13,7 @@ use bevy_ecs::{
     component::Component,
     observer::On,
     query::With,
+    reflect::ReflectComponent,
     system::{Commands, Query},
 };
 use bevy_input::keyboard::{KeyCode, KeyboardInput};
@@ -21,12 +22,14 @@ use bevy_input_focus::FocusedInput;
 use bevy_log::warn_once;
 use bevy_math::ops;
 use bevy_picking::events::{Drag, DragEnd, DragStart, Pointer, Press};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
 use bevy_ui::{ComputedNode, ComputedNodeTarget, InteractionDisabled, UiGlobalTransform, UiScale};
 
 use crate::{Callback, Notify, ValueChange};
 
 /// Defines how the slider should behave when you click on the track (not the thumb).
-#[derive(Debug, Default, PartialEq, Clone, Copy)]
+#[derive(Debug, Default, PartialEq, Clone, Copy, Reflect)]
+#[reflect(Clone, PartialEq, Default)]
 pub enum TrackClick {
     /// Clicking on the track lets you drag to edit the value, just like clicking on the thumb.
     #[default]
@@ -181,6 +184,8 @@ impl Default for SliderRange {
 /// shortcuts. Defaults to 1.0.
 #[derive(Component, Debug, PartialEq, Clone)]
 #[component(immutable)]
+#[derive(Reflect)]
+#[reflect(Component)]
 pub struct SliderStep(pub f32);
 
 impl Default for SliderStep {
@@ -198,7 +203,8 @@ impl Default for SliderStep {
 /// The value in this component represents the number of decimal places of desired precision, so a
 /// value of 2 would round to the nearest 1/100th. A value of -3 would round to the nearest
 /// thousand.
-#[derive(Component, Debug, Default, Clone, Copy)]
+#[derive(Component, Debug, Default, Clone, Copy, Reflect)]
+#[reflect(Component, Default)]
 pub struct SliderPrecision(pub i32);
 
 impl SliderPrecision {
@@ -209,7 +215,8 @@ impl SliderPrecision {
 }
 
 /// Component used to manage the state of a slider during dragging.
-#[derive(Component, Default)]
+#[derive(Component, Default, Reflect)]
+#[reflect(Component)]
 pub struct CoreSliderDragState {
     /// Whether the slider is currently being dragged.
     pub dragging: bool,

crates/bevy_feathers/src/alpha_pattern.rs

@@ -4,11 +4,12 @@ use bevy_ecs::{
     component::Component,
     lifecycle::Add,
     observer::On,
+    reflect::ReflectComponent,
     resource::Resource,
     system::{Query, Res},
     world::FromWorld,
 };
-use bevy_reflect::TypePath;
+use bevy_reflect::{prelude::ReflectDefault, Reflect, TypePath};
 use bevy_render::render_resource::{AsBindGroup, ShaderRef};
 use bevy_ui_render::ui_material::{MaterialNode, UiMaterial};
 
@@ -34,7 +35,8 @@ impl FromWorld for AlphaPatternResource {
 }
 
 /// Marker that tells us we want to fill in the [`MaterialNode`] with the alpha material.
-#[derive(Component, Default, Clone)]
+#[derive(Component, Default, Clone, Reflect)]
+#[reflect(Component, Default)]
 pub(crate) struct AlphaPattern;
 
 /// Observer to fill in the material handle (since we don't have access to the materials asset

crates/bevy_feathers/src/controls/button.rs

@@ -7,12 +7,14 @@ use bevy_ecs::{
     hierarchy::{ChildOf, Children},
     lifecycle::RemovedComponents,
     query::{Added, Changed, Has, Or},
+    reflect::ReflectComponent,
     schedule::IntoScheduleConfigs,
     spawn::{SpawnRelated, SpawnableList},
     system::{Commands, In, Query},
 };
 use bevy_input_focus::tab_navigation::TabIndex;
 use bevy_picking::{hover::Hovered, PickingSystems};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
 use bevy_ui::{AlignItems, InteractionDisabled, JustifyContent, Node, Pressed, UiRect, Val};
 
 use crate::{
@@ -27,7 +29,8 @@ use crate::{
 
 /// Color variants for buttons. This also functions as a component used by the dynamic styling
 /// system to identify which entities are buttons.
-#[derive(Component, Default, Clone)]
+#[derive(Component, Default, Clone, Reflect)]
+#[reflect(Component, Clone, Default)]
 pub enum ButtonVariant {
     /// The standard button appearance
     #[default]

crates/bevy_feathers/src/controls/checkbox.rs

@@ -8,13 +8,15 @@ use bevy_ecs::{
     hierarchy::{ChildOf, Children},
     lifecycle::RemovedComponents,
     query::{Added, Changed, Has, Or, With},
+    reflect::ReflectComponent,
     schedule::IntoScheduleConfigs,
     spawn::{Spawn, SpawnRelated, SpawnableList},
     system::{Commands, In, Query},
 };
 use bevy_input_focus::tab_navigation::TabIndex;
 use bevy_math::Rot2;
 use bevy_picking::{hover::Hovered, PickingSystems};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
 use bevy_render::view::Visibility;
 use bevy_ui::{
     AlignItems, BorderRadius, Checked, Display, FlexDirection, InteractionDisabled, JustifyContent,
@@ -38,15 +40,18 @@ pub struct CheckboxProps {
 }
 
 /// Marker for the checkbox frame (contains both checkbox and label)
-#[derive(Component, Default, Clone)]
+#[derive(Component, Default, Clone, Reflect)]
+#[reflect(Component, Clone, Default)]
 struct CheckboxFrame;
 
 /// Marker for the checkbox outline
-#[derive(Component, Default, Clone)]
+#[derive(Component, Default, Clone, Reflect)]
+#[reflect(Component, Clone, Default)]
 struct CheckboxOutline;
 
 /// Marker for the checkbox check mark
-#[derive(Component, Default, Clone)]
+#[derive(Component, Default, Clone, Reflect)]
+#[reflect(Component, Clone, Default)]
 struct CheckboxMark;
 
 /// Template function to spawn a checkbox.

crates/bevy_feathers/src/controls/color_swatch.rs

@@ -1,6 +1,9 @@
 use bevy_asset::Handle;
 use bevy_color::Alpha;
-use bevy_ecs::{bundle::Bundle, children, component::Component, spawn::SpawnRelated};
+use bevy_ecs::{
+    bundle::Bundle, children, component::Component, reflect::ReflectComponent, spawn::SpawnRelated,
+};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
 use bevy_ui::{BackgroundColor, BorderRadius, Node, PositionType, Val};
 use bevy_ui_render::ui_material::MaterialNode;
 
@@ -11,13 +14,15 @@ use crate::{
 };
 
 /// Marker identifying a color swatch.
-#[derive(Component, Default, Clone)]
+#[derive(Component, Default, Clone, Reflect)]
+#[reflect(Component, Clone, Default)]
 pub struct ColorSwatch;
 
 /// Marker identifying the color swatch foreground, the piece that actually displays the color
 /// in front of the alpha pattern. This exists so that users can reach in and change the color
 /// dynamically.
-#[derive(Component, Default, Clone)]
+#[derive(Component, Default, Clone, Reflect)]
+#[reflect(Component, Clone, Default)]
 pub struct ColorSwatchFg;
 
 /// Template function to spawn a color swatch.

crates/bevy_feathers/src/controls/radio.rs

@@ -8,12 +8,14 @@ use bevy_ecs::{
     hierarchy::{ChildOf, Children},
     lifecycle::RemovedComponents,
     query::{Added, Changed, Has, Or, With},
+    reflect::ReflectComponent,
     schedule::IntoScheduleConfigs,
     spawn::{Spawn, SpawnRelated, SpawnableList},
     system::{Commands, Query},
 };
 use bevy_input_focus::tab_navigation::TabIndex;
 use bevy_picking::{hover::Hovered, PickingSystems};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
 use bevy_render::view::Visibility;
 use bevy_ui::{
     AlignItems, BorderRadius, Checked, Display, FlexDirection, InteractionDisabled, JustifyContent,
@@ -30,11 +32,13 @@ use crate::{
 };
 
 /// Marker for the radio outline
-#[derive(Component, Default, Clone)]
+#[derive(Component, Default, Clone, Reflect)]
+#[reflect(Component, Clone, Default)]
 struct RadioOutline;
 
 /// Marker for the radio check mark
-#[derive(Component, Default, Clone)]
+#[derive(Component, Default, Clone, Reflect)]
+#[reflect(Component, Clone, Default)]
 struct RadioMark;
 
 /// Template function to spawn a radio.