ferroui-base 0.3.0

// @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 super::plain::{new_resource_key, property_value};
use crate::animation::*;
use crate::collections::*;
use crate::controls::*;
use crate::data::core::ValueTypes;
use crate::data::{BindingBase, BindingExpressionBase, BindingPriority};
use crate::input::gesture_recognizers::*;
use crate::input::text_input::*;
use crate::input::*;
use crate::interactivity::*;
use crate::layout::*;
use crate::logical_tree::*;
use crate::media::effects::*;
use crate::media::imaging::*;
use crate::media::*;
use crate::ferro_class_info;
use crate::metadata::{into_markup_value, MarkupDelegate, MarkupType};
use crate::reactive::IDisposable;
use crate::styling::*;
use crate::utilities::EventArgs;
use crate::*;
use std::rc::Rc;
use crate::ferro_markup_type;
use crate::metadata::MarkupTyped;

// FerroUI

ferro_class_info!(FerroObject {
    markup: {
        namespace: "FerroUI",
        methods: [
            fn Bind(&'static FerroProperty, Rc<dyn BindingBase>) -> Rc<dyn BindingExpressionBase> =>
                |this: &Ref<FerroObject>, property: &'static FerroProperty, binding: Rc<dyn BindingBase>| {
                    this.bind_binding(property, &*binding)
                },
            try fn SetValue(&'static FerroProperty, Option<BoxedValue>, BindingPriority) -> Option<Rc<dyn IDisposable>> =>
                |this: &Ref<FerroObject>, property: &'static FerroProperty, value: Option<BoxedValue>, priority: BindingPriority| {
                    // The value is set as a value of the type of the property.
                    property_value(property, value).map(|value| this.set_value_untyped(property, value.as_any(), priority))
                },
        ],
        events: [
            // The arguments borrow the values of the change: the handler receives them held by value.
            PropertyChanged(Option<BoxedValue>, OwnedFerroPropertyChangedEventArgs) => |this: &Ref<FerroObject>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.property_changed(move |e: &FerroPropertyChangedEventArgs<'_>| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.to_owned_args())]);
                })
            },
        ],
    },
});

