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