ferroui_controls_inking/
markup.rs

1//! Explicit metadata for the plain service objects and the inking enum family.
2use super::*;
3use ferroui_base::data::core::ValueTypes;
4use ferroui_base::input::PointerType;
5use ferroui_base::media::Color;
6use ferroui_base::metadata::{into_markup_value, MarkupDelegate, MarkupType, MarkupTyped};
7use ferroui_base::{ferro_markup_enum, ferro_markup_type, Matrix, Point, Rect, Ref, Size};
8use std::rc::Rc;
9
10ferro_markup_enum!(InkInputProcessingMode { None, Inking, Erasing }, { namespace: "FerroUI.Controls" });
11ferro_markup_enum!(InkInputRightDragAction { LeaveUnprocessed, AllowProcessing }, { namespace: "FerroUI.Controls" });
12ferro_markup_enum!(InkHighContrastAdjustment { UseSystemColorsWhenNecessary, UseSystemColors, UseOriginalColors }, { namespace: "FerroUI.Controls" });
13ferro_markup_enum!(InkPresenterPredefinedConfiguration { SimpleSinglePointer, SimpleMultiplePointer }, { namespace: "FerroUI.Controls" });
14ferro_markup_enum!(InkPersistenceFormat { GifWithEmbeddedIsf, Isf, Portable }, { namespace: "FerroUI.Controls" });
15ferro_markup_enum!(flags CoreInputDeviceTypes { None = CoreInputDeviceTypes::NONE, Touch = CoreInputDeviceTypes::TOUCH,
16    Pen = CoreInputDeviceTypes::PEN, Mouse = CoreInputDeviceTypes::MOUSE }, { namespace: "FerroUI.Controls" });
17
18ferro_markup_type!(class InkPresenter {
19    namespace: "FerroUI.Controls",
20    handles: [Rc<InkPresenter>, Option<Rc<InkPresenter>>],
21    this: Rc<InkPresenter>,
22    constructors: [() => InkPresenter::new],
23    properties: [
24        InputDeviceTypes: CoreInputDeviceTypes { get: |p: &Rc<InkPresenter>| p.input_device_types(), set: |p: &Rc<InkPresenter>, v| p.set_input_device_types(v) },
25        IsInputEnabled: bool { get: |p: &Rc<InkPresenter>| p.is_input_enabled(), set: |p: &Rc<InkPresenter>, v| p.set_is_input_enabled(v) },
26        HighContrastAdjustment: InkHighContrastAdjustment { get: |p: &Rc<InkPresenter>| p.high_contrast_adjustment(), set: |p: &Rc<InkPresenter>, v| p.set_high_contrast_adjustment(v) },
27        StrokeContainer: Rc<InkStrokeContainer> { get: |p: &Rc<InkPresenter>| p.stroke_container() },
28        InputProcessingConfiguration: Rc<InkInputProcessingConfiguration> { get: |p: &Rc<InkPresenter>| p.input_processing_configuration() },
29        InputConfiguration: Rc<InkInputConfiguration> { get: |p: &Rc<InkPresenter>| p.input_configuration() },
30        StrokeInput: Rc<InkStrokeInput> { get: |p: &Rc<InkPresenter>| p.stroke_input() },
31        UnprocessedInput: Rc<InkUnprocessedInput> { get: |p: &Rc<InkPresenter>| p.unprocessed_input() },
32    ],
33    methods: [
34        try fn UpdateDefaultDrawingAttributes(InkDrawingAttributes) => |p: &Rc<InkPresenter>, attributes| p.update_default_drawing_attributes(&attributes),
35        fn CopyDefaultDrawingAttributes() -> InkDrawingAttributes => |p: &Rc<InkPresenter>| p.copy_default_drawing_attributes(),
36        fn SetPredefinedConfiguration(InkPresenterPredefinedConfiguration) => |p: &Rc<InkPresenter>, value| p.set_predefined_configuration(value),
37        try fn ActivateCustomDrying() -> Rc<InkSynchronizer> => |p: &Rc<InkPresenter>| p.activate_custom_drying(),
38    ],
39    events: [
40        StrokesCollected(Option<Rc<InkPresenter>>, InkStrokesCollectedEventArgs) => |p: &Rc<InkPresenter>, handler: MarkupDelegate| {
41            let sender = Rc::downgrade(p);
42            p.strokes_collected(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
43        },
44        StrokesErased(Option<Rc<InkPresenter>>, InkStrokesErasedEventArgs) => |p: &Rc<InkPresenter>, handler: MarkupDelegate| {
45            let sender = Rc::downgrade(p);
46            p.strokes_erased(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
47        },
48    ],
49});
50ferro_markup_type!(class InkInputProcessingConfiguration {
51    namespace: "FerroUI.Controls", handles: [Rc<InkInputProcessingConfiguration>, Option<Rc<InkInputProcessingConfiguration>>], this: Rc<InkInputProcessingConfiguration>,
52    properties: [
53        Mode: InkInputProcessingMode { get: |p: &Rc<InkInputProcessingConfiguration>| p.mode(), set: |p: &Rc<InkInputProcessingConfiguration>, v| p.set_mode(v) },
54        RightDragAction: InkInputRightDragAction { get: |p: &Rc<InkInputProcessingConfiguration>| p.right_drag_action(), set: |p: &Rc<InkInputProcessingConfiguration>, v| p.set_right_drag_action(v) },
55    ],
56});
57ferro_markup_type!(class InkInputConfiguration {
58    namespace: "FerroUI.Controls", handles: [Rc<InkInputConfiguration>, Option<Rc<InkInputConfiguration>>], this: Rc<InkInputConfiguration>,
59    properties: [
60        IsPrimaryBarrelButtonInputEnabled: bool { get: |p: &Rc<InkInputConfiguration>| p.is_primary_barrel_button_input_enabled(), set: |p: &Rc<InkInputConfiguration>, v| p.set_is_primary_barrel_button_input_enabled(v) },
61        IsEraserInputEnabled: bool { get: |p: &Rc<InkInputConfiguration>| p.is_eraser_input_enabled(), set: |p: &Rc<InkInputConfiguration>, v| p.set_is_eraser_input_enabled(v) },
62    ],
63});
64ferro_markup_type!(class InkStrokeContainer {
65    namespace: "FerroUI.Controls", handles: [Rc<InkStrokeContainer>, Option<Rc<InkStrokeContainer>>], this: Rc<InkStrokeContainer>,
66    constructors: [() => InkStrokeContainer::new],
67    properties: [BoundingRect: Rect { get: |p: &Rc<InkStrokeContainer>| p.bounding_rect() }],
68    methods: [
69        fn Clear() => |p: &Rc<InkStrokeContainer>| p.clear(),
70        fn GetStrokes() -> Vec<Rc<InkStroke>> => |p: &Rc<InkStrokeContainer>| p.get_strokes(),
71        try fn AddStroke(Rc<InkStroke>) => |p: &Rc<InkStrokeContainer>, stroke| p.add_stroke(stroke),
72        try fn AddStrokes(Vec<Rc<InkStroke>>) => |p: &Rc<InkStrokeContainer>, strokes| p.add_strokes(strokes),
73        fn GetStrokeById(u32) -> Option<Rc<InkStroke>> => |p: &Rc<InkStrokeContainer>, id| p.get_stroke_by_id(id),
74        fn DeleteSelected() -> Rect => |p: &Rc<InkStrokeContainer>| p.delete_selected(),
75        try fn MoveSelected(Point) -> Rect => |p: &Rc<InkStrokeContainer>, delta| p.move_selected(delta),
76        fn SelectWithLine(Point, Point) -> Rect => |p: &Rc<InkStrokeContainer>, from, to| p.select_with_line(from, to),
77        fn SelectWithPolyLine(Vec<Point>) -> Rect => |p: &Rc<InkStrokeContainer>, points: Vec<Point>| p.select_with_poly_line(&points),
78        try fn CopySelectedToClipboard() => |p: &Rc<InkStrokeContainer>| p.copy_selected_to_clipboard(),
79        try fn CanPasteFromClipboard() -> bool => |p: &Rc<InkStrokeContainer>| p.can_paste_from_clipboard(),
80        try fn PasteFromClipboard(Point) -> Rect => |p: &Rc<InkStrokeContainer>, position| p.paste_from_clipboard(position),
81    ],
82});
83ferro_markup_type!(class InkStroke {
84    namespace: "FerroUI.Controls", handles: [Rc<InkStroke>, Option<Rc<InkStroke>>], this: Rc<InkStroke>,
85    properties: [
86        Id: u32 { get: |p: &Rc<InkStroke>| p.id() },
87        DrawingAttributes: InkDrawingAttributes { get: |p: &Rc<InkStroke>| p.drawing_attributes(), try_set: |p: &Rc<InkStroke>, value| p.set_drawing_attributes(value) },
88        Selected: bool { get: |p: &Rc<InkStroke>| p.selected(), set: |p: &Rc<InkStroke>, v| p.set_selected(v) },
89        BoundingRect: Rect { get: |p: &Rc<InkStroke>| p.bounding_rect() },
90        PointTransform: Matrix { get: |p: &Rc<InkStroke>| p.point_transform(), try_set: |p: &Rc<InkStroke>, v| p.set_point_transform(v) },
91    ],
92});
93ferro_markup_type!(class InkStrokeInput { namespace: "FerroUI.Controls", handles: [Rc<InkStrokeInput>, Option<Rc<InkStrokeInput>>], this: Rc<InkStrokeInput>,
94    properties: [InkPresenter: Option<Rc<InkPresenter>> { get: |p: &Rc<InkStrokeInput>| p.ink_presenter() }],
95    events: [
96        StrokeStarted(Option<Rc<InkStrokeInput>>, InkPointerEventArgs) => |p: &Rc<InkStrokeInput>, handler: MarkupDelegate| {
97            let sender = Rc::downgrade(p);
98            p.stroke_started(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
99        },
100        StrokeContinued(Option<Rc<InkStrokeInput>>, InkPointerEventArgs) => |p: &Rc<InkStrokeInput>, handler: MarkupDelegate| {
101            let sender = Rc::downgrade(p);
102            p.stroke_continued(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
103        },
104        StrokeEnded(Option<Rc<InkStrokeInput>>, InkPointerEventArgs) => |p: &Rc<InkStrokeInput>, handler: MarkupDelegate| {
105            let sender = Rc::downgrade(p);
106            p.stroke_ended(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
107        },
108        StrokeCanceled(Option<Rc<InkStrokeInput>>, InkPointerEventArgs) => |p: &Rc<InkStrokeInput>, handler: MarkupDelegate| {
109            let sender = Rc::downgrade(p);
110            p.stroke_canceled(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
111        },
112    ],
113});
114ferro_markup_type!(class InkUnprocessedInput { namespace: "FerroUI.Controls", handles: [Rc<InkUnprocessedInput>, Option<Rc<InkUnprocessedInput>>], this: Rc<InkUnprocessedInput>,
115    properties: [InkPresenter: Option<Rc<InkPresenter>> { get: |p: &Rc<InkUnprocessedInput>| p.ink_presenter() }],
116    events: [
117        PointerEntered(Option<Rc<InkUnprocessedInput>>, InkPointerEventArgs) => |p: &Rc<InkUnprocessedInput>, handler: MarkupDelegate| {
118            let sender = Rc::downgrade(p);
119            p.pointer_entered(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
120        },
121        PointerHovered(Option<Rc<InkUnprocessedInput>>, InkPointerEventArgs) => |p: &Rc<InkUnprocessedInput>, handler: MarkupDelegate| {
122            let sender = Rc::downgrade(p);
123            p.pointer_hovered(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
124        },
125        PointerExited(Option<Rc<InkUnprocessedInput>>, InkPointerEventArgs) => |p: &Rc<InkUnprocessedInput>, handler: MarkupDelegate| {
126            let sender = Rc::downgrade(p);
127            p.pointer_exited(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
128        },
129        PointerPressed(Option<Rc<InkUnprocessedInput>>, InkPointerEventArgs) => |p: &Rc<InkUnprocessedInput>, handler: MarkupDelegate| {
130            let sender = Rc::downgrade(p);
131            p.pointer_pressed(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
132        },
133        PointerMoved(Option<Rc<InkUnprocessedInput>>, InkPointerEventArgs) => |p: &Rc<InkUnprocessedInput>, handler: MarkupDelegate| {
134            let sender = Rc::downgrade(p);
135            p.pointer_moved(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
136        },
137        PointerReleased(Option<Rc<InkUnprocessedInput>>, InkPointerEventArgs) => |p: &Rc<InkUnprocessedInput>, handler: MarkupDelegate| {
138            let sender = Rc::downgrade(p);
139            p.pointer_released(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
140        },
141        PointerLost(Option<Rc<InkUnprocessedInput>>, InkPointerEventArgs) => |p: &Rc<InkUnprocessedInput>, handler: MarkupDelegate| {
142            let sender = Rc::downgrade(p);
143            p.pointer_lost(move |args| { handler.invoke(&[into_markup_value(sender.upgrade()), into_markup_value(args.clone())]); })
144        },
145    ],
146});
147ferro_markup_type!(class InkSynchronizer {
148    namespace: "FerroUI.Controls", handles: [Rc<InkSynchronizer>, Option<Rc<InkSynchronizer>>], this: Rc<InkSynchronizer>,
149    methods: [
150        try fn BeginDry() -> Vec<Rc<InkStroke>> => |p: &Rc<InkSynchronizer>| p.begin_dry(),
151        try fn EndDry() => |p: &Rc<InkSynchronizer>| p.end_dry(),
152    ],
153});
154ferro_markup_type!(class InkPresenterRuler {
155    namespace: "FerroUI.Controls", handles: [Rc<InkPresenterRuler>, Option<Rc<InkPresenterRuler>>], this: Rc<InkPresenterRuler>,
156    properties: [
157        Kind: InkPresenterStencilKind { get: |p: &Rc<InkPresenterRuler>| p.kind() },
158        IsVisible: bool { get: |p: &Rc<InkPresenterRuler>| p.is_visible(), set: |p: &Rc<InkPresenterRuler>, value| p.set_is_visible(value) },
159        Transform: Matrix { get: |p: &Rc<InkPresenterRuler>| p.transform(), try_set: |p: &Rc<InkPresenterRuler>, value| p.set_transform(value) },
160        Length: f64 { get: |p: &Rc<InkPresenterRuler>| p.length(), try_set: |p: &Rc<InkPresenterRuler>, value| p.set_length(value) },
161        Width: f64 { get: |p: &Rc<InkPresenterRuler>| p.width(), try_set: |p: &Rc<InkPresenterRuler>, value| p.set_width(value) },
162        AreTickMarksVisible: bool { get: |p: &Rc<InkPresenterRuler>| p.are_tick_marks_visible(), set: |p: &Rc<InkPresenterRuler>, value| p.set_are_tick_marks_visible(value) },
163        IsCompassVisible: bool { get: |p: &Rc<InkPresenterRuler>| p.is_compass_visible(), set: |p: &Rc<InkPresenterRuler>, value| p.set_is_compass_visible(value) },
164        BackgroundColor: Color { get: |p: &Rc<InkPresenterRuler>| p.background_color(), set: |p: &Rc<InkPresenterRuler>, value| p.set_background_color(value) },
165        ForegroundColor: Color { get: |p: &Rc<InkPresenterRuler>| p.foreground_color(), set: |p: &Rc<InkPresenterRuler>, value| p.set_foreground_color(value) },
166    ],
167});
168ferro_markup_type!(class InkPresenterProtractor {
169    namespace: "FerroUI.Controls", handles: [Rc<InkPresenterProtractor>, Option<Rc<InkPresenterProtractor>>], this: Rc<InkPresenterProtractor>,
170    properties: [
171        Kind: InkPresenterStencilKind { get: |p: &Rc<InkPresenterProtractor>| p.kind() },
172        IsVisible: bool { get: |p: &Rc<InkPresenterProtractor>| p.is_visible(), set: |p: &Rc<InkPresenterProtractor>, value| p.set_is_visible(value) },
173        Transform: Matrix { get: |p: &Rc<InkPresenterProtractor>| p.transform(), try_set: |p: &Rc<InkPresenterProtractor>, value| p.set_transform(value) },
174        Radius: f64 { get: |p: &Rc<InkPresenterProtractor>| p.radius(), try_set: |p: &Rc<InkPresenterProtractor>, value| p.set_radius(value) },
175        AreTickMarksVisible: bool { get: |p: &Rc<InkPresenterProtractor>| p.are_tick_marks_visible(), set: |p: &Rc<InkPresenterProtractor>, value| p.set_are_tick_marks_visible(value) },
176        AreRaysVisible: bool { get: |p: &Rc<InkPresenterProtractor>| p.are_rays_visible(), set: |p: &Rc<InkPresenterProtractor>, value| p.set_are_rays_visible(value) },
177        IsCenterMarkerVisible: bool { get: |p: &Rc<InkPresenterProtractor>| p.is_center_marker_visible(), set: |p: &Rc<InkPresenterProtractor>, value| p.set_is_center_marker_visible(value) },
178        IsAngleReadoutVisible: bool { get: |p: &Rc<InkPresenterProtractor>| p.is_angle_readout_visible(), set: |p: &Rc<InkPresenterProtractor>, value| p.set_is_angle_readout_visible(value) },
179        IsResizable: bool { get: |p: &Rc<InkPresenterProtractor>| p.is_resizable(), set: |p: &Rc<InkPresenterProtractor>, value| p.set_is_resizable(value) },
180        BackgroundColor: Color { get: |p: &Rc<InkPresenterProtractor>| p.background_color(), set: |p: &Rc<InkPresenterProtractor>, value| p.set_background_color(value) },
181        ForegroundColor: Color { get: |p: &Rc<InkPresenterProtractor>| p.foreground_color(), set: |p: &Rc<InkPresenterProtractor>, value| p.set_foreground_color(value) },
182        AccentColor: Color { get: |p: &Rc<InkPresenterProtractor>| p.accent_color(), set: |p: &Rc<InkPresenterProtractor>, value| p.set_accent_color(value) },
183    ],
184});
185
186ferro_markup_type!(struct InkPoint {
187    namespace: "FerroUI.Controls", handles: [InkPoint],
188    constructors: [try (Point, f32) => InkPoint::new],
189    properties: [
190        Position: Point { get: |p: &InkPoint| p.position },
191        Pressure: f32 { get: |p: &InkPoint| p.pressure },
192        TiltX: f32 { get: |p: &InkPoint| p.tilt_x },
193        TiltY: f32 { get: |p: &InkPoint| p.tilt_y },
194        Twist: f32 { get: |p: &InkPoint| p.twist },
195        Timestamp: u64 { get: |p: &InkPoint| p.timestamp },
196    ],
197});
198ferro_markup_type!(struct InkDrawingAttributes {
199    namespace: "FerroUI.Controls", handles: [InkDrawingAttributes, Option<InkDrawingAttributes>],
200    constructors: [() => InkDrawingAttributes::new],
201    properties: [
202        Color: Color { get: |p: &InkDrawingAttributes| p.color },
203        Size: Size { get: |p: &InkDrawingAttributes| p.size },
204        PenTip: PenTipShape { get: |p: &InkDrawingAttributes| p.pen_tip },
205        PenTipTransform: Matrix { get: |p: &InkDrawingAttributes| p.pen_tip_transform },
206        DrawAsHighlighter: bool { get: |p: &InkDrawingAttributes| p.draw_as_highlighter },
207        IgnorePressure: bool { get: |p: &InkDrawingAttributes| p.ignore_pressure },
208        FitToCurve: bool { get: |p: &InkDrawingAttributes| p.fit_to_curve },
209        IgnoreTilt: bool { get: |p: &InkDrawingAttributes| p.ignore_tilt },
210        Kind: InkDrawingAttributesKind { get: |p: &InkDrawingAttributes| p.kind },
211        PencilOpacity: f64 { get: |p: &InkDrawingAttributes| p.pencil_opacity },
212    ],
213});
214ferro_markup_type!(class InkPointerEventArgs {
215    namespace: "FerroUI.Controls", handles: [InkPointerEventArgs], this: InkPointerEventArgs,
216    properties: [
217        PointerId: i32 { get: |p: &InkPointerEventArgs| p.pointer_id },
218        DeviceType: PointerType { get: |p: &InkPointerEventArgs| p.device_type },
219        Point: InkPoint { get: |p: &InkPointerEventArgs| p.point },
220        Handled: bool { get: InkPointerEventArgs::handled, set: InkPointerEventArgs::set_handled },
221        IsBarrelButtonPressed: bool { get: |p: &InkPointerEventArgs| p.is_barrel_button_pressed },
222        IsEraser: bool { get: |p: &InkPointerEventArgs| p.is_eraser },
223        IsRightButtonPressed: bool { get: |p: &InkPointerEventArgs| p.is_right_button_pressed },
224    ],
225});
226ferro_markup_type!(class InkStrokesCollectedEventArgs {
227    namespace: "FerroUI.Controls", handles: [InkStrokesCollectedEventArgs], this: InkStrokesCollectedEventArgs,
228    properties: [Strokes: Vec<Rc<InkStroke>> { get: |p: &InkStrokesCollectedEventArgs| p.strokes.clone() }],
229});
230ferro_markup_type!(class InkStrokesErasedEventArgs {
231    namespace: "FerroUI.Controls", handles: [InkStrokesErasedEventArgs], this: InkStrokesErasedEventArgs,
232    properties: [Strokes: Vec<Rc<InkStroke>> { get: |p: &InkStrokesErasedEventArgs| p.strokes.clone() }],
233});
234ferro_markup_type!(class InkToolbarIsStencilButtonCheckedChangedEventArgs {
235    namespace: "FerroUI.Controls", handles: [InkToolbarIsStencilButtonCheckedChangedEventArgs], this: InkToolbarIsStencilButtonCheckedChangedEventArgs,
236    properties: [
237        StencilButton: Ref<InkToolbarStencilButton> { get: |p: &InkToolbarIsStencilButtonCheckedChangedEventArgs| p.stencil_button.clone() },
238        StencilKind: InkToolbarStencilKind { get: |p: &InkToolbarIsStencilButtonCheckedChangedEventArgs| p.stencil_kind },
239    ],
240});
241
242pub(crate) const TYPES: &[&MarkupType] = &[
243    <InkPoint as MarkupTyped>::MARKUP,
244    <InkDrawingAttributes as MarkupTyped>::MARKUP,
245    <InkPointerEventArgs as MarkupTyped>::MARKUP,
246    <InkStrokesCollectedEventArgs as MarkupTyped>::MARKUP,
247    <InkStrokesErasedEventArgs as MarkupTyped>::MARKUP,
248    <InkToolbarIsStencilButtonCheckedChangedEventArgs as MarkupTyped>::MARKUP,
249    <CoreInputDeviceTypes as MarkupTyped>::MARKUP,
250    <InkInputProcessingMode as MarkupTyped>::MARKUP,
251    <InkInputRightDragAction as MarkupTyped>::MARKUP,
252    <InkHighContrastAdjustment as MarkupTyped>::MARKUP,
253    <InkPresenterPredefinedConfiguration as MarkupTyped>::MARKUP,
254    <InkPersistenceFormat as MarkupTyped>::MARKUP,
255    <PenTipShape as MarkupTyped>::MARKUP,
256    <InkDrawingAttributesKind as MarkupTyped>::MARKUP,
257    <InkToolbarButtonFlyoutPlacement as MarkupTyped>::MARKUP,
258    <InkToolbarFlyoutItemKind as MarkupTyped>::MARKUP,
259    <InkToolbarInitialControls as MarkupTyped>::MARKUP,
260    <InkToolbarMenuKind as MarkupTyped>::MARKUP,
261    <InkToolbarStencilKind as MarkupTyped>::MARKUP,
262    <InkToolbarToggle as MarkupTyped>::MARKUP,
263    <InkToolbarTool as MarkupTyped>::MARKUP,
264    <InkPresenter as MarkupTyped>::MARKUP,
265    <InkInputProcessingConfiguration as MarkupTyped>::MARKUP,
266    <InkInputConfiguration as MarkupTyped>::MARKUP,
267    <InkStrokeContainer as MarkupTyped>::MARKUP,
268    <InkStroke as MarkupTyped>::MARKUP,
269    <InkStrokeInput as MarkupTyped>::MARKUP,
270    <InkUnprocessedInput as MarkupTyped>::MARKUP,
271    <InkSynchronizer as MarkupTyped>::MARKUP,
272    <InkPresenterRuler as MarkupTyped>::MARKUP,
273    <InkPresenterProtractor as MarkupTyped>::MARKUP,
274    <InkPresenterStencilKind as MarkupTyped>::MARKUP,
275];
276
277pub(crate) fn register_markup() {
278    MarkupType::register_all(TYPES);
279    ValueTypes::register_global(|| {
280        ValueTypes::register_nullable::<Rc<InkPresenter>>();
281        ValueTypes::register_nullable::<Rc<InkInputProcessingConfiguration>>();
282        ValueTypes::register_nullable::<Rc<InkInputConfiguration>>();
283        ValueTypes::register_nullable::<Rc<InkStrokeInput>>();
284        ValueTypes::register_nullable::<Rc<InkUnprocessedInput>>();
285        ValueTypes::register_nullable::<Rc<InkSynchronizer>>();
286        ValueTypes::register_nullable::<InkDrawingAttributes>();
287        ValueTypes::register_nullable::<Rc<InkStrokeContainer>>();
288        ValueTypes::register_nullable::<Rc<InkStroke>>();
289        ValueTypes::register_nullable::<Rc<InkPresenterRuler>>();
290        ValueTypes::register_nullable::<Rc<InkPresenterProtractor>>();
291    });
292}
ferroui_controls_inking/markup.rs

ferroui_controls_inking/
markup.rs