ferro_class_info!(StyledElement {
    markup: {
        namespace: "FerroUI",
        properties: [
            Classes: Classes { get: StyledElement::classes },
            Styles: Ref<Styles> { get: StyledElement::styles },
            Resources: Rc<dyn IResourceDictionary> {
                get: |this: &Ref<StyledElement>| -> Rc<dyn IResourceDictionary> { this.resources().into() },
                try_set: |this: &Ref<StyledElement>, 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."),
                    }
                }
            },
        ],
        events: [
            AttachedToLogicalTree(Option<BoxedValue>, LogicalTreeAttachmentEventArgs) => |this: &Ref<StyledElement>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.attached_to_logical_tree(move |e: &LogicalTreeAttachmentEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            DetachedFromLogicalTree(Option<BoxedValue>, LogicalTreeAttachmentEventArgs) => |this: &Ref<StyledElement>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.detached_from_logical_tree(move |e: &LogicalTreeAttachmentEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            DataContextChanged(Option<BoxedValue>, EventArgs) => |this: &Ref<StyledElement>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.data_context_changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
            Initialized(Option<BoxedValue>, EventArgs) => |this: &Ref<StyledElement>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.initialized(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
            ResourcesChanged(Option<BoxedValue>, ResourcesChangedEventArgs) => |this: &Ref<StyledElement>, 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<StyledElement>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.actual_theme_variant_changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

ferro_class_info!(Visual {
    markup: {
        namespace: "FerroUI",
        properties: [
            FlowDirection: FlowDirection {
                get: |this: &Ref<Visual>| this.get_value(Visual::flow_direction_property()),
                set: |this: &Ref<Visual>, value: FlowDirection| this.set_value(Visual::flow_direction_property(), value)
            },
        ],
        events: [
            AttachedToVisualTree(Option<BoxedValue>, VisualTreeAttachmentEventArgs) => |this: &Ref<Visual>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.attached_to_visual_tree(move |e: &VisualTreeAttachmentEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            DetachedFromVisualTree(Option<BoxedValue>, VisualTreeAttachmentEventArgs) => |this: &Ref<Visual>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.detached_from_visual_tree(move |e: &VisualTreeAttachmentEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
        ],
        attributes: [UsableDuringInitialization],
    },
});

// FerroUI.Animation

ferro_class_info!(Animation {
    markup: {
        namespace: "FerroUI.Animation",
        content: Children,
        properties: [
            Children: KeyFrames { get: Animation::children },
        ],
        methods: [
            static fn SetAnimator(Rc<dyn IAnimationSetter>, Rc<dyn ICustomAnimator>) =>
            |setter: Rc<dyn IAnimationSetter>, value: Rc<dyn ICustomAnimator>| Animation::set_animator(&setter, value),
        ],
    },
});

ferro_class_info!(AnimatorKeyFrame {
    markup: {
        namespace: "FerroUI.Animation",
        properties: [
            FillBefore: bool { get: AnimatorKeyFrame::fill_before, set: AnimatorKeyFrame::set_fill_before },
            FillAfter: bool { get: AnimatorKeyFrame::fill_after, set: AnimatorKeyFrame::set_fill_after },
        ],
    },
});

ferro_class_info!(KeyFrame {
    markup: {
        namespace: "FerroUI.Animation",
        content: Setters,
        properties: [
            Setters: FerroList<Rc<dyn IAnimationSetter>> { get: KeyFrame::setters },
            KeyTime: TimeSpan { get: KeyFrame::key_time, set: KeyFrame::set_key_time },
            Cue: Cue { get: KeyFrame::cue, set: KeyFrame::set_cue },
            KeySpline: Option<Ref<KeySpline>> { get: KeyFrame::key_spline, set: KeyFrame::set_key_spline },
        ],
    },
});

ferro_class_info!(KeySpline {
    markup: {
        namespace: "FerroUI.Animation",
        parse: KeySpline::parse,
        constructors: [
            (f64, f64, f64, f64) => KeySpline::with_points,
        ],
        properties: [
            ControlPointX1: f64 { get: KeySpline::control_point_x1, set: KeySpline::set_control_point_x1 },
            ControlPointY1: f64 { get: KeySpline::control_point_y1, set: KeySpline::set_control_point_y1 },
            ControlPointX2: f64 { get: KeySpline::control_point_x2, set: KeySpline::set_control_point_x2 },
            ControlPointY2: f64 { get: KeySpline::control_point_y2, set: KeySpline::set_control_point_y2 },
        ],
    },
});

// FerroUI.Controls

ferro_markup_type!(static NameScope {
    namespace: "FerroUI.Controls",
    type_info: NameScope,
    methods: [
        static fn GetNameScope(Ref<StyledElement>) -> Option<NameScopeRef> =>
            |styled: Ref<StyledElement>| NameScope::get_name_scope(&styled),
        static fn SetNameScope(Ref<StyledElement>, Option<NameScopeRef>) =>
            |styled: Ref<StyledElement>, scope: Option<NameScopeRef>| NameScope::set_name_scope(&styled, scope),
    ],
});

// The key of a resource is any object in the managed original; `resource_key` converts the kinds of key the
// port has.
ferro_class_info!(ResourceDictionary {
    markup: {
        namespace: "FerroUI.Controls",
        properties: [
            Count: i32 { get: |this: &Ref<ResourceDictionary>| this.count() as i32 },
            MergedDictionaries: FerroList<Rc<dyn IResourceProvider>> { get: ResourceDictionary::merged_dictionaries },
            ThemeDictionaries: FerroDictionary<ThemeVariant, Rc<dyn IThemeVariantProvider>> { get: ResourceDictionary::theme_dictionaries },
        ],
        methods: [
            try fn Add(Option<BoxedValue>, Option<BoxedValue>) =>
                |this: &Ref<ResourceDictionary>, key: Option<BoxedValue>, value: Option<BoxedValue>| {
                    new_resource_key(this, key).map(|key| this.add(key, value))
                },
            try fn AddDeferred(Option<BoxedValue>, Rc<dyn IDeferredContent>) =>
                |this: &Ref<ResourceDictionary>, key: Option<BoxedValue>, content: Rc<dyn IDeferredContent>| {
                    new_resource_key(this, key).map(|key| this.add_deferred(key, content))
                },
            try fn AddNotSharedDeferred(Option<BoxedValue>, Rc<dyn IDeferredContent>) =>
                |this: &Ref<ResourceDictionary>, key: Option<BoxedValue>, content: Rc<dyn IDeferredContent>| {
                    new_resource_key(this, key).map(|key| this.add_not_shared_deferred(key, content))
                },
            fn EnsureCapacity(i32) =>
                |this: &Ref<ResourceDictionary>, capacity: i32| this.ensure_capacity(capacity.max(0) as usize),
        ],
    },
});

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

// FerroUI.Input

ferro_markup_type!(static AccessKeyHandler {
    namespace: "FerroUI.Input",
    type_info: AccessKeyHandler,
    fields: [
        AccessKeyEvent: RoutedEvent<AccessKeyEventArgs> => || *AccessKeyHandler::access_key_event(),
        AccessKeyPressedEvent: RoutedEvent<AccessKeyPressedEventArgs> => || *AccessKeyHandler::access_key_pressed_event(),
    ],
});

ferro_markup_type!(static DragDrop {
    namespace: "FerroUI.Input",
    type_info: DragDrop,
    fields: [
        DragEnterEvent: RoutedEvent<DragEventArgs> => || *DragDrop::drag_enter_event(),
        DragLeaveEvent: RoutedEvent<DragEventArgs> => || *DragDrop::drag_leave_event(),
        DragOverEvent: RoutedEvent<DragEventArgs> => || *DragDrop::drag_over_event(),
        DropEvent: RoutedEvent<DragEventArgs> => || *DragDrop::drop_event(),
    ],
});

ferro_class_info!(InputElement {
    markup: {
        namespace: "FerroUI.Input",
        properties: [
            KeyBindings: FerroList<Ref<KeyBinding>> { get: InputElement::key_bindings },
            GestureRecognizers: GestureRecognizerCollection { get: InputElement::gesture_recognizers },
        ],
        fields: [
            PinchEvent: RoutedEvent<PinchEventArgs> => || *InputElement::pinch_event(),
            PinchEndedEvent: RoutedEvent<PinchEndedEventArgs> => || *InputElement::pinch_ended_event(),
            PullGestureEvent: RoutedEvent<PullGestureEventArgs> => || *InputElement::pull_gesture_event(),
            PullGestureEndedEvent: RoutedEvent<PullGestureEndedEventArgs> => || *InputElement::pull_gesture_ended_event(),
            SwipeGestureEvent: RoutedEvent<SwipeGestureEventArgs> => || *InputElement::swipe_gesture_event(),
            SwipeGestureEndedEvent: RoutedEvent<SwipeGestureEndedEventArgs> => || *InputElement::swipe_gesture_ended_event(),
            ScrollGestureEvent: RoutedEvent<ScrollGestureEventArgs> => || *InputElement::scroll_gesture_event(),
            ScrollGestureInertiaStartingEvent: RoutedEvent<ScrollGestureInertiaStartingEventArgs> => || *InputElement::scroll_gesture_inertia_starting_event(),
            ScrollGestureEndedEvent: RoutedEvent<ScrollGestureEndedEventArgs> => || *InputElement::scroll_gesture_ended_event(),
            PointerTouchPadGestureMagnifyEvent: RoutedEvent<PointerDeltaEventArgs> => || *InputElement::pointer_touch_pad_gesture_magnify_event(),
            PointerTouchPadGestureRotateEvent: RoutedEvent<PointerDeltaEventArgs> => || *InputElement::pointer_touch_pad_gesture_rotate_event(),
            PointerTouchPadGestureSwipeEvent: RoutedEvent<PointerDeltaEventArgs> => || *InputElement::pointer_touch_pad_gesture_swipe_event(),
            TappedEvent: RoutedEvent<TappedEventArgs> => || *InputElement::tapped_event(),
            RightTappedEvent: RoutedEvent<TappedEventArgs> => || *InputElement::right_tapped_event(),
            HoldingEvent: RoutedEvent<HoldingRoutedEventArgs> => || *InputElement::holding_event(),
            DoubleTappedEvent: RoutedEvent<TappedEventArgs> => || *InputElement::double_tapped_event(),
            GotFocusEvent: RoutedEvent<FocusChangedEventArgs> => || *InputElement::got_focus_event(),
            GettingFocusEvent: RoutedEvent<FocusChangingEventArgs> => || *InputElement::getting_focus_event(),
            LostFocusEvent: RoutedEvent<FocusChangedEventArgs> => || *InputElement::lost_focus_event(),
            LosingFocusEvent: RoutedEvent<FocusChangingEventArgs> => || *InputElement::losing_focus_event(),
            KeyDownEvent: RoutedEvent<KeyEventArgs> => || *InputElement::key_down_event(),
            KeyUpEvent: RoutedEvent<KeyEventArgs> => || *InputElement::key_up_event(),
            TextInputEvent: RoutedEvent<TextInputEventArgs> => || *InputElement::text_input_event(),
            TextInputMethodClientRequestedEvent: RoutedEvent<TextInputMethodClientRequestedEventArgs> => || *InputElement::text_input_method_client_requested_event(),
            PointerEnteredEvent: RoutedEvent<PointerEventArgs> => || *InputElement::pointer_entered_event(),
            PointerExitedEvent: RoutedEvent<PointerEventArgs> => || *InputElement::pointer_exited_event(),
            PointerMovedEvent: RoutedEvent<PointerEventArgs> => || *InputElement::pointer_moved_event(),
            PointerPressedEvent: RoutedEvent<PointerPressedEventArgs> => || *InputElement::pointer_pressed_event(),
            PointerReleasedEvent: RoutedEvent<PointerReleasedEventArgs> => || *InputElement::pointer_released_event(),
            PointerCaptureLostEvent: RoutedEvent<PointerCaptureLostEventArgs> => || *InputElement::pointer_capture_lost_event(),
            PointerWheelChangedEvent: RoutedEvent<PointerWheelEventArgs> => || *InputElement::pointer_wheel_changed_event(),
            ContextRequestedEvent: RoutedEvent<ContextRequestedEventArgs> => || *InputElement::context_requested_event(),
            ContextCanceledEvent: RoutedEvent<RoutedEventArgs> => || *InputElement::context_canceled_event(),
        ],
        attributes: [PseudoClasses(":disabled", ":focus", ":focus-visible", ":focus-within", ":pointerover")],
    },
});

ferro_markup_type!(static InputMethod {
    namespace: "FerroUI.Input",
    type_info: InputMethod,
    fields: [
        TextInputMethodClientRequeryRequestedEvent: RoutedEvent<TextInputMethodClientRequeryRequestedEventArgs> => || *InputMethod::text_input_method_client_requery_requested_event(),
    ],
});

// FerroUI.Input.GestureRecognizers

ferro_class_info!(PullGestureRecognizer {
    markup: {
        namespace: "FerroUI.Input.GestureRecognizers",
        constructors: [
            (PullDirection) => PullGestureRecognizer::with_direction,
        ],
    },
});

// FerroUI.Layout

ferro_class_info!(Layoutable {
    markup: {
        namespace: "FerroUI.Layout",
        events: [
            EffectiveViewportChanged(Option<BoxedValue>, EffectiveViewportChangedEventArgs) => |this: &Ref<Layoutable>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.effective_viewport_changed(move |e: &EffectiveViewportChangedEventArgs| {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(e.clone())]);
                })
            },
            LayoutUpdated(Option<BoxedValue>, EventArgs) => |this: &Ref<Layoutable>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.layout_updated(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

// FerroUI.Media

ferro_class_info!(CacheMode {
    markup: {
        namespace: "FerroUI.Media",
        parse: CacheMode::parse,
    },
});

ferro_class_info!(CombinedGeometry {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Ref<Geometry>, Ref<Geometry>) => CombinedGeometry::with_geometries,
            (GeometryCombineMode, Option<Ref<Geometry>>, Option<Ref<Geometry>>) => CombinedGeometry::with_mode,
            (GeometryCombineMode, Option<Ref<Geometry>>, Option<Ref<Geometry>>, Option<Ref<Transform>>) =>
                |mode: GeometryCombineMode, a: Option<Ref<Geometry>>, b: Option<Ref<Geometry>>, t: Option<Ref<Transform>>| {
                    CombinedGeometry::with_mode_and_transform(mode, a, b, t)
                },
        ],
    },
});

ferro_class_info!(DashStyle {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Option<MediaCollection<f64>>, f64) => |dashes: Option<MediaCollection<f64>>, offset: f64| {
                DashStyle::with_dash_list(dashes.unwrap_or_default(), offset)
            },
        ],
        static_properties: [
            Dash: Rc<dyn IDashStyle> { get: || -> Rc<dyn IDashStyle> { DashStyle::dash() } },
            Dot: Rc<dyn IDashStyle> { get: || -> Rc<dyn IDashStyle> { DashStyle::dot() } },
            DashDot: Rc<dyn IDashStyle> { get: || -> Rc<dyn IDashStyle> { DashStyle::dash_dot() } },
            DashDotDot: Rc<dyn IDashStyle> { get: || -> Rc<dyn IDashStyle> { DashStyle::dash_dot_dot() } },
        ],
    },
});

ferro_class_info!(DrawingBrush {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Ref<Drawing>) => |drawing: Ref<Drawing>| DrawingBrush::with_drawing(drawing),
        ],
    },
});

