ferroui_controls/markup_types/

classes.rs

// @generated by scripts/generate_markup_types.py — do not edit
//! The `markup` part of the classes of the object model of this crate:
//! what markup needs to know about each class beyond its registered
//! properties (content property, plain properties, constructors with
//! arguments, methods, routed events as static values, plain events,
//! attributes of the type and of its registered properties), as the managed
//! original declares it. The hand-written members come from
//! `scripts/markup_types_overrides.py`.
//!
//! A plain event lists the parameters of the handler of the managed
//! original: nothing for an event without arguments, the sender and the
//! arguments otherwise (the adapter passes the instance as the sender).

// Obsolete members of the managed original are declared too (with `[Obsolete]`).
#![allow(deprecated)]

use crate::animation::*;
use crate::application_lifetimes::IApplicationLifetime;
use crate::automation::peers::*;
use crate::chrome::*;
use crate::documents::*;
use crate::presenters::*;
use crate::pull_to_refresh::*;
use crate::templates::{DataTemplates, IDataTemplate, ITemplateOf};
use crate::primitives::*;
use crate::*;
use ferroui_base::animation::easings::Easing;
use ferroui_base::animation::TimeSpan;
use ferroui_base::collections::FerroList;
use ferroui_base::controls::{Classes, IResourceDictionary, ResourceDictionary, ResourcesChangedEventArgs};
use ferroui_base::data::core::ValueTypes;
use ferroui_base::input::*;
use ferroui_base::interactivity::*;
use ferroui_base::media::{
    FontFamily, FontFeatureCollection, FontStretch, FontStyle, FontWeight, IBrush, TextAlignment, TextDecorationCollection,
    TextLineBounds, TextTrimming, TextWrapping,
};
use ferroui_base::metadata::{into_markup_value, MarkupDelegate, MarkupType};
use ferroui_base::styling::*;
use ferroui_base::utilities::{CancelEventArgs, EventArgs};
use ferroui_base::{ferro_class_info, BoxedValue, FerroObject, IFerroDependencyResolver, PixelPoint, Rect, Ref, Size, Vector};
use std::rc::Rc;
use ferroui_base::ferro_markup_type;
use ferroui_base::metadata::MarkupTyped;

// FerroUI

