Crate ferroui_reactiveui_controls 

ferroui-reactiveui-controls

The integration of ReactiveUI (ferroui-reactiveui) with FerroUI, ported from the integration of ReactiveUI with the reference UI framework, together with the matching parts of ReactiveUI.Binding and ReactiveUI.Primitives:

• the scheduler of the user-interface thread, FerroScheduler, which the application sets as RxSchedulers::main_thread_scheduler, and FerroScheduler::install_on_ui_thread, which makes the dispatcher’s synchronization context the context of the user-interface thread;
• the property observation of FerroUI objects (FerroObjectObservableForProperty), the command binding of FerroUI controls (FerroCreatesCommandBinding, with ReactiveCommandAdapter, a command of ReactiveUI as a command of FerroUI) and the view thread invoker (FerroViewThreadInvoker), which FerroBindingModule (or register_binding_integration) registers;
• the activation of the views of FerroUI (FerroActivationForViewFetcher);
• the properties of FerroUI objects as signals (FerroObjectReactiveExtensions);
• property paths through the properties of FerroUI objects (ferro_property, ferro_prop!) and the lookup of the FerroUI object behind an untyped object of ReactiveUI (FerroObjectHandles);
• the reactive views, the view hosts, the data-template hook, suspension and use_reactive_ui on the application builder.

Macros

ferro_prop

A PropertyPath of one property of a FerroUI object (x => x.Text on a control).

Structs

AutoDataTemplateBindingHook

A binding hook that gives an ItemsControl a default data template when it has no item template and no data templates (AutoDataTemplateBindingHook).

AutoSuspendHelper

Automatic suspension and state persistence for FerroUI applications (AutoSuspendHelper).

BindableView

A control of a reactive view class (a document whose root is ReactiveUserControlBase or ReactiveWindowBase) as the view that the bindings of ReactiveUI take: an IViewFor<VM> over the control’s ViewModel property, which raises PropertyChanged for ViewModel when the property changes.

ControlViewFor

A control of a class that implements IControlViewFor, as a view of ReactiveUI (IViewFor<TViewModel> on the control).

FerroActivationForViewFetcher

The activation of the views of FerroUI (FerroActivationForViewFetcher).

FerroBindingModule

Registers the property observer of FerroUI objects, the command binder of FerroUI controls and the view thread invoker with the dependency resolver (FerroBindingModule).

FerroCreatesCommandBinding

Binds commands to the input elements of FerroUI, through a command source’s Command property or through a routed event (FerroCreatesCommandBinding).

FerroObjectHandles

The registry of the types that stand for a FerroUI object in the untyped values of ReactiveUI, and the lookup of the object behind such a value.

FerroObjectObservableForProperty

Observes a property of a FerroUI object through the registered property of that name (FerroObjectObservableForProperty).

FerroPropertySignal

A property of a FerroUI object as a signal: an observer whose values on_next handles, and the observable of the property (FerroPropertySignal<T>).

FerroPropertySubscription

The object and the handler a property observation detaches when it is disposed (FerroPropertySubscription): disposing it removes the property-changed handler from the object; only the first call does anything.

FerroScheduler

The scheduler of the user-interface thread: it runs its work on the thread of a Dispatcher, at a priority, and coalesces the work scheduled before the dispatcher runs it into one job of the dispatcher (a drain).

FerroViewThreadInvoker

Routes the writes of the bindings to a FerroUI object onto the FerroScheduler of the dispatcher that owns it (FerroViewThreadInvoker).

NavigationTarget

A pending navigation target (NavigationTarget): the view model to display and the optional view contract.

ReactiveCommandAdapter

A command of ReactiveUI as a command of FerroUI: each member forwards to the command it wraps, with the parameter seen as &dyn Any.

ReactiveCommandParameter

A command parameter of ReactiveUI that is not one of the values the property system compares, held by a control’s CommandParameter: it compares by identity, as an object does upstream.

ReactiveUserControlBase

A non-generic ReactiveUI UserControl base that owns the view model property (ReactiveUserControlBase).

ReactiveView

A reactive view class instance typed by its view model (ReactiveUserControl<TViewModel>, ReactiveWindow<TViewModel>): a handle that dereferences to the control and, shared as an Rc, is its IViewFor<TViewModel>.

ReactiveViewFor

A control with a ViewModel property as an untyped view of ReactiveUI (IViewFor).

ReactiveWindowBase

A non-generic ReactiveUI Window base that owns the view model property (ReactiveWindowBase).

RoutedViewHost

Hosts the view associated with the current ReactiveUI routing state (RoutedViewHost).

SplatApp

Configures the support of FerroUI on a ReactiveUI builder and builds the Splat application once (SplatApp).

StartupConfiguration

Builds ReactiveUI once the platform services of the application are ready (StartupConfiguration).

SubscriptionErrors

Handles the errors of observable subscriptions (SubscriptionErrors).

UntypedViewModel

A view model of a type that was not registered, as the value of a property: the view model itself, compared by identity.

ViewAssembly

The types of an application that hold its views (an assembly scanned upstream).

ViewAssemblyType

A type of a ViewAssembly: its name and, for a view, how it is registered.

ViewForValue

A view that is not a control, as the content of a host (the view object itself as Content upstream): compared by identity.

ViewHostNavigation

Resolves and wires the view a content host displays for a view model (ViewHostNavigation).

ViewModelPropertySync

Keeps a view’s view model property and its data context in step (ViewModelPropertySync).

ViewModelViewHost