ferro_class_info!(DrawingGroup {
    markup: {
        namespace: "FerroUI.Media",
        content: Children,
    },
});

ferro_class_info!(DrawingImage {
    markup: {
        namespace: "FerroUI.Media",
        content: Drawing,
        constructors: [
            (Ref<Drawing>) => |drawing: Ref<Drawing>| DrawingImage::with_drawing(drawing),
        ],
        events: [
            Invalidated(Option<BoxedValue>, EventArgs) => |this: &Ref<DrawingImage>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.invalidated(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

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

ferro_class_info!(EllipseGeometry {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Rect) => EllipseGeometry::with_rect,
        ],
    },
});

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

ferro_class_info!(Geometry {
    markup: {
        namespace: "FerroUI.Media",
        parse: Geometry::parse,
        events: [
            Changed(Option<BoxedValue>, EventArgs) => |this: &Ref<Geometry>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

ferro_class_info!(GeometryDrawing {
    markup: {
        namespace: "FerroUI.Media",
        content: Geometry,
    },
});

ferro_class_info!(GeometryGroup {
    markup: {
        namespace: "FerroUI.Media",
        content: Children,
    },
});

ferro_class_info!(GradientBrush {
    markup: {
        namespace: "FerroUI.Media",
        content: GradientStops,
    },
});

ferro_class_info!(GradientStop {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Color, f64) => GradientStop::with_color_and_offset,
        ],
    },
});

ferro_class_info!(ImageBrush {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Option<Rc<dyn IImageBrushSource>>) => ImageBrush::with_source,
        ],
    },
});

