Struct bevy_inspector_egui::inspector_egui_impls::InspectorEguiImpl

pub struct InspectorEguiImpl { /* private fields */ }

Function pointers for displaying a concrete type, to be registered in the TypeRegistry.

This can used for leaf types like u8 or String, as well as people who want to completely customize the way to display a certain type.

Implementations

impl InspectorEguiImpl

pub fn new(
    fn_mut: fn(_: &mut dyn Any, _: &mut Ui, _: &dyn Any, _: InspectorUi<'_, '_>) -> bool,
    fn_readonly: fn(_: &dyn Any, _: &mut Ui, _: &dyn Any, _: InspectorUi<'_, '_>),
    fn_many: for<'a> fn(_: &mut Ui, _: &dyn Any, _: InspectorUi<'_, '_>, _: &mut [&mut dyn Reflect], _: &dyn Fn(&mut dyn Reflect) -> &mut dyn Reflect) -> bool
) -> Self

Create a new InspectorEguiImpl from functions displaying a type

Examples found in repository

src/inspector_egui_impls/mod.rs (lines 100-104)

fn add_no_many<T: 'static>(
    type_registry: &mut TypeRegistry,
    fn_mut: InspectorEguiImplFn,
    fn_readonly: InspectorEguiImplFnReadonly,
) {
    type_registry
        .get_mut(TypeId::of::<T>())
        .unwrap_or_else(|| panic!("{} not registered", std::any::type_name::<T>()))
        .insert(InspectorEguiImpl::new(
            fn_mut,
            fn_readonly,
            many_unimplemented::<T>,
        ));
}
fn add<T: 'static>(
    type_registry: &mut TypeRegistry,
    fn_mut: InspectorEguiImplFn,
    fn_readonly: InspectorEguiImplFnReadonly,
    fn_many: InspectorEguiImplFnMany,
) {
    type_registry
        .get_mut(TypeId::of::<T>())
        .unwrap_or_else(|| panic!("{} not registered", std::any::type_name::<T>()))
        .insert(InspectorEguiImpl::new(fn_mut, fn_readonly, fn_many));
}

pub fn execute<'a, 'c: 'a>(
    &'a self,
    value: &mut dyn Any,
    ui: &mut Ui,
    options: &dyn Any,
    env: InspectorUi<'_, '_>
) -> bool

Examples found in repository

src/egui_reflect_inspector/mod.rs (line 214)

    pub fn ui_for_reflect_with_options(
        &mut self,
        value: &mut dyn Reflect,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        let mut options = options;
        if options.is::<()>() {
            if let Some(data) = self
                .type_registry
                .get_type_data::<ReflectInspectorOptions>(Any::type_id(value))
            {
                options = &data.0;
            }
        }

        if let Some(s) = self
            .type_registry
            .get_type_data::<InspectorEguiImpl>(Any::type_id(value))
        {
            return s.execute(value.as_any_mut(), ui, options, self.reborrow());
        }

        if let Some(changed) = (self.short_circuit)(self, value, ui, id, options) {
            return changed;
        }

        match value.reflect_mut() {
            bevy_reflect::ReflectMut::Struct(value) => self.ui_for_struct(value, ui, id, options),
            bevy_reflect::ReflectMut::TupleStruct(value) => {
                self.ui_for_tuple_struct(value, ui, id, options)
            }
            bevy_reflect::ReflectMut::Tuple(value) => self.ui_for_tuple(value, ui, id, options),
            bevy_reflect::ReflectMut::List(value) => self.ui_for_list(value, ui, id, options),
            bevy_reflect::ReflectMut::Array(value) => self.ui_for_array(value, ui, id, options),
            bevy_reflect::ReflectMut::Map(value) => self.ui_for_reflect_map(value, ui, id, options),
            bevy_reflect::ReflectMut::Enum(value) => self.ui_for_enum(value, ui, id, options),
            bevy_reflect::ReflectMut::Value(value) => self.ui_for_value(value, ui, id, options),
        }
    }

