fidl_fuchsia_ui_pointer__common/
fidl_fuchsia_ui_pointer__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// A floating-point 3x3 matrix.
12/// - The values are placed in column-major order.
13pub type Mat3 = [f32; 9];
14
15/// A floating-point two-dimensional point.
16/// - The values are placed in (x, y) order.
17pub type Point2 = [f32; 2];
18
19/// The relative motion performed by a mouse device.
20/// - The valid range is defined in [`MouseDeviceInfo.RelativeMotionRange`].
21/// - The values are placed in (x, y) order.
22pub type RelativeMotion = [f32; 2];
23
24/// The valid values of relative motion for a mouse device.
25/// - The ranges are placed in (x, y) order.
26pub type RelativeMotionRange = [fidl_fuchsia_input_report__common::Axis; 2];
27
28pub const MOUSE_MAX_EVENT: u32 = 128;
29
30pub const TOUCH_MAX_EVENT: u32 = 128;
31
32/// The possible states of a pointer event. These phases of events in a stream
33/// follow a state machine that starts with the `ADD` phase, followed by zero or
34/// more `CHANGE` phases, and finally terminates with `REMOVE` or `CANCEL`
35/// phase.
36/// ```
37/// ADD ---> CHANGE* -+-> REMOVE
38///                   |
39///                   +-> CANCEL
40/// ```
41///
42/// A finite sequence of pointer events that follows this state machine,
43/// starting from the initial state, is called an **interaction**. A closed (or
44/// past) interaction is one where it has reached the terminal state; an open
45/// (or current) interaction is one where it has not.
46///
47/// For a given device pointer, a stream of events is observed as a succession
48/// of zero or more closed interactions (the past history of user engagement),
49/// followed by at most one open interaction (the current user engagement).
50///
51/// When we need to group pointer events by their interaction, an event carries
52/// an **interaction id** that is unique in that pointer stream. This common
53/// reference makes it possible to operate on a closed interaction, as well as
54/// an open interaction.
55///
56/// For example, touch events are typically observed as a succession of
57/// interactions, as fingers engage and disengage with the display.
58#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
59#[repr(u32)]
60pub enum EventPhase {
61    /// The device has started tracking the pointer.
62    Add = 1,
63    /// The device has reported an update to the pointer state.
64    Change = 2,
65    /// The device has stopped tracking the pointer.
66    Remove = 3,
67    /// The pointer is no longer available.
68    Cancel = 4,
69}
70
71impl EventPhase {
72    #[inline]
73    pub fn from_primitive(prim: u32) -> Option<Self> {
74        match prim {
75            1 => Some(Self::Add),
76            2 => Some(Self::Change),
77            3 => Some(Self::Remove),
78            4 => Some(Self::Cancel),
79            _ => None,
80        }
81    }
82
83    #[inline]
84    pub const fn into_primitive(self) -> u32 {
85        self as u32
86    }
87}
88
89/// A description of mouse event stream's relationship to this view.
90#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
91#[repr(u32)]
92pub enum MouseViewStatus {
93    /// The stream is directed towards this view.
94    Entered = 1,
95    /// The stream is directed away from this view.
96    Exited = 2,
97}
98
99impl MouseViewStatus {
100    #[inline]
101    pub fn from_primitive(prim: u32) -> Option<Self> {
102        match prim {
103            1 => Some(Self::Entered),
104            2 => Some(Self::Exited),
105            _ => None,
106        }
107    }
108
109    #[inline]
110    pub const fn into_primitive(self) -> u32 {
111        self as u32
112    }
113}
114
115/// A description of the interaction's relationship to this client.
116#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
117#[repr(u32)]
118pub enum TouchInteractionStatus {
119    /// The client has been denied ownership of the interaction.
120    Denied = 1,
121    /// The client has been granted ownership of the interaction.
122    Granted = 2,
123}
124
125impl TouchInteractionStatus {
126    #[inline]
127    pub fn from_primitive(prim: u32) -> Option<Self> {
128        match prim {
129            1 => Some(Self::Denied),
130            2 => Some(Self::Granted),
131            _ => None,
132        }
133    }
134
135    #[inline]
136    pub const fn into_primitive(self) -> u32 {
137        self as u32
138    }
139}
140
141/// The possible interaction dispositions that a client can respond with to a
142/// given |TouchPointerSample|. Used as part of a gesture disambiguation scheme.
143///
144/// The responses are based on the idea of an ownership claim on a interaction.
145/// Clients may assert a claim of ownership on an open interaction, but only one
146/// client's claim is granted by the server; other clients' claims are denied.
147#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
148#[repr(u32)]
149pub enum TouchResponseType {
150    /// The client has no further interest in this interaction; it declines
151    /// ownership of the interaction. The client will stop receiving events for
152    /// this interaction.
153    No = 1,
154    /// The client is interested in this interaction, but needs to see more
155    /// events to decide; the client has not yet claimed ownership of this
156    /// interaction.
157    Maybe = 2,
158    /// The client is interested in this interaction, but needs to see more
159    /// events to decide; the client has not yet claimed ownership of the
160    /// interaction. During ownership resolution, it exerts its priority over
161    /// lower-priority "maybe" claims, but always loses to a "yes" claim.
162    MaybePrioritize = 3,
163    /// The client is interested in this interaction, but needs to see more
164    /// events to decide; the client has not yet claimed ownership of the
165    /// interaction. Moreover, it suppresses lower-priority claims that try to
166    /// resolve interaction ownership.
167    MaybeSuppress = 4,
168    /// The client is interested in this interaction, but needs to see more
169    /// events to decide; the client has not yet claimed ownership of the
170    /// interaction. Moreover, it suppresses lower-priority claims that try to
171    /// resolve interaction ownership. During ownership resolution, it exerts
172    /// its priority over lower-priority "maybe" claims, but always loses to a
173    /// "yes" claim.
174    MaybePrioritizeSuppress = 5,
175    /// The client is interested in this interaction, but needs to see a
176    /// subsequent interaction to decide; the client has not yet claimed
177    /// ownership of this interaction. It prevents ownership resolution when the
178    /// interaction closes.
179    Hold = 6,
180    /// The client is interested in this interaction, but needs to see a
181    /// subsequent interaction to decide; the client has not yet claimed
182    /// ownership of this interaction. It prevents ownership resolution when the
183    /// interaction closes. Moreover, it suppresses lower-priority claims that
184    /// try to resolve interaction ownership.
185    HoldSuppress = 7,
186    /// The client wishes exclusive access to the remaining events in this
187    /// interaction; it claims ownership of this interaction (but that claim may
188    /// be granted or denied). During ownership resolution, it yields its
189    /// priority to lower-priority "yes" claims.
190    Yes = 8,
191    /// The client wishes exclusive access to the remaining events in this
192    /// interaction; it claims ownership of this interaction (but that claim may
193    /// be granted or denied). During ownership resolution, it exerts its
194    /// priority over lower-priority "yes" claims.
195    YesPrioritize = 9,
196}
197
198impl TouchResponseType {
199    #[inline]
200    pub fn from_primitive(prim: u32) -> Option<Self> {
201        match prim {
202            1 => Some(Self::No),
203            2 => Some(Self::Maybe),
204            3 => Some(Self::MaybePrioritize),
205            4 => Some(Self::MaybeSuppress),
206            5 => Some(Self::MaybePrioritizeSuppress),
207            6 => Some(Self::Hold),
208            7 => Some(Self::HoldSuppress),
209            8 => Some(Self::Yes),
210            9 => Some(Self::YesPrioritize),
211            _ => None,
212        }
213    }
214
215    #[inline]
216    pub const fn into_primitive(self) -> u32 {
217        self as u32
218    }
219}
220
221/// The status of a mouse event stream, sent from server to client.
222///
223/// Invariant: a client's mouse events are bracketed by
224/// [`MouseViewStatus.ENTERED`] and [`MouseViewStatus.EXITED`].
225#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
226pub struct MouseEventStreamInfo {
227    /// An identifier for the mouse device that issues a mouse event stream.
228    pub device_id: u32,
229    /// The mouse event stream's enter/exit status, sent from server to client.
230    pub status: MouseViewStatus,
231}
232
233impl fidl::Persistable for MouseEventStreamInfo {}
234
235#[derive(Clone, Debug, PartialEq)]
236pub struct MouseSourceWatchResponse {
237    pub events: Vec<MouseEvent>,
238}
239
240impl fidl::Persistable for MouseSourceWatchResponse {}
241
242/// An axis-aligned rectangle. It is defined by its minimal and maximal extents
243/// in a coordinate system.
244#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
245pub struct Rectangle {
246    /// The minimal extent of this rectangle, inclusive.
247    /// - Its coordinates are pairwise less than the maximal extent's
248    ///   coordinates.
249    pub min: [f32; 2],
250    /// The maximal extent of this rectangle, inclusive.
251    /// - Its coordinates are pairwise greater than the minimal extent's
252    ///   coordinates.
253    pub max: [f32; 2],
254}
255
256impl fidl::Persistable for Rectangle {}
257
258/// A unique identifier for a "interaction" of touch events in an event stream.
259/// Touch events are observed as a succession of interactions, as fingers engage
260/// and disengage with the display.
261///
262/// A finite sequence of pointer events that follows the `EventPhase` state
263/// machine, starting from the initial state ADD, is called an **interaction**.
264/// A closed (or past) interaction is one where it has reached the terminal
265/// state (REMOVE or CANCEL); an open (or current) interaction is one where it
266/// has not.
267///
268/// For a given device pointer, a stream of events is observed as a succession
269/// of zero or more closed interactions (the past history of user engagement),
270/// followed by at most one open interaction (the current user engagement).
271///
272/// Because we need to group pointer events by their interaction, touch event
273/// carries an **interaction id** that is unique in that pointer stream. This
274/// common reference makes it possible to operate on a closed interaction, as
275/// well as an open interaction.
276///
277/// Also see `EventPhase` for a discussion on event streams by mice.
278#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
279#[repr(C)]
280pub struct TouchInteractionId {
281    /// An identifier for the pointer device that issues touch event streams.
282    /// A device may own multiple pointers, each with its own |pointer_id|.
283    pub device_id: u32,
284    /// An identifier of the pointer that issued this event. It is unique only
285    /// to a specific |device_id|. Each (device_id, pointer_id) pair issues at
286    /// most one open interaction at a time.
287    pub pointer_id: u32,
288    /// An identifier of the interaction. It is unique only to a specific
289    /// (device_id, pointer_id) pair.
290    pub interaction_id: u32,
291}
292
293impl fidl::Persistable for TouchInteractionId {}
294
295/// The result of gesture disambiguation for a interaction of touch events, sent
296/// from server to client.
297#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
298pub struct TouchInteractionResult {
299    /// The interaction that this pointer sample belongs to.
300    pub interaction: TouchInteractionId,
301    /// The interaction's disposition, sent from server to client.
302    pub status: TouchInteractionStatus,
303}
304
305impl fidl::Persistable for TouchInteractionResult {}
306
307#[derive(Clone, Debug, PartialEq)]
308pub struct TouchSourceUpdateResponseRequest {
309    pub interaction: TouchInteractionId,
310    pub response: TouchResponse,
311}
312
313impl fidl::Persistable for TouchSourceUpdateResponseRequest {}
314
315#[derive(Clone, Debug, PartialEq)]
316pub struct TouchSourceWatchRequest {
317    pub responses: Vec<TouchResponse>,
318}
319
320impl fidl::Persistable for TouchSourceWatchRequest {}
321
322#[derive(Clone, Debug, PartialEq)]
323pub struct TouchSourceWatchResponse {
324    pub events: Vec<TouchEvent>,
325}
326
327impl fidl::Persistable for TouchSourceWatchResponse {}
328
329/// The parameters of the associated view and viewport, sufficient to correctly
330/// interpret the position and scale of pointer events dispatched to this view.
331///
332/// Ordering. These parameters arrive over the same channel as pointer events,
333/// to provide synchronous context for interpreting the position of pointer
334/// events in the view's local coordinate system.
335///
336/// Inter-protocol redundancy. Some of these parameters may also be sent over an
337/// independent channel dedicated to view control; the client is responsible for
338/// correct use of asynchronously received parameters.
339///
340/// TODO(https://fxbug.dev/42162292): Rename viewport, it is used in Flatland.
341#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
342pub struct ViewParameters {
343    /// The view's area of content, placed in the coordinate system of the view.
344    ///
345    /// The rectangle is defined by the parent view's setup of clipping on this
346    /// view.
347    pub view: Rectangle,
348    /// The viewport's area of interaction, placed in an independent coordinate
349    /// system.
350    ///
351    /// A pointer event's position is defined in the coordinate system of this
352    /// viewport.
353    ///
354    /// A change in viewport extents means the region for pointer interaction
355    /// has itself moved, or changed in size, or both.
356    pub viewport: Rectangle,
357    /// The transform matrix that relates a point's position in the viewport's
358    /// coordinate system to its position in the view's coordinate system.
359    pub viewport_to_view_transform: [f32; 9],
360}
361
362impl fidl::Persistable for ViewParameters {}
363
364/// Information about a device that issues a mouse event stream.
365#[derive(Clone, Debug, Default, PartialEq)]
366pub struct MouseDeviceInfo {
367    /// An identifier for the mouse device that issues a mouse event stream.
368    /// Required.
369    pub id: Option<u32>,
370    /// Range of vertical scroll values issued by the device.
371    pub scroll_v_range: Option<fidl_fuchsia_input_report__common::Axis>,
372    /// Range of horizontal scroll values issued by the device.
373    pub scroll_h_range: Option<fidl_fuchsia_input_report__common::Axis>,
374    /// Button identifiers issued by the device, in priority order.
375    pub buttons: Option<Vec<u8>>,
376    /// Range of relative movement values issued by the device.
377    pub relative_motion_range: Option<[fidl_fuchsia_input_report__common::Axis; 2]>,
378    #[doc(hidden)]
379    pub __source_breaking: fidl::marker::SourceBreaking,
380}
381
382impl fidl::Persistable for MouseDeviceInfo {}
383
384/// The self-sufficient, self-consistent collection of pointer-related data,
385/// sent from server to client.
386#[derive(Clone, Debug, Default, PartialEq)]
387pub struct MouseEvent {
388    /// The time this event was observed.
389    /// Required.
390    pub timestamp: Option<i64>,
391    /// The parameters of the associated view and viewport, sufficient to
392    /// correctly interpret the position, orientation, magnitude, and
393    /// inter-event distance of pointer events dispatched to a view.
394    /// - It is issued on connection and on change.
395    pub view_parameters: Option<ViewParameters>,
396    /// A description of the mouse device, sufficient to correctly interpret
397    /// the capabilities and usage intent of the device.
398    /// - It is issued once per device.
399    pub device_info: Option<MouseDeviceInfo>,
400    /// A description of each sampled data point in a mouse event stream.
401    ///
402    /// Issuance policy. There are two dispatch modes, "hover" and "latched".
403    /// Hover mode is default, and the stream is dispatched in fragments to the
404    /// visible client that each mouse event hovers above. Latched mode directs
405    /// the stream to a single client (regardless of view boundary) until
406    /// unlatched. Latched mode is typically toggled when the user presses the
407    /// primary mouse button, but is ultimately a product-specific policy.
408    pub pointer_sample: Option<MousePointerSample>,
409    /// The signal for view entry/exit in hover mode.
410    /// - It is issued on hover entry into a view, and hover exit from a view.
411    pub stream_info: Option<MouseEventStreamInfo>,
412    /// An identifier to correlate this event's send/receive occurrence across
413    /// component boundaries or abstraction layers.
414    pub trace_flow_id: Option<u64>,
415    #[doc(hidden)]
416    pub __source_breaking: fidl::marker::SourceBreaking,
417}
418
419impl fidl::Persistable for MouseEvent {}
420
421/// A description of each sampled data point in a mouse event stream.
422///
423/// `MousePointerSample` may bundle multiple state changes into one event.
424/// For example, if user scrolls mouse wheel and presses the left buttton
425/// down at the same time, client may receive scroll and button state changes
426/// together in 1 event, or receive button change and scroll change in
427/// separate events.
428#[derive(Clone, Debug, Default, PartialEq)]
429pub struct MousePointerSample {
430    /// An identifier for the mouse device that issues a mouse event stream.
431    /// Required.
432    pub device_id: Option<u32>,
433    /// The position of this event, in the viewport's coordinate system.
434    /// Required.
435    pub position_in_viewport: Option<[f32; 2]>,
436    /// Relative vertical scrolling displacement by detent.
437    pub scroll_v: Option<i64>,
438    /// Relative horizontal scrolling displacement by detent.
439    pub scroll_h: Option<i64>,
440    /// Identifiers of currently pressed buttons.
441    pub pressed_buttons: Option<Vec<u8>>,
442    /// The relative movement performed, independent of the viewport's
443    /// coordinate system.
444    pub relative_motion: Option<[f32; 2]>,
445    /// Recommended vertical scrolling displacement by physical pixel, it is
446    /// computed with accelerator, detent / mm to pixel ratio, etc.
447    pub scroll_v_physical_pixel: Option<f64>,
448    /// Recommended horizontal scrolling displacement by physical pixel, it
449    /// is computed with accelerator, detent / mm to pixel ratio, etc.
450    pub scroll_h_physical_pixel: Option<f64>,
451    /// Indicated if the scroll event is from a precision scroll device (HI_RES
452    /// mouse or touchpad). Clients may want to play interpolation animations
453    /// on non precision scroll device for smooth scrolling.
454    pub is_precision_scroll: Option<bool>,
455    #[doc(hidden)]
456    pub __source_breaking: fidl::marker::SourceBreaking,
457}
458
459impl fidl::Persistable for MousePointerSample {}
460
461/// Information about a device that issues touch event streams.
462#[derive(Clone, Debug, Default, PartialEq)]
463pub struct TouchDeviceInfo {
464    /// An identifier for the touch device that issues touch event streams.
465    /// A device may own multiple pointers, each with its own pointer id and its
466    /// own touch event stream.
467    /// Required.
468    pub id: Option<u32>,
469    #[doc(hidden)]
470    pub __source_breaking: fidl::marker::SourceBreaking,
471}
472
473impl fidl::Persistable for TouchDeviceInfo {}
474
475/// The self-sufficient, self-consistent collection of pointer-related data,
476/// sent from server to client.
477#[derive(Clone, Debug, Default, PartialEq)]
478pub struct TouchEvent {
479    /// The time this event was observed.
480    /// Required.
481    pub timestamp: Option<i64>,
482    /// The parameters of the associated view and viewport, sufficient to
483    /// correctly interpret the position, orientation, magnitude, and
484    /// inter-event distance of touch events dispatched to a view.
485    /// - It is issued on connection and on change.
486    pub view_parameters: Option<ViewParameters>,
487    /// A description of the pointer device, sufficient to correctly interpret
488    /// the capabilities and usage intent of the device.
489    /// - It is issued once per device.
490    pub device_info: Option<TouchDeviceInfo>,
491    /// A description of each sampled data point in an interaction of touch
492    /// events.
493    /// - It is issued on every sample in the interaction.
494    pub pointer_sample: Option<TouchPointerSample>,
495    /// The result of gesture disambiguation for a interaction of touch events.
496    /// - It is issued once per interaction.
497    pub interaction_result: Option<TouchInteractionResult>,
498    /// An identifier to correlate this event's send/receive occurrence across
499    /// component boundaries or abstraction layers.
500    pub trace_flow_id: Option<u64>,
501    #[doc(hidden)]
502    pub __source_breaking: fidl::marker::SourceBreaking,
503}
504
505impl fidl::Persistable for TouchEvent {}
506
507/// A description of each sampled data point in a touch event stream.
508/// All fields are required.
509#[derive(Clone, Debug, Default, PartialEq)]
510pub struct TouchPointerSample {
511    /// The interaction that this pointer sample belongs to.
512    pub interaction: Option<TouchInteractionId>,
513    /// The state of this event in the interaction's state machine.
514    pub phase: Option<EventPhase>,
515    /// The position of this event, in the viewport's coordinate system.
516    pub position_in_viewport: Option<[f32; 2]>,
517    #[doc(hidden)]
518    pub __source_breaking: fidl::marker::SourceBreaking,
519}
520
521impl fidl::Persistable for TouchPointerSample {}
522
523/// A feedback event per |Event|, sent from client to server.
524///
525/// Only |TouchPointerSample| requires a |TouchResponseType|; for other events,
526/// the server expects an empty |TouchResponse| table.
527#[derive(Clone, Debug, Default, PartialEq)]
528pub struct TouchResponse {
529    /// The interaction disposition that a client responds with for a given
530    /// |TouchPointerSample|.
531    pub response_type: Option<TouchResponseType>,
532    /// An identifier to correlate this response's send/receive occurrence across
533    /// component boundaries or abstraction layers.
534    pub trace_flow_id: Option<u64>,
535    #[doc(hidden)]
536    pub __source_breaking: fidl::marker::SourceBreaking,
537}
538
539impl fidl::Persistable for TouchResponse {}
540
541pub mod mouse_source_ordinals {
542    pub const WATCH: u64 = 0x5b1f6e917ac1abb4;
543}
544
545pub mod touch_source_ordinals {
546    pub const WATCH: u64 = 0x38453127dd0fc7d;
547    pub const UPDATE_RESPONSE: u64 = 0x6c746a313b39898a;
548}
549
550mod internal {
551    use super::*;
552    unsafe impl fidl::encoding::TypeMarker for EventPhase {
553        type Owned = Self;
554
555        #[inline(always)]
556        fn inline_align(_context: fidl::encoding::Context) -> usize {
557            std::mem::align_of::<u32>()
558        }
559
560        #[inline(always)]
561        fn inline_size(_context: fidl::encoding::Context) -> usize {
562            std::mem::size_of::<u32>()
563        }
564
565        #[inline(always)]
566        fn encode_is_copy() -> bool {
567            true
568        }
569
570        #[inline(always)]
571        fn decode_is_copy() -> bool {
572            false
573        }
574    }
575
576    impl fidl::encoding::ValueTypeMarker for EventPhase {
577        type Borrowed<'a> = Self;
578        #[inline(always)]
579        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
580            *value
581        }
582    }
583
584    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EventPhase {
585        #[inline]
586        unsafe fn encode(
587            self,
588            encoder: &mut fidl::encoding::Encoder<'_, D>,
589            offset: usize,
590            _depth: fidl::encoding::Depth,
591        ) -> fidl::Result<()> {
592            encoder.debug_check_bounds::<Self>(offset);
593            encoder.write_num(self.into_primitive(), offset);
594            Ok(())
595        }
596    }
597
598    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventPhase {
599        #[inline(always)]
600        fn new_empty() -> Self {
601            Self::Add
602        }
603
604        #[inline]
605        unsafe fn decode(
606            &mut self,
607            decoder: &mut fidl::encoding::Decoder<'_, D>,
608            offset: usize,
609            _depth: fidl::encoding::Depth,
610        ) -> fidl::Result<()> {
611            decoder.debug_check_bounds::<Self>(offset);
612            let prim = decoder.read_num::<u32>(offset);
613
614            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
615            Ok(())
616        }
617    }
618    unsafe impl fidl::encoding::TypeMarker for MouseViewStatus {
619        type Owned = Self;
620
621        #[inline(always)]
622        fn inline_align(_context: fidl::encoding::Context) -> usize {
623            std::mem::align_of::<u32>()
624        }
625
626        #[inline(always)]
627        fn inline_size(_context: fidl::encoding::Context) -> usize {
628            std::mem::size_of::<u32>()
629        }
630
631        #[inline(always)]
632        fn encode_is_copy() -> bool {
633            true
634        }
635
636        #[inline(always)]
637        fn decode_is_copy() -> bool {
638            false
639        }
640    }
641
642    impl fidl::encoding::ValueTypeMarker for MouseViewStatus {
643        type Borrowed<'a> = Self;
644        #[inline(always)]
645        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
646            *value
647        }
648    }
649
650    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
651        for MouseViewStatus
652    {
653        #[inline]
654        unsafe fn encode(
655            self,
656            encoder: &mut fidl::encoding::Encoder<'_, D>,
657            offset: usize,
658            _depth: fidl::encoding::Depth,
659        ) -> fidl::Result<()> {
660            encoder.debug_check_bounds::<Self>(offset);
661            encoder.write_num(self.into_primitive(), offset);
662            Ok(())
663        }
664    }
665
666    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MouseViewStatus {
667        #[inline(always)]
668        fn new_empty() -> Self {
669            Self::Entered
670        }
671
672        #[inline]
673        unsafe fn decode(
674            &mut self,
675            decoder: &mut fidl::encoding::Decoder<'_, D>,
676            offset: usize,
677            _depth: fidl::encoding::Depth,
678        ) -> fidl::Result<()> {
679            decoder.debug_check_bounds::<Self>(offset);
680            let prim = decoder.read_num::<u32>(offset);
681
682            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
683            Ok(())
684        }
685    }
686    unsafe impl fidl::encoding::TypeMarker for TouchInteractionStatus {
687        type Owned = Self;
688
689        #[inline(always)]
690        fn inline_align(_context: fidl::encoding::Context) -> usize {
691            std::mem::align_of::<u32>()
692        }
693
694        #[inline(always)]
695        fn inline_size(_context: fidl::encoding::Context) -> usize {
696            std::mem::size_of::<u32>()
697        }
698
699        #[inline(always)]
700        fn encode_is_copy() -> bool {
701            true
702        }
703
704        #[inline(always)]
705        fn decode_is_copy() -> bool {
706            false
707        }
708    }
709
710    impl fidl::encoding::ValueTypeMarker for TouchInteractionStatus {
711        type Borrowed<'a> = Self;
712        #[inline(always)]
713        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
714            *value
715        }
716    }
717
718    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
719        for TouchInteractionStatus
720    {
721        #[inline]
722        unsafe fn encode(
723            self,
724            encoder: &mut fidl::encoding::Encoder<'_, D>,
725            offset: usize,
726            _depth: fidl::encoding::Depth,
727        ) -> fidl::Result<()> {
728            encoder.debug_check_bounds::<Self>(offset);
729            encoder.write_num(self.into_primitive(), offset);
730            Ok(())
731        }
732    }
733
734    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
735        for TouchInteractionStatus
736    {
737        #[inline(always)]
738        fn new_empty() -> Self {
739            Self::Denied
740        }
741
742        #[inline]
743        unsafe fn decode(
744            &mut self,
745            decoder: &mut fidl::encoding::Decoder<'_, D>,
746            offset: usize,
747            _depth: fidl::encoding::Depth,
748        ) -> fidl::Result<()> {
749            decoder.debug_check_bounds::<Self>(offset);
750            let prim = decoder.read_num::<u32>(offset);
751
752            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
753            Ok(())
754        }
755    }
756    unsafe impl fidl::encoding::TypeMarker for TouchResponseType {
757        type Owned = Self;
758
759        #[inline(always)]
760        fn inline_align(_context: fidl::encoding::Context) -> usize {
761            std::mem::align_of::<u32>()
762        }
763
764        #[inline(always)]
765        fn inline_size(_context: fidl::encoding::Context) -> usize {
766            std::mem::size_of::<u32>()
767        }
768
769        #[inline(always)]
770        fn encode_is_copy() -> bool {
771            true
772        }
773
774        #[inline(always)]
775        fn decode_is_copy() -> bool {
776            false
777        }
778    }
779
780    impl fidl::encoding::ValueTypeMarker for TouchResponseType {
781        type Borrowed<'a> = Self;
782        #[inline(always)]
783        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
784            *value
785        }
786    }
787
788    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
789        for TouchResponseType
790    {
791        #[inline]
792        unsafe fn encode(
793            self,
794            encoder: &mut fidl::encoding::Encoder<'_, D>,
795            offset: usize,
796            _depth: fidl::encoding::Depth,
797        ) -> fidl::Result<()> {
798            encoder.debug_check_bounds::<Self>(offset);
799            encoder.write_num(self.into_primitive(), offset);
800            Ok(())
801        }
802    }
803
804    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchResponseType {
805        #[inline(always)]
806        fn new_empty() -> Self {
807            Self::No
808        }
809
810        #[inline]
811        unsafe fn decode(
812            &mut self,
813            decoder: &mut fidl::encoding::Decoder<'_, D>,
814            offset: usize,
815            _depth: fidl::encoding::Depth,
816        ) -> fidl::Result<()> {
817            decoder.debug_check_bounds::<Self>(offset);
818            let prim = decoder.read_num::<u32>(offset);
819
820            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
821            Ok(())
822        }
823    }
824
825    impl fidl::encoding::ValueTypeMarker for MouseEventStreamInfo {
826        type Borrowed<'a> = &'a Self;
827        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
828            value
829        }
830    }
831
832    unsafe impl fidl::encoding::TypeMarker for MouseEventStreamInfo {
833        type Owned = Self;
834
835        #[inline(always)]
836        fn inline_align(_context: fidl::encoding::Context) -> usize {
837            4
838        }
839
840        #[inline(always)]
841        fn inline_size(_context: fidl::encoding::Context) -> usize {
842            8
843        }
844    }
845
846    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MouseEventStreamInfo, D>
847        for &MouseEventStreamInfo
848    {
849        #[inline]
850        unsafe fn encode(
851            self,
852            encoder: &mut fidl::encoding::Encoder<'_, D>,
853            offset: usize,
854            _depth: fidl::encoding::Depth,
855        ) -> fidl::Result<()> {
856            encoder.debug_check_bounds::<MouseEventStreamInfo>(offset);
857            // Delegate to tuple encoding.
858            fidl::encoding::Encode::<MouseEventStreamInfo, D>::encode(
859                (
860                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_id),
861                    <MouseViewStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
862                ),
863                encoder,
864                offset,
865                _depth,
866            )
867        }
868    }
869    unsafe impl<
870            D: fidl::encoding::ResourceDialect,
871            T0: fidl::encoding::Encode<u32, D>,
872            T1: fidl::encoding::Encode<MouseViewStatus, D>,
873        > fidl::encoding::Encode<MouseEventStreamInfo, D> for (T0, T1)
874    {
875        #[inline]
876        unsafe fn encode(
877            self,
878            encoder: &mut fidl::encoding::Encoder<'_, D>,
879            offset: usize,
880            depth: fidl::encoding::Depth,
881        ) -> fidl::Result<()> {
882            encoder.debug_check_bounds::<MouseEventStreamInfo>(offset);
883            // Zero out padding regions. There's no need to apply masks
884            // because the unmasked parts will be overwritten by fields.
885            // Write the fields.
886            self.0.encode(encoder, offset + 0, depth)?;
887            self.1.encode(encoder, offset + 4, depth)?;
888            Ok(())
889        }
890    }
891
892    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MouseEventStreamInfo {
893        #[inline(always)]
894        fn new_empty() -> Self {
895            Self {
896                device_id: fidl::new_empty!(u32, D),
897                status: fidl::new_empty!(MouseViewStatus, D),
898            }
899        }
900
901        #[inline]
902        unsafe fn decode(
903            &mut self,
904            decoder: &mut fidl::encoding::Decoder<'_, D>,
905            offset: usize,
906            _depth: fidl::encoding::Depth,
907        ) -> fidl::Result<()> {
908            decoder.debug_check_bounds::<Self>(offset);
909            // Verify that padding bytes are zero.
910            fidl::decode!(u32, D, &mut self.device_id, decoder, offset + 0, _depth)?;
911            fidl::decode!(MouseViewStatus, D, &mut self.status, decoder, offset + 4, _depth)?;
912            Ok(())
913        }
914    }
915
916    impl fidl::encoding::ValueTypeMarker for MouseSourceWatchResponse {
917        type Borrowed<'a> = &'a Self;
918        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
919            value
920        }
921    }
922
923    unsafe impl fidl::encoding::TypeMarker for MouseSourceWatchResponse {
924        type Owned = Self;
925
926        #[inline(always)]
927        fn inline_align(_context: fidl::encoding::Context) -> usize {
928            8
929        }
930
931        #[inline(always)]
932        fn inline_size(_context: fidl::encoding::Context) -> usize {
933            16
934        }
935    }
936
937    unsafe impl<D: fidl::encoding::ResourceDialect>
938        fidl::encoding::Encode<MouseSourceWatchResponse, D> for &MouseSourceWatchResponse
939    {
940        #[inline]
941        unsafe fn encode(
942            self,
943            encoder: &mut fidl::encoding::Encoder<'_, D>,
944            offset: usize,
945            _depth: fidl::encoding::Depth,
946        ) -> fidl::Result<()> {
947            encoder.debug_check_bounds::<MouseSourceWatchResponse>(offset);
948            // Delegate to tuple encoding.
949            fidl::encoding::Encode::<MouseSourceWatchResponse, D>::encode(
950                (
951                    <fidl::encoding::Vector<MouseEvent, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.events),
952                ),
953                encoder, offset, _depth
954            )
955        }
956    }
957    unsafe impl<
958            D: fidl::encoding::ResourceDialect,
959            T0: fidl::encoding::Encode<fidl::encoding::Vector<MouseEvent, 128>, D>,
960        > fidl::encoding::Encode<MouseSourceWatchResponse, D> for (T0,)
961    {
962        #[inline]
963        unsafe fn encode(
964            self,
965            encoder: &mut fidl::encoding::Encoder<'_, D>,
966            offset: usize,
967            depth: fidl::encoding::Depth,
968        ) -> fidl::Result<()> {
969            encoder.debug_check_bounds::<MouseSourceWatchResponse>(offset);
970            // Zero out padding regions. There's no need to apply masks
971            // because the unmasked parts will be overwritten by fields.
972            // Write the fields.
973            self.0.encode(encoder, offset + 0, depth)?;
974            Ok(())
975        }
976    }
977
978    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
979        for MouseSourceWatchResponse
980    {
981        #[inline(always)]
982        fn new_empty() -> Self {
983            Self { events: fidl::new_empty!(fidl::encoding::Vector<MouseEvent, 128>, D) }
984        }
985
986        #[inline]
987        unsafe fn decode(
988            &mut self,
989            decoder: &mut fidl::encoding::Decoder<'_, D>,
990            offset: usize,
991            _depth: fidl::encoding::Depth,
992        ) -> fidl::Result<()> {
993            decoder.debug_check_bounds::<Self>(offset);
994            // Verify that padding bytes are zero.
995            fidl::decode!(fidl::encoding::Vector<MouseEvent, 128>, D, &mut self.events, decoder, offset + 0, _depth)?;
996            Ok(())
997        }
998    }
999
1000    impl fidl::encoding::ValueTypeMarker for Rectangle {
1001        type Borrowed<'a> = &'a Self;
1002        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1003            value
1004        }
1005    }
1006
1007    unsafe impl fidl::encoding::TypeMarker for Rectangle {
1008        type Owned = Self;
1009
1010        #[inline(always)]
1011        fn inline_align(_context: fidl::encoding::Context) -> usize {
1012            4
1013        }
1014
1015        #[inline(always)]
1016        fn inline_size(_context: fidl::encoding::Context) -> usize {
1017            16
1018        }
1019    }
1020
1021    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Rectangle, D>
1022        for &Rectangle
1023    {
1024        #[inline]
1025        unsafe fn encode(
1026            self,
1027            encoder: &mut fidl::encoding::Encoder<'_, D>,
1028            offset: usize,
1029            _depth: fidl::encoding::Depth,
1030        ) -> fidl::Result<()> {
1031            encoder.debug_check_bounds::<Rectangle>(offset);
1032            // Delegate to tuple encoding.
1033            fidl::encoding::Encode::<Rectangle, D>::encode(
1034                (
1035                    <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow(
1036                        &self.min,
1037                    ),
1038                    <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow(
1039                        &self.max,
1040                    ),
1041                ),
1042                encoder,
1043                offset,
1044                _depth,
1045            )
1046        }
1047    }
1048    unsafe impl<
1049            D: fidl::encoding::ResourceDialect,
1050            T0: fidl::encoding::Encode<fidl::encoding::Array<f32, 2>, D>,
1051            T1: fidl::encoding::Encode<fidl::encoding::Array<f32, 2>, D>,
1052        > fidl::encoding::Encode<Rectangle, D> for (T0, T1)
1053    {
1054        #[inline]
1055        unsafe fn encode(
1056            self,
1057            encoder: &mut fidl::encoding::Encoder<'_, D>,
1058            offset: usize,
1059            depth: fidl::encoding::Depth,
1060        ) -> fidl::Result<()> {
1061            encoder.debug_check_bounds::<Rectangle>(offset);
1062            // Zero out padding regions. There's no need to apply masks
1063            // because the unmasked parts will be overwritten by fields.
1064            // Write the fields.
1065            self.0.encode(encoder, offset + 0, depth)?;
1066            self.1.encode(encoder, offset + 8, depth)?;
1067            Ok(())
1068        }
1069    }
1070
1071    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Rectangle {
1072        #[inline(always)]
1073        fn new_empty() -> Self {
1074            Self {
1075                min: fidl::new_empty!(fidl::encoding::Array<f32, 2>, D),
1076                max: fidl::new_empty!(fidl::encoding::Array<f32, 2>, D),
1077            }
1078        }
1079
1080        #[inline]
1081        unsafe fn decode(
1082            &mut self,
1083            decoder: &mut fidl::encoding::Decoder<'_, D>,
1084            offset: usize,
1085            _depth: fidl::encoding::Depth,
1086        ) -> fidl::Result<()> {
1087            decoder.debug_check_bounds::<Self>(offset);
1088            // Verify that padding bytes are zero.
1089            fidl::decode!(fidl::encoding::Array<f32, 2>, D, &mut self.min, decoder, offset + 0, _depth)?;
1090            fidl::decode!(fidl::encoding::Array<f32, 2>, D, &mut self.max, decoder, offset + 8, _depth)?;
1091            Ok(())
1092        }
1093    }
1094
1095    impl fidl::encoding::ValueTypeMarker for TouchInteractionId {
1096        type Borrowed<'a> = &'a Self;
1097        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1098            value
1099        }
1100    }
1101
1102    unsafe impl fidl::encoding::TypeMarker for TouchInteractionId {
1103        type Owned = Self;
1104
1105        #[inline(always)]
1106        fn inline_align(_context: fidl::encoding::Context) -> usize {
1107            4
1108        }
1109
1110        #[inline(always)]
1111        fn inline_size(_context: fidl::encoding::Context) -> usize {
1112            12
1113        }
1114        #[inline(always)]
1115        fn encode_is_copy() -> bool {
1116            true
1117        }
1118
1119        #[inline(always)]
1120        fn decode_is_copy() -> bool {
1121            true
1122        }
1123    }
1124
1125    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TouchInteractionId, D>
1126        for &TouchInteractionId
1127    {
1128        #[inline]
1129        unsafe fn encode(
1130            self,
1131            encoder: &mut fidl::encoding::Encoder<'_, D>,
1132            offset: usize,
1133            _depth: fidl::encoding::Depth,
1134        ) -> fidl::Result<()> {
1135            encoder.debug_check_bounds::<TouchInteractionId>(offset);
1136            unsafe {
1137                // Copy the object into the buffer.
1138                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1139                (buf_ptr as *mut TouchInteractionId)
1140                    .write_unaligned((self as *const TouchInteractionId).read());
1141                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1142                // done second because the memcpy will write garbage to these bytes.
1143            }
1144            Ok(())
1145        }
1146    }
1147    unsafe impl<
1148            D: fidl::encoding::ResourceDialect,
1149            T0: fidl::encoding::Encode<u32, D>,
1150            T1: fidl::encoding::Encode<u32, D>,
1151            T2: fidl::encoding::Encode<u32, D>,
1152        > fidl::encoding::Encode<TouchInteractionId, D> for (T0, T1, T2)
1153    {
1154        #[inline]
1155        unsafe fn encode(
1156            self,
1157            encoder: &mut fidl::encoding::Encoder<'_, D>,
1158            offset: usize,
1159            depth: fidl::encoding::Depth,
1160        ) -> fidl::Result<()> {
1161            encoder.debug_check_bounds::<TouchInteractionId>(offset);
1162            // Zero out padding regions. There's no need to apply masks
1163            // because the unmasked parts will be overwritten by fields.
1164            // Write the fields.
1165            self.0.encode(encoder, offset + 0, depth)?;
1166            self.1.encode(encoder, offset + 4, depth)?;
1167            self.2.encode(encoder, offset + 8, depth)?;
1168            Ok(())
1169        }
1170    }
1171
1172    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchInteractionId {
1173        #[inline(always)]
1174        fn new_empty() -> Self {
1175            Self {
1176                device_id: fidl::new_empty!(u32, D),
1177                pointer_id: fidl::new_empty!(u32, D),
1178                interaction_id: fidl::new_empty!(u32, D),
1179            }
1180        }
1181
1182        #[inline]
1183        unsafe fn decode(
1184            &mut self,
1185            decoder: &mut fidl::encoding::Decoder<'_, D>,
1186            offset: usize,
1187            _depth: fidl::encoding::Depth,
1188        ) -> fidl::Result<()> {
1189            decoder.debug_check_bounds::<Self>(offset);
1190            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1191            // Verify that padding bytes are zero.
1192            // Copy from the buffer into the object.
1193            unsafe {
1194                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
1195            }
1196            Ok(())
1197        }
1198    }
1199
1200    impl fidl::encoding::ValueTypeMarker for TouchInteractionResult {
1201        type Borrowed<'a> = &'a Self;
1202        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1203            value
1204        }
1205    }
1206
1207    unsafe impl fidl::encoding::TypeMarker for TouchInteractionResult {
1208        type Owned = Self;
1209
1210        #[inline(always)]
1211        fn inline_align(_context: fidl::encoding::Context) -> usize {
1212            4
1213        }
1214
1215        #[inline(always)]
1216        fn inline_size(_context: fidl::encoding::Context) -> usize {
1217            16
1218        }
1219    }
1220
1221    unsafe impl<D: fidl::encoding::ResourceDialect>
1222        fidl::encoding::Encode<TouchInteractionResult, D> for &TouchInteractionResult
1223    {
1224        #[inline]
1225        unsafe fn encode(
1226            self,
1227            encoder: &mut fidl::encoding::Encoder<'_, D>,
1228            offset: usize,
1229            _depth: fidl::encoding::Depth,
1230        ) -> fidl::Result<()> {
1231            encoder.debug_check_bounds::<TouchInteractionResult>(offset);
1232            // Delegate to tuple encoding.
1233            fidl::encoding::Encode::<TouchInteractionResult, D>::encode(
1234                (
1235                    <TouchInteractionId as fidl::encoding::ValueTypeMarker>::borrow(
1236                        &self.interaction,
1237                    ),
1238                    <TouchInteractionStatus as fidl::encoding::ValueTypeMarker>::borrow(
1239                        &self.status,
1240                    ),
1241                ),
1242                encoder,
1243                offset,
1244                _depth,
1245            )
1246        }
1247    }
1248    unsafe impl<
1249            D: fidl::encoding::ResourceDialect,
1250            T0: fidl::encoding::Encode<TouchInteractionId, D>,
1251            T1: fidl::encoding::Encode<TouchInteractionStatus, D>,
1252        > fidl::encoding::Encode<TouchInteractionResult, D> for (T0, T1)
1253    {
1254        #[inline]
1255        unsafe fn encode(
1256            self,
1257            encoder: &mut fidl::encoding::Encoder<'_, D>,
1258            offset: usize,
1259            depth: fidl::encoding::Depth,
1260        ) -> fidl::Result<()> {
1261            encoder.debug_check_bounds::<TouchInteractionResult>(offset);
1262            // Zero out padding regions. There's no need to apply masks
1263            // because the unmasked parts will be overwritten by fields.
1264            // Write the fields.
1265            self.0.encode(encoder, offset + 0, depth)?;
1266            self.1.encode(encoder, offset + 12, depth)?;
1267            Ok(())
1268        }
1269    }
1270
1271    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1272        for TouchInteractionResult
1273    {
1274        #[inline(always)]
1275        fn new_empty() -> Self {
1276            Self {
1277                interaction: fidl::new_empty!(TouchInteractionId, D),
1278                status: fidl::new_empty!(TouchInteractionStatus, D),
1279            }
1280        }
1281
1282        #[inline]
1283        unsafe fn decode(
1284            &mut self,
1285            decoder: &mut fidl::encoding::Decoder<'_, D>,
1286            offset: usize,
1287            _depth: fidl::encoding::Depth,
1288        ) -> fidl::Result<()> {
1289            decoder.debug_check_bounds::<Self>(offset);
1290            // Verify that padding bytes are zero.
1291            fidl::decode!(
1292                TouchInteractionId,
1293                D,
1294                &mut self.interaction,
1295                decoder,
1296                offset + 0,
1297                _depth
1298            )?;
1299            fidl::decode!(
1300                TouchInteractionStatus,
1301                D,
1302                &mut self.status,
1303                decoder,
1304                offset + 12,
1305                _depth
1306            )?;
1307            Ok(())
1308        }
1309    }
1310
1311    impl fidl::encoding::ValueTypeMarker for TouchSourceUpdateResponseRequest {
1312        type Borrowed<'a> = &'a Self;
1313        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1314            value
1315        }
1316    }
1317
1318    unsafe impl fidl::encoding::TypeMarker for TouchSourceUpdateResponseRequest {
1319        type Owned = Self;
1320
1321        #[inline(always)]
1322        fn inline_align(_context: fidl::encoding::Context) -> usize {
1323            8
1324        }
1325
1326        #[inline(always)]
1327        fn inline_size(_context: fidl::encoding::Context) -> usize {
1328            32
1329        }
1330    }
1331
1332    unsafe impl<D: fidl::encoding::ResourceDialect>
1333        fidl::encoding::Encode<TouchSourceUpdateResponseRequest, D>
1334        for &TouchSourceUpdateResponseRequest
1335    {
1336        #[inline]
1337        unsafe fn encode(
1338            self,
1339            encoder: &mut fidl::encoding::Encoder<'_, D>,
1340            offset: usize,
1341            _depth: fidl::encoding::Depth,
1342        ) -> fidl::Result<()> {
1343            encoder.debug_check_bounds::<TouchSourceUpdateResponseRequest>(offset);
1344            // Delegate to tuple encoding.
1345            fidl::encoding::Encode::<TouchSourceUpdateResponseRequest, D>::encode(
1346                (
1347                    <TouchInteractionId as fidl::encoding::ValueTypeMarker>::borrow(
1348                        &self.interaction,
1349                    ),
1350                    <TouchResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.response),
1351                ),
1352                encoder,
1353                offset,
1354                _depth,
1355            )
1356        }
1357    }
1358    unsafe impl<
1359            D: fidl::encoding::ResourceDialect,
1360            T0: fidl::encoding::Encode<TouchInteractionId, D>,
1361            T1: fidl::encoding::Encode<TouchResponse, D>,
1362        > fidl::encoding::Encode<TouchSourceUpdateResponseRequest, D> for (T0, T1)
1363    {
1364        #[inline]
1365        unsafe fn encode(
1366            self,
1367            encoder: &mut fidl::encoding::Encoder<'_, D>,
1368            offset: usize,
1369            depth: fidl::encoding::Depth,
1370        ) -> fidl::Result<()> {
1371            encoder.debug_check_bounds::<TouchSourceUpdateResponseRequest>(offset);
1372            // Zero out padding regions. There's no need to apply masks
1373            // because the unmasked parts will be overwritten by fields.
1374            unsafe {
1375                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
1376                (ptr as *mut u64).write_unaligned(0);
1377            }
1378            // Write the fields.
1379            self.0.encode(encoder, offset + 0, depth)?;
1380            self.1.encode(encoder, offset + 16, depth)?;
1381            Ok(())
1382        }
1383    }
1384
1385    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1386        for TouchSourceUpdateResponseRequest
1387    {
1388        #[inline(always)]
1389        fn new_empty() -> Self {
1390            Self {
1391                interaction: fidl::new_empty!(TouchInteractionId, D),
1392                response: fidl::new_empty!(TouchResponse, D),
1393            }
1394        }
1395
1396        #[inline]
1397        unsafe fn decode(
1398            &mut self,
1399            decoder: &mut fidl::encoding::Decoder<'_, D>,
1400            offset: usize,
1401            _depth: fidl::encoding::Depth,
1402        ) -> fidl::Result<()> {
1403            decoder.debug_check_bounds::<Self>(offset);
1404            // Verify that padding bytes are zero.
1405            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
1406            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1407            let mask = 0xffffffff00000000u64;
1408            let maskedval = padval & mask;
1409            if maskedval != 0 {
1410                return Err(fidl::Error::NonZeroPadding {
1411                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
1412                });
1413            }
1414            fidl::decode!(
1415                TouchInteractionId,
1416                D,
1417                &mut self.interaction,
1418                decoder,
1419                offset + 0,
1420                _depth
1421            )?;
1422            fidl::decode!(TouchResponse, D, &mut self.response, decoder, offset + 16, _depth)?;
1423            Ok(())
1424        }
1425    }
1426
1427    impl fidl::encoding::ValueTypeMarker for TouchSourceWatchRequest {
1428        type Borrowed<'a> = &'a Self;
1429        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1430            value
1431        }
1432    }
1433
1434    unsafe impl fidl::encoding::TypeMarker for TouchSourceWatchRequest {
1435        type Owned = Self;
1436
1437        #[inline(always)]
1438        fn inline_align(_context: fidl::encoding::Context) -> usize {
1439            8
1440        }
1441
1442        #[inline(always)]
1443        fn inline_size(_context: fidl::encoding::Context) -> usize {
1444            16
1445        }
1446    }
1447
1448    unsafe impl<D: fidl::encoding::ResourceDialect>
1449        fidl::encoding::Encode<TouchSourceWatchRequest, D> for &TouchSourceWatchRequest
1450    {
1451        #[inline]
1452        unsafe fn encode(
1453            self,
1454            encoder: &mut fidl::encoding::Encoder<'_, D>,
1455            offset: usize,
1456            _depth: fidl::encoding::Depth,
1457        ) -> fidl::Result<()> {
1458            encoder.debug_check_bounds::<TouchSourceWatchRequest>(offset);
1459            // Delegate to tuple encoding.
1460            fidl::encoding::Encode::<TouchSourceWatchRequest, D>::encode(
1461                (
1462                    <fidl::encoding::Vector<TouchResponse, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.responses),
1463                ),
1464                encoder, offset, _depth
1465            )
1466        }
1467    }
1468    unsafe impl<
1469            D: fidl::encoding::ResourceDialect,
1470            T0: fidl::encoding::Encode<fidl::encoding::Vector<TouchResponse, 128>, D>,
1471        > fidl::encoding::Encode<TouchSourceWatchRequest, D> for (T0,)
1472    {
1473        #[inline]
1474        unsafe fn encode(
1475            self,
1476            encoder: &mut fidl::encoding::Encoder<'_, D>,
1477            offset: usize,
1478            depth: fidl::encoding::Depth,
1479        ) -> fidl::Result<()> {
1480            encoder.debug_check_bounds::<TouchSourceWatchRequest>(offset);
1481            // Zero out padding regions. There's no need to apply masks
1482            // because the unmasked parts will be overwritten by fields.
1483            // Write the fields.
1484            self.0.encode(encoder, offset + 0, depth)?;
1485            Ok(())
1486        }
1487    }
1488
1489    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1490        for TouchSourceWatchRequest
1491    {
1492        #[inline(always)]
1493        fn new_empty() -> Self {
1494            Self { responses: fidl::new_empty!(fidl::encoding::Vector<TouchResponse, 128>, D) }
1495        }
1496
1497        #[inline]
1498        unsafe fn decode(
1499            &mut self,
1500            decoder: &mut fidl::encoding::Decoder<'_, D>,
1501            offset: usize,
1502            _depth: fidl::encoding::Depth,
1503        ) -> fidl::Result<()> {
1504            decoder.debug_check_bounds::<Self>(offset);
1505            // Verify that padding bytes are zero.
1506            fidl::decode!(fidl::encoding::Vector<TouchResponse, 128>, D, &mut self.responses, decoder, offset + 0, _depth)?;
1507            Ok(())
1508        }
1509    }
1510
1511    impl fidl::encoding::ValueTypeMarker for TouchSourceWatchResponse {
1512        type Borrowed<'a> = &'a Self;
1513        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1514            value
1515        }
1516    }
1517
1518    unsafe impl fidl::encoding::TypeMarker for TouchSourceWatchResponse {
1519        type Owned = Self;
1520
1521        #[inline(always)]
1522        fn inline_align(_context: fidl::encoding::Context) -> usize {
1523            8
1524        }
1525
1526        #[inline(always)]
1527        fn inline_size(_context: fidl::encoding::Context) -> usize {
1528            16
1529        }
1530    }
1531
1532    unsafe impl<D: fidl::encoding::ResourceDialect>
1533        fidl::encoding::Encode<TouchSourceWatchResponse, D> for &TouchSourceWatchResponse
1534    {
1535        #[inline]
1536        unsafe fn encode(
1537            self,
1538            encoder: &mut fidl::encoding::Encoder<'_, D>,
1539            offset: usize,
1540            _depth: fidl::encoding::Depth,
1541        ) -> fidl::Result<()> {
1542            encoder.debug_check_bounds::<TouchSourceWatchResponse>(offset);
1543            // Delegate to tuple encoding.
1544            fidl::encoding::Encode::<TouchSourceWatchResponse, D>::encode(
1545                (
1546                    <fidl::encoding::Vector<TouchEvent, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.events),
1547                ),
1548                encoder, offset, _depth
1549            )
1550        }
1551    }
1552    unsafe impl<
1553            D: fidl::encoding::ResourceDialect,
1554            T0: fidl::encoding::Encode<fidl::encoding::Vector<TouchEvent, 128>, D>,
1555        > fidl::encoding::Encode<TouchSourceWatchResponse, D> for (T0,)
1556    {
1557        #[inline]
1558        unsafe fn encode(
1559            self,
1560            encoder: &mut fidl::encoding::Encoder<'_, D>,
1561            offset: usize,
1562            depth: fidl::encoding::Depth,
1563        ) -> fidl::Result<()> {
1564            encoder.debug_check_bounds::<TouchSourceWatchResponse>(offset);
1565            // Zero out padding regions. There's no need to apply masks
1566            // because the unmasked parts will be overwritten by fields.
1567            // Write the fields.
1568            self.0.encode(encoder, offset + 0, depth)?;
1569            Ok(())
1570        }
1571    }
1572
1573    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1574        for TouchSourceWatchResponse
1575    {
1576        #[inline(always)]
1577        fn new_empty() -> Self {
1578            Self { events: fidl::new_empty!(fidl::encoding::Vector<TouchEvent, 128>, D) }
1579        }
1580
1581        #[inline]
1582        unsafe fn decode(
1583            &mut self,
1584            decoder: &mut fidl::encoding::Decoder<'_, D>,
1585            offset: usize,
1586            _depth: fidl::encoding::Depth,
1587        ) -> fidl::Result<()> {
1588            decoder.debug_check_bounds::<Self>(offset);
1589            // Verify that padding bytes are zero.
1590            fidl::decode!(fidl::encoding::Vector<TouchEvent, 128>, D, &mut self.events, decoder, offset + 0, _depth)?;
1591            Ok(())
1592        }
1593    }
1594
1595    impl fidl::encoding::ValueTypeMarker for ViewParameters {
1596        type Borrowed<'a> = &'a Self;
1597        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1598            value
1599        }
1600    }
1601
1602    unsafe impl fidl::encoding::TypeMarker for ViewParameters {
1603        type Owned = Self;
1604
1605        #[inline(always)]
1606        fn inline_align(_context: fidl::encoding::Context) -> usize {
1607            4
1608        }
1609
1610        #[inline(always)]
1611        fn inline_size(_context: fidl::encoding::Context) -> usize {
1612            68
1613        }
1614    }
1615
1616    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ViewParameters, D>
1617        for &ViewParameters
1618    {
1619        #[inline]
1620        unsafe fn encode(
1621            self,
1622            encoder: &mut fidl::encoding::Encoder<'_, D>,
1623            offset: usize,
1624            _depth: fidl::encoding::Depth,
1625        ) -> fidl::Result<()> {
1626            encoder.debug_check_bounds::<ViewParameters>(offset);
1627            // Delegate to tuple encoding.
1628            fidl::encoding::Encode::<ViewParameters, D>::encode(
1629                (
1630                    <Rectangle as fidl::encoding::ValueTypeMarker>::borrow(&self.view),
1631                    <Rectangle as fidl::encoding::ValueTypeMarker>::borrow(&self.viewport),
1632                    <fidl::encoding::Array<f32, 9> as fidl::encoding::ValueTypeMarker>::borrow(
1633                        &self.viewport_to_view_transform,
1634                    ),
1635                ),
1636                encoder,
1637                offset,
1638                _depth,
1639            )
1640        }
1641    }
1642    unsafe impl<
1643            D: fidl::encoding::ResourceDialect,
1644            T0: fidl::encoding::Encode<Rectangle, D>,
1645            T1: fidl::encoding::Encode<Rectangle, D>,
1646            T2: fidl::encoding::Encode<fidl::encoding::Array<f32, 9>, D>,
1647        > fidl::encoding::Encode<ViewParameters, D> for (T0, T1, T2)
1648    {
1649        #[inline]
1650        unsafe fn encode(
1651            self,
1652            encoder: &mut fidl::encoding::Encoder<'_, D>,
1653            offset: usize,
1654            depth: fidl::encoding::Depth,
1655        ) -> fidl::Result<()> {
1656            encoder.debug_check_bounds::<ViewParameters>(offset);
1657            // Zero out padding regions. There's no need to apply masks
1658            // because the unmasked parts will be overwritten by fields.
1659            // Write the fields.
1660            self.0.encode(encoder, offset + 0, depth)?;
1661            self.1.encode(encoder, offset + 16, depth)?;
1662            self.2.encode(encoder, offset + 32, depth)?;
1663            Ok(())
1664        }
1665    }
1666
1667    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ViewParameters {
1668        #[inline(always)]
1669        fn new_empty() -> Self {
1670            Self {
1671                view: fidl::new_empty!(Rectangle, D),
1672                viewport: fidl::new_empty!(Rectangle, D),
1673                viewport_to_view_transform: fidl::new_empty!(fidl::encoding::Array<f32, 9>, D),
1674            }
1675        }
1676
1677        #[inline]
1678        unsafe fn decode(
1679            &mut self,
1680            decoder: &mut fidl::encoding::Decoder<'_, D>,
1681            offset: usize,
1682            _depth: fidl::encoding::Depth,
1683        ) -> fidl::Result<()> {
1684            decoder.debug_check_bounds::<Self>(offset);
1685            // Verify that padding bytes are zero.
1686            fidl::decode!(Rectangle, D, &mut self.view, decoder, offset + 0, _depth)?;
1687            fidl::decode!(Rectangle, D, &mut self.viewport, decoder, offset + 16, _depth)?;
1688            fidl::decode!(fidl::encoding::Array<f32, 9>, D, &mut self.viewport_to_view_transform, decoder, offset + 32, _depth)?;
1689            Ok(())
1690        }
1691    }
1692
1693    impl MouseDeviceInfo {
1694        #[inline(always)]
1695        fn max_ordinal_present(&self) -> u64 {
1696            if let Some(_) = self.relative_motion_range {
1697                return 5;
1698            }
1699            if let Some(_) = self.buttons {
1700                return 4;
1701            }
1702            if let Some(_) = self.scroll_h_range {
1703                return 3;
1704            }
1705            if let Some(_) = self.scroll_v_range {
1706                return 2;
1707            }
1708            if let Some(_) = self.id {
1709                return 1;
1710            }
1711            0
1712        }
1713    }
1714
1715    impl fidl::encoding::ValueTypeMarker for MouseDeviceInfo {
1716        type Borrowed<'a> = &'a Self;
1717        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1718            value
1719        }
1720    }
1721
1722    unsafe impl fidl::encoding::TypeMarker for MouseDeviceInfo {
1723        type Owned = Self;
1724
1725        #[inline(always)]
1726        fn inline_align(_context: fidl::encoding::Context) -> usize {
1727            8
1728        }
1729
1730        #[inline(always)]
1731        fn inline_size(_context: fidl::encoding::Context) -> usize {
1732            16
1733        }
1734    }
1735
1736    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MouseDeviceInfo, D>
1737        for &MouseDeviceInfo
1738    {
1739        unsafe fn encode(
1740            self,
1741            encoder: &mut fidl::encoding::Encoder<'_, D>,
1742            offset: usize,
1743            mut depth: fidl::encoding::Depth,
1744        ) -> fidl::Result<()> {
1745            encoder.debug_check_bounds::<MouseDeviceInfo>(offset);
1746            // Vector header
1747            let max_ordinal: u64 = self.max_ordinal_present();
1748            encoder.write_num(max_ordinal, offset);
1749            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1750            // Calling encoder.out_of_line_offset(0) is not allowed.
1751            if max_ordinal == 0 {
1752                return Ok(());
1753            }
1754            depth.increment()?;
1755            let envelope_size = 8;
1756            let bytes_len = max_ordinal as usize * envelope_size;
1757            #[allow(unused_variables)]
1758            let offset = encoder.out_of_line_offset(bytes_len);
1759            let mut _prev_end_offset: usize = 0;
1760            if 1 > max_ordinal {
1761                return Ok(());
1762            }
1763
1764            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1765            // are envelope_size bytes.
1766            let cur_offset: usize = (1 - 1) * envelope_size;
1767
1768            // Zero reserved fields.
1769            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1770
1771            // Safety:
1772            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1773            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1774            //   envelope_size bytes, there is always sufficient room.
1775            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1776                self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1777                encoder,
1778                offset + cur_offset,
1779                depth,
1780            )?;
1781
1782            _prev_end_offset = cur_offset + envelope_size;
1783            if 2 > max_ordinal {
1784                return Ok(());
1785            }
1786
1787            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1788            // are envelope_size bytes.
1789            let cur_offset: usize = (2 - 1) * envelope_size;
1790
1791            // Zero reserved fields.
1792            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1793
1794            // Safety:
1795            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1796            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1797            //   envelope_size bytes, there is always sufficient room.
1798            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_input_report__common::Axis, D>(
1799            self.scroll_v_range.as_ref().map(<fidl_fuchsia_input_report__common::Axis as fidl::encoding::ValueTypeMarker>::borrow),
1800            encoder, offset + cur_offset, depth
1801        )?;
1802
1803            _prev_end_offset = cur_offset + envelope_size;
1804            if 3 > max_ordinal {
1805                return Ok(());
1806            }
1807
1808            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1809            // are envelope_size bytes.
1810            let cur_offset: usize = (3 - 1) * envelope_size;
1811
1812            // Zero reserved fields.
1813            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1814
1815            // Safety:
1816            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1817            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1818            //   envelope_size bytes, there is always sufficient room.
1819            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_input_report__common::Axis, D>(
1820            self.scroll_h_range.as_ref().map(<fidl_fuchsia_input_report__common::Axis as fidl::encoding::ValueTypeMarker>::borrow),
1821            encoder, offset + cur_offset, depth
1822        )?;
1823
1824            _prev_end_offset = cur_offset + envelope_size;
1825            if 4 > max_ordinal {
1826                return Ok(());
1827            }
1828
1829            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1830            // are envelope_size bytes.
1831            let cur_offset: usize = (4 - 1) * envelope_size;
1832
1833            // Zero reserved fields.
1834            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1835
1836            // Safety:
1837            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1838            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1839            //   envelope_size bytes, there is always sufficient room.
1840            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
1841                self.buttons.as_ref().map(
1842                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
1843                ),
1844                encoder,
1845                offset + cur_offset,
1846                depth,
1847            )?;
1848
1849            _prev_end_offset = cur_offset + envelope_size;
1850            if 5 > max_ordinal {
1851                return Ok(());
1852            }
1853
1854            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1855            // are envelope_size bytes.
1856            let cur_offset: usize = (5 - 1) * envelope_size;
1857
1858            // Zero reserved fields.
1859            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1860
1861            // Safety:
1862            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1863            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1864            //   envelope_size bytes, there is always sufficient room.
1865            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<fidl_fuchsia_input_report__common::Axis, 2>, D>(
1866            self.relative_motion_range.as_ref().map(<fidl::encoding::Array<fidl_fuchsia_input_report__common::Axis, 2> as fidl::encoding::ValueTypeMarker>::borrow),
1867            encoder, offset + cur_offset, depth
1868        )?;
1869
1870            _prev_end_offset = cur_offset + envelope_size;
1871
1872            Ok(())
1873        }
1874    }
1875
1876    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MouseDeviceInfo {
1877        #[inline(always)]
1878        fn new_empty() -> Self {
1879            Self::default()
1880        }
1881
1882        unsafe fn decode(
1883            &mut self,
1884            decoder: &mut fidl::encoding::Decoder<'_, D>,
1885            offset: usize,
1886            mut depth: fidl::encoding::Depth,
1887        ) -> fidl::Result<()> {
1888            decoder.debug_check_bounds::<Self>(offset);
1889            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1890                None => return Err(fidl::Error::NotNullable),
1891                Some(len) => len,
1892            };
1893            // Calling decoder.out_of_line_offset(0) is not allowed.
1894            if len == 0 {
1895                return Ok(());
1896            };
1897            depth.increment()?;
1898            let envelope_size = 8;
1899            let bytes_len = len * envelope_size;
1900            let offset = decoder.out_of_line_offset(bytes_len)?;
1901            // Decode the envelope for each type.
1902            let mut _next_ordinal_to_read = 0;
1903            let mut next_offset = offset;
1904            let end_offset = offset + bytes_len;
1905            _next_ordinal_to_read += 1;
1906            if next_offset >= end_offset {
1907                return Ok(());
1908            }
1909
1910            // Decode unknown envelopes for gaps in ordinals.
1911            while _next_ordinal_to_read < 1 {
1912                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1913                _next_ordinal_to_read += 1;
1914                next_offset += envelope_size;
1915            }
1916
1917            let next_out_of_line = decoder.next_out_of_line();
1918            let handles_before = decoder.remaining_handles();
1919            if let Some((inlined, num_bytes, num_handles)) =
1920                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1921            {
1922                let member_inline_size =
1923                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1924                if inlined != (member_inline_size <= 4) {
1925                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1926                }
1927                let inner_offset;
1928                let mut inner_depth = depth.clone();
1929                if inlined {
1930                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1931                    inner_offset = next_offset;
1932                } else {
1933                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1934                    inner_depth.increment()?;
1935                }
1936                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1937                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1938                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1939                {
1940                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1941                }
1942                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1943                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1944                }
1945            }
1946
1947            next_offset += envelope_size;
1948            _next_ordinal_to_read += 1;
1949            if next_offset >= end_offset {
1950                return Ok(());
1951            }
1952
1953            // Decode unknown envelopes for gaps in ordinals.
1954            while _next_ordinal_to_read < 2 {
1955                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1956                _next_ordinal_to_read += 1;
1957                next_offset += envelope_size;
1958            }
1959
1960            let next_out_of_line = decoder.next_out_of_line();
1961            let handles_before = decoder.remaining_handles();
1962            if let Some((inlined, num_bytes, num_handles)) =
1963                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1964            {
1965                let member_inline_size = <fidl_fuchsia_input_report__common::Axis as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1966                if inlined != (member_inline_size <= 4) {
1967                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1968                }
1969                let inner_offset;
1970                let mut inner_depth = depth.clone();
1971                if inlined {
1972                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1973                    inner_offset = next_offset;
1974                } else {
1975                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1976                    inner_depth.increment()?;
1977                }
1978                let val_ref = self.scroll_v_range.get_or_insert_with(|| {
1979                    fidl::new_empty!(fidl_fuchsia_input_report__common::Axis, D)
1980                });
1981                fidl::decode!(
1982                    fidl_fuchsia_input_report__common::Axis,
1983                    D,
1984                    val_ref,
1985                    decoder,
1986                    inner_offset,
1987                    inner_depth
1988                )?;
1989                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1990                {
1991                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1992                }
1993                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1994                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1995                }
1996            }
1997
1998            next_offset += envelope_size;
1999            _next_ordinal_to_read += 1;
2000            if next_offset >= end_offset {
2001                return Ok(());
2002            }
2003
2004            // Decode unknown envelopes for gaps in ordinals.
2005            while _next_ordinal_to_read < 3 {
2006                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2007                _next_ordinal_to_read += 1;
2008                next_offset += envelope_size;
2009            }
2010
2011            let next_out_of_line = decoder.next_out_of_line();
2012            let handles_before = decoder.remaining_handles();
2013            if let Some((inlined, num_bytes, num_handles)) =
2014                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2015            {
2016                let member_inline_size = <fidl_fuchsia_input_report__common::Axis as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2017                if inlined != (member_inline_size <= 4) {
2018                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2019                }
2020                let inner_offset;
2021                let mut inner_depth = depth.clone();
2022                if inlined {
2023                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2024                    inner_offset = next_offset;
2025                } else {
2026                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2027                    inner_depth.increment()?;
2028                }
2029                let val_ref = self.scroll_h_range.get_or_insert_with(|| {
2030                    fidl::new_empty!(fidl_fuchsia_input_report__common::Axis, D)
2031                });
2032                fidl::decode!(
2033                    fidl_fuchsia_input_report__common::Axis,
2034                    D,
2035                    val_ref,
2036                    decoder,
2037                    inner_offset,
2038                    inner_depth
2039                )?;
2040                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2041                {
2042                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2043                }
2044                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2045                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2046                }
2047            }
2048
2049            next_offset += envelope_size;
2050            _next_ordinal_to_read += 1;
2051            if next_offset >= end_offset {
2052                return Ok(());
2053            }
2054
2055            // Decode unknown envelopes for gaps in ordinals.
2056            while _next_ordinal_to_read < 4 {
2057                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2058                _next_ordinal_to_read += 1;
2059                next_offset += envelope_size;
2060            }
2061
2062            let next_out_of_line = decoder.next_out_of_line();
2063            let handles_before = decoder.remaining_handles();
2064            if let Some((inlined, num_bytes, num_handles)) =
2065                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2066            {
2067                let member_inline_size =
2068                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
2069                        decoder.context,
2070                    );
2071                if inlined != (member_inline_size <= 4) {
2072                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2073                }
2074                let inner_offset;
2075                let mut inner_depth = depth.clone();
2076                if inlined {
2077                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2078                    inner_offset = next_offset;
2079                } else {
2080                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2081                    inner_depth.increment()?;
2082                }
2083                let val_ref = self
2084                    .buttons
2085                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
2086                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
2087                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2088                {
2089                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2090                }
2091                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2092                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2093                }
2094            }
2095
2096            next_offset += envelope_size;
2097            _next_ordinal_to_read += 1;
2098            if next_offset >= end_offset {
2099                return Ok(());
2100            }
2101
2102            // Decode unknown envelopes for gaps in ordinals.
2103            while _next_ordinal_to_read < 5 {
2104                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2105                _next_ordinal_to_read += 1;
2106                next_offset += envelope_size;
2107            }
2108
2109            let next_out_of_line = decoder.next_out_of_line();
2110            let handles_before = decoder.remaining_handles();
2111            if let Some((inlined, num_bytes, num_handles)) =
2112                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2113            {
2114                let member_inline_size = <fidl::encoding::Array<
2115                    fidl_fuchsia_input_report__common::Axis,
2116                    2,
2117                > as fidl::encoding::TypeMarker>::inline_size(
2118                    decoder.context
2119                );
2120                if inlined != (member_inline_size <= 4) {
2121                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2122                }
2123                let inner_offset;
2124                let mut inner_depth = depth.clone();
2125                if inlined {
2126                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2127                    inner_offset = next_offset;
2128                } else {
2129                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2130                    inner_depth.increment()?;
2131                }
2132                let val_ref =
2133                self.relative_motion_range.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<fidl_fuchsia_input_report__common::Axis, 2>, D));
2134                fidl::decode!(fidl::encoding::Array<fidl_fuchsia_input_report__common::Axis, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
2135                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2136                {
2137                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2138                }
2139                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2140                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2141                }
2142            }
2143
2144            next_offset += envelope_size;
2145
2146            // Decode the remaining unknown envelopes.
2147            while next_offset < end_offset {
2148                _next_ordinal_to_read += 1;
2149                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2150                next_offset += envelope_size;
2151            }
2152
2153            Ok(())
2154        }
2155    }
2156
2157    impl MouseEvent {
2158        #[inline(always)]
2159        fn max_ordinal_present(&self) -> u64 {
2160            if let Some(_) = self.trace_flow_id {
2161                return 6;
2162            }
2163            if let Some(_) = self.stream_info {
2164                return 5;
2165            }
2166            if let Some(_) = self.pointer_sample {
2167                return 4;
2168            }
2169            if let Some(_) = self.device_info {
2170                return 3;
2171            }
2172            if let Some(_) = self.view_parameters {
2173                return 2;
2174            }
2175            if let Some(_) = self.timestamp {
2176                return 1;
2177            }
2178            0
2179        }
2180    }
2181
2182    impl fidl::encoding::ValueTypeMarker for MouseEvent {
2183        type Borrowed<'a> = &'a Self;
2184        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2185            value
2186        }
2187    }
2188
2189    unsafe impl fidl::encoding::TypeMarker for MouseEvent {
2190        type Owned = Self;
2191
2192        #[inline(always)]
2193        fn inline_align(_context: fidl::encoding::Context) -> usize {
2194            8
2195        }
2196
2197        #[inline(always)]
2198        fn inline_size(_context: fidl::encoding::Context) -> usize {
2199            16
2200        }
2201    }
2202
2203    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MouseEvent, D>
2204        for &MouseEvent
2205    {
2206        unsafe fn encode(
2207            self,
2208            encoder: &mut fidl::encoding::Encoder<'_, D>,
2209            offset: usize,
2210            mut depth: fidl::encoding::Depth,
2211        ) -> fidl::Result<()> {
2212            encoder.debug_check_bounds::<MouseEvent>(offset);
2213            // Vector header
2214            let max_ordinal: u64 = self.max_ordinal_present();
2215            encoder.write_num(max_ordinal, offset);
2216            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2217            // Calling encoder.out_of_line_offset(0) is not allowed.
2218            if max_ordinal == 0 {
2219                return Ok(());
2220            }
2221            depth.increment()?;
2222            let envelope_size = 8;
2223            let bytes_len = max_ordinal as usize * envelope_size;
2224            #[allow(unused_variables)]
2225            let offset = encoder.out_of_line_offset(bytes_len);
2226            let mut _prev_end_offset: usize = 0;
2227            if 1 > max_ordinal {
2228                return Ok(());
2229            }
2230
2231            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2232            // are envelope_size bytes.
2233            let cur_offset: usize = (1 - 1) * envelope_size;
2234
2235            // Zero reserved fields.
2236            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2237
2238            // Safety:
2239            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2240            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2241            //   envelope_size bytes, there is always sufficient room.
2242            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2243                self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2244                encoder,
2245                offset + cur_offset,
2246                depth,
2247            )?;
2248
2249            _prev_end_offset = cur_offset + envelope_size;
2250            if 2 > max_ordinal {
2251                return Ok(());
2252            }
2253
2254            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2255            // are envelope_size bytes.
2256            let cur_offset: usize = (2 - 1) * envelope_size;
2257
2258            // Zero reserved fields.
2259            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2260
2261            // Safety:
2262            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2263            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2264            //   envelope_size bytes, there is always sufficient room.
2265            fidl::encoding::encode_in_envelope_optional::<ViewParameters, D>(
2266                self.view_parameters
2267                    .as_ref()
2268                    .map(<ViewParameters as fidl::encoding::ValueTypeMarker>::borrow),
2269                encoder,
2270                offset + cur_offset,
2271                depth,
2272            )?;
2273
2274            _prev_end_offset = cur_offset + envelope_size;
2275            if 3 > max_ordinal {
2276                return Ok(());
2277            }
2278
2279            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2280            // are envelope_size bytes.
2281            let cur_offset: usize = (3 - 1) * envelope_size;
2282
2283            // Zero reserved fields.
2284            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2285
2286            // Safety:
2287            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2288            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2289            //   envelope_size bytes, there is always sufficient room.
2290            fidl::encoding::encode_in_envelope_optional::<MouseDeviceInfo, D>(
2291                self.device_info
2292                    .as_ref()
2293                    .map(<MouseDeviceInfo as fidl::encoding::ValueTypeMarker>::borrow),
2294                encoder,
2295                offset + cur_offset,
2296                depth,
2297            )?;
2298
2299            _prev_end_offset = cur_offset + envelope_size;
2300            if 4 > max_ordinal {
2301                return Ok(());
2302            }
2303
2304            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2305            // are envelope_size bytes.
2306            let cur_offset: usize = (4 - 1) * envelope_size;
2307
2308            // Zero reserved fields.
2309            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2310
2311            // Safety:
2312            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2313            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2314            //   envelope_size bytes, there is always sufficient room.
2315            fidl::encoding::encode_in_envelope_optional::<MousePointerSample, D>(
2316                self.pointer_sample
2317                    .as_ref()
2318                    .map(<MousePointerSample as fidl::encoding::ValueTypeMarker>::borrow),
2319                encoder,
2320                offset + cur_offset,
2321                depth,
2322            )?;
2323
2324            _prev_end_offset = cur_offset + envelope_size;
2325            if 5 > max_ordinal {
2326                return Ok(());
2327            }
2328
2329            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2330            // are envelope_size bytes.
2331            let cur_offset: usize = (5 - 1) * envelope_size;
2332
2333            // Zero reserved fields.
2334            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2335
2336            // Safety:
2337            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2338            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2339            //   envelope_size bytes, there is always sufficient room.
2340            fidl::encoding::encode_in_envelope_optional::<MouseEventStreamInfo, D>(
2341                self.stream_info
2342                    .as_ref()
2343                    .map(<MouseEventStreamInfo as fidl::encoding::ValueTypeMarker>::borrow),
2344                encoder,
2345                offset + cur_offset,
2346                depth,
2347            )?;
2348
2349            _prev_end_offset = cur_offset + envelope_size;
2350            if 6 > max_ordinal {
2351                return Ok(());
2352            }
2353
2354            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2355            // are envelope_size bytes.
2356            let cur_offset: usize = (6 - 1) * envelope_size;
2357
2358            // Zero reserved fields.
2359            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2360
2361            // Safety:
2362            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2363            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2364            //   envelope_size bytes, there is always sufficient room.
2365            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2366                self.trace_flow_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2367                encoder,
2368                offset + cur_offset,
2369                depth,
2370            )?;
2371
2372            _prev_end_offset = cur_offset + envelope_size;
2373
2374            Ok(())
2375        }
2376    }
2377
2378    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MouseEvent {
2379        #[inline(always)]
2380        fn new_empty() -> Self {
2381            Self::default()
2382        }
2383
2384        unsafe fn decode(
2385            &mut self,
2386            decoder: &mut fidl::encoding::Decoder<'_, D>,
2387            offset: usize,
2388            mut depth: fidl::encoding::Depth,
2389        ) -> fidl::Result<()> {
2390            decoder.debug_check_bounds::<Self>(offset);
2391            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2392                None => return Err(fidl::Error::NotNullable),
2393                Some(len) => len,
2394            };
2395            // Calling decoder.out_of_line_offset(0) is not allowed.
2396            if len == 0 {
2397                return Ok(());
2398            };
2399            depth.increment()?;
2400            let envelope_size = 8;
2401            let bytes_len = len * envelope_size;
2402            let offset = decoder.out_of_line_offset(bytes_len)?;
2403            // Decode the envelope for each type.
2404            let mut _next_ordinal_to_read = 0;
2405            let mut next_offset = offset;
2406            let end_offset = offset + bytes_len;
2407            _next_ordinal_to_read += 1;
2408            if next_offset >= end_offset {
2409                return Ok(());
2410            }
2411
2412            // Decode unknown envelopes for gaps in ordinals.
2413            while _next_ordinal_to_read < 1 {
2414                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2415                _next_ordinal_to_read += 1;
2416                next_offset += envelope_size;
2417            }
2418
2419            let next_out_of_line = decoder.next_out_of_line();
2420            let handles_before = decoder.remaining_handles();
2421            if let Some((inlined, num_bytes, num_handles)) =
2422                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2423            {
2424                let member_inline_size =
2425                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2426                if inlined != (member_inline_size <= 4) {
2427                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2428                }
2429                let inner_offset;
2430                let mut inner_depth = depth.clone();
2431                if inlined {
2432                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2433                    inner_offset = next_offset;
2434                } else {
2435                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2436                    inner_depth.increment()?;
2437                }
2438                let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
2439                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2440                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2441                {
2442                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2443                }
2444                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2445                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2446                }
2447            }
2448
2449            next_offset += envelope_size;
2450            _next_ordinal_to_read += 1;
2451            if next_offset >= end_offset {
2452                return Ok(());
2453            }
2454
2455            // Decode unknown envelopes for gaps in ordinals.
2456            while _next_ordinal_to_read < 2 {
2457                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2458                _next_ordinal_to_read += 1;
2459                next_offset += envelope_size;
2460            }
2461
2462            let next_out_of_line = decoder.next_out_of_line();
2463            let handles_before = decoder.remaining_handles();
2464            if let Some((inlined, num_bytes, num_handles)) =
2465                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2466            {
2467                let member_inline_size =
2468                    <ViewParameters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2469                if inlined != (member_inline_size <= 4) {
2470                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2471                }
2472                let inner_offset;
2473                let mut inner_depth = depth.clone();
2474                if inlined {
2475                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2476                    inner_offset = next_offset;
2477                } else {
2478                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2479                    inner_depth.increment()?;
2480                }
2481                let val_ref =
2482                    self.view_parameters.get_or_insert_with(|| fidl::new_empty!(ViewParameters, D));
2483                fidl::decode!(ViewParameters, D, val_ref, decoder, inner_offset, inner_depth)?;
2484                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2485                {
2486                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2487                }
2488                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2489                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2490                }
2491            }
2492
2493            next_offset += envelope_size;
2494            _next_ordinal_to_read += 1;
2495            if next_offset >= end_offset {
2496                return Ok(());
2497            }
2498
2499            // Decode unknown envelopes for gaps in ordinals.
2500            while _next_ordinal_to_read < 3 {
2501                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2502                _next_ordinal_to_read += 1;
2503                next_offset += envelope_size;
2504            }
2505
2506            let next_out_of_line = decoder.next_out_of_line();
2507            let handles_before = decoder.remaining_handles();
2508            if let Some((inlined, num_bytes, num_handles)) =
2509                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2510            {
2511                let member_inline_size =
2512                    <MouseDeviceInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2513                if inlined != (member_inline_size <= 4) {
2514                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2515                }
2516                let inner_offset;
2517                let mut inner_depth = depth.clone();
2518                if inlined {
2519                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2520                    inner_offset = next_offset;
2521                } else {
2522                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2523                    inner_depth.increment()?;
2524                }
2525                let val_ref =
2526                    self.device_info.get_or_insert_with(|| fidl::new_empty!(MouseDeviceInfo, D));
2527                fidl::decode!(MouseDeviceInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2528                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2529                {
2530                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2531                }
2532                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2533                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2534                }
2535            }
2536
2537            next_offset += envelope_size;
2538            _next_ordinal_to_read += 1;
2539            if next_offset >= end_offset {
2540                return Ok(());
2541            }
2542
2543            // Decode unknown envelopes for gaps in ordinals.
2544            while _next_ordinal_to_read < 4 {
2545                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2546                _next_ordinal_to_read += 1;
2547                next_offset += envelope_size;
2548            }
2549
2550            let next_out_of_line = decoder.next_out_of_line();
2551            let handles_before = decoder.remaining_handles();
2552            if let Some((inlined, num_bytes, num_handles)) =
2553                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2554            {
2555                let member_inline_size =
2556                    <MousePointerSample as fidl::encoding::TypeMarker>::inline_size(
2557                        decoder.context,
2558                    );
2559                if inlined != (member_inline_size <= 4) {
2560                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2561                }
2562                let inner_offset;
2563                let mut inner_depth = depth.clone();
2564                if inlined {
2565                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2566                    inner_offset = next_offset;
2567                } else {
2568                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2569                    inner_depth.increment()?;
2570                }
2571                let val_ref = self
2572                    .pointer_sample
2573                    .get_or_insert_with(|| fidl::new_empty!(MousePointerSample, D));
2574                fidl::decode!(MousePointerSample, D, val_ref, decoder, inner_offset, inner_depth)?;
2575                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2576                {
2577                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2578                }
2579                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2580                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2581                }
2582            }
2583
2584            next_offset += envelope_size;
2585            _next_ordinal_to_read += 1;
2586            if next_offset >= end_offset {
2587                return Ok(());
2588            }
2589
2590            // Decode unknown envelopes for gaps in ordinals.
2591            while _next_ordinal_to_read < 5 {
2592                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2593                _next_ordinal_to_read += 1;
2594                next_offset += envelope_size;
2595            }
2596
2597            let next_out_of_line = decoder.next_out_of_line();
2598            let handles_before = decoder.remaining_handles();
2599            if let Some((inlined, num_bytes, num_handles)) =
2600                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2601            {
2602                let member_inline_size =
2603                    <MouseEventStreamInfo as fidl::encoding::TypeMarker>::inline_size(
2604                        decoder.context,
2605                    );
2606                if inlined != (member_inline_size <= 4) {
2607                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2608                }
2609                let inner_offset;
2610                let mut inner_depth = depth.clone();
2611                if inlined {
2612                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2613                    inner_offset = next_offset;
2614                } else {
2615                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2616                    inner_depth.increment()?;
2617                }
2618                let val_ref = self
2619                    .stream_info
2620                    .get_or_insert_with(|| fidl::new_empty!(MouseEventStreamInfo, D));
2621                fidl::decode!(
2622                    MouseEventStreamInfo,
2623                    D,
2624                    val_ref,
2625                    decoder,
2626                    inner_offset,
2627                    inner_depth
2628                )?;
2629                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2630                {
2631                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2632                }
2633                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2634                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2635                }
2636            }
2637
2638            next_offset += envelope_size;
2639            _next_ordinal_to_read += 1;
2640            if next_offset >= end_offset {
2641                return Ok(());
2642            }
2643
2644            // Decode unknown envelopes for gaps in ordinals.
2645            while _next_ordinal_to_read < 6 {
2646                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2647                _next_ordinal_to_read += 1;
2648                next_offset += envelope_size;
2649            }
2650
2651            let next_out_of_line = decoder.next_out_of_line();
2652            let handles_before = decoder.remaining_handles();
2653            if let Some((inlined, num_bytes, num_handles)) =
2654                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2655            {
2656                let member_inline_size =
2657                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2658                if inlined != (member_inline_size <= 4) {
2659                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2660                }
2661                let inner_offset;
2662                let mut inner_depth = depth.clone();
2663                if inlined {
2664                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2665                    inner_offset = next_offset;
2666                } else {
2667                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2668                    inner_depth.increment()?;
2669                }
2670                let val_ref = self.trace_flow_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
2671                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2672                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2673                {
2674                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2675                }
2676                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2677                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2678                }
2679            }
2680
2681            next_offset += envelope_size;
2682
2683            // Decode the remaining unknown envelopes.
2684            while next_offset < end_offset {
2685                _next_ordinal_to_read += 1;
2686                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2687                next_offset += envelope_size;
2688            }
2689
2690            Ok(())
2691        }
2692    }
2693
2694    impl MousePointerSample {
2695        #[inline(always)]
2696        fn max_ordinal_present(&self) -> u64 {
2697            if let Some(_) = self.is_precision_scroll {
2698                return 9;
2699            }
2700            if let Some(_) = self.scroll_h_physical_pixel {
2701                return 8;
2702            }
2703            if let Some(_) = self.scroll_v_physical_pixel {
2704                return 7;
2705            }
2706            if let Some(_) = self.relative_motion {
2707                return 6;
2708            }
2709            if let Some(_) = self.pressed_buttons {
2710                return 5;
2711            }
2712            if let Some(_) = self.scroll_h {
2713                return 4;
2714            }
2715            if let Some(_) = self.scroll_v {
2716                return 3;
2717            }
2718            if let Some(_) = self.position_in_viewport {
2719                return 2;
2720            }
2721            if let Some(_) = self.device_id {
2722                return 1;
2723            }
2724            0
2725        }
2726    }
2727
2728    impl fidl::encoding::ValueTypeMarker for MousePointerSample {
2729        type Borrowed<'a> = &'a Self;
2730        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2731            value
2732        }
2733    }
2734
2735    unsafe impl fidl::encoding::TypeMarker for MousePointerSample {
2736        type Owned = Self;
2737
2738        #[inline(always)]
2739        fn inline_align(_context: fidl::encoding::Context) -> usize {
2740            8
2741        }
2742
2743        #[inline(always)]
2744        fn inline_size(_context: fidl::encoding::Context) -> usize {
2745            16
2746        }
2747    }
2748
2749    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MousePointerSample, D>
2750        for &MousePointerSample
2751    {
2752        unsafe fn encode(
2753            self,
2754            encoder: &mut fidl::encoding::Encoder<'_, D>,
2755            offset: usize,
2756            mut depth: fidl::encoding::Depth,
2757        ) -> fidl::Result<()> {
2758            encoder.debug_check_bounds::<MousePointerSample>(offset);
2759            // Vector header
2760            let max_ordinal: u64 = self.max_ordinal_present();
2761            encoder.write_num(max_ordinal, offset);
2762            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2763            // Calling encoder.out_of_line_offset(0) is not allowed.
2764            if max_ordinal == 0 {
2765                return Ok(());
2766            }
2767            depth.increment()?;
2768            let envelope_size = 8;
2769            let bytes_len = max_ordinal as usize * envelope_size;
2770            #[allow(unused_variables)]
2771            let offset = encoder.out_of_line_offset(bytes_len);
2772            let mut _prev_end_offset: usize = 0;
2773            if 1 > max_ordinal {
2774                return Ok(());
2775            }
2776
2777            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2778            // are envelope_size bytes.
2779            let cur_offset: usize = (1 - 1) * envelope_size;
2780
2781            // Zero reserved fields.
2782            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2783
2784            // Safety:
2785            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2786            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2787            //   envelope_size bytes, there is always sufficient room.
2788            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2789                self.device_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2790                encoder,
2791                offset + cur_offset,
2792                depth,
2793            )?;
2794
2795            _prev_end_offset = cur_offset + envelope_size;
2796            if 2 > max_ordinal {
2797                return Ok(());
2798            }
2799
2800            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2801            // are envelope_size bytes.
2802            let cur_offset: usize = (2 - 1) * envelope_size;
2803
2804            // Zero reserved fields.
2805            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2806
2807            // Safety:
2808            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2809            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2810            //   envelope_size bytes, there is always sufficient room.
2811            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 2>, D>(
2812                self.position_in_viewport.as_ref().map(
2813                    <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow,
2814                ),
2815                encoder,
2816                offset + cur_offset,
2817                depth,
2818            )?;
2819
2820            _prev_end_offset = cur_offset + envelope_size;
2821            if 3 > max_ordinal {
2822                return Ok(());
2823            }
2824
2825            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2826            // are envelope_size bytes.
2827            let cur_offset: usize = (3 - 1) * envelope_size;
2828
2829            // Zero reserved fields.
2830            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2831
2832            // Safety:
2833            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2834            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2835            //   envelope_size bytes, there is always sufficient room.
2836            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2837                self.scroll_v.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2838                encoder,
2839                offset + cur_offset,
2840                depth,
2841            )?;
2842
2843            _prev_end_offset = cur_offset + envelope_size;
2844            if 4 > max_ordinal {
2845                return Ok(());
2846            }
2847
2848            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2849            // are envelope_size bytes.
2850            let cur_offset: usize = (4 - 1) * envelope_size;
2851
2852            // Zero reserved fields.
2853            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2854
2855            // Safety:
2856            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2857            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2858            //   envelope_size bytes, there is always sufficient room.
2859            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2860                self.scroll_h.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2861                encoder,
2862                offset + cur_offset,
2863                depth,
2864            )?;
2865
2866            _prev_end_offset = cur_offset + envelope_size;
2867            if 5 > max_ordinal {
2868                return Ok(());
2869            }
2870
2871            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2872            // are envelope_size bytes.
2873            let cur_offset: usize = (5 - 1) * envelope_size;
2874
2875            // Zero reserved fields.
2876            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2877
2878            // Safety:
2879            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2880            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2881            //   envelope_size bytes, there is always sufficient room.
2882            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
2883                self.pressed_buttons.as_ref().map(
2884                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
2885                ),
2886                encoder,
2887                offset + cur_offset,
2888                depth,
2889            )?;
2890
2891            _prev_end_offset = cur_offset + envelope_size;
2892            if 6 > max_ordinal {
2893                return Ok(());
2894            }
2895
2896            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2897            // are envelope_size bytes.
2898            let cur_offset: usize = (6 - 1) * envelope_size;
2899
2900            // Zero reserved fields.
2901            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2902
2903            // Safety:
2904            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2905            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2906            //   envelope_size bytes, there is always sufficient room.
2907            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 2>, D>(
2908                self.relative_motion.as_ref().map(
2909                    <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow,
2910                ),
2911                encoder,
2912                offset + cur_offset,
2913                depth,
2914            )?;
2915
2916            _prev_end_offset = cur_offset + envelope_size;
2917            if 7 > max_ordinal {
2918                return Ok(());
2919            }
2920
2921            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2922            // are envelope_size bytes.
2923            let cur_offset: usize = (7 - 1) * envelope_size;
2924
2925            // Zero reserved fields.
2926            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2927
2928            // Safety:
2929            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2930            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2931            //   envelope_size bytes, there is always sufficient room.
2932            fidl::encoding::encode_in_envelope_optional::<f64, D>(
2933                self.scroll_v_physical_pixel
2934                    .as_ref()
2935                    .map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
2936                encoder,
2937                offset + cur_offset,
2938                depth,
2939            )?;
2940
2941            _prev_end_offset = cur_offset + envelope_size;
2942            if 8 > max_ordinal {
2943                return Ok(());
2944            }
2945
2946            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2947            // are envelope_size bytes.
2948            let cur_offset: usize = (8 - 1) * envelope_size;
2949
2950            // Zero reserved fields.
2951            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2952
2953            // Safety:
2954            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2955            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2956            //   envelope_size bytes, there is always sufficient room.
2957            fidl::encoding::encode_in_envelope_optional::<f64, D>(
2958                self.scroll_h_physical_pixel
2959                    .as_ref()
2960                    .map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
2961                encoder,
2962                offset + cur_offset,
2963                depth,
2964            )?;
2965
2966            _prev_end_offset = cur_offset + envelope_size;
2967            if 9 > max_ordinal {
2968                return Ok(());
2969            }
2970
2971            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2972            // are envelope_size bytes.
2973            let cur_offset: usize = (9 - 1) * envelope_size;
2974
2975            // Zero reserved fields.
2976            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2977
2978            // Safety:
2979            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2980            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2981            //   envelope_size bytes, there is always sufficient room.
2982            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2983                self.is_precision_scroll
2984                    .as_ref()
2985                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2986                encoder,
2987                offset + cur_offset,
2988                depth,
2989            )?;
2990
2991            _prev_end_offset = cur_offset + envelope_size;
2992
2993            Ok(())
2994        }
2995    }
2996
2997    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MousePointerSample {
2998        #[inline(always)]
2999        fn new_empty() -> Self {
3000            Self::default()
3001        }
3002
3003        unsafe fn decode(
3004            &mut self,
3005            decoder: &mut fidl::encoding::Decoder<'_, D>,
3006            offset: usize,
3007            mut depth: fidl::encoding::Depth,
3008        ) -> fidl::Result<()> {
3009            decoder.debug_check_bounds::<Self>(offset);
3010            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3011                None => return Err(fidl::Error::NotNullable),
3012                Some(len) => len,
3013            };
3014            // Calling decoder.out_of_line_offset(0) is not allowed.
3015            if len == 0 {
3016                return Ok(());
3017            };
3018            depth.increment()?;
3019            let envelope_size = 8;
3020            let bytes_len = len * envelope_size;
3021            let offset = decoder.out_of_line_offset(bytes_len)?;
3022            // Decode the envelope for each type.
3023            let mut _next_ordinal_to_read = 0;
3024            let mut next_offset = offset;
3025            let end_offset = offset + bytes_len;
3026            _next_ordinal_to_read += 1;
3027            if next_offset >= end_offset {
3028                return Ok(());
3029            }
3030
3031            // Decode unknown envelopes for gaps in ordinals.
3032            while _next_ordinal_to_read < 1 {
3033                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3034                _next_ordinal_to_read += 1;
3035                next_offset += envelope_size;
3036            }
3037
3038            let next_out_of_line = decoder.next_out_of_line();
3039            let handles_before = decoder.remaining_handles();
3040            if let Some((inlined, num_bytes, num_handles)) =
3041                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3042            {
3043                let member_inline_size =
3044                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3045                if inlined != (member_inline_size <= 4) {
3046                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3047                }
3048                let inner_offset;
3049                let mut inner_depth = depth.clone();
3050                if inlined {
3051                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3052                    inner_offset = next_offset;
3053                } else {
3054                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3055                    inner_depth.increment()?;
3056                }
3057                let val_ref = self.device_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
3058                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3059                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3060                {
3061                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3062                }
3063                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3064                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3065                }
3066            }
3067
3068            next_offset += envelope_size;
3069            _next_ordinal_to_read += 1;
3070            if next_offset >= end_offset {
3071                return Ok(());
3072            }
3073
3074            // Decode unknown envelopes for gaps in ordinals.
3075            while _next_ordinal_to_read < 2 {
3076                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3077                _next_ordinal_to_read += 1;
3078                next_offset += envelope_size;
3079            }
3080
3081            let next_out_of_line = decoder.next_out_of_line();
3082            let handles_before = decoder.remaining_handles();
3083            if let Some((inlined, num_bytes, num_handles)) =
3084                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3085            {
3086                let member_inline_size =
3087                    <fidl::encoding::Array<f32, 2> as fidl::encoding::TypeMarker>::inline_size(
3088                        decoder.context,
3089                    );
3090                if inlined != (member_inline_size <= 4) {
3091                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3092                }
3093                let inner_offset;
3094                let mut inner_depth = depth.clone();
3095                if inlined {
3096                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3097                    inner_offset = next_offset;
3098                } else {
3099                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3100                    inner_depth.increment()?;
3101                }
3102                let val_ref = self
3103                    .position_in_viewport
3104                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 2>, D));
3105                fidl::decode!(fidl::encoding::Array<f32, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
3106                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3107                {
3108                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3109                }
3110                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3111                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3112                }
3113            }
3114
3115            next_offset += envelope_size;
3116            _next_ordinal_to_read += 1;
3117            if next_offset >= end_offset {
3118                return Ok(());
3119            }
3120
3121            // Decode unknown envelopes for gaps in ordinals.
3122            while _next_ordinal_to_read < 3 {
3123                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3124                _next_ordinal_to_read += 1;
3125                next_offset += envelope_size;
3126            }
3127
3128            let next_out_of_line = decoder.next_out_of_line();
3129            let handles_before = decoder.remaining_handles();
3130            if let Some((inlined, num_bytes, num_handles)) =
3131                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3132            {
3133                let member_inline_size =
3134                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3135                if inlined != (member_inline_size <= 4) {
3136                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3137                }
3138                let inner_offset;
3139                let mut inner_depth = depth.clone();
3140                if inlined {
3141                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3142                    inner_offset = next_offset;
3143                } else {
3144                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3145                    inner_depth.increment()?;
3146                }
3147                let val_ref = self.scroll_v.get_or_insert_with(|| fidl::new_empty!(i64, D));
3148                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3149                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3150                {
3151                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3152                }
3153                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3154                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3155                }
3156            }
3157
3158            next_offset += envelope_size;
3159            _next_ordinal_to_read += 1;
3160            if next_offset >= end_offset {
3161                return Ok(());
3162            }
3163
3164            // Decode unknown envelopes for gaps in ordinals.
3165            while _next_ordinal_to_read < 4 {
3166                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3167                _next_ordinal_to_read += 1;
3168                next_offset += envelope_size;
3169            }
3170
3171            let next_out_of_line = decoder.next_out_of_line();
3172            let handles_before = decoder.remaining_handles();
3173            if let Some((inlined, num_bytes, num_handles)) =
3174                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3175            {
3176                let member_inline_size =
3177                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3178                if inlined != (member_inline_size <= 4) {
3179                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3180                }
3181                let inner_offset;
3182                let mut inner_depth = depth.clone();
3183                if inlined {
3184                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3185                    inner_offset = next_offset;
3186                } else {
3187                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3188                    inner_depth.increment()?;
3189                }
3190                let val_ref = self.scroll_h.get_or_insert_with(|| fidl::new_empty!(i64, D));
3191                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3192                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3193                {
3194                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3195                }
3196                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3197                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3198                }
3199            }
3200
3201            next_offset += envelope_size;
3202            _next_ordinal_to_read += 1;
3203            if next_offset >= end_offset {
3204                return Ok(());
3205            }
3206
3207            // Decode unknown envelopes for gaps in ordinals.
3208            while _next_ordinal_to_read < 5 {
3209                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3210                _next_ordinal_to_read += 1;
3211                next_offset += envelope_size;
3212            }
3213
3214            let next_out_of_line = decoder.next_out_of_line();
3215            let handles_before = decoder.remaining_handles();
3216            if let Some((inlined, num_bytes, num_handles)) =
3217                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3218            {
3219                let member_inline_size =
3220                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
3221                        decoder.context,
3222                    );
3223                if inlined != (member_inline_size <= 4) {
3224                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3225                }
3226                let inner_offset;
3227                let mut inner_depth = depth.clone();
3228                if inlined {
3229                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3230                    inner_offset = next_offset;
3231                } else {
3232                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3233                    inner_depth.increment()?;
3234                }
3235                let val_ref = self
3236                    .pressed_buttons
3237                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
3238                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
3239                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3240                {
3241                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3242                }
3243                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3244                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3245                }
3246            }
3247
3248            next_offset += envelope_size;
3249            _next_ordinal_to_read += 1;
3250            if next_offset >= end_offset {
3251                return Ok(());
3252            }
3253
3254            // Decode unknown envelopes for gaps in ordinals.
3255            while _next_ordinal_to_read < 6 {
3256                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3257                _next_ordinal_to_read += 1;
3258                next_offset += envelope_size;
3259            }
3260
3261            let next_out_of_line = decoder.next_out_of_line();
3262            let handles_before = decoder.remaining_handles();
3263            if let Some((inlined, num_bytes, num_handles)) =
3264                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3265            {
3266                let member_inline_size =
3267                    <fidl::encoding::Array<f32, 2> as fidl::encoding::TypeMarker>::inline_size(
3268                        decoder.context,
3269                    );
3270                if inlined != (member_inline_size <= 4) {
3271                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3272                }
3273                let inner_offset;
3274                let mut inner_depth = depth.clone();
3275                if inlined {
3276                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3277                    inner_offset = next_offset;
3278                } else {
3279                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3280                    inner_depth.increment()?;
3281                }
3282                let val_ref = self
3283                    .relative_motion
3284                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 2>, D));
3285                fidl::decode!(fidl::encoding::Array<f32, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
3286                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3287                {
3288                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3289                }
3290                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3291                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3292                }
3293            }
3294
3295            next_offset += envelope_size;
3296            _next_ordinal_to_read += 1;
3297            if next_offset >= end_offset {
3298                return Ok(());
3299            }
3300
3301            // Decode unknown envelopes for gaps in ordinals.
3302            while _next_ordinal_to_read < 7 {
3303                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3304                _next_ordinal_to_read += 1;
3305                next_offset += envelope_size;
3306            }
3307
3308            let next_out_of_line = decoder.next_out_of_line();
3309            let handles_before = decoder.remaining_handles();
3310            if let Some((inlined, num_bytes, num_handles)) =
3311                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3312            {
3313                let member_inline_size =
3314                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3315                if inlined != (member_inline_size <= 4) {
3316                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3317                }
3318                let inner_offset;
3319                let mut inner_depth = depth.clone();
3320                if inlined {
3321                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3322                    inner_offset = next_offset;
3323                } else {
3324                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3325                    inner_depth.increment()?;
3326                }
3327                let val_ref =
3328                    self.scroll_v_physical_pixel.get_or_insert_with(|| fidl::new_empty!(f64, D));
3329                fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
3330                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3331                {
3332                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3333                }
3334                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3335                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3336                }
3337            }
3338
3339            next_offset += envelope_size;
3340            _next_ordinal_to_read += 1;
3341            if next_offset >= end_offset {
3342                return Ok(());
3343            }
3344
3345            // Decode unknown envelopes for gaps in ordinals.
3346            while _next_ordinal_to_read < 8 {
3347                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3348                _next_ordinal_to_read += 1;
3349                next_offset += envelope_size;
3350            }
3351
3352            let next_out_of_line = decoder.next_out_of_line();
3353            let handles_before = decoder.remaining_handles();
3354            if let Some((inlined, num_bytes, num_handles)) =
3355                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3356            {
3357                let member_inline_size =
3358                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3359                if inlined != (member_inline_size <= 4) {
3360                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3361                }
3362                let inner_offset;
3363                let mut inner_depth = depth.clone();
3364                if inlined {
3365                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3366                    inner_offset = next_offset;
3367                } else {
3368                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3369                    inner_depth.increment()?;
3370                }
3371                let val_ref =
3372                    self.scroll_h_physical_pixel.get_or_insert_with(|| fidl::new_empty!(f64, D));
3373                fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
3374                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3375                {
3376                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3377                }
3378                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3379                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3380                }
3381            }
3382
3383            next_offset += envelope_size;
3384            _next_ordinal_to_read += 1;
3385            if next_offset >= end_offset {
3386                return Ok(());
3387            }
3388
3389            // Decode unknown envelopes for gaps in ordinals.
3390            while _next_ordinal_to_read < 9 {
3391                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3392                _next_ordinal_to_read += 1;
3393                next_offset += envelope_size;
3394            }
3395
3396            let next_out_of_line = decoder.next_out_of_line();
3397            let handles_before = decoder.remaining_handles();
3398            if let Some((inlined, num_bytes, num_handles)) =
3399                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3400            {
3401                let member_inline_size =
3402                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3403                if inlined != (member_inline_size <= 4) {
3404                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3405                }
3406                let inner_offset;
3407                let mut inner_depth = depth.clone();
3408                if inlined {
3409                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3410                    inner_offset = next_offset;
3411                } else {
3412                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3413                    inner_depth.increment()?;
3414                }
3415                let val_ref =
3416                    self.is_precision_scroll.get_or_insert_with(|| fidl::new_empty!(bool, D));
3417                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3418                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3419                {
3420                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3421                }
3422                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3423                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3424                }
3425            }
3426
3427            next_offset += envelope_size;
3428
3429            // Decode the remaining unknown envelopes.
3430            while next_offset < end_offset {
3431                _next_ordinal_to_read += 1;
3432                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3433                next_offset += envelope_size;
3434            }
3435
3436            Ok(())
3437        }
3438    }
3439
3440    impl TouchDeviceInfo {
3441        #[inline(always)]
3442        fn max_ordinal_present(&self) -> u64 {
3443            if let Some(_) = self.id {
3444                return 1;
3445            }
3446            0
3447        }
3448    }
3449
3450    impl fidl::encoding::ValueTypeMarker for TouchDeviceInfo {
3451        type Borrowed<'a> = &'a Self;
3452        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3453            value
3454        }
3455    }
3456
3457    unsafe impl fidl::encoding::TypeMarker for TouchDeviceInfo {
3458        type Owned = Self;
3459
3460        #[inline(always)]
3461        fn inline_align(_context: fidl::encoding::Context) -> usize {
3462            8
3463        }
3464
3465        #[inline(always)]
3466        fn inline_size(_context: fidl::encoding::Context) -> usize {
3467            16
3468        }
3469    }
3470
3471    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TouchDeviceInfo, D>
3472        for &TouchDeviceInfo
3473    {
3474        unsafe fn encode(
3475            self,
3476            encoder: &mut fidl::encoding::Encoder<'_, D>,
3477            offset: usize,
3478            mut depth: fidl::encoding::Depth,
3479        ) -> fidl::Result<()> {
3480            encoder.debug_check_bounds::<TouchDeviceInfo>(offset);
3481            // Vector header
3482            let max_ordinal: u64 = self.max_ordinal_present();
3483            encoder.write_num(max_ordinal, offset);
3484            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3485            // Calling encoder.out_of_line_offset(0) is not allowed.
3486            if max_ordinal == 0 {
3487                return Ok(());
3488            }
3489            depth.increment()?;
3490            let envelope_size = 8;
3491            let bytes_len = max_ordinal as usize * envelope_size;
3492            #[allow(unused_variables)]
3493            let offset = encoder.out_of_line_offset(bytes_len);
3494            let mut _prev_end_offset: usize = 0;
3495            if 1 > max_ordinal {
3496                return Ok(());
3497            }
3498
3499            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3500            // are envelope_size bytes.
3501            let cur_offset: usize = (1 - 1) * envelope_size;
3502
3503            // Zero reserved fields.
3504            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3505
3506            // Safety:
3507            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3508            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3509            //   envelope_size bytes, there is always sufficient room.
3510            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3511                self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3512                encoder,
3513                offset + cur_offset,
3514                depth,
3515            )?;
3516
3517            _prev_end_offset = cur_offset + envelope_size;
3518
3519            Ok(())
3520        }
3521    }
3522
3523    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchDeviceInfo {
3524        #[inline(always)]
3525        fn new_empty() -> Self {
3526            Self::default()
3527        }
3528
3529        unsafe fn decode(
3530            &mut self,
3531            decoder: &mut fidl::encoding::Decoder<'_, D>,
3532            offset: usize,
3533            mut depth: fidl::encoding::Depth,
3534        ) -> fidl::Result<()> {
3535            decoder.debug_check_bounds::<Self>(offset);
3536            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3537                None => return Err(fidl::Error::NotNullable),
3538                Some(len) => len,
3539            };
3540            // Calling decoder.out_of_line_offset(0) is not allowed.
3541            if len == 0 {
3542                return Ok(());
3543            };
3544            depth.increment()?;
3545            let envelope_size = 8;
3546            let bytes_len = len * envelope_size;
3547            let offset = decoder.out_of_line_offset(bytes_len)?;
3548            // Decode the envelope for each type.
3549            let mut _next_ordinal_to_read = 0;
3550            let mut next_offset = offset;
3551            let end_offset = offset + bytes_len;
3552            _next_ordinal_to_read += 1;
3553            if next_offset >= end_offset {
3554                return Ok(());
3555            }
3556
3557            // Decode unknown envelopes for gaps in ordinals.
3558            while _next_ordinal_to_read < 1 {
3559                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3560                _next_ordinal_to_read += 1;
3561                next_offset += envelope_size;
3562            }
3563
3564            let next_out_of_line = decoder.next_out_of_line();
3565            let handles_before = decoder.remaining_handles();
3566            if let Some((inlined, num_bytes, num_handles)) =
3567                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3568            {
3569                let member_inline_size =
3570                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3571                if inlined != (member_inline_size <= 4) {
3572                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3573                }
3574                let inner_offset;
3575                let mut inner_depth = depth.clone();
3576                if inlined {
3577                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3578                    inner_offset = next_offset;
3579                } else {
3580                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3581                    inner_depth.increment()?;
3582                }
3583                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
3584                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3585                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3586                {
3587                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3588                }
3589                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3590                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3591                }
3592            }
3593
3594            next_offset += envelope_size;
3595
3596            // Decode the remaining unknown envelopes.
3597            while next_offset < end_offset {
3598                _next_ordinal_to_read += 1;
3599                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3600                next_offset += envelope_size;
3601            }
3602
3603            Ok(())
3604        }
3605    }
3606
3607    impl TouchEvent {
3608        #[inline(always)]
3609        fn max_ordinal_present(&self) -> u64 {
3610            if let Some(_) = self.trace_flow_id {
3611                return 6;
3612            }
3613            if let Some(_) = self.interaction_result {
3614                return 5;
3615            }
3616            if let Some(_) = self.pointer_sample {
3617                return 4;
3618            }
3619            if let Some(_) = self.device_info {
3620                return 3;
3621            }
3622            if let Some(_) = self.view_parameters {
3623                return 2;
3624            }
3625            if let Some(_) = self.timestamp {
3626                return 1;
3627            }
3628            0
3629        }
3630    }
3631
3632    impl fidl::encoding::ValueTypeMarker for TouchEvent {
3633        type Borrowed<'a> = &'a Self;
3634        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3635            value
3636        }
3637    }
3638
3639    unsafe impl fidl::encoding::TypeMarker for TouchEvent {
3640        type Owned = Self;
3641
3642        #[inline(always)]
3643        fn inline_align(_context: fidl::encoding::Context) -> usize {
3644            8
3645        }
3646
3647        #[inline(always)]
3648        fn inline_size(_context: fidl::encoding::Context) -> usize {
3649            16
3650        }
3651    }
3652
3653    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TouchEvent, D>
3654        for &TouchEvent
3655    {
3656        unsafe fn encode(
3657            self,
3658            encoder: &mut fidl::encoding::Encoder<'_, D>,
3659            offset: usize,
3660            mut depth: fidl::encoding::Depth,
3661        ) -> fidl::Result<()> {
3662            encoder.debug_check_bounds::<TouchEvent>(offset);
3663            // Vector header
3664            let max_ordinal: u64 = self.max_ordinal_present();
3665            encoder.write_num(max_ordinal, offset);
3666            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3667            // Calling encoder.out_of_line_offset(0) is not allowed.
3668            if max_ordinal == 0 {
3669                return Ok(());
3670            }
3671            depth.increment()?;
3672            let envelope_size = 8;
3673            let bytes_len = max_ordinal as usize * envelope_size;
3674            #[allow(unused_variables)]
3675            let offset = encoder.out_of_line_offset(bytes_len);
3676            let mut _prev_end_offset: usize = 0;
3677            if 1 > max_ordinal {
3678                return Ok(());
3679            }
3680
3681            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3682            // are envelope_size bytes.
3683            let cur_offset: usize = (1 - 1) * envelope_size;
3684
3685            // Zero reserved fields.
3686            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3687
3688            // Safety:
3689            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3690            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3691            //   envelope_size bytes, there is always sufficient room.
3692            fidl::encoding::encode_in_envelope_optional::<i64, D>(
3693                self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3694                encoder,
3695                offset + cur_offset,
3696                depth,
3697            )?;
3698
3699            _prev_end_offset = cur_offset + envelope_size;
3700            if 2 > max_ordinal {
3701                return Ok(());
3702            }
3703
3704            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3705            // are envelope_size bytes.
3706            let cur_offset: usize = (2 - 1) * envelope_size;
3707
3708            // Zero reserved fields.
3709            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3710
3711            // Safety:
3712            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3713            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3714            //   envelope_size bytes, there is always sufficient room.
3715            fidl::encoding::encode_in_envelope_optional::<ViewParameters, D>(
3716                self.view_parameters
3717                    .as_ref()
3718                    .map(<ViewParameters as fidl::encoding::ValueTypeMarker>::borrow),
3719                encoder,
3720                offset + cur_offset,
3721                depth,
3722            )?;
3723
3724            _prev_end_offset = cur_offset + envelope_size;
3725            if 3 > max_ordinal {
3726                return Ok(());
3727            }
3728
3729            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3730            // are envelope_size bytes.
3731            let cur_offset: usize = (3 - 1) * envelope_size;
3732
3733            // Zero reserved fields.
3734            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3735
3736            // Safety:
3737            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3738            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3739            //   envelope_size bytes, there is always sufficient room.
3740            fidl::encoding::encode_in_envelope_optional::<TouchDeviceInfo, D>(
3741                self.device_info
3742                    .as_ref()
3743                    .map(<TouchDeviceInfo as fidl::encoding::ValueTypeMarker>::borrow),
3744                encoder,
3745                offset + cur_offset,
3746                depth,
3747            )?;
3748
3749            _prev_end_offset = cur_offset + envelope_size;
3750            if 4 > max_ordinal {
3751                return Ok(());
3752            }
3753
3754            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3755            // are envelope_size bytes.
3756            let cur_offset: usize = (4 - 1) * envelope_size;
3757
3758            // Zero reserved fields.
3759            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3760
3761            // Safety:
3762            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3763            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3764            //   envelope_size bytes, there is always sufficient room.
3765            fidl::encoding::encode_in_envelope_optional::<TouchPointerSample, D>(
3766                self.pointer_sample
3767                    .as_ref()
3768                    .map(<TouchPointerSample as fidl::encoding::ValueTypeMarker>::borrow),
3769                encoder,
3770                offset + cur_offset,
3771                depth,
3772            )?;
3773
3774            _prev_end_offset = cur_offset + envelope_size;
3775            if 5 > max_ordinal {
3776                return Ok(());
3777            }
3778
3779            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3780            // are envelope_size bytes.
3781            let cur_offset: usize = (5 - 1) * envelope_size;
3782
3783            // Zero reserved fields.
3784            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3785
3786            // Safety:
3787            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3788            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3789            //   envelope_size bytes, there is always sufficient room.
3790            fidl::encoding::encode_in_envelope_optional::<TouchInteractionResult, D>(
3791                self.interaction_result
3792                    .as_ref()
3793                    .map(<TouchInteractionResult as fidl::encoding::ValueTypeMarker>::borrow),
3794                encoder,
3795                offset + cur_offset,
3796                depth,
3797            )?;
3798
3799            _prev_end_offset = cur_offset + envelope_size;
3800            if 6 > max_ordinal {
3801                return Ok(());
3802            }
3803
3804            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3805            // are envelope_size bytes.
3806            let cur_offset: usize = (6 - 1) * envelope_size;
3807
3808            // Zero reserved fields.
3809            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3810
3811            // Safety:
3812            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3813            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3814            //   envelope_size bytes, there is always sufficient room.
3815            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3816                self.trace_flow_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3817                encoder,
3818                offset + cur_offset,
3819                depth,
3820            )?;
3821
3822            _prev_end_offset = cur_offset + envelope_size;
3823
3824            Ok(())
3825        }
3826    }
3827
3828    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchEvent {
3829        #[inline(always)]
3830        fn new_empty() -> Self {
3831            Self::default()
3832        }
3833
3834        unsafe fn decode(
3835            &mut self,
3836            decoder: &mut fidl::encoding::Decoder<'_, D>,
3837            offset: usize,
3838            mut depth: fidl::encoding::Depth,
3839        ) -> fidl::Result<()> {
3840            decoder.debug_check_bounds::<Self>(offset);
3841            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3842                None => return Err(fidl::Error::NotNullable),
3843                Some(len) => len,
3844            };
3845            // Calling decoder.out_of_line_offset(0) is not allowed.
3846            if len == 0 {
3847                return Ok(());
3848            };
3849            depth.increment()?;
3850            let envelope_size = 8;
3851            let bytes_len = len * envelope_size;
3852            let offset = decoder.out_of_line_offset(bytes_len)?;
3853            // Decode the envelope for each type.
3854            let mut _next_ordinal_to_read = 0;
3855            let mut next_offset = offset;
3856            let end_offset = offset + bytes_len;
3857            _next_ordinal_to_read += 1;
3858            if next_offset >= end_offset {
3859                return Ok(());
3860            }
3861
3862            // Decode unknown envelopes for gaps in ordinals.
3863            while _next_ordinal_to_read < 1 {
3864                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3865                _next_ordinal_to_read += 1;
3866                next_offset += envelope_size;
3867            }
3868
3869            let next_out_of_line = decoder.next_out_of_line();
3870            let handles_before = decoder.remaining_handles();
3871            if let Some((inlined, num_bytes, num_handles)) =
3872                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3873            {
3874                let member_inline_size =
3875                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3876                if inlined != (member_inline_size <= 4) {
3877                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3878                }
3879                let inner_offset;
3880                let mut inner_depth = depth.clone();
3881                if inlined {
3882                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3883                    inner_offset = next_offset;
3884                } else {
3885                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3886                    inner_depth.increment()?;
3887                }
3888                let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
3889                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3890                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3891                {
3892                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3893                }
3894                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3895                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3896                }
3897            }
3898
3899            next_offset += envelope_size;
3900            _next_ordinal_to_read += 1;
3901            if next_offset >= end_offset {
3902                return Ok(());
3903            }
3904
3905            // Decode unknown envelopes for gaps in ordinals.
3906            while _next_ordinal_to_read < 2 {
3907                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3908                _next_ordinal_to_read += 1;
3909                next_offset += envelope_size;
3910            }
3911
3912            let next_out_of_line = decoder.next_out_of_line();
3913            let handles_before = decoder.remaining_handles();
3914            if let Some((inlined, num_bytes, num_handles)) =
3915                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3916            {
3917                let member_inline_size =
3918                    <ViewParameters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3919                if inlined != (member_inline_size <= 4) {
3920                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3921                }
3922                let inner_offset;
3923                let mut inner_depth = depth.clone();
3924                if inlined {
3925                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3926                    inner_offset = next_offset;
3927                } else {
3928                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3929                    inner_depth.increment()?;
3930                }
3931                let val_ref =
3932                    self.view_parameters.get_or_insert_with(|| fidl::new_empty!(ViewParameters, D));
3933                fidl::decode!(ViewParameters, D, val_ref, decoder, inner_offset, inner_depth)?;
3934                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3935                {
3936                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3937                }
3938                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3939                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3940                }
3941            }
3942
3943            next_offset += envelope_size;
3944            _next_ordinal_to_read += 1;
3945            if next_offset >= end_offset {
3946                return Ok(());
3947            }
3948
3949            // Decode unknown envelopes for gaps in ordinals.
3950            while _next_ordinal_to_read < 3 {
3951                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3952                _next_ordinal_to_read += 1;
3953                next_offset += envelope_size;
3954            }
3955
3956            let next_out_of_line = decoder.next_out_of_line();
3957            let handles_before = decoder.remaining_handles();
3958            if let Some((inlined, num_bytes, num_handles)) =
3959                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3960            {
3961                let member_inline_size =
3962                    <TouchDeviceInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3963                if inlined != (member_inline_size <= 4) {
3964                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3965                }
3966                let inner_offset;
3967                let mut inner_depth = depth.clone();
3968                if inlined {
3969                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3970                    inner_offset = next_offset;
3971                } else {
3972                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3973                    inner_depth.increment()?;
3974                }
3975                let val_ref =
3976                    self.device_info.get_or_insert_with(|| fidl::new_empty!(TouchDeviceInfo, D));
3977                fidl::decode!(TouchDeviceInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
3978                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3979                {
3980                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3981                }
3982                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3983                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3984                }
3985            }
3986
3987            next_offset += envelope_size;
3988            _next_ordinal_to_read += 1;
3989            if next_offset >= end_offset {
3990                return Ok(());
3991            }
3992
3993            // Decode unknown envelopes for gaps in ordinals.
3994            while _next_ordinal_to_read < 4 {
3995                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3996                _next_ordinal_to_read += 1;
3997                next_offset += envelope_size;
3998            }
3999
4000            let next_out_of_line = decoder.next_out_of_line();
4001            let handles_before = decoder.remaining_handles();
4002            if let Some((inlined, num_bytes, num_handles)) =
4003                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4004            {
4005                let member_inline_size =
4006                    <TouchPointerSample as fidl::encoding::TypeMarker>::inline_size(
4007                        decoder.context,
4008                    );
4009                if inlined != (member_inline_size <= 4) {
4010                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4011                }
4012                let inner_offset;
4013                let mut inner_depth = depth.clone();
4014                if inlined {
4015                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4016                    inner_offset = next_offset;
4017                } else {
4018                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4019                    inner_depth.increment()?;
4020                }
4021                let val_ref = self
4022                    .pointer_sample
4023                    .get_or_insert_with(|| fidl::new_empty!(TouchPointerSample, D));
4024                fidl::decode!(TouchPointerSample, D, val_ref, decoder, inner_offset, inner_depth)?;
4025                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4026                {
4027                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4028                }
4029                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4030                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4031                }
4032            }
4033
4034            next_offset += envelope_size;
4035            _next_ordinal_to_read += 1;
4036            if next_offset >= end_offset {
4037                return Ok(());
4038            }
4039
4040            // Decode unknown envelopes for gaps in ordinals.
4041            while _next_ordinal_to_read < 5 {
4042                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4043                _next_ordinal_to_read += 1;
4044                next_offset += envelope_size;
4045            }
4046
4047            let next_out_of_line = decoder.next_out_of_line();
4048            let handles_before = decoder.remaining_handles();
4049            if let Some((inlined, num_bytes, num_handles)) =
4050                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4051            {
4052                let member_inline_size =
4053                    <TouchInteractionResult as fidl::encoding::TypeMarker>::inline_size(
4054                        decoder.context,
4055                    );
4056                if inlined != (member_inline_size <= 4) {
4057                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4058                }
4059                let inner_offset;
4060                let mut inner_depth = depth.clone();
4061                if inlined {
4062                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4063                    inner_offset = next_offset;
4064                } else {
4065                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4066                    inner_depth.increment()?;
4067                }
4068                let val_ref = self
4069                    .interaction_result
4070                    .get_or_insert_with(|| fidl::new_empty!(TouchInteractionResult, D));
4071                fidl::decode!(
4072                    TouchInteractionResult,
4073                    D,
4074                    val_ref,
4075                    decoder,
4076                    inner_offset,
4077                    inner_depth
4078                )?;
4079                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4080                {
4081                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4082                }
4083                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4084                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4085                }
4086            }
4087
4088            next_offset += envelope_size;
4089            _next_ordinal_to_read += 1;
4090            if next_offset >= end_offset {
4091                return Ok(());
4092            }
4093
4094            // Decode unknown envelopes for gaps in ordinals.
4095            while _next_ordinal_to_read < 6 {
4096                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4097                _next_ordinal_to_read += 1;
4098                next_offset += envelope_size;
4099            }
4100
4101            let next_out_of_line = decoder.next_out_of_line();
4102            let handles_before = decoder.remaining_handles();
4103            if let Some((inlined, num_bytes, num_handles)) =
4104                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4105            {
4106                let member_inline_size =
4107                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4108                if inlined != (member_inline_size <= 4) {
4109                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4110                }
4111                let inner_offset;
4112                let mut inner_depth = depth.clone();
4113                if inlined {
4114                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4115                    inner_offset = next_offset;
4116                } else {
4117                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4118                    inner_depth.increment()?;
4119                }
4120                let val_ref = self.trace_flow_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4121                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4122                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4123                {
4124                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4125                }
4126                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4127                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4128                }
4129            }
4130
4131            next_offset += envelope_size;
4132
4133            // Decode the remaining unknown envelopes.
4134            while next_offset < end_offset {
4135                _next_ordinal_to_read += 1;
4136                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4137                next_offset += envelope_size;
4138            }
4139
4140            Ok(())
4141        }
4142    }
4143
4144    impl TouchPointerSample {
4145        #[inline(always)]
4146        fn max_ordinal_present(&self) -> u64 {
4147            if let Some(_) = self.position_in_viewport {
4148                return 3;
4149            }
4150            if let Some(_) = self.phase {
4151                return 2;
4152            }
4153            if let Some(_) = self.interaction {
4154                return 1;
4155            }
4156            0
4157        }
4158    }
4159
4160    impl fidl::encoding::ValueTypeMarker for TouchPointerSample {
4161        type Borrowed<'a> = &'a Self;
4162        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4163            value
4164        }
4165    }
4166
4167    unsafe impl fidl::encoding::TypeMarker for TouchPointerSample {
4168        type Owned = Self;
4169
4170        #[inline(always)]
4171        fn inline_align(_context: fidl::encoding::Context) -> usize {
4172            8
4173        }
4174
4175        #[inline(always)]
4176        fn inline_size(_context: fidl::encoding::Context) -> usize {
4177            16
4178        }
4179    }
4180
4181    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TouchPointerSample, D>
4182        for &TouchPointerSample
4183    {
4184        unsafe fn encode(
4185            self,
4186            encoder: &mut fidl::encoding::Encoder<'_, D>,
4187            offset: usize,
4188            mut depth: fidl::encoding::Depth,
4189        ) -> fidl::Result<()> {
4190            encoder.debug_check_bounds::<TouchPointerSample>(offset);
4191            // Vector header
4192            let max_ordinal: u64 = self.max_ordinal_present();
4193            encoder.write_num(max_ordinal, offset);
4194            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4195            // Calling encoder.out_of_line_offset(0) is not allowed.
4196            if max_ordinal == 0 {
4197                return Ok(());
4198            }
4199            depth.increment()?;
4200            let envelope_size = 8;
4201            let bytes_len = max_ordinal as usize * envelope_size;
4202            #[allow(unused_variables)]
4203            let offset = encoder.out_of_line_offset(bytes_len);
4204            let mut _prev_end_offset: usize = 0;
4205            if 1 > max_ordinal {
4206                return Ok(());
4207            }
4208
4209            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4210            // are envelope_size bytes.
4211            let cur_offset: usize = (1 - 1) * envelope_size;
4212
4213            // Zero reserved fields.
4214            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4215
4216            // Safety:
4217            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4218            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4219            //   envelope_size bytes, there is always sufficient room.
4220            fidl::encoding::encode_in_envelope_optional::<TouchInteractionId, D>(
4221                self.interaction
4222                    .as_ref()
4223                    .map(<TouchInteractionId as fidl::encoding::ValueTypeMarker>::borrow),
4224                encoder,
4225                offset + cur_offset,
4226                depth,
4227            )?;
4228
4229            _prev_end_offset = cur_offset + envelope_size;
4230            if 2 > max_ordinal {
4231                return Ok(());
4232            }
4233
4234            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4235            // are envelope_size bytes.
4236            let cur_offset: usize = (2 - 1) * envelope_size;
4237
4238            // Zero reserved fields.
4239            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4240
4241            // Safety:
4242            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4243            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4244            //   envelope_size bytes, there is always sufficient room.
4245            fidl::encoding::encode_in_envelope_optional::<EventPhase, D>(
4246                self.phase.as_ref().map(<EventPhase as fidl::encoding::ValueTypeMarker>::borrow),
4247                encoder,
4248                offset + cur_offset,
4249                depth,
4250            )?;
4251
4252            _prev_end_offset = cur_offset + envelope_size;
4253            if 3 > max_ordinal {
4254                return Ok(());
4255            }
4256
4257            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4258            // are envelope_size bytes.
4259            let cur_offset: usize = (3 - 1) * envelope_size;
4260
4261            // Zero reserved fields.
4262            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4263
4264            // Safety:
4265            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4266            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4267            //   envelope_size bytes, there is always sufficient room.
4268            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 2>, D>(
4269                self.position_in_viewport.as_ref().map(
4270                    <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow,
4271                ),
4272                encoder,
4273                offset + cur_offset,
4274                depth,
4275            )?;
4276
4277            _prev_end_offset = cur_offset + envelope_size;
4278
4279            Ok(())
4280        }
4281    }
4282
4283    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchPointerSample {
4284        #[inline(always)]
4285        fn new_empty() -> Self {
4286            Self::default()
4287        }
4288
4289        unsafe fn decode(
4290            &mut self,
4291            decoder: &mut fidl::encoding::Decoder<'_, D>,
4292            offset: usize,
4293            mut depth: fidl::encoding::Depth,
4294        ) -> fidl::Result<()> {
4295            decoder.debug_check_bounds::<Self>(offset);
4296            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4297                None => return Err(fidl::Error::NotNullable),
4298                Some(len) => len,
4299            };
4300            // Calling decoder.out_of_line_offset(0) is not allowed.
4301            if len == 0 {
4302                return Ok(());
4303            };
4304            depth.increment()?;
4305            let envelope_size = 8;
4306            let bytes_len = len * envelope_size;
4307            let offset = decoder.out_of_line_offset(bytes_len)?;
4308            // Decode the envelope for each type.
4309            let mut _next_ordinal_to_read = 0;
4310            let mut next_offset = offset;
4311            let end_offset = offset + bytes_len;
4312            _next_ordinal_to_read += 1;
4313            if next_offset >= end_offset {
4314                return Ok(());
4315            }
4316
4317            // Decode unknown envelopes for gaps in ordinals.
4318            while _next_ordinal_to_read < 1 {
4319                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4320                _next_ordinal_to_read += 1;
4321                next_offset += envelope_size;
4322            }
4323
4324            let next_out_of_line = decoder.next_out_of_line();
4325            let handles_before = decoder.remaining_handles();
4326            if let Some((inlined, num_bytes, num_handles)) =
4327                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4328            {
4329                let member_inline_size =
4330                    <TouchInteractionId as fidl::encoding::TypeMarker>::inline_size(
4331                        decoder.context,
4332                    );
4333                if inlined != (member_inline_size <= 4) {
4334                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4335                }
4336                let inner_offset;
4337                let mut inner_depth = depth.clone();
4338                if inlined {
4339                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4340                    inner_offset = next_offset;
4341                } else {
4342                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4343                    inner_depth.increment()?;
4344                }
4345                let val_ref =
4346                    self.interaction.get_or_insert_with(|| fidl::new_empty!(TouchInteractionId, D));
4347                fidl::decode!(TouchInteractionId, D, val_ref, decoder, inner_offset, inner_depth)?;
4348                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4349                {
4350                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4351                }
4352                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4353                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4354                }
4355            }
4356
4357            next_offset += envelope_size;
4358            _next_ordinal_to_read += 1;
4359            if next_offset >= end_offset {
4360                return Ok(());
4361            }
4362
4363            // Decode unknown envelopes for gaps in ordinals.
4364            while _next_ordinal_to_read < 2 {
4365                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4366                _next_ordinal_to_read += 1;
4367                next_offset += envelope_size;
4368            }
4369
4370            let next_out_of_line = decoder.next_out_of_line();
4371            let handles_before = decoder.remaining_handles();
4372            if let Some((inlined, num_bytes, num_handles)) =
4373                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4374            {
4375                let member_inline_size =
4376                    <EventPhase as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4377                if inlined != (member_inline_size <= 4) {
4378                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4379                }
4380                let inner_offset;
4381                let mut inner_depth = depth.clone();
4382                if inlined {
4383                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4384                    inner_offset = next_offset;
4385                } else {
4386                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4387                    inner_depth.increment()?;
4388                }
4389                let val_ref = self.phase.get_or_insert_with(|| fidl::new_empty!(EventPhase, D));
4390                fidl::decode!(EventPhase, D, val_ref, decoder, inner_offset, inner_depth)?;
4391                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4392                {
4393                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4394                }
4395                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4396                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4397                }
4398            }
4399
4400            next_offset += envelope_size;
4401            _next_ordinal_to_read += 1;
4402            if next_offset >= end_offset {
4403                return Ok(());
4404            }
4405
4406            // Decode unknown envelopes for gaps in ordinals.
4407            while _next_ordinal_to_read < 3 {
4408                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4409                _next_ordinal_to_read += 1;
4410                next_offset += envelope_size;
4411            }
4412
4413            let next_out_of_line = decoder.next_out_of_line();
4414            let handles_before = decoder.remaining_handles();
4415            if let Some((inlined, num_bytes, num_handles)) =
4416                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4417            {
4418                let member_inline_size =
4419                    <fidl::encoding::Array<f32, 2> as fidl::encoding::TypeMarker>::inline_size(
4420                        decoder.context,
4421                    );
4422                if inlined != (member_inline_size <= 4) {
4423                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4424                }
4425                let inner_offset;
4426                let mut inner_depth = depth.clone();
4427                if inlined {
4428                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4429                    inner_offset = next_offset;
4430                } else {
4431                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4432                    inner_depth.increment()?;
4433                }
4434                let val_ref = self
4435                    .position_in_viewport
4436                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 2>, D));
4437                fidl::decode!(fidl::encoding::Array<f32, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
4438                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4439                {
4440                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4441                }
4442                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4443                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4444                }
4445            }
4446
4447            next_offset += envelope_size;
4448
4449            // Decode the remaining unknown envelopes.
4450            while next_offset < end_offset {
4451                _next_ordinal_to_read += 1;
4452                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4453                next_offset += envelope_size;
4454            }
4455
4456            Ok(())
4457        }
4458    }
4459
4460    impl TouchResponse {
4461        #[inline(always)]
4462        fn max_ordinal_present(&self) -> u64 {
4463            if let Some(_) = self.trace_flow_id {
4464                return 2;
4465            }
4466            if let Some(_) = self.response_type {
4467                return 1;
4468            }
4469            0
4470        }
4471    }
4472
4473    impl fidl::encoding::ValueTypeMarker for TouchResponse {
4474        type Borrowed<'a> = &'a Self;
4475        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4476            value
4477        }
4478    }
4479
4480    unsafe impl fidl::encoding::TypeMarker for TouchResponse {
4481        type Owned = Self;
4482
4483        #[inline(always)]
4484        fn inline_align(_context: fidl::encoding::Context) -> usize {
4485            8
4486        }
4487
4488        #[inline(always)]
4489        fn inline_size(_context: fidl::encoding::Context) -> usize {
4490            16
4491        }
4492    }
4493
4494    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TouchResponse, D>
4495        for &TouchResponse
4496    {
4497        unsafe fn encode(
4498            self,
4499            encoder: &mut fidl::encoding::Encoder<'_, D>,
4500            offset: usize,
4501            mut depth: fidl::encoding::Depth,
4502        ) -> fidl::Result<()> {
4503            encoder.debug_check_bounds::<TouchResponse>(offset);
4504            // Vector header
4505            let max_ordinal: u64 = self.max_ordinal_present();
4506            encoder.write_num(max_ordinal, offset);
4507            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4508            // Calling encoder.out_of_line_offset(0) is not allowed.
4509            if max_ordinal == 0 {
4510                return Ok(());
4511            }
4512            depth.increment()?;
4513            let envelope_size = 8;
4514            let bytes_len = max_ordinal as usize * envelope_size;
4515            #[allow(unused_variables)]
4516            let offset = encoder.out_of_line_offset(bytes_len);
4517            let mut _prev_end_offset: usize = 0;
4518            if 1 > max_ordinal {
4519                return Ok(());
4520            }
4521
4522            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4523            // are envelope_size bytes.
4524            let cur_offset: usize = (1 - 1) * envelope_size;
4525
4526            // Zero reserved fields.
4527            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4528
4529            // Safety:
4530            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4531            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4532            //   envelope_size bytes, there is always sufficient room.
4533            fidl::encoding::encode_in_envelope_optional::<TouchResponseType, D>(
4534                self.response_type
4535                    .as_ref()
4536                    .map(<TouchResponseType as fidl::encoding::ValueTypeMarker>::borrow),
4537                encoder,
4538                offset + cur_offset,
4539                depth,
4540            )?;
4541
4542            _prev_end_offset = cur_offset + envelope_size;
4543            if 2 > max_ordinal {
4544                return Ok(());
4545            }
4546
4547            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4548            // are envelope_size bytes.
4549            let cur_offset: usize = (2 - 1) * envelope_size;
4550
4551            // Zero reserved fields.
4552            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4553
4554            // Safety:
4555            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4556            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4557            //   envelope_size bytes, there is always sufficient room.
4558            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4559                self.trace_flow_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4560                encoder,
4561                offset + cur_offset,
4562                depth,
4563            )?;
4564
4565            _prev_end_offset = cur_offset + envelope_size;
4566
4567            Ok(())
4568        }
4569    }
4570
4571    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TouchResponse {
4572        #[inline(always)]
4573        fn new_empty() -> Self {
4574            Self::default()
4575        }
4576
4577        unsafe fn decode(
4578            &mut self,
4579            decoder: &mut fidl::encoding::Decoder<'_, D>,
4580            offset: usize,
4581            mut depth: fidl::encoding::Depth,
4582        ) -> fidl::Result<()> {
4583            decoder.debug_check_bounds::<Self>(offset);
4584            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4585                None => return Err(fidl::Error::NotNullable),
4586                Some(len) => len,
4587            };
4588            // Calling decoder.out_of_line_offset(0) is not allowed.
4589            if len == 0 {
4590                return Ok(());
4591            };
4592            depth.increment()?;
4593            let envelope_size = 8;
4594            let bytes_len = len * envelope_size;
4595            let offset = decoder.out_of_line_offset(bytes_len)?;
4596            // Decode the envelope for each type.
4597            let mut _next_ordinal_to_read = 0;
4598            let mut next_offset = offset;
4599            let end_offset = offset + bytes_len;
4600            _next_ordinal_to_read += 1;
4601            if next_offset >= end_offset {
4602                return Ok(());
4603            }
4604
4605            // Decode unknown envelopes for gaps in ordinals.
4606            while _next_ordinal_to_read < 1 {
4607                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4608                _next_ordinal_to_read += 1;
4609                next_offset += envelope_size;
4610            }
4611
4612            let next_out_of_line = decoder.next_out_of_line();
4613            let handles_before = decoder.remaining_handles();
4614            if let Some((inlined, num_bytes, num_handles)) =
4615                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4616            {
4617                let member_inline_size =
4618                    <TouchResponseType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4619                if inlined != (member_inline_size <= 4) {
4620                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4621                }
4622                let inner_offset;
4623                let mut inner_depth = depth.clone();
4624                if inlined {
4625                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4626                    inner_offset = next_offset;
4627                } else {
4628                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4629                    inner_depth.increment()?;
4630                }
4631                let val_ref = self
4632                    .response_type
4633                    .get_or_insert_with(|| fidl::new_empty!(TouchResponseType, D));
4634                fidl::decode!(TouchResponseType, D, val_ref, decoder, inner_offset, inner_depth)?;
4635                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4636                {
4637                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4638                }
4639                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4640                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4641                }
4642            }
4643
4644            next_offset += envelope_size;
4645            _next_ordinal_to_read += 1;
4646            if next_offset >= end_offset {
4647                return Ok(());
4648            }
4649
4650            // Decode unknown envelopes for gaps in ordinals.
4651            while _next_ordinal_to_read < 2 {
4652                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4653                _next_ordinal_to_read += 1;
4654                next_offset += envelope_size;
4655            }
4656
4657            let next_out_of_line = decoder.next_out_of_line();
4658            let handles_before = decoder.remaining_handles();
4659            if let Some((inlined, num_bytes, num_handles)) =
4660                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4661            {
4662                let member_inline_size =
4663                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4664                if inlined != (member_inline_size <= 4) {
4665                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4666                }
4667                let inner_offset;
4668                let mut inner_depth = depth.clone();
4669                if inlined {
4670                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4671                    inner_offset = next_offset;
4672                } else {
4673                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4674                    inner_depth.increment()?;
4675                }
4676                let val_ref = self.trace_flow_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4677                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4678                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4679                {
4680                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4681                }
4682                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4683                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4684                }
4685            }
4686
4687            next_offset += envelope_size;
4688
4689            // Decode the remaining unknown envelopes.
4690            while next_offset < end_offset {
4691                _next_ordinal_to_read += 1;
4692                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4693                next_offset += envelope_size;
4694            }
4695
4696            Ok(())
4697        }
4698    }
4699}