ferro_class_info!(LineGeometry {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Point, Point) => LineGeometry::with_points,
        ],
    },
});

ferro_class_info!(MatrixTransform {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Matrix) => MatrixTransform::with_matrix,
        ],
    },
});

ferro_class_info!(PathFigure {
    markup: {
        namespace: "FerroUI.Media",
        content: Segments,
    },
});

ferro_class_info!(PathGeometry {
    markup: {
        namespace: "FerroUI.Media",
        content: Figures,
        parse: PathGeometry::parse,
    },
});

ferro_class_info!(Pen {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Option<Rc<dyn IBrush>>, f64, Option<Rc<dyn IDashStyle>>, PenLineCap, PenLineJoin, f64) => Pen::with_all,
        ],
    },
});

ferro_class_info!(PolyBezierSegment {
    markup: {
        namespace: "FerroUI.Media",
        content: Points,
        constructors: [
            (Points, bool) => |points: Points, is_stroked: bool| PolyBezierSegment::with_points(points.iter(), is_stroked),
        ],
    },
});

ferro_class_info!(PolyLineSegment {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Points) => |points: Points| PolyLineSegment::with_points(points.iter()),
        ],
    },
});

ferro_class_info!(PolylineGeometry {
    markup: {
        namespace: "FerroUI.Media",
        content: Points,
        constructors: [
            (Points, bool) => |points: Points, is_filled: bool| PolylineGeometry::with_points(points.iter(), is_filled),
            (Points, bool, FillRule) => |points: Points, is_filled: bool, fill_rule: FillRule| {
                PolylineGeometry::with_points_and_fill_rule(points.iter(), is_filled, fill_rule)
            },
        ],
    },
});

