Struct InspectorContext

pub struct InspectorContext {
    pub stack_panel: Handle<UiNode>,
    pub menu: Menu,
    pub entries: Vec<ContextEntry>,
    pub property_definitions: Arc<PropertyEditorDefinitionContainer>,
    pub environment: Option<Arc<dyn InspectorEnvironment>>,
    pub sync_flag: u64,
    pub object_type_id: TypeId,
    pub name_column_width: f32,
}

The widget handle and associated information that represents what an Inspector is currently displaying.

Fields

stack_panel: Handle<UiNode>

The handle of a UI node containing property editor widgets. This would usually be a vertical Stack widget, but any widget will sever the same purpose so long as it produces messages that are recognized by the PropertyEditorDefinitions contained in InspectorContext::property_definitions.

To ensure this, the widget should be composed of widgets produced by PropertyEditorDefinition::create_instance.

menu: Menu

The context menu that opens when right-clicking on the inspector.

entries: Vec<ContextEntry>

List of the editors in this inspector, in order, with each entry giving the editor widget handle, the name of the field being edited, and so on.

property_definitions: Arc<PropertyEditorDefinitionContainer>

List if property definitions that are by sync to update the widgets of stack_panel, with the current values of properties that may have changed.

environment: Option<Arc<dyn InspectorEnvironment>>

Untyped information from the application that is using the inspector. This can be used by editors that may be supplied by that application, if those editors know the actual type of this value to be able to successfully cast it.

sync_flag: u64

The value given to UiMessage::flags when sync is generating update messages for editor widgets. This identifies sync messages and prevents the Inspector from trying to translate them, and thereby it prevents sync messages from potentially creating an infinite message loop.

object_type_id: TypeId

Type id of the object for which the context was created.

name_column_width: f32

A width of the property name column.

Implementations

impl InspectorContext

pub fn from_object( object: &(dyn Reflect + 'static), ctx: &mut BuildContext<'_>, definition_container: Arc<PropertyEditorDefinitionContainer>, environment: Option<Arc<dyn InspectorEnvironment>>, sync_flag: u64, layer_index: usize, generate_property_string_values: bool, filter: PropertyFilter, name_column_width: f32, ) -> InspectorContext

Build the widgets for an Inspector to represent the given object by accessing the object’s fields through reflection.

• object: The object to inspect.
• ctx: The general context for widget creation.
• definition_container: The list of property editor definitions that will create the editors based on the type of each field.
• environment: Untyped optional generic information about the application using the inspector, which may be useful to some editors. Often this will be Fyroxed’s EditorEnvironment.
• sync_flag: Flag bits to identify messages that are sent by the sync method to update an editor with the current value of the property that it is editing. This becomes the value of UiMessage::flags.
• layer_index: Inspectors can be nested within the editors of other inspectors. The layer_index is the count of how deeply nested this inspector will be.
• generate_property_string_values: Should we use format!("{:?}", field) to construct string representations for each property?
• filter: A filter function that controls whether each field will be included in the inspector.

pub fn sync( &self, object: &(dyn Reflect + 'static), ui: &mut UserInterface, layer_index: usize, generate_property_string_values: bool, filter: PropertyFilter, ) -> Result<(), Vec<InspectorError>>

Update the widgest to reflect the value of the given object. We will iterate through the fields and find the appropriate PropertyEditorDefinition for each field. We call create_message to get each property editor definition to generate the appropriate message to get the editor widget to update itself, and we set the flags of each message to InspectorContext::sync_flag before sending the message.

• object: The object to take the property values from.
• ui: The UserInterface to include in the PropertyEditorMessageContext.
• layer_index: The depth of the nesting of this inspector.
• generator_property_string_values: if any editors within this inspector contain inner inspectors, should those inspectors generate strings for their properties?
• filter: filter function for the fields of object and for any inspectors within the editors of this inspector.

pub fn property_editors(&self) -> impl Iterator<Item = &ContextEntry>

Iterates through every property.

pub fn find_property_editor(&self, name: &str) -> Option<&ContextEntry>

Return the entry for the property with the given name.

pub fn find_property_editor_by_tag(&self, tag: &str) -> Option<&ContextEntry>

Return the entry for the property with the given tag.

pub fn find_property_editor_widget(&self, name: &str) -> Handle<UiNode>

Shortcut for getting the editor widget from the property with the given name. Returns Handle::NONE if there is no property with that name.

Trait Implementations

impl Clone for InspectorContext

fn clone(&self) -> InspectorContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InspectorContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for InspectorContext

fn default() -> InspectorContext

Returns the “default value” for a type.

impl PartialEq for InspectorContext

fn eq(&self, other: &InspectorContext) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.