pub fn execute_readonly<'a, 'c: 'a>(
    &'a self,
    value: &dyn Any,
    ui: &mut Ui,
    options: &dyn Any,
    env: InspectorUi<'_, '_>
)

Examples found in repository

src/egui_reflect_inspector/mod.rs (line 261)

    pub fn ui_for_reflect_readonly_with_options(
        &mut self,
        value: &dyn Reflect,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        let mut options = options;
        if options.is::<()>() {
            if let Some(data) = self
                .type_registry
                .get_type_data::<ReflectInspectorOptions>(Any::type_id(value))
            {
                options = &data.0;
            }
        }

        if let Some(s) = self
            .type_registry
            .get_type_data::<InspectorEguiImpl>(Any::type_id(value))
        {
            s.execute_readonly(value.as_any(), ui, options, self.reborrow());
            return;
        }

        if let Some(()) = (self.short_circuit_readonly)(self, value, ui, id, options) {
            return;
        }

        match value.reflect_ref() {
            bevy_reflect::ReflectRef::Struct(value) => {
                self.ui_for_struct_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::TupleStruct(value) => {
                self.ui_for_tuple_struct_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Tuple(value) => {
                self.ui_for_tuple_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::List(value) => {
                self.ui_for_list_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Array(value) => {
                self.ui_for_array_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Map(value) => {
                self.ui_for_reflect_map_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Enum(value) => {
                self.ui_for_enum_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Value(value) => {
                self.ui_for_value_readonly(value, ui, id, options)
            }
        }
    }

pub fn execute_many<'a, 'c: 'a, 'e>(
    &'a self,
    ui: &mut Ui,
    options: &dyn Any,
    env: InspectorUi<'_, '_>,
    values: &mut [&mut dyn Reflect],
    projector: &dyn Fn(&mut dyn Reflect) -> &mut dyn Reflect
) -> bool

Examples found in repository

src/egui_reflect_inspector/mod.rs (line 327)

    pub fn ui_for_reflect_many_with_options(
        &mut self,
        type_id: TypeId,
        name: &str,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: &dyn Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        let Some(registration) = self.type_registry.get(type_id) else {
            error_message_not_in_type_registry(ui, name);
            return false;
        };
        let info = registration.type_info();

        let mut options = options;
        if options.is::<()>() {
            if let Some(data) = self
                .type_registry
                .get_type_data::<ReflectInspectorOptions>(type_id)
            {
                options = &data.0;
            }
        }

        if let Some(s) = self
            .type_registry
            .get_type_data::<InspectorEguiImpl>(type_id)
        {
            return s.execute_many(ui, options, self.reborrow(), values, projector);
        }

        if let Some(changed) =
            (self.short_circuit_many)(self, type_id, name, ui, id, options, values, projector)
        {
            return changed;
        }

        match info {
            TypeInfo::Struct(info) => {
                self.ui_for_struct_many(info, ui, id, options, values, projector)
            }
            TypeInfo::TupleStruct(info) => {
                self.ui_for_tuple_struct_many(info, ui, id, options, values, projector)
            }
            TypeInfo::Tuple(info) => {
                self.ui_for_tuple_many(info, ui, id, options, values, projector)
            }
            TypeInfo::List(info) => self.ui_for_list_many(info, ui, id, options, values, projector),
            TypeInfo::Array(info) => {
                error_message_no_multiedit(
                    ui,
                    &pretty_type_name::pretty_type_name_str(info.type_name()),
                );
                false
            }
            TypeInfo::Map(info) => {
                error_message_no_multiedit(
                    ui,
                    &pretty_type_name::pretty_type_name_str(info.type_name()),
                );
                false
            }
            TypeInfo::Enum(info) => self.ui_for_enum_many(info, ui, id, options, values, projector),
            TypeInfo::Value(info) => self.ui_for_value_many(info, ui, id, options),
            TypeInfo::Dynamic(_) => {
                error_message_no_multiedit(
                    ui,
                    &pretty_type_name::pretty_type_name_str(info.type_name()),
                );
                false
            }
        }
    }

Trait Implementations

impl Clone for InspectorEguiImpl

fn clone(&self) -> InspectorEguiImpl

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.