ferro_class_info!(RectangleGeometry {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Rect) => RectangleGeometry::with_rect,
            (Rect, f64, f64) => RectangleGeometry::with_rect_and_radii,
        ],
    },
});

ferro_class_info!(Rotate3DTransform {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (f64, f64, f64, f64, f64, f64, f64) => Rotate3DTransform::with_values,
        ],
    },
});

ferro_class_info!(RotateTransform {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (f64) => RotateTransform::with_angle,
            (f64, f64, f64) => RotateTransform::with_angle_and_center,
        ],
    },
});

ferro_class_info!(ScaleTransform {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (f64, f64) => ScaleTransform::with_scale,
        ],
    },
});

ferro_class_info!(SkewTransform {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (f64, f64) => SkewTransform::with_angles,
        ],
    },
});

ferro_class_info!(SolidColorBrush {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Color) => SolidColorBrush::with_color,
            (Color, f64) => SolidColorBrush::with_color_and_opacity,
            (u32) => SolidColorBrush::from_uint32,
        ],
    },
});

ferro_class_info!(StreamGeometry {
    markup: {
        namespace: "FerroUI.Media",
        parse: StreamGeometry::parse,
    },
});

ferro_class_info!(Transform {
    markup: {
        namespace: "FerroUI.Media",
        parse: Transform::parse,
        events: [
            Changed(Option<BoxedValue>, EventArgs) => |this: &Ref<Transform>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

ferro_class_info!(TransformGroup {
    markup: {
        namespace: "FerroUI.Media",
        content: Children,
    },
});

ferro_class_info!(TranslateTransform {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (f64, f64) => TranslateTransform::with_offset,
        ],
    },
});

ferro_class_info!(VisualBrush {
    markup: {
        namespace: "FerroUI.Media",
        constructors: [
            (Ref<Visual>) => |visual: Ref<Visual>| VisualBrush::with_visual(visual),
        ],
    },
});

// FerroUI.Media.Imaging

ferro_class_info!(CroppedBitmap {
    markup: {
        namespace: "FerroUI.Media.Imaging",
        constructors: [
            (Rc<dyn IImage>, PixelRect) => CroppedBitmap::with_source,
        ],
        events: [
            Invalidated(Option<BoxedValue>, EventArgs) => |this: &Ref<CroppedBitmap>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.invalidated(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

// FerroUI.Styling

ferro_class_info!(ContainerQuery {
    markup: {
        namespace: "FerroUI.Styling",
        properties: [
            Query: Option<StyleQuery> { get: ContainerQuery::query, set: ContainerQuery::set_query },
            Name: Option<String> { get: ContainerQuery::name, set: ContainerQuery::set_name },
        ],
    },
});

ferro_class_info!(ControlTheme {
    markup: {
        namespace: "FerroUI.Styling",
        constructors: [
            (&'static TypeInfo) => ControlTheme::with_target_type,
        ],
        properties: [
            TargetType: Option<&'static TypeInfo> { get: ControlTheme::target_type, set: ControlTheme::set_target_type },
            BasedOn: Option<Ref<ControlTheme>> { get: ControlTheme::based_on, set: ControlTheme::set_based_on },
        ],
    },
});

ferro_class_info!(Style {
    markup: {
        namespace: "FerroUI.Styling",
        properties: [
            Selector: Option<Selector> { get: Style::selector, set: Style::set_selector },
        ],
    },
});

ferro_class_info!(StyleBase {
    markup: {
        namespace: "FerroUI.Styling",
        properties: [
            Children: StyleChildren { get: StyleBase::children },
            Resources: Rc<dyn IResourceDictionary> {
                get: |this: &Ref<StyleBase>| -> Rc<dyn IResourceDictionary> { this.resources().into() },
                try_set: |this: &Ref<StyleBase>, 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."),
                    }
                }
            },
            Setters: FerroList<Rc<dyn SetterBase>> { get: StyleBase::setters },
            Animations: FerroList<Rc<dyn IAnimation>> { get: StyleBase::animations },
        ],
        methods: [
            fn Add(Rc<dyn SetterBase>) => |this: &Ref<StyleBase>, setter: Rc<dyn SetterBase>| this.add(setter),
            fn Add(Rc<dyn IStyle>) => |this: &Ref<StyleBase>, style: Rc<dyn IStyle>| this.add_style(style),
        ],
        events: [
            OwnerChanged(Option<BoxedValue>, EventArgs) => |this: &Ref<StyleBase>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.owner_changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

ferro_class_info!(Styles {
    markup: {
        namespace: "FerroUI.Styling",
        properties: [
            Resources: Rc<dyn IResourceDictionary> {
                get: |this: &Ref<Styles>| -> Rc<dyn IResourceDictionary> { this.resources().into() },
                try_set: |this: &Ref<Styles>, 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."),
                    }
                }
            },
        ],
        methods: [
            try fn Add(Rc<dyn IStyle>) => |this: &Ref<Styles>, style: Rc<dyn IStyle>| {
                // A style that has an owner cannot be added to styles that have one.
                let owned = style.as_object().and_then(|o| o.to_ref().cast::<StyleBase>()).is_some_and(|s| s.owner().is_some());
                if owned && this.owner().is_some() {
                    return Err("The Style already has a parent.");
                }
                Ok(this.add(style))
            },
        ],
        events: [
            OwnerChanged(Option<BoxedValue>, EventArgs) => |this: &Ref<Styles>, handler: MarkupDelegate| {
                let sender = this.downgrade();
                this.owner_changed(move || {
                    handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(EventArgs::EMPTY)]);
                })
            },
        ],
    },
});

// FerroUI.Interactivity

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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 AccessKeyEventArgs {
    namespace: "FerroUI.Input",
    handles: [AccessKeyEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        IsMultiple: bool {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<AccessKeyEventArgs, _>(e, |e| e.is_multiple())
        },
    ],
});

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

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

ferro_markup_type!(class DragEventArgs {
    namespace: "FerroUI.Input",
    handles: [DragEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        DragEffects: DragDropEffects {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<DragEventArgs, _>(e, |e| e.drag_effects()),
            try_set: |e: &Rc<dyn IRoutedEventArgs>, value: DragDropEffects| typed_event_args::<DragEventArgs, _>(e, |e| e.set_drag_effects(value))
        },
        KeyModifiers: KeyModifiers {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<DragEventArgs, _>(e, |e| e.key_modifiers())
        },
    ],
});

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

ferro_markup_type!(class FocusChangingEventArgs {
    namespace: "FerroUI.Input",
    handles: [FocusChangingEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        NewFocusedElement: Option<Ref<InputElement>> {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<FocusChangingEventArgs, _>(e, |e| e.new_focused_element())
        },
        Canceled: bool {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<FocusChangingEventArgs, _>(e, |e| e.canceled())
        },
    ],
});

ferro_markup_type!(class HoldingRoutedEventArgs {
    namespace: "FerroUI.Input",
    handles: [HoldingRoutedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        HoldingState: HoldingState {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<HoldingRoutedEventArgs, _>(e, |e| e.holding_state())
        },
        Position: Point {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<HoldingRoutedEventArgs, _>(e, |e| e.position())
        },
        PointerType: PointerType {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<HoldingRoutedEventArgs, _>(e, |e| e.pointer_type())
        },
    ],
});

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

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

ferro_markup_type!(class PinchEventArgs {
    namespace: "FerroUI.Input",
    handles: [PinchEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        Scale: f64 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PinchEventArgs, _>(e, |e| e.scale())
        },
        ScaleOrigin: Point {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PinchEventArgs, _>(e, |e| e.scale_origin())
        },
        Angle: f64 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PinchEventArgs, _>(e, |e| e.angle())
        },
        AngleDelta: f64 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PinchEventArgs, _>(e, |e| e.angle_delta())
        },
    ],
});

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

ferro_markup_type!(class PointerDeltaEventArgs {
    namespace: "FerroUI.Input",
    handles: [PointerDeltaEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: PointerEventArgs,
    properties: [
        Delta: Vector {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PointerDeltaEventArgs, _>(e, |e| e.delta())
        },
    ],
});

ferro_markup_type!(class PointerEventArgs {
    namespace: "FerroUI.Input",
    handles: [PointerEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        Timestamp: u64 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PointerEventArgs, _>(e, |e| e.timestamp())
        },
        KeyModifiers: KeyModifiers {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PointerEventArgs, _>(e, |e| e.key_modifiers())
        },
    ],
});

ferro_markup_type!(class PointerPressedEventArgs {
    namespace: "FerroUI.Input",
    handles: [PointerPressedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: PointerEventArgs,
    properties: [
        ClickCount: i32 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PointerPressedEventArgs, _>(e, |e| e.click_count())
        },
    ],
});

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

ferro_markup_type!(class PointerWheelEventArgs {
    namespace: "FerroUI.Input",
    handles: [PointerWheelEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: PointerEventArgs,
    properties: [
        Delta: Vector {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PointerWheelEventArgs, _>(e, |e| e.delta())
        },
    ],
});

ferro_markup_type!(class PullGestureEndedEventArgs {
    namespace: "FerroUI.Input",
    handles: [PullGestureEndedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        Id: i32 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PullGestureEndedEventArgs, _>(e, |e| e.id())
        },
        PullDirection: PullDirection {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PullGestureEndedEventArgs, _>(e, |e| e.pull_direction())
        },
    ],
});

ferro_markup_type!(class PullGestureEventArgs {
    namespace: "FerroUI.Input",
    handles: [PullGestureEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        Id: i32 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PullGestureEventArgs, _>(e, |e| e.id())
        },
        Delta: Vector {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PullGestureEventArgs, _>(e, |e| e.delta())
        },
        PullDirection: PullDirection {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<PullGestureEventArgs, _>(e, |e| e.pull_direction())
        },
    ],
});

ferro_markup_type!(class ScrollGestureEndedEventArgs {
    namespace: "FerroUI.Input",
    handles: [ScrollGestureEndedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        Id: i32 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<ScrollGestureEndedEventArgs, _>(e, |e| e.id())
        },
    ],
});