Loads and displays the view associated with the ViewModel property (ViewModelViewHost).

ViewRegistrar

Registers the views of assemblies with a dependency resolver (ViewRegistrar).

Enums

ViewLink

How an adapter holds its control: strongly, for a view that is handed to others (a view a locator creates), or weakly, for the view a control uses for itself (its own activation), so that the control and its handlers do not keep each other alive.

Constants

REACTIVEUI_XML_NAMESPACE

The XML namespace of ReactiveUI (http://reactiveui.net).

Statics

ASSEMBLY

What this crate states about itself for markup: its assembly name and the XML namespace of ReactiveUI mapped to its namespace ([assembly: XmlnsDefinition("http://reactiveui.net", ..)]).

Traits

AppBuilderExtensions

Extends the application builder of ferroui-controls with ReactiveUI (AppBuilderExtensions, extension(AppBuilder builder)).

FerroAppBuilderExtensions

with_ferro on an application builder that is a builder of ReactiveUI.Binding (WithFerro on IAppBuilder, which casts the builder).

FerroBindingBuilderExtensions

The FerroUI members of the builder of ReactiveUI.Binding (FerroBindingBuilderExtensions): with_ferro registers the FerroBindingModule, which adds the property observation of FerroUI objects, the command binding of FerroUI controls and the view thread invoker.

FerroObjectReactiveExtensions

The properties of a FerroUI object as signals (FerroObjectReactiveExtensions): a signal observes the property, as FerroObjectExtensions::get_observable does (the current value on subscription, then each change), and sets the property to each value pushed into it.

IControlViewFor

A control class that is a view of the view model type ViewModel (a control that implements IViewFor<TViewModel> upstream, with a plain ViewModel property).

IReactiveViewClass

A control class with a ViewModel property of the untyped value of the property system.

ITypedReactiveViewClass

A reactive view class that a typed handle can restrict to one type of view model.

IViewControl

An adapter that shows a control as a view of ReactiveUI.

ReactiveUIBuilderFerroExtensions

Extends ReactiveUI’s builder with the services of FerroUI (extension(IReactiveUIBuilder builder)).

Functions

boxed_parameter

A command parameter of ReactiveUI as the value of a control’s CommandParameter: a BoxedValue (or a handle to an object of FerroUI) as it is; a string, a number, a character or a boolean boxed as itself, so that the control’s parameter compares as the value; anything else in a ReactiveCommandParameter.

control_target

The handle of control as the binder takes a control.

control_type

The handle type of class T as the binder sees a control: what TypeId the command binding of a control of class T passes (ICreatesCommandBinding::get_affinity_for_object).

element_control

The element element (named name in the document of the view) as the control a command binds to (v => v.Element).

element_property

The property property of the element element (named name in the document of the view), as the side of a binding the binding writes with set (v => v.Element.Property).

ferro_property

A path of the property name of a FerroUI object of class T, read with get: its step gives the object as its owner (ferro_property_owner), and the path observes the change of the registered property of that name.

ferro_property_owner

The owner of the properties of object, as a step of a path gives it to the property observers chosen at run time: the object as its untyped handle, without a PropertyChanged notification.

is_view_model_of

Whether the value of a property holds a view model of type VM (value is TViewModel).

observe_ferro_property

Runs changed each time the registered property name of object changes, until the result is disposed; a property the class does not register is never observed.

owned_element_property

element_property whose step to the element names the view as the owner of the element, so that the binding hooks see the element and its property (the default item template of an items control, AutoDataTemplateBindingHook).

parameter_as_any

The value a command of ReactiveUI is executed with, from the value of a control’s CommandParameter: the value itself, or the object of a ReactiveCommandParameter.

register_binding_integration

Registers what FerroBindingModule registers with resolver: the property observer of FerroUI objects (a lazy singleton of dyn ICreatesObservableForProperty), the command binder of FerroUI controls (dyn ICreatesCommandBinding) and the shared view thread invoker (dyn IViewThreadInvoker).

register_types

Registers the namespace, the types and the assembly of this crate (and of the crates it is built on). Cheap and idempotent.

register_view_control

Registers the adapter type T on this thread, so that view_control finds the control of its views. Idempotent; the adapters of this crate register themselves when they are created.

register_view_model

Registers the view model type VM on this thread: a view model of the type is then the value of a DataContext itself (Rc<VM> as the box), and a reference type of the untyped value conversions (ValueTypes::register_reference). Idempotent.

same_view_model

Whether two values of properties hold the same view model (ReferenceEquals of the objects): both null, or the same object behind any of their forms.

same_view_model_object

Whether two view models are the same object (ReferenceEquals).

value_of_optional_view_model

value_of_view_model of an optional view model.

value_of_view_model

The value of a property that holds view_model (object written to a property): the view model itself when its type is registered, else an UntypedViewModel.

view_control

The control behind a view (view as Control): the control of an adapter of a registered type, None for any other view.

view_model_of_optional

view_model_of_value of an optional value.

view_model_of_value

The view model held by the value of a property (object read as a view model): the object form of a registered reference handle, the view model of an UntypedViewModel, or the value itself.

Type Aliases

ReactiveUserControl

A ReactiveUI UserControl that implements IViewFor<TViewModel> (ReactiveUserControl<TViewModel>).

ReactiveWindow

A ReactiveUI Window that implements IViewFor<TViewModel> (ReactiveWindow<TViewModel>).

ViewModelFilter

The filter of the view models a reactive view takes from its DataContext (IsValidViewModelValue).