ferro_class_info!(Application {
    markup: {
        namespace: "FerroUI",
        properties: [
            Styles: Ref<Styles> { get: Application::styles },
            ApplicationLifetime: Option<Rc<dyn IApplicationLifetime>> { set: Application::set_application_lifetime },
            DataTemplates: DataTemplates { get: Application::data_templates },
            Resources: Rc<dyn IResourceDictionary> {
                get: |this: &Ref<Application>| -> Rc<dyn IResourceDictionary> { this.resources().into() },
                try_set: |this: &Ref<Application>, value: Rc<dyn IResourceDictionary>| {
                    match value.as_object().and_then(|object| object.to_ref().cast::<ResourceDictionary>()) {
                        Some(dictionary) => Ok(this.set_resources(dictionary)),
                        None => Err("The resource dictionary is not a ResourceDictionary."),
                    }
                }
            },
        ],
        static_properties: [
            Current: Option<Ref<Application>> { get: Application::current },
        ],
        events: [
            ResourcesChanged(Option<BoxedValue>, ResourcesChangedEventArgs) => |this: &Ref<Application>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.resources_changed(move |e: &ResourcesChangedEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            ActualThemeVariantChanged(Option<BoxedValue>, EventArgs) => |this: &Ref<Application>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.actual_theme_variant_changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

// FerroUI.Animation

ferro_class_info!(ConnectedAnimationService {
    markup: {
        namespace: "FerroUI.Animation",
        properties: [
            DefaultDuration: TimeSpan { get: ConnectedAnimationService::default_duration, set: ConnectedAnimationService::set_default_duration },
            DefaultEasingFunction: Option<Easing> { get: ConnectedAnimationService::default_easing_function, set: ConnectedAnimationService::set_default_easing_function },
        ],
    },
});

// FerroUI.Automation.Peers

ferro_class_info!(AutomationPeer {
    markup: {
        namespace: "FerroUI.Automation.Peers",
        properties: [
            EventsSource: Option<Ref<AutomationPeer>> {
                get: AutomationPeer::events_source,
                set: |this: &Ref<AutomationPeer>, value: Option<Ref<AutomationPeer>>| this.set_events_source(value)
            },
        ],
        methods: [
            fn RaiseTextEditTextChangedEvent(crate::automation::provider::TextEditChangeType, Vec<String>) => AutomationPeer::raise_text_edit_text_changed_event,
        ],
        events: [
            ChildrenChanged(Option<BoxedValue>, EventArgs) => |this: &Ref<AutomationPeer>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.children_changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

ferro_class_info!(WindowBaseAutomationPeer {
    markup: {
        namespace: "FerroUI.Automation.Peers",
        events: [
            FocusChanged(Option<BoxedValue>, EventArgs) => |this: &Ref<WindowBaseAutomationPeer>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.focus_changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

// FerroUI.Controls

ferro_class_info!(Button {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            ClickEvent: RoutedEvent<RoutedEventArgs> => || *Button::click_event(),
        ],
        attributes: [PseudoClasses(":flyout-open", ":pressed")],
    },
});

ferro_class_info!(ButtonSpinner {
    markup: {
        namespace: "FerroUI.Controls",
        attributes: [
            TemplatePart("PART_DecreaseButton", type(Ref<Button>)),
            TemplatePart("PART_IncreaseButton", type(Ref<Button>)),
            PseudoClasses(":left", ":right"),
        ],
    },
});

ferro_class_info!(Canvas {
    markup: {
        namespace: "FerroUI.Controls",
        methods: [
            static fn GetLeft(Ref<FerroObject>) -> f64 =>
                |element: Ref<FerroObject>| element.get_value(Canvas::left_property()),
            static fn SetLeft(Ref<FerroObject>, f64) =>
                |element: Ref<FerroObject>, value: f64| element.set_value(Canvas::left_property(), value),
            static fn GetTop(Ref<FerroObject>) -> f64 =>
                |element: Ref<FerroObject>| element.get_value(Canvas::top_property()),
            static fn SetTop(Ref<FerroObject>, f64) =>
                |element: Ref<FerroObject>, value: f64| element.set_value(Canvas::top_property(), value),
            static fn GetRight(Ref<FerroObject>) -> f64 =>
                |element: Ref<FerroObject>| element.get_value(Canvas::right_property()),
            static fn SetRight(Ref<FerroObject>, f64) =>
                |element: Ref<FerroObject>, value: f64| element.set_value(Canvas::right_property(), value),
            static fn GetBottom(Ref<FerroObject>) -> f64 =>
                |element: Ref<FerroObject>| element.get_value(Canvas::bottom_property()),
            static fn SetBottom(Ref<FerroObject>, f64) =>
                |element: Ref<FerroObject>, value: f64| element.set_value(Canvas::bottom_property(), value),
        ],
    },
});

ferro_class_info!(ColumnDefinition {
    markup: {
        namespace: "FerroUI.Controls",
        constructors: [
            (f64, GridUnitType) => ColumnDefinition::with_value,
            (GridLength) => ColumnDefinition::with_width,
        ],
    },
});

ferro_class_info!(ComboBox {
    markup: {
        namespace: "FerroUI.Controls",
        property_attributes: [
            SelectionBoxItemTemplate: [InheritDataTypeFromItems("ItemsSource")],
        ],
        events: [
            DropDownClosed(Option<BoxedValue>, EventArgs) => |this: &Ref<ComboBox>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.drop_down_closed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
            DropDownOpened(Option<BoxedValue>, EventArgs) => |this: &Ref<ComboBox>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.drop_down_opened(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
        attributes: [
            TemplatePart("PART_Popup", type(Ref<Popup>), IsRequired = true),
            TemplatePart("PART_EditableTextBox", type(Ref<TextBox>), IsRequired = false),
            PseudoClasses(":dropdownopen", ":pressed"),
        ],
    },
});

ferro_class_info!(ContentControl {
    markup: {
        namespace: "FerroUI.Controls",
        content: Content,
        property_attributes: [
            Content: [DependsOn("ContentTemplate")],
        ],
        attributes: [
            TemplatePart("PART_ContentPresenter", type(Ref<ContentPresenter>)),
            PseudoClasses(":empty"),
        ],
    },
});

ferro_class_info!(ContextMenu {
    markup: {
        namespace: "FerroUI.Controls",
        events: [
            Opening(Option<BoxedValue>, CancelEventArgs) => |this: &Ref<ContextMenu>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.opening(move |e: &CancelEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            Closing(Option<BoxedValue>, CancelEventArgs) => |this: &Ref<ContextMenu>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.closing(move |e: &CancelEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
        ],
    },
});

ferro_class_info!(Control {
    markup: {
        namespace: "FerroUI.Controls",
        properties: [
            DataTemplates: DataTemplates { get: Control::data_templates },
        ],
        fields: [
            RequestBringIntoViewEvent: RoutedEvent<RequestBringIntoViewEventArgs> => || *Control::request_bring_into_view_event(),
            LoadedEvent: RoutedEvent<RoutedEventArgs> => || *Control::loaded_event(),
            UnloadedEvent: RoutedEvent<RoutedEventArgs> => || *Control::unloaded_event(),
            SizeChangedEvent: RoutedEvent<SizeChangedEventArgs> => || *Control::size_changed_event(),
        ],
    },
});

// `SetError` has no getter and no registered property in the managed original either: markup sees it as the
// attached property `DataValidationErrors.Error`.
ferro_class_info!(DataValidationErrors {
    markup: {
        namespace: "FerroUI.Controls",
        methods: [
            static fn SetError(Ref<Control>, Option<ferroui_base::data::BindingError>) =>
                |control: Ref<Control>, error: Option<ferroui_base::data::BindingError>| {
                    DataValidationErrors::set_error(&control, error.as_ref())
                },
        ],
        attributes: [PseudoClasses(":error")],
    },
});

ferro_class_info!(Decorator {
    markup: {
        namespace: "FerroUI.Controls",
        content: Child,
    },
});

ferro_class_info!(DefinitionBase {
    markup: {
        namespace: "FerroUI.Controls",
        properties: [
            SharedSizeGroup: Option<String> {
                get: |this: &Ref<DefinitionBase>| this.get_value(DefinitionBase::shared_size_group_property()),
                set: |this: &Ref<DefinitionBase>, value: Option<String>| this.set_value(DefinitionBase::shared_size_group_property(), value)
            },
        ],
    },
});

ferro_markup_type!(static Design {
    namespace: "FerroUI.Controls",
    type_info: Design,
    methods: [
        static fn SetDataContext(Rc<dyn IDataTemplate>, Option<BoxedValue>) =>
                |template: Rc<dyn IDataTemplate>, value: Option<BoxedValue>| Design::set_data_context_for_data_template(&template, value),
        static fn GetDataContext(Rc<dyn IDataTemplate>) -> Option<BoxedValue> =>
                |template: Rc<dyn IDataTemplate>| Design::get_data_context_for_data_template(&template),
        static fn SetPreviewWith(Ref<FerroObject>, Option<Rc<dyn ITemplateOf<Option<Ref<Control>>>>>) =>
                |target: Ref<FerroObject>, template: Option<Rc<dyn ITemplateOf<Option<Ref<Control>>>>>| Design::set_preview_with_template(&target, template),
        static fn SetPreviewWith(Ref<FerroObject>, Option<Ref<Control>>) =>
                |target: Ref<FerroObject>, control: Option<Ref<Control>>| Design::set_preview_with(&target, control),
        static fn SetPreviewWith(Ref<ResourceDictionary>, Option<Rc<dyn ITemplateOf<Option<Ref<Control>>>>>) =>
                |target: Ref<ResourceDictionary>, template: Option<Rc<dyn ITemplateOf<Option<Ref<Control>>>>>| {
                    Design::set_preview_with_template(&target.upcast(), template)
                },
        static fn SetPreviewWith(Ref<ResourceDictionary>, Option<Ref<Control>>) =>
                |target: Ref<ResourceDictionary>, control: Option<Ref<Control>>| Design::set_preview_with(&target.upcast(), control),
        static fn SetPreviewWith(Rc<dyn IDataTemplate>, Option<Rc<dyn ITemplateOf<Option<Ref<Control>>>>>) =>
                |target: Rc<dyn IDataTemplate>, template: Option<Rc<dyn ITemplateOf<Option<Ref<Control>>>>>| Design::set_preview_with_template_for_data_template(&target, template),
        static fn SetPreviewWith(Rc<dyn IDataTemplate>, Option<Ref<Control>>) =>
                |target: Rc<dyn IDataTemplate>, control: Option<Ref<Control>>| Design::set_preview_with_for_data_template(&target, control),
        static fn SetPreviewWith(Rc<dyn IStyle>, Option<Rc<dyn ITemplateOf<Option<Ref<Control>>>>>) =>
                |target: Rc<dyn IStyle>, template: Option<Rc<dyn ITemplateOf<Option<Ref<Control>>>>>| Design::set_preview_with_template_for_style(&target, template),
        static fn SetPreviewWith(Rc<dyn IStyle>, Option<Ref<Control>>) =>
                |target: Rc<dyn IStyle>, control: Option<Ref<Control>>| Design::set_preview_with_for_style(&target, control),
        static fn GetPreviewWith(Ref<FerroObject>) -> Option<Ref<Control>> =>
                |target: Ref<FerroObject>| Design::get_preview_with(&target),
        static fn GetPreviewWith(Ref<ResourceDictionary>) -> Option<Ref<Control>> =>
                |target: Ref<ResourceDictionary>| Design::get_preview_with(&target.upcast::<FerroObject>()),
        static fn GetPreviewWith(Rc<dyn IDataTemplate>) -> Option<Ref<Control>> =>
                |target: Rc<dyn IDataTemplate>| Design::get_preview_with_for_data_template(&target),
        static fn GetPreviewWith(Rc<dyn IStyle>) -> Option<Ref<Control>> =>
                |target: Rc<dyn IStyle>| Design::get_preview_with_for_style(&target),
    ],
});

ferro_class_info!(Expander {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            CollapsedEvent: RoutedEvent<RoutedEventArgs> => || *Expander::collapsed_event(),
            CollapsingEvent: RoutedEvent<CancelRoutedEventArgs> => || *Expander::collapsing_event(),
            ExpandedEvent: RoutedEvent<RoutedEventArgs> => || *Expander::expanded_event(),
            ExpandingEvent: RoutedEvent<CancelRoutedEventArgs> => || *Expander::expanding_event(),
        ],
        attributes: [PseudoClasses(":expanded", ":up", ":down", ":left", ":right")],
    },
});

ferro_class_info!(Flyout {
    markup: {
        namespace: "FerroUI.Controls",
        content: Content,
        properties: [
            FlyoutPresenterClasses: Classes { get: Flyout::flyout_presenter_classes },
        ],
    },
});

ferro_class_info!(Grid {
    markup: {
        namespace: "FerroUI.Controls",
        properties: [
            ColumnDefinitions: ColumnDefinitions { get: Grid::column_definitions, set: Grid::set_column_definitions },
            RowDefinitions: RowDefinitions { get: Grid::row_definitions, set: Grid::set_row_definitions },
        ],
    },
});

ferro_class_info!(HyperlinkButton {
    markup: {
        namespace: "FerroUI.Controls",
        attributes: [PseudoClasses(":visited")],
    },
});

ferro_class_info!(Image {
    markup: {
        namespace: "FerroUI.Controls",
        content: Source,
    },
});

ferro_class_info!(ItemsControl {
    markup: {
        namespace: "FerroUI.Controls",
        content: Items,
        properties: [
            Items: ItemCollection { get: ItemsControl::items },
        ],
        property_attributes: [
            DisplayMemberBinding: [AssignBinding, InheritDataTypeFromItems("ItemsSource")],
            ItemTemplate: [InheritDataTypeFromItems("ItemsSource")],
        ],
        events: [
            PreparingContainer(Option<BoxedValue>, ContainerPreparedEventArgs) => |this: &Ref<ItemsControl>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.preparing_container(move |e: &ContainerPreparedEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            ContainerPrepared(Option<BoxedValue>, ContainerPreparedEventArgs) => |this: &Ref<ItemsControl>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.container_prepared(move |e: &ContainerPreparedEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            ContainerIndexChanged(Option<BoxedValue>, ContainerIndexChangedEventArgs) => |this: &Ref<ItemsControl>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.container_index_changed(move |e: &ContainerIndexChangedEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            ContainerClearing(Option<BoxedValue>, ContainerClearingEventArgs) => |this: &Ref<ItemsControl>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.container_clearing(move |e: &ContainerClearingEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
        ],
        attributes: [PseudoClasses(":empty", ":singleitem")],
    },
});

ferro_class_info!(Label {
    markup: {
        namespace: "FerroUI.Controls",
        property_attributes: [
            Target: [ResolveByName],
        ],
    },
});

ferro_class_info!(ListBoxItem {
    markup: {
        namespace: "FerroUI.Controls",
        attributes: [PseudoClasses(":pressed", ":selected")],
    },
});

ferro_class_info!(MenuBase {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            OpenedEvent: RoutedEvent<RoutedEventArgs> => || *MenuBase::opened_event(),
            ClosedEvent: RoutedEvent<RoutedEventArgs> => || *MenuBase::closed_event(),
        ],
    },
});

ferro_class_info!(MenuItem {
    markup: {
        namespace: "FerroUI.Controls",
        properties: [
            IsSelected: bool { get: MenuItem::is_selected, set: MenuItem::set_is_selected },
        ],
        fields: [
            ClickEvent: RoutedEvent<RoutedEventArgs> => || *MenuItem::click_event(),
            PointerEnteredItemEvent: RoutedEvent<RoutedEventArgs> => || *MenuItem::pointer_entered_item_event(),
            PointerExitedItemEvent: RoutedEvent<RoutedEventArgs> => || *MenuItem::pointer_exited_item_event(),
            SubmenuOpenedEvent: RoutedEvent<RoutedEventArgs> => || *MenuItem::submenu_opened_event(),
        ],
        attributes: [
            TemplatePart("PART_Popup", type(Ref<Popup>)),
            PseudoClasses(":separator", ":radio", ":toggle", ":checked", ":icon", ":open", ":pressed", ":selected"),
        ],
    },
});

ferro_class_info!(NativeMenu {
    markup: {
        namespace: "FerroUI.Controls",
        content: Items,
        properties: [
            Items: FerroList<Ref<NativeMenuItemBase>> { get: NativeMenu::items },
        ],
    },
});

ferro_class_info!(NativeMenuBar {
    markup: {
        namespace: "FerroUI.Controls",
        attributes: [TemplatePart("PART_NativeMenuPresenter", type(Ref<MenuBase>))],
    },
});

// The handler of `Click` takes the sender and empty event arguments in the managed original (`EventHandler`).
ferro_class_info!(NativeMenuItem {
    markup: {
        namespace: "FerroUI.Controls",
        content: Menu,
        constructors: [
            (String) => |header: String| NativeMenuItem::with_header(&header),
        ],
        events: [
            Click(Option<BoxedValue>, EventArgs) => |this: &Ref<NativeMenuItem>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.click(move |_item: &NativeMenuItem| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

ferro_class_info!(Page {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            PageNavigationSystemBackButtonPressedEvent: RoutedEvent<RoutedEventArgs> => || *Page::page_navigation_system_back_button_pressed_event(),
        ],
        events: [
            NavigatedTo(Option<BoxedValue>, NavigatedToEventArgs) => |this: &Ref<Page>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.navigated_to(move |e: &NavigatedToEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            NavigatedFrom(Option<BoxedValue>, NavigatedFromEventArgs) => |this: &Ref<Page>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.navigated_from(move |e: &NavigatedFromEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
        ],
    },
});

ferro_class_info!(Panel {
    markup: {
        namespace: "FerroUI.Controls",
        content: Children,
        properties: [
            Children: Controls { get: Panel::children },
        ],
    },
});

ferro_class_info!(RefreshContainer {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            RefreshRequestedEvent: RoutedEvent<RefreshRequestedEventArgs> => || *RefreshContainer::refresh_requested_event(),
        ],
    },
});

ferro_class_info!(RefreshVisualizer {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            RefreshRequestedEvent: RoutedEvent<RefreshRequestedEventArgs> => || *RefreshVisualizer::refresh_requested_event(),
        ],
    },
});

ferro_class_info!(RelativePanel {
    markup: {
        namespace: "FerroUI.Controls",
        property_attributes: [
            Above: [ResolveByName],
            AlignBottomWith: [ResolveByName],
            AlignHorizontalCenterWith: [ResolveByName],
            AlignLeftWith: [ResolveByName],
            AlignRightWith: [ResolveByName],
            AlignTopWith: [ResolveByName],
            AlignVerticalCenterWith: [ResolveByName],
            Below: [ResolveByName],
            LeftOf: [ResolveByName],
            RightOf: [ResolveByName],
        ],
        methods: [
            static fn GetAlignLeftWith(Ref<FerroObject>) -> Option<BoxedValue> =>
                |element: Ref<FerroObject>| element.get_value(RelativePanel::align_left_with_property()),
            static fn SetAlignLeftWith(Ref<FerroObject>, Option<BoxedValue>) =>
                |element: Ref<FerroObject>, value: Option<BoxedValue>| element.set_value(RelativePanel::align_left_with_property(), value),
            static fn GetAlignRightWithPanel(Ref<FerroObject>) -> bool =>
                |element: Ref<FerroObject>| element.get_value(RelativePanel::align_right_with_panel_property()),
            static fn SetAlignRightWithPanel(Ref<FerroObject>, bool) =>
                |element: Ref<FerroObject>, value: bool| element.set_value(RelativePanel::align_right_with_panel_property(), value),
            static fn GetAlignRightWith(Ref<FerroObject>) -> Option<BoxedValue> =>
                |element: Ref<FerroObject>| element.get_value(RelativePanel::align_right_with_property()),
            static fn SetAlignRightWith(Ref<FerroObject>, Option<BoxedValue>) =>
                |element: Ref<FerroObject>, value: Option<BoxedValue>| element.set_value(RelativePanel::align_right_with_property(), value),
            static fn GetAlignTopWithPanel(Ref<FerroObject>) -> bool =>
                |element: Ref<FerroObject>| element.get_value(RelativePanel::align_top_with_panel_property()),
            static fn SetAlignTopWithPanel(Ref<FerroObject>, bool) =>
                |element: Ref<FerroObject>, value: bool| element.set_value(RelativePanel::align_top_with_panel_property(), value),
            static fn GetAlignTopWith(Ref<FerroObject>) -> Option<BoxedValue> =>
                |element: Ref<FerroObject>| element.get_value(RelativePanel::align_top_with_property()),
            static fn SetAlignTopWith(Ref<FerroObject>, Option<BoxedValue>) =>
                |element: Ref<FerroObject>, value: Option<BoxedValue>| element.set_value(RelativePanel::align_top_with_property(), value),
            static fn GetAlignVerticalCenterWithPanel(Ref<FerroObject>) -> bool =>
                |element: Ref<FerroObject>| element.get_value(RelativePanel::align_vertical_center_with_panel_property()),
            static fn SetAlignVerticalCenterWithPanel(Ref<FerroObject>, bool) =>
                |element: Ref<FerroObject>, value: bool| element.set_value(RelativePanel::align_vertical_center_with_panel_property(), value),
            static fn GetAlignVerticalCenterWith(Ref<FerroObject>) -> Option<BoxedValue> =>
                |element: Ref<FerroObject>| element.get_value(RelativePanel::align_vertical_center_with_property()),
            static fn SetAlignVerticalCenterWith(Ref<FerroObject>, Option<BoxedValue>) =>
                |element: Ref<FerroObject>, value: Option<BoxedValue>| element.set_value(RelativePanel::align_vertical_center_with_property(), value),
            static fn GetBelow(Ref<FerroObject>) -> Option<BoxedValue> =>
                |element: Ref<FerroObject>| element.get_value(RelativePanel::below_property()),
            static fn SetBelow(Ref<FerroObject>, Option<BoxedValue>) =>
                |element: Ref<FerroObject>, value: Option<BoxedValue>| element.set_value(RelativePanel::below_property(), value),
            static fn GetLeftOf(Ref<FerroObject>) -> Option<BoxedValue> =>
                |element: Ref<FerroObject>| element.get_value(RelativePanel::left_of_property()),
            static fn SetLeftOf(Ref<FerroObject>, Option<BoxedValue>) =>
                |element: Ref<FerroObject>, value: Option<BoxedValue>| element.set_value(RelativePanel::left_of_property(), value),
            static fn GetRightOf(Ref<FerroObject>) -> Option<BoxedValue> =>
                |element: Ref<FerroObject>| element.get_value(RelativePanel::right_of_property()),
            static fn SetRightOf(Ref<FerroObject>, Option<BoxedValue>) =>
                |element: Ref<FerroObject>, value: Option<BoxedValue>| element.set_value(RelativePanel::right_of_property(), value),
        ],
    },
});

ferro_class_info!(RowDefinition {
    markup: {
        namespace: "FerroUI.Controls",
        constructors: [
            (f64, GridUnitType) => RowDefinition::with_value,
            (GridLength) => RowDefinition::with_height,
        ],
    },
});

ferro_class_info!(SelectingMultiPage {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            SelectionChangedEvent: RoutedEvent<PageSelectionChangedEventArgs> => || *SelectingMultiPage::selection_changed_event(),
        ],
    },
});

ferro_class_info!(Slider {
    markup: {
        namespace: "FerroUI.Controls",
        attributes: [
            TemplatePart("PART_DecreaseButton", type(Ref<Button>)),
            TemplatePart("PART_IncreaseButton", type(Ref<Button>)),
            TemplatePart("PART_Track", type(Ref<Track>)),
            PseudoClasses(":vertical", ":horizontal", ":pressed"),
        ],
    },
});

ferro_class_info!(Spinner {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            SpinEvent: RoutedEvent<SpinEventArgs> => || *Spinner::spin_event(),
        ],
    },
});

ferro_class_info!(SplitButton {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            ClickEvent: RoutedEvent<RoutedEventArgs> => || *SplitButton::click_event(),
        ],
        attributes: [
            TemplatePart("PART_PrimaryButton", type(Ref<Button>)),
            TemplatePart("PART_SecondaryButton", type(Ref<Button>)),
            PseudoClasses(":flyout-open", ":pressed"),
        ],
    },
});

ferro_class_info!(StackPanel {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            HorizontalSnapPointsChangedEvent: RoutedEvent<RoutedEventArgs> => || *StackPanel::horizontal_snap_points_changed_event(),
            VerticalSnapPointsChangedEvent: RoutedEvent<RoutedEventArgs> => || *StackPanel::vertical_snap_points_changed_event(),
        ],
    },
});

ferro_class_info!(TabControl {
    markup: {
        namespace: "FerroUI.Controls",
        attributes: [
            TemplatePart("PART_ItemsPresenter", type(Ref<ItemsPresenter>)),
            TemplatePart("PART_SelectedContentHost", type(Ref<ContentPresenter>)),
            TemplatePart("PART_SelectedContentHost2", type(Ref<ContentPresenter>)),
        ],
    },
});

ferro_class_info!(TabItem {
    markup: {
        namespace: "FerroUI.Controls",
        attributes: [PseudoClasses(":pressed", ":selected")],
    },
});

ferro_class_info!(TableView {
    markup: {
        namespace: "FerroUI.Controls",
        properties: [
            DisplayMemberBinding: Option<AssignedBinding> { get: TableView::display_member_binding, set: TableView::set_display_member_binding } [AssignBinding, InheritDataTypeFromItems("ItemsSource")],
            ItemTemplate: Option<Rc<dyn IDataTemplate>> { get: TableView::item_template, set: TableView::set_item_template } [InheritDataTypeFromItems("ItemsSource")],
        ],
    },
});

ferro_class_info!(TextBlock {
    markup: {
        namespace: "FerroUI.Controls",
        content: Inlines,
        properties: [
            LayoutRoundingPlacement: TextLayoutRoundingPlacement {
                get: |this: &Ref<TextBlock>| this.get_value(TextBlock::layout_rounding_placement_property()),
                set: |this: &Ref<TextBlock>, value: TextLayoutRoundingPlacement| {
                    this.set_value(TextBlock::layout_rounding_placement_property(), value)
                }
            },
            TextLineBounds: TextLineBounds {
                get: |this: &Ref<TextBlock>| this.get_value(TextBlock::text_line_bounds_property()),
                set: |this: &Ref<TextBlock>, value: TextLineBounds| {
                    this.set_value(TextBlock::text_line_bounds_property(), value)
                }
            },
            LineHeight: f64 {
                get: |this: &Ref<TextBlock>| this.get_value(TextBlock::line_height_property()),
                set: |this: &Ref<TextBlock>, value: f64| this.set_value(TextBlock::line_height_property(), value)
            },
            LineSpacing: f64 {
                get: |this: &Ref<TextBlock>| this.get_value(TextBlock::line_spacing_property()),
                set: |this: &Ref<TextBlock>, value: f64| this.set_value(TextBlock::line_spacing_property(), value)
            },
            MaxLines: i32 {
                get: |this: &Ref<TextBlock>| this.get_value(TextBlock::max_lines_property()),
                set: |this: &Ref<TextBlock>, value: i32| this.set_value(TextBlock::max_lines_property(), value)
            },
            TextWrapping: TextWrapping {
                get: |this: &Ref<TextBlock>| this.get_value(TextBlock::text_wrapping_property()),
                set: |this: &Ref<TextBlock>, value: TextWrapping| this.set_value(TextBlock::text_wrapping_property(), value)
            },
            TextTrimming: Rc<dyn TextTrimming> {
                get: |this: &Ref<TextBlock>| this.get_value(TextBlock::text_trimming_property()),
                set: |this: &Ref<TextBlock>, value: Rc<dyn TextTrimming>| this.set_value(TextBlock::text_trimming_property(), value)
            },
            TextAlignment: TextAlignment {
                get: |this: &Ref<TextBlock>| this.get_value(TextBlock::text_alignment_property()),
                set: |this: &Ref<TextBlock>, value: TextAlignment| this.set_value(TextBlock::text_alignment_property(), value)
            },
            BaselineOffset: f64 {
                get: |this: &Ref<TextBlock>| this.get_value(TextBlock::baseline_offset_property()),
                set: |this: &Ref<TextBlock>, value: f64| this.set_value(TextBlock::baseline_offset_property(), value)
            },
        ],
    },
});

ferro_class_info!(TextBox {
    markup: {
        namespace: "FerroUI.Controls",
        content: Text,
        properties: [
            SelectedText: String {
                get: TextBox::selected_text,
                set: |text_box: &Ref<TextBox>, value: String| text_box.set_selected_text(Some(&value))
            },
        ],
        methods: [
            fn ClearSelection() => TextBox::clear_selection,
            fn Cut() => TextBox::cut,
            fn Copy() => TextBox::copy,
            fn Paste() => TextBox::paste,
            fn Clear() => TextBox::clear,
            fn ScrollToLine(i32) => |text_box: &Ref<TextBox>, line_index: i32| text_box.scroll_to_line(line_index),
            fn SelectAll() => TextBox::select_all,
            fn Undo() => TextBox::undo,
            fn Redo() => TextBox::redo,
        ],
        fields: [
            CopyingToClipboardEvent: RoutedEvent<RoutedEventArgs> => || *TextBox::copying_to_clipboard_event(),
            CuttingToClipboardEvent: RoutedEvent<RoutedEventArgs> => || *TextBox::cutting_to_clipboard_event(),
            PastingFromClipboardEvent: RoutedEvent<RoutedEventArgs> => || *TextBox::pasting_from_clipboard_event(),
            TextChangedEvent: RoutedEvent<TextChangedEventArgs> => || *TextBox::text_changed_event(),
            TextChangingEvent: RoutedEvent<TextChangingEventArgs> => || *TextBox::text_changing_event(),
        ],
        static_properties: [
            CutGesture: Option<KeyGesture> { get: TextBox::cut_gesture },
            CopyGesture: Option<KeyGesture> { get: TextBox::copy_gesture },
            PasteGesture: Option<KeyGesture> { get: TextBox::paste_gesture },
        ],
        attributes: [
            TemplatePart("PART_TextPresenter", type(Ref<TextPresenter>), IsRequired = true),
            TemplatePart("PART_ScrollViewer", type(Ref<ScrollViewer>)),
            PseudoClasses(":empty"),
            PseudoClasses(":touch-mode"),
        ],
    },
});

ferro_class_info!(ToggleSplitButton {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            IsCheckedChangedEvent: RoutedEvent<RoutedEventArgs> => || *ToggleSplitButton::is_checked_changed_event(),
        ],
        attributes: [PseudoClasses(":checked")],
    },
});

ferro_class_info!(ToolTip {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            ToolTipOpeningEvent: RoutedEvent<CancelRoutedEventArgs> => || *ToolTip::tool_tip_opening_event(),
            ToolTipClosingEvent: RoutedEvent<RoutedEventArgs> => || *ToolTip::tool_tip_closing_event(),
        ],
        attributes: [PseudoClasses(":open")],
    },
});

// `StorageProvider` is a read-only property of the managed original: markup reads it
// (`{Binding $parent[TopLevel].StorageProvider}`), and the generator declares a read-only property only for a
// collection.
ferro_class_info!(TopLevel {
    markup: {
        namespace: "FerroUI.Controls",
        properties: [
            StorageProvider: Rc<dyn ferroui_base::platform::storage::IStorageProvider> {
                get: |this: &Ref<TopLevel>| this.storage_provider()
            },
        ],
        fields: [
            BackRequestedEvent: RoutedEvent<RoutedEventArgs> => || *TopLevel::back_requested_event(),
        ],
        events: [
            Opened(Option<BoxedValue>, EventArgs) => |this: &Ref<TopLevel>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.opened(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
            Closed(Option<BoxedValue>, EventArgs) => |this: &Ref<TopLevel>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.closed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
            ScalingChanged(Option<BoxedValue>, EventArgs) => |this: &Ref<TopLevel>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.scaling_changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
        attributes: [
            TemplatePart("PART_TransparencyFallback", type(Ref<Border>)),
            TemplatePart("PART_VisualLayerManager", type(Ref<VisualLayerManager>)),
        ],
    },
});

ferro_class_info!(TransitioningContentControl {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            TransitionCompletedEvent: RoutedEvent<TransitionCompletedEventArgs> => || *TransitioningContentControl::transition_completed_event(),
        ],
    },
});

ferro_class_info!(TreeViewItem {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            ExpandedEvent: RoutedEvent<RoutedEventArgs> => || *TreeViewItem::expanded_event(),
            CollapsedEvent: RoutedEvent<RoutedEventArgs> => || *TreeViewItem::collapsed_event(),
        ],
        attributes: [TemplatePart("PART_Header", type(Ref<Control>)), PseudoClasses(":pressed", ":selected")],
    },
});

ferro_class_info!(Viewbox {
    markup: {
        namespace: "FerroUI.Controls",
        content: Child,
    },
});

ferro_class_info!(VirtualizingStackPanel {
    markup: {
        namespace: "FerroUI.Controls",
        fields: [
            HorizontalSnapPointsChangedEvent: RoutedEvent<RoutedEventArgs> => || *VirtualizingStackPanel::horizontal_snap_points_changed_event(),
            VerticalSnapPointsChangedEvent: RoutedEvent<RoutedEventArgs> => || *VirtualizingStackPanel::vertical_snap_points_changed_event(),
        ],
    },
});

ferro_class_info!(Window {
    markup: {
        namespace: "FerroUI.Controls",
        properties: [
            SystemDecorations: WindowDecorations { get: Window::system_decorations, set: Window::set_system_decorations } [Obsolete("Use WindowDecorations instead.")],
            Position: PixelPoint { get: Window::position, set: Window::set_position },
        ],
        methods: [
            fn Close() => |window: &Ref<Window>| window.close(),
        ],
        fields: [
            WindowClosedEvent: RoutedEvent<RoutedEventArgs> => || *Window::window_closed_event(),
            WindowOpenedEvent: RoutedEvent<RoutedEventArgs> => || *Window::window_opened_event(),
        ],
        events: [
            Closing(Option<BoxedValue>, WindowClosingEventArgs) => |this: &Ref<Window>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.closing(move |e: &WindowClosingEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
        ],
    },
});

ferro_class_info!(WindowBase {
    markup: {
        namespace: "FerroUI.Controls",
        methods: [
            fn Activate() => |window: &Ref<WindowBase>| window.activate(),
            fn Hide() => |window: &Ref<WindowBase>| window.hide(),
            fn Show() => |window: &Ref<WindowBase>| window.show(),
        ],
        events: [
            Activated(Option<BoxedValue>, EventArgs) => |this: &Ref<WindowBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.activated(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
            Deactivated(Option<BoxedValue>, EventArgs) => |this: &Ref<WindowBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.deactivated(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
            PositionChanged(Option<BoxedValue>, PixelPointEventArgs) => |this: &Ref<WindowBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.position_changed(move |e: &PixelPointEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            Resized(Option<BoxedValue>, WindowResizedEventArgs) => |this: &Ref<WindowBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.resized(move |e: &WindowResizedEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
        ],
    },
});

// FerroUI.Controls.Automation.Peers

ferro_class_info!(EmbeddableControlRootAutomationPeer {
    markup: {
        namespace: "FerroUI.Controls.Automation.Peers",
        events: [
            FocusChanged(Option<BoxedValue>, EventArgs) => |this: &Ref<EmbeddableControlRootAutomationPeer>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.focus_changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

// FerroUI.Controls.Chrome

ferro_class_info!(WindowDrawnDecorations {
    markup: {
        namespace: "FerroUI.Controls.Chrome",
        properties: [
            TitleBarDecorations: TitleBarDecorations {
                get: |this: &Ref<WindowDrawnDecorations>| this.get_value(WindowDrawnDecorations::title_bar_decorations_property()),
                set: |this: &Ref<WindowDrawnDecorations>, value: TitleBarDecorations| this.set_value(WindowDrawnDecorations::title_bar_decorations_property(), value)
            },
        ],
        attributes: [
            TemplatePart("PART_CloseButton", type(Ref<Button>)),
            TemplatePart("PART_MinimizeButton", type(Ref<Button>)),
            TemplatePart("PART_MaximizeButton", type(Ref<Button>)),
            TemplatePart("PART_FullScreenButton", type(Ref<Button>)),
            TemplatePart("PART_PopoverCloseButton", type(Ref<Button>)),
            TemplatePart("PART_PopoverFullScreenButton", type(Ref<Button>)),
            TemplatePart("PART_TitleBar", type(Ref<Panel>)),
        ],
    },
});

ferro_class_info!(WindowDrawnDecorationsContent {
    markup: {
        namespace: "FerroUI.Controls.Chrome",
        properties: [
            Overlay: Option<Ref<Control>> {
                get: WindowDrawnDecorationsContent::overlay,
                set: |content: &Ref<WindowDrawnDecorationsContent>, value: Option<Ref<Control>>| content.set_overlay(value)
            },
            Underlay: Option<Ref<Control>> {
                get: WindowDrawnDecorationsContent::underlay,
                set: |content: &Ref<WindowDrawnDecorationsContent>, value: Option<Ref<Control>>| content.set_underlay(value)
            },
            FullscreenPopover: Option<Ref<Control>> {
                get: WindowDrawnDecorationsContent::fullscreen_popover,
                set: |content: &Ref<WindowDrawnDecorationsContent>, value: Option<Ref<Control>>| {
                    content.set_fullscreen_popover(value)
                }
            },
        ],
    },
});

// FerroUI.Controls.Documents

ferro_class_info!(Inline {
    markup: {
        namespace: "FerroUI.Controls.Documents",
        properties: [
            TextDecorations: Option<TextDecorationCollection> {
                get: |this: &Ref<Inline>| this.get_value(Inline::text_decorations_property()),
                set: |this: &Ref<Inline>, value: Option<TextDecorationCollection>| this.set_value(Inline::text_decorations_property(), value)
            },
        ],
        methods: [
            static fn GetTextDecorations(Ref<Control>) -> Option<TextDecorationCollection> =>
                |element: Ref<Control>| element.get_value(Inline::text_decorations_property()),
            static fn SetTextDecorations(Ref<Control>, Option<TextDecorationCollection>) =>
                |element: Ref<Control>, value: Option<TextDecorationCollection>| element.set_value(Inline::text_decorations_property(), value),
        ],
    },
});

ferro_class_info!(InlineUIContainer {
    markup: {
        namespace: "FerroUI.Controls.Documents",
        content: Child,
        constructors: [
            (Ref<Control>) => |child: Ref<Control>| InlineUIContainer::with_child(child),
        ],
    },
});

ferro_class_info!(LineBreak {
    markup: {
        namespace: "FerroUI.Controls.Documents",
        attributes: [TrimSurroundingWhitespace],
    },
});

ferro_class_info!(Run {
    markup: {
        namespace: "FerroUI.Controls.Documents",
        content: Text,
        constructors: [
            (Option<String>) => |text: Option<String>| Run::with_text(text.as_deref()),
        ],
    },
});

ferro_class_info!(Span {
    markup: {
        namespace: "FerroUI.Controls.Documents",
        content: Inlines,
    },
});

ferro_class_info!(TextElement {
    markup: {
        namespace: "FerroUI.Controls.Documents",
        properties: [
            FontFamily: FontFamily {
                get: |this: &Ref<TextElement>| this.get_value(TextElement::font_family_property()),
                set: |this: &Ref<TextElement>, value: FontFamily| this.set_value(TextElement::font_family_property(), value)
            },
            FontFeatures: Option<FontFeatureCollection> {
                get: |this: &Ref<TextElement>| this.get_value(TextElement::font_features_property()),
                set: |this: &Ref<TextElement>, value: Option<FontFeatureCollection>| this.set_value(TextElement::font_features_property(), value)
            },
            FontSize: f64 {
                get: |this: &Ref<TextElement>| this.get_value(TextElement::font_size_property()),
                set: |this: &Ref<TextElement>, value: f64| this.set_value(TextElement::font_size_property(), value)
            },
            FontStyle: FontStyle {
                get: |this: &Ref<TextElement>| this.get_value(TextElement::font_style_property()),
                set: |this: &Ref<TextElement>, value: FontStyle| this.set_value(TextElement::font_style_property(), value)
            },
            FontWeight: FontWeight {
                get: |this: &Ref<TextElement>| this.get_value(TextElement::font_weight_property()),
                set: |this: &Ref<TextElement>, value: FontWeight| this.set_value(TextElement::font_weight_property(), value)
            },
            FontStretch: FontStretch {
                get: |this: &Ref<TextElement>| this.get_value(TextElement::font_stretch_property()),
                set: |this: &Ref<TextElement>, value: FontStretch| this.set_value(TextElement::font_stretch_property(), value)
            },
            Foreground: Option<Rc<dyn IBrush>> {
                get: |this: &Ref<TextElement>| this.get_value(TextElement::foreground_property()),
                set: |this: &Ref<TextElement>, value: Option<Rc<dyn IBrush>>| this.set_value(TextElement::foreground_property(), value)
            },
            LetterSpacing: f64 {
                get: |this: &Ref<TextElement>| this.get_value(TextElement::letter_spacing_property()),
                set: |this: &Ref<TextElement>, value: f64| this.set_value(TextElement::letter_spacing_property(), value)
            },
        ],
        methods: [
            fn FindName(String) -> Option<Ref<FerroObject>> =>
                |element: &Ref<TextElement>, name: String| element.find_name(&name),
            static fn GetFontFamily(Ref<Control>) -> FontFamily =>
                |element: Ref<Control>| element.get_value(TextElement::font_family_property()),
            static fn SetFontFamily(Ref<Control>, FontFamily) =>
                |element: Ref<Control>, value: FontFamily| element.set_value(TextElement::font_family_property(), value),
            static fn GetFontFeatures(Ref<Control>) -> Option<FontFeatureCollection> =>
                |element: Ref<Control>| element.get_value(TextElement::font_features_property()),
            static fn SetFontFeatures(Ref<Control>, Option<FontFeatureCollection>) =>
                |element: Ref<Control>, value: Option<FontFeatureCollection>| element.set_value(TextElement::font_features_property(), value),
            static fn GetFontSize(Ref<Control>) -> f64 =>
                |element: Ref<Control>| element.get_value(TextElement::font_size_property()),
            static fn SetFontSize(Ref<Control>, f64) =>
                |element: Ref<Control>, value: f64| element.set_value(TextElement::font_size_property(), value),
            static fn GetFontStyle(Ref<Control>) -> FontStyle =>
                |element: Ref<Control>| element.get_value(TextElement::font_style_property()),
            static fn SetFontStyle(Ref<Control>, FontStyle) =>
                |element: Ref<Control>, value: FontStyle| element.set_value(TextElement::font_style_property(), value),
            static fn GetFontWeight(Ref<Control>) -> FontWeight =>
                |element: Ref<Control>| element.get_value(TextElement::font_weight_property()),
            static fn SetFontWeight(Ref<Control>, FontWeight) =>
                |element: Ref<Control>, value: FontWeight| element.set_value(TextElement::font_weight_property(), value),
            static fn GetFontStretch(Ref<Control>) -> FontStretch =>
                |element: Ref<Control>| element.get_value(TextElement::font_stretch_property()),
            static fn SetFontStretch(Ref<Control>, FontStretch) =>
                |element: Ref<Control>, value: FontStretch| element.set_value(TextElement::font_stretch_property(), value),
            static fn GetForeground(Ref<Control>) -> Option<Rc<dyn IBrush>> =>
                |element: Ref<Control>| element.get_value(TextElement::foreground_property()),
            static fn SetForeground(Ref<Control>, Option<Rc<dyn IBrush>>) =>
                |element: Ref<Control>, value: Option<Rc<dyn IBrush>>| element.set_value(TextElement::foreground_property(), value),
        ],
    },
});

// FerroUI.Controls.Presenters

ferro_class_info!(ContentPresenter {
    markup: {
        namespace: "FerroUI.Controls.Presenters",
        content: Content,
        property_attributes: [
            Content: [DependsOn("ContentTemplate")],
        ],
        attributes: [PseudoClasses(":empty")],
    },
});

ferro_class_info!(TextPresenter {
    markup: {
        namespace: "FerroUI.Controls.Presenters",
        content: Text,
        properties: [
            FontFamily: FontFamily { get: TextPresenter::font_family, set: TextPresenter::set_font_family },
            FontFeatures: Option<FontFeatureCollection> { get: TextPresenter::font_features, set: TextPresenter::set_font_features },
            FontSize: f64 { get: TextPresenter::font_size, set: TextPresenter::set_font_size },
            FontStyle: FontStyle { get: TextPresenter::font_style, set: TextPresenter::set_font_style },
            FontWeight: FontWeight { get: TextPresenter::font_weight, set: TextPresenter::set_font_weight },
            FontStretch: FontStretch { get: TextPresenter::font_stretch, set: TextPresenter::set_font_stretch },
            Foreground: Option<Rc<dyn IBrush>> { get: TextPresenter::foreground, set: TextPresenter::set_foreground },
        ],
        events: [
            CaretBoundsChanged(Option<BoxedValue>, EventArgs) => |this: &Ref<TextPresenter>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.caret_bounds_changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

// FerroUI.Controls.Primitives

ferro_class_info!(FlyoutBase {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        events: [
            Opened(Option<BoxedValue>, EventArgs) => |this: &Ref<FlyoutBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.opened(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
            Closed(Option<BoxedValue>, EventArgs) => |this: &Ref<FlyoutBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.closed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

ferro_class_info!(HeaderedContentControl {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        attributes: [TemplatePart("PART_HeaderPresenter", type(Ref<ContentPresenter>))],
    },
});

ferro_class_info!(HeaderedItemsControl {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        attributes: [TemplatePart("PART_HeaderPresenter", type(Ref<ContentPresenter>))],
    },
});

ferro_class_info!(PickerPresenterBase {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        events: [
            Confirmed(Option<BoxedValue>, EventArgs) => |this: &Ref<PickerPresenterBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.confirmed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
            Dismissed(Option<BoxedValue>, EventArgs) => |this: &Ref<PickerPresenterBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.dismissed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

ferro_class_info!(Popup {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        content: Child,
        properties: [
            DependencyResolver: Option<Rc<dyn IFerroDependencyResolver>> { set: Popup::set_dependency_resolver },
            TakesFocusFromNativeControl: bool {
                get: |this: &Ref<Popup>| this.get_value(Popup::takes_focus_from_native_control_property()),
                set: |this: &Ref<Popup>, value: bool| this.set_value(Popup::takes_focus_from_native_control_property(), value)
            },
        ],
        property_attributes: [
            PlacementTarget: [ResolveByName],
        ],
        events: [
            Closed(Option<BoxedValue>, EventArgs) => |this: &Ref<Popup>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.closed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
            Opened(Option<BoxedValue>, EventArgs) => |this: &Ref<Popup>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.opened(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

ferro_class_info!(PopupFlyoutBase {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        events: [
            Closing(Option<BoxedValue>, CancelEventArgs) => |this: &Ref<PopupFlyoutBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.closing(move |e: &CancelEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            Opening(Option<BoxedValue>, EventArgs) => |this: &Ref<PopupFlyoutBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.opening(move |e: &CancelEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
        ],
    },
});

ferro_class_info!(RangeBase {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        fields: [
            ValueChangedEvent: RoutedEvent<RangeBaseValueChangedEventArgs> => || *RangeBase::value_changed_event(),
        ],
    },
});

ferro_class_info!(SelectingItemsControl {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        property_attributes: [
            SelectedValueBinding: [AssignBinding, InheritDataTypeFromItems("ItemsSource")],
        ],
        fields: [
            IsSelectedChangedEvent: RoutedEvent<RoutedEventArgs> => || *SelectingItemsControl::is_selected_changed_event(),
            SelectionChangedEvent: RoutedEvent<SelectionChangedEventArgs> => || *SelectingItemsControl::selection_changed_event(),
        ],
    },
});

ferro_class_info!(TemplatedControl {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        fields: [
            TemplateAppliedEvent: RoutedEvent<TemplateAppliedEventArgs> => || *TemplatedControl::template_applied_event(),
        ],
    },
});

ferro_class_info!(Thumb {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        fields: [
            DragStartedEvent: RoutedEvent<VectorEventArgs> => || *Thumb::drag_started_event(),
            DragDeltaEvent: RoutedEvent<VectorEventArgs> => || *Thumb::drag_delta_event(),
            DragCompletedEvent: RoutedEvent<VectorEventArgs> => || *Thumb::drag_completed_event(),
        ],
        attributes: [PseudoClasses(":pressed")],
    },
});

ferro_class_info!(ToggleButton {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        fields: [
            IsCheckedChangedEvent: RoutedEvent<RoutedEventArgs> => || *ToggleButton::is_checked_changed_event(),
        ],
        attributes: [PseudoClasses(":checked", ":unchecked", ":indeterminate")],
    },
});

ferro_class_info!(Track {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        content: Thumb,
        attributes: [PseudoClasses(":vertical", ":horizontal")],
    },
});

ferro_class_info!(VisualLayerManager {
    markup: {
        namespace: "FerroUI.Controls.Primitives",
        properties: [
            EnableAdornerLayer: bool { get: VisualLayerManager::enable_adorner_layer, set: VisualLayerManager::set_enable_adorner_layer },
            EnableOverlayLayer: bool { get: VisualLayerManager::enable_overlay_layer, set: VisualLayerManager::set_enable_overlay_layer },
            EnableTextSelectorLayer: bool { get: VisualLayerManager::enable_text_selector_layer, set: VisualLayerManager::set_enable_text_selector_layer },
        ],
    },
});

// FerroUI.Controls.PullToRefresh

ferro_class_info!(RefreshInfoProvider {
    markup: {
        namespace: "FerroUI.Controls.PullToRefresh",
        fields: [
            RefreshStartedEvent: RoutedEvent<RoutedEventArgs> => || *RefreshInfoProvider::refresh_started_event(),
            RefreshCompletedEvent: RoutedEvent<RoutedEventArgs> => || *RefreshInfoProvider::refresh_completed_event(),
        ],
    },
});

ferro_class_info!(ScrollablePullGestureRecognizer {
    markup: {
        namespace: "FerroUI.Controls.PullToRefresh",
        properties: [
            IsMouseEnabled: bool { get: ScrollablePullGestureRecognizer::is_mouse_enabled, set: ScrollablePullGestureRecognizer::set_is_mouse_enabled },
        ],
    },
});

// FerroUI.Interactivity

/// Carries the metadata of `RoutedEvent<TEventArgs>` for the arguments of this crate.
pub(crate) struct RoutedEventOf<TEventArgs>(std::marker::PhantomData<TEventArgs>);

ferro_markup_type!(class RoutedEventOf<CancelRoutedEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<CancelRoutedEventArgs>, Option<RoutedEvent<CancelRoutedEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [CancelRoutedEventArgs],
});

ferro_markup_type!(class RoutedEventOf<PageSelectionChangedEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<PageSelectionChangedEventArgs>, Option<RoutedEvent<PageSelectionChangedEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [PageSelectionChangedEventArgs],
});

ferro_markup_type!(class RoutedEventOf<RangeBaseValueChangedEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<RangeBaseValueChangedEventArgs>, Option<RoutedEvent<RangeBaseValueChangedEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [RangeBaseValueChangedEventArgs],
});

ferro_markup_type!(class RoutedEventOf<RefreshRequestedEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<RefreshRequestedEventArgs>, Option<RoutedEvent<RefreshRequestedEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [RefreshRequestedEventArgs],
});

ferro_markup_type!(class RoutedEventOf<RequestBringIntoViewEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<RequestBringIntoViewEventArgs>, Option<RoutedEvent<RequestBringIntoViewEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [RequestBringIntoViewEventArgs],
});

ferro_markup_type!(class RoutedEventOf<SelectionChangedEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<SelectionChangedEventArgs>, Option<RoutedEvent<SelectionChangedEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [SelectionChangedEventArgs],
});

ferro_markup_type!(class RoutedEventOf<SizeChangedEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<SizeChangedEventArgs>, Option<RoutedEvent<SizeChangedEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [SizeChangedEventArgs],
});

ferro_markup_type!(class RoutedEventOf<SpinEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<SpinEventArgs>, Option<RoutedEvent<SpinEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [SpinEventArgs],
});

ferro_markup_type!(class RoutedEventOf<TemplateAppliedEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<TemplateAppliedEventArgs>, Option<RoutedEvent<TemplateAppliedEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [TemplateAppliedEventArgs],
});

ferro_markup_type!(class RoutedEventOf<TextChangedEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<TextChangedEventArgs>, Option<RoutedEvent<TextChangedEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [TextChangedEventArgs],
});

ferro_markup_type!(class RoutedEventOf<TextChangingEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<TextChangingEventArgs>, Option<RoutedEvent<TextChangingEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [TextChangingEventArgs],
});

ferro_markup_type!(class RoutedEventOf<TransitionCompletedEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<TransitionCompletedEventArgs>, Option<RoutedEvent<TransitionCompletedEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [TransitionCompletedEventArgs],
});

ferro_markup_type!(class RoutedEventOf<VectorEventArgs> as "RoutedEvent`1" {
    namespace: "FerroUI.Interactivity",
    handles: [RoutedEvent<VectorEventArgs>, Option<RoutedEvent<VectorEventArgs>>],
    base: RoutedEvent,
    generic: "RoutedEvent`1" [VectorEventArgs],
});

// The typed arguments of routed events.

/// The arguments of a routed event as the typed arguments `T`.
fn typed_event_args<T: 'static, R>(e: &Rc<dyn IRoutedEventArgs>, f: impl FnOnce(&T) -> R) -> Result<R, String> {
    match e.query_args(std::any::TypeId::of::<T>()).and_then(|args| args.downcast_ref::<T>()) {
        Some(args) => Ok(f(args)),
        None => Err(format!("The arguments are not {}.", std::any::type_name::<T>())),
    }
}

ferro_markup_type!(class PageSelectionChangedEventArgs {
    namespace: "FerroUI.Controls",
    handles: [PageSelectionChangedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        PreviousPage: Option<Ref<Page>> {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PageSelectionChangedEventArgs, _>(e, |e| e.previous_page())
        },
        CurrentPage: Option<Ref<Page>> {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PageSelectionChangedEventArgs, _>(e, |e| e.current_page())
        },
    ],
});

ferro_markup_type!(class RangeBaseValueChangedEventArgs {
    namespace: "FerroUI.Controls.Primitives",
    handles: [RangeBaseValueChangedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        OldValue: f64 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<RangeBaseValueChangedEventArgs, _>(e, |e| e.old_value())
        },
        NewValue: f64 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<RangeBaseValueChangedEventArgs, _>(e, |e| e.new_value())
        },
    ],
});

ferro_markup_type!(class RefreshRequestedEventArgs {
    namespace: "FerroUI.Controls",
    handles: [RefreshRequestedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
});

ferro_markup_type!(class RequestBringIntoViewEventArgs {
    namespace: "FerroUI.Controls",
    handles: [RequestBringIntoViewEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        TargetRect: Rect {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<RequestBringIntoViewEventArgs, _>(e, |e| e.target_rect()),
            try_set: |e: &Rc<dyn IRoutedEventArgs>, value: Rect| typed_event_args::<RequestBringIntoViewEventArgs, _>(e, |e| e.set_target_rect(value))
        },
    ],
});

ferro_markup_type!(class SelectionChangedEventArgs {
    namespace: "FerroUI.Controls",
    handles: [SelectionChangedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
});

ferro_markup_type!(class SizeChangedEventArgs {
    namespace: "FerroUI.Controls",
    handles: [SizeChangedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        HeightChanged: bool {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SizeChangedEventArgs, _>(e, |e| e.height_changed())
        },
        NewSize: Size {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SizeChangedEventArgs, _>(e, |e| e.new_size())
        },
        PreviousSize: Size {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SizeChangedEventArgs, _>(e, |e| e.previous_size())
        },
        WidthChanged: bool {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SizeChangedEventArgs, _>(e, |e| e.width_changed())
        },
    ],
});

ferro_markup_type!(class SpinEventArgs {
    namespace: "FerroUI.Controls",
    handles: [SpinEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        UsingMouseWheel: bool {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SpinEventArgs, _>(e, |e| e.using_mouse_wheel())
        },
    ],
});

ferro_markup_type!(class TemplateAppliedEventArgs {
    namespace: "FerroUI.Controls.Primitives",
    handles: [TemplateAppliedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
});

ferro_markup_type!(class TextChangedEventArgs {
    namespace: "FerroUI.Controls",
    handles: [TextChangedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
});

ferro_markup_type!(class TextChangingEventArgs {
    namespace: "FerroUI.Controls",
    handles: [TextChangingEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
});

ferro_markup_type!(class TransitionCompletedEventArgs {
    namespace: "FerroUI.Controls",
    handles: [TransitionCompletedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        HasRunToCompletion: bool {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<TransitionCompletedEventArgs, _>(e, |e| e.has_run_to_completion())
        },
    ],
});

/// Registers the casts of the typed routed events declared in this file to the
/// untyped routed event, with the untyped value conversions of the current thread.
pub(super) fn register_value_types() {
    ValueTypes::register_cast::<RoutedEvent<CancelRoutedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PageSelectionChangedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<RangeBaseValueChangedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<RefreshRequestedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<RequestBringIntoViewEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<SelectionChangedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<SizeChangedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<SpinEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<TemplateAppliedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<TextChangedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<TextChangingEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<TransitionCompletedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<VectorEventArgs>, RoutedEvent>(|event| event.as_routed_event());
}

/// The types declared in this file that are not classes: the types that own static
/// members only and the typed routed events. (The metadata of a class is reached
/// from its runtime type and needs no registration.)
pub(super) const TYPES: &[&MarkupType] = &[
    <Design as MarkupTyped>::MARKUP,
    <RoutedEventOf<CancelRoutedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<PageSelectionChangedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<RangeBaseValueChangedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<RefreshRequestedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<RequestBringIntoViewEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<SelectionChangedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<SizeChangedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<SpinEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<TemplateAppliedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<TextChangedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<TextChangingEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<TransitionCompletedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEventOf<VectorEventArgs> as MarkupTyped>::MARKUP,
    <PageSelectionChangedEventArgs as MarkupTyped>::MARKUP,
    <RangeBaseValueChangedEventArgs as MarkupTyped>::MARKUP,
    <RefreshRequestedEventArgs as MarkupTyped>::MARKUP,
    <RequestBringIntoViewEventArgs as MarkupTyped>::MARKUP,
    <SelectionChangedEventArgs as MarkupTyped>::MARKUP,
    <SizeChangedEventArgs as MarkupTyped>::MARKUP,
    <SpinEventArgs as MarkupTyped>::MARKUP,
    <TemplateAppliedEventArgs as MarkupTyped>::MARKUP,
    <TextChangedEventArgs as MarkupTyped>::MARKUP,
    <TextChangingEventArgs as MarkupTyped>::MARKUP,
    <TransitionCompletedEventArgs as MarkupTyped>::MARKUP,
];