ferro_markup_type!(class ScrollGestureEventArgs {
    namespace: "FerroUI.Input",
    handles: [ScrollGestureEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        Id: i32 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<ScrollGestureEventArgs, _>(e, |e| e.id())
        },
        Delta: Vector {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<ScrollGestureEventArgs, _>(e, |e| e.delta())
        },
        ShouldEndScrollGesture: bool {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<ScrollGestureEventArgs, _>(e, |e| e.should_end_scroll_gesture()),
            try_set: |e: &Rc<dyn IRoutedEventArgs>, value: bool| typed_event_args::<ScrollGestureEventArgs, _>(e, |e| e.set_should_end_scroll_gesture(value))
        },
    ],
});

ferro_markup_type!(class ScrollGestureInertiaStartingEventArgs {
    namespace: "FerroUI.Input",
    handles: [ScrollGestureInertiaStartingEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        Id: i32 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<ScrollGestureInertiaStartingEventArgs, _>(e, |e| e.id())
        },
        Inertia: Vector {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<ScrollGestureInertiaStartingEventArgs, _>(e, |e| e.inertia())
        },
    ],
});

ferro_markup_type!(class SwipeGestureEndedEventArgs {
    namespace: "FerroUI.Input",
    handles: [SwipeGestureEndedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        Id: i32 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SwipeGestureEndedEventArgs, _>(e, |e| e.id())
        },
        Velocity: Vector {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SwipeGestureEndedEventArgs, _>(e, |e| e.velocity())
        },
    ],
});

ferro_markup_type!(class SwipeGestureEventArgs {
    namespace: "FerroUI.Input",
    handles: [SwipeGestureEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        Id: i32 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SwipeGestureEventArgs, _>(e, |e| e.id())
        },
        Delta: Vector {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SwipeGestureEventArgs, _>(e, |e| e.delta())
        },
        Velocity: Vector {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SwipeGestureEventArgs, _>(e, |e| e.velocity())
        },
        SwipeDirection: SwipeDirection {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<SwipeGestureEventArgs, _>(e, |e| e.swipe_direction())
        },
    ],
});

ferro_markup_type!(class TappedEventArgs {
    namespace: "FerroUI.Input",
    handles: [TappedEventArgs],
    this: Rc<dyn IRoutedEventArgs>,
    base: Rc<dyn IRoutedEventArgs>,
    properties: [
        KeyModifiers: KeyModifiers {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<TappedEventArgs, _>(e, |e| e.key_modifiers())
        },
        Timestamp: u64 {
            try_get: |e: &Rc<dyn IRoutedEventArgs>| typed_event_args::<TappedEventArgs, _>(e, |e| e.timestamp())
        },
    ],
});

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

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

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

/// 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<AccessKeyEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<AccessKeyPressedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<ContextRequestedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<DragEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<FocusChangedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<FocusChangingEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<HoldingRoutedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<KeyEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PinchEndedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PinchEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PointerCaptureLostEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PointerDeltaEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PointerEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PointerPressedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PointerReleasedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PointerWheelEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PullGestureEndedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<PullGestureEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<RoutedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<ScrollGestureEndedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<ScrollGestureEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<ScrollGestureInertiaStartingEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<SwipeGestureEndedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<SwipeGestureEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<TappedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<TextInputEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<TextInputMethodClientRequeryRequestedEventArgs>, RoutedEvent>(|event| event.as_routed_event());
    ValueTypes::register_cast::<RoutedEvent<TextInputMethodClientRequestedEventArgs>, 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] = &[
    <AccessKeyHandler as MarkupTyped>::MARKUP,
    <DragDrop as MarkupTyped>::MARKUP,
    <InputMethod as MarkupTyped>::MARKUP,
    <NameScope as MarkupTyped>::MARKUP,
    <RoutedEvent<AccessKeyEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<AccessKeyPressedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<ContextRequestedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<DragEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<FocusChangedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<FocusChangingEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<HoldingRoutedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<KeyEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<PinchEndedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<PinchEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<PointerCaptureLostEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<PointerDeltaEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<PointerEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<PointerPressedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<PointerReleasedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<PointerWheelEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<PullGestureEndedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<PullGestureEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<RoutedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<ScrollGestureEndedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<ScrollGestureEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<ScrollGestureInertiaStartingEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<SwipeGestureEndedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<SwipeGestureEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<TappedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<TextInputEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<TextInputMethodClientRequeryRequestedEventArgs> as MarkupTyped>::MARKUP,
    <RoutedEvent<TextInputMethodClientRequestedEventArgs> as MarkupTyped>::MARKUP,
    <AccessKeyEventArgs as MarkupTyped>::MARKUP,
    <AccessKeyPressedEventArgs as MarkupTyped>::MARKUP,
    <ContextRequestedEventArgs as MarkupTyped>::MARKUP,
    <DragEventArgs as MarkupTyped>::MARKUP,
    <FocusChangedEventArgs as MarkupTyped>::MARKUP,
    <FocusChangingEventArgs as MarkupTyped>::MARKUP,
    <HoldingRoutedEventArgs as MarkupTyped>::MARKUP,
    <KeyEventArgs as MarkupTyped>::MARKUP,
    <PinchEndedEventArgs as MarkupTyped>::MARKUP,
    <PinchEventArgs as MarkupTyped>::MARKUP,
    <PointerCaptureLostEventArgs as MarkupTyped>::MARKUP,
    <PointerDeltaEventArgs as MarkupTyped>::MARKUP,
    <PointerEventArgs as MarkupTyped>::MARKUP,
    <PointerPressedEventArgs as MarkupTyped>::MARKUP,
    <PointerReleasedEventArgs as MarkupTyped>::MARKUP,
    <PointerWheelEventArgs as MarkupTyped>::MARKUP,
    <PullGestureEndedEventArgs as MarkupTyped>::MARKUP,
    <PullGestureEventArgs as MarkupTyped>::MARKUP,
    <ScrollGestureEndedEventArgs as MarkupTyped>::MARKUP,
    <ScrollGestureEventArgs as MarkupTyped>::MARKUP,
    <ScrollGestureInertiaStartingEventArgs as MarkupTyped>::MARKUP,
    <SwipeGestureEndedEventArgs as MarkupTyped>::MARKUP,
    <SwipeGestureEventArgs as MarkupTyped>::MARKUP,
    <TappedEventArgs as MarkupTyped>::MARKUP,
    <TextInputEventArgs as MarkupTyped>::MARKUP,
    <TextInputMethodClientRequeryRequestedEventArgs as MarkupTyped>::MARKUP,
    <TextInputMethodClientRequestedEventArgs as MarkupTyped>::MARKUP,
];