fidl_fuchsia_ui_pointerinjector__common/
fidl_fuchsia_ui_pointerinjector__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 pair of points, representing minimal and maximal extents.
12/// - The values are placed in (minimal, maximal) order.
13pub type Extents = [[f32; 2]; 2];
14
15/// A floating-point 3x3 matrix.
16/// - The values are placed in column-major order.
17pub type Mat3 = [f32; 9];
18
19/// A floating-point two-dimensional point.
20/// - The values are placed in (x, y) order.
21pub type Point2 = [f32; 2];
22
23/// The relative motion performed by a mouse device.
24/// - The valid range is defined in [`Config.RelativeMotionRange`].
25/// - The values are placed in (x, y) order.
26pub type RelativeMotion = [f32; 2];
27
28/// The valid values of relative motion for a mouse device.
29/// - The ranges are placed in (x, y) order.
30pub type RelativeMotionRange = [fidl_fuchsia_input_report__common::Axis; 2];
31
32pub const MAX_INJECT: u32 = 128;
33
34/// A characterization of a device that issues pointer event streams.
35#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
36#[repr(u32)]
37pub enum DeviceType {
38    /// A device intended for manipulation by direct contact over its surface.
39    Touch = 1,
40    /// A device intended for manipulation by precise movement over a surface.
41    Mouse = 2,
42}
43
44impl DeviceType {
45    #[inline]
46    pub fn from_primitive(prim: u32) -> Option<Self> {
47        match prim {
48            1 => Some(Self::Touch),
49            2 => Some(Self::Mouse),
50            _ => None,
51        }
52    }
53
54    #[inline]
55    pub const fn into_primitive(self) -> u32 {
56        self as u32
57    }
58}
59
60/// A specification of the UI clients that may have injected events dispatched
61/// to them in an |Target|. One is specified in |Config|.
62///
63/// A useful concept is "latching", where one or more clients may start
64/// receiving the pointer event stream, prior to assignment of stream ownership.
65/// After ownership is assigned (e.g., through a gesture disambiguation
66/// protocol), non-owning clients have their latch terminated -- they stop
67/// receiving the pointer event stream.
68/// - A client's latch does not itself confer stream ownership (receiving the
69///   entire pointer event stream); gesture disambiguation or device termination
70///   may prematurely end the stream dispatched to that client.
71/// - It's possible for a client to latch while hidden from the user (i.e.,
72///   manipulate a surface that is invisible to the user), where the occluding
73///   surface is owned by a client outside of |Target|. Conversely, these
74///   occluding clients cannot latch, because latched clients must be in
75///   |Target|'s view tree.
76#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
77#[repr(u32)]
78pub enum DispatchPolicy {
79    /// A single client latches onto a pointer event stream, where:
80    /// - the pointer event stream starts within the viewport rectangle,
81    /// - the latch happens on the ADD phase of the pointer event stream,
82    /// - the client is the |Target| itself.
83    /// Ownership is assigned immediately to the client.
84    ///
85    /// Note: This policy guarantees confidentiality, integrity, and
86    ///       availability of dispatch to the client, but by itself, does *not*
87    ///       confer immunity against UI redress attacks.
88    ExclusiveTarget = 1,
89    /// Multiple clients may latch onto a pointer stream, where:
90    /// - the pointer stream starts within the viewport rectangle,
91    /// - a hit test is performed on the ADD phase of the pointer event stream,
92    ///   which returns the top-most surface (in paint order) in the |Target|'s
93    ///   view tree,
94    /// - the top-most surface's client latches onto the pointer stream,
95    /// - the client's ancestors in the |Target|'s view tree also latch onto the
96    ///   pointer stream.
97    ///
98    /// With multiple latches, a pointer stream is dispatched in parallel to
99    /// each latched client, until ownership is assigned via gesture
100    /// disambiguation. The owner client will continue to receive the pointer
101    /// stream, and non-owners will receive a final CANCEL event for the stream.
102    ///
103    /// Note: It's possible for no clients to latch, if the hit test fails to
104    ///       hit any surface in any sub-view of |Target|.
105    /// Note: Each client will have its own copy of the viewport, placed
106    ///       accordingly in its own coordinate system.
107    TopHitAndAncestorsInTarget = 2,
108    /// The top hit client in the |Target|'s view tree receives hover events when
109    /// a cursor is positioned over it, unless the mouse is latched to a specific
110    /// client.
111    ///
112    /// A mouse initiates a latch via button down, and until the release of that
113    /// latch, mouse events are delivered to that latched client; other clients
114    /// do not receive hover events in the latch duration.
115    ///
116    /// Note: It's possible for no client to latch, if the hit test fails to
117    ///       hit any surface in any sub-view of |Target|.
118    /// Note: Each client will have its own copy of the viewport, placed
119    ///       accordingly in its own coordinate system.
120    MouseHoverAndLatchInTarget = 3,
121}
122
123impl DispatchPolicy {
124    #[inline]
125    pub fn from_primitive(prim: u32) -> Option<Self> {
126        match prim {
127            1 => Some(Self::ExclusiveTarget),
128            2 => Some(Self::TopHitAndAncestorsInTarget),
129            3 => Some(Self::MouseHoverAndLatchInTarget),
130            _ => None,
131        }
132    }
133
134    #[inline]
135    pub const fn into_primitive(self) -> u32 {
136        self as u32
137    }
138}
139
140/// The possible states of a pointer event stream's state machine.
141///
142/// A typical pointer will move through this state machine:
143/// ADD - CHANGE* - REMOVE
144#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
145#[repr(u32)]
146pub enum EventPhase {
147    /// The device has started tracking the pointer.
148    Add = 1,
149    /// The device has reported an update to the pointer state.
150    Change = 2,
151    /// The device has stopped tracking the pointer.
152    Remove = 3,
153    /// The event stream is no longer available.
154    Cancel = 4,
155}
156
157impl EventPhase {
158    #[inline]
159    pub fn from_primitive(prim: u32) -> Option<Self> {
160        match prim {
161            1 => Some(Self::Add),
162            2 => Some(Self::Change),
163            3 => Some(Self::Remove),
164            4 => Some(Self::Cancel),
165            _ => None,
166        }
167    }
168
169    #[inline]
170    pub const fn into_primitive(self) -> u32 {
171        self as u32
172    }
173}
174
175/// A description of each sampled data point for a pointer device.
176#[derive(Clone, Debug, Default, PartialEq)]
177pub struct PointerSample {
178    /// An identifier of the pointer that issued this event.
179    /// It is unique only to a specific pointer device.
180    pub pointer_id: Option<u32>,
181    /// The state of this event in the pointer event stream's state machine.
182    pub phase: Option<EventPhase>,
183    /// The position of this event, in the viewport's coordinate system.
184    pub position_in_viewport: Option<[f32; 2]>,
185    /// Relative vertical scrolling displacement by detent.
186    pub scroll_v: Option<i64>,
187    /// Relative horizontal scrolling displacement by detent.
188    pub scroll_h: Option<i64>,
189    /// Identifiers of currently pressed buttons.
190    pub pressed_buttons: Option<Vec<u8>>,
191    /// The movement of a mouse, independent of the viewport's coordinate
192    /// system.
193    pub relative_motion: Option<[f32; 2]>,
194    /// Recommended vertical scrolling displacement by physical pixel, it is
195    /// computed with accelerator, detent / mm to pixel ratio, etc.
196    pub scroll_v_physical_pixel: Option<f64>,
197    /// Recommended horizontal scrolling displacement by physical pixel, it
198    /// is computed with accelerator, detent / mm to pixel ratio, etc.
199    pub scroll_h_physical_pixel: Option<f64>,
200    /// Indicated if the scroll event is from a precision scroll device (HI_RES
201    /// mouse or touchpad). Clients may want to play interpolation animations
202    /// on non precision scroll device for smooth scrolling.
203    pub is_precision_scroll: Option<bool>,
204    #[doc(hidden)]
205    pub __source_breaking: fidl::marker::SourceBreaking,
206}
207
208impl fidl::Persistable for PointerSample {}
209
210/// A rectangular region that directs injected events into a target.
211///
212/// The viewport relates a pointer's position across multiple independent
213/// coordinate systems: the context, the viewport, and the dispatch clients.
214/// Intuitively, the viewport is how a pointer's position is mapped to an
215/// interactive part of the scene.
216///
217/// A matrix is used to relate the viewport coordinate system to the context
218/// coordinate system. A pair of extents defines the viewport's size in the
219/// viewport coordinate system. Together, they define the viewport's placement
220/// in the context coordinate system.
221///
222/// The viewport coordinate system is used to convey a pointer's coordinates in
223/// a scale-invariant way to dispatch clients, so that pointer movement can be
224/// interpreted correctly under effects like magnification. The context defines
225/// the viewport's minimal and maximal extents in the viewport coordinate
226/// system.
227/// - The boundary of the viewport, a rectangle, is axis aligned with the
228///   viewport coordinate system; however it may otherwise be freely positioned
229///   ("float") within it: there is translation and scaling, but no rotation.
230/// - Floating gives the injector some choice in how to convey coordinates, such
231///   as in Vulkan NDC, or in display pixel coordinates.
232/// - The viewport rectangle defines a latch region used in dispatch (described
233///   below).
234///
235/// A dispatch client receives a pointer's coordinates in the viewport
236/// coordinate system, along with a matrix to convert coordinates from the
237/// viewport coordinate system to the dispatch client's coordinate system.
238///
239/// All fields required.
240///
241/// TODO(https://fxbug.dev/42162296): Rename Viewport, it is used in Flatland.
242#[derive(Clone, Debug, Default, PartialEq)]
243pub struct Viewport {
244    /// The viewport's minimal and maximal extents in the viewport coordinate
245    /// system.
246    pub extents: Option<[[f32; 2]; 2]>,
247    /// A transformation matrix that describes how to map the viewport
248    /// coordinate system to the context coordinate system.
249    ///
250    /// This transform, together with |extents|, defines the viewport's
251    /// placement in the context coordinate system.
252    ///
253    /// This transform must be an invertible matrix (i.e., has a non-zero
254    /// determinant), which guarantees it describes a bijection between the
255    /// viewport coordinate system and the context coordinate system. A
256    /// non-invertible matrix is rejected.
257    pub viewport_to_context_transform: Option<[f32; 9]>,
258    #[doc(hidden)]
259    pub __source_breaking: fidl::marker::SourceBreaking,
260}
261
262impl fidl::Persistable for Viewport {}
263
264/// A selection of FIFO data sent over the channel.
265/// Each data may have a different issuance policy.
266#[derive(Clone, Debug)]
267pub enum Data {
268    /// The parameters of the viewport, sufficient for a client to correctly
269    /// interpret the position and scale of pointer events dispatched to it.
270    /// - It is issued on every change to the viewport.
271    Viewport(Viewport),
272    /// A description of each sampled data point in a pointer event stream.
273    /// - It is issued on every sample in the pointer event stream.
274    PointerSample(PointerSample),
275    #[doc(hidden)]
276    __SourceBreaking { unknown_ordinal: u64 },
277}
278
279/// Pattern that matches an unknown `Data` member.
280#[macro_export]
281macro_rules! DataUnknown {
282    () => {
283        _
284    };
285}
286
287// Custom PartialEq so that unknown variants are not equal to themselves.
288impl PartialEq for Data {
289    fn eq(&self, other: &Self) -> bool {
290        match (self, other) {
291            (Self::Viewport(x), Self::Viewport(y)) => *x == *y,
292            (Self::PointerSample(x), Self::PointerSample(y)) => *x == *y,
293            _ => false,
294        }
295    }
296}
297
298impl Data {
299    #[inline]
300    pub fn ordinal(&self) -> u64 {
301        match *self {
302            Self::Viewport(_) => 1,
303            Self::PointerSample(_) => 2,
304            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
305        }
306    }
307
308    #[inline]
309    pub fn unknown_variant_for_testing() -> Self {
310        Self::__SourceBreaking { unknown_ordinal: 0 }
311    }
312
313    #[inline]
314    pub fn is_unknown(&self) -> bool {
315        match self {
316            Self::__SourceBreaking { .. } => true,
317            _ => false,
318        }
319    }
320}
321
322impl fidl::Persistable for Data {}
323
324pub mod device_ordinals {
325    pub const INJECT: u64 = 0x123882bb65bff40;
326    pub const INJECT_EVENTS: u64 = 0x55a9b59dabe61637;
327}
328
329pub mod registry_ordinals {
330    pub const REGISTER: u64 = 0x9f8410fe7326a00;
331}
332
333mod internal {
334    use super::*;
335    unsafe impl fidl::encoding::TypeMarker for DeviceType {
336        type Owned = Self;
337
338        #[inline(always)]
339        fn inline_align(_context: fidl::encoding::Context) -> usize {
340            std::mem::align_of::<u32>()
341        }
342
343        #[inline(always)]
344        fn inline_size(_context: fidl::encoding::Context) -> usize {
345            std::mem::size_of::<u32>()
346        }
347
348        #[inline(always)]
349        fn encode_is_copy() -> bool {
350            true
351        }
352
353        #[inline(always)]
354        fn decode_is_copy() -> bool {
355            false
356        }
357    }
358
359    impl fidl::encoding::ValueTypeMarker for DeviceType {
360        type Borrowed<'a> = Self;
361        #[inline(always)]
362        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
363            *value
364        }
365    }
366
367    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeviceType {
368        #[inline]
369        unsafe fn encode(
370            self,
371            encoder: &mut fidl::encoding::Encoder<'_, D>,
372            offset: usize,
373            _depth: fidl::encoding::Depth,
374        ) -> fidl::Result<()> {
375            encoder.debug_check_bounds::<Self>(offset);
376            encoder.write_num(self.into_primitive(), offset);
377            Ok(())
378        }
379    }
380
381    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceType {
382        #[inline(always)]
383        fn new_empty() -> Self {
384            Self::Touch
385        }
386
387        #[inline]
388        unsafe fn decode(
389            &mut self,
390            decoder: &mut fidl::encoding::Decoder<'_, D>,
391            offset: usize,
392            _depth: fidl::encoding::Depth,
393        ) -> fidl::Result<()> {
394            decoder.debug_check_bounds::<Self>(offset);
395            let prim = decoder.read_num::<u32>(offset);
396
397            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
398            Ok(())
399        }
400    }
401    unsafe impl fidl::encoding::TypeMarker for DispatchPolicy {
402        type Owned = Self;
403
404        #[inline(always)]
405        fn inline_align(_context: fidl::encoding::Context) -> usize {
406            std::mem::align_of::<u32>()
407        }
408
409        #[inline(always)]
410        fn inline_size(_context: fidl::encoding::Context) -> usize {
411            std::mem::size_of::<u32>()
412        }
413
414        #[inline(always)]
415        fn encode_is_copy() -> bool {
416            true
417        }
418
419        #[inline(always)]
420        fn decode_is_copy() -> bool {
421            false
422        }
423    }
424
425    impl fidl::encoding::ValueTypeMarker for DispatchPolicy {
426        type Borrowed<'a> = Self;
427        #[inline(always)]
428        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
429            *value
430        }
431    }
432
433    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DispatchPolicy {
434        #[inline]
435        unsafe fn encode(
436            self,
437            encoder: &mut fidl::encoding::Encoder<'_, D>,
438            offset: usize,
439            _depth: fidl::encoding::Depth,
440        ) -> fidl::Result<()> {
441            encoder.debug_check_bounds::<Self>(offset);
442            encoder.write_num(self.into_primitive(), offset);
443            Ok(())
444        }
445    }
446
447    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DispatchPolicy {
448        #[inline(always)]
449        fn new_empty() -> Self {
450            Self::ExclusiveTarget
451        }
452
453        #[inline]
454        unsafe fn decode(
455            &mut self,
456            decoder: &mut fidl::encoding::Decoder<'_, D>,
457            offset: usize,
458            _depth: fidl::encoding::Depth,
459        ) -> fidl::Result<()> {
460            decoder.debug_check_bounds::<Self>(offset);
461            let prim = decoder.read_num::<u32>(offset);
462
463            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
464            Ok(())
465        }
466    }
467    unsafe impl fidl::encoding::TypeMarker for EventPhase {
468        type Owned = Self;
469
470        #[inline(always)]
471        fn inline_align(_context: fidl::encoding::Context) -> usize {
472            std::mem::align_of::<u32>()
473        }
474
475        #[inline(always)]
476        fn inline_size(_context: fidl::encoding::Context) -> usize {
477            std::mem::size_of::<u32>()
478        }
479
480        #[inline(always)]
481        fn encode_is_copy() -> bool {
482            true
483        }
484
485        #[inline(always)]
486        fn decode_is_copy() -> bool {
487            false
488        }
489    }
490
491    impl fidl::encoding::ValueTypeMarker for EventPhase {
492        type Borrowed<'a> = Self;
493        #[inline(always)]
494        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
495            *value
496        }
497    }
498
499    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EventPhase {
500        #[inline]
501        unsafe fn encode(
502            self,
503            encoder: &mut fidl::encoding::Encoder<'_, D>,
504            offset: usize,
505            _depth: fidl::encoding::Depth,
506        ) -> fidl::Result<()> {
507            encoder.debug_check_bounds::<Self>(offset);
508            encoder.write_num(self.into_primitive(), offset);
509            Ok(())
510        }
511    }
512
513    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventPhase {
514        #[inline(always)]
515        fn new_empty() -> Self {
516            Self::Add
517        }
518
519        #[inline]
520        unsafe fn decode(
521            &mut self,
522            decoder: &mut fidl::encoding::Decoder<'_, D>,
523            offset: usize,
524            _depth: fidl::encoding::Depth,
525        ) -> fidl::Result<()> {
526            decoder.debug_check_bounds::<Self>(offset);
527            let prim = decoder.read_num::<u32>(offset);
528
529            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
530            Ok(())
531        }
532    }
533
534    impl PointerSample {
535        #[inline(always)]
536        fn max_ordinal_present(&self) -> u64 {
537            if let Some(_) = self.is_precision_scroll {
538                return 10;
539            }
540            if let Some(_) = self.scroll_h_physical_pixel {
541                return 9;
542            }
543            if let Some(_) = self.scroll_v_physical_pixel {
544                return 8;
545            }
546            if let Some(_) = self.relative_motion {
547                return 7;
548            }
549            if let Some(_) = self.pressed_buttons {
550                return 6;
551            }
552            if let Some(_) = self.scroll_h {
553                return 5;
554            }
555            if let Some(_) = self.scroll_v {
556                return 4;
557            }
558            if let Some(_) = self.position_in_viewport {
559                return 3;
560            }
561            if let Some(_) = self.phase {
562                return 2;
563            }
564            if let Some(_) = self.pointer_id {
565                return 1;
566            }
567            0
568        }
569    }
570
571    impl fidl::encoding::ValueTypeMarker for PointerSample {
572        type Borrowed<'a> = &'a Self;
573        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
574            value
575        }
576    }
577
578    unsafe impl fidl::encoding::TypeMarker for PointerSample {
579        type Owned = Self;
580
581        #[inline(always)]
582        fn inline_align(_context: fidl::encoding::Context) -> usize {
583            8
584        }
585
586        #[inline(always)]
587        fn inline_size(_context: fidl::encoding::Context) -> usize {
588            16
589        }
590    }
591
592    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PointerSample, D>
593        for &PointerSample
594    {
595        unsafe fn encode(
596            self,
597            encoder: &mut fidl::encoding::Encoder<'_, D>,
598            offset: usize,
599            mut depth: fidl::encoding::Depth,
600        ) -> fidl::Result<()> {
601            encoder.debug_check_bounds::<PointerSample>(offset);
602            // Vector header
603            let max_ordinal: u64 = self.max_ordinal_present();
604            encoder.write_num(max_ordinal, offset);
605            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
606            // Calling encoder.out_of_line_offset(0) is not allowed.
607            if max_ordinal == 0 {
608                return Ok(());
609            }
610            depth.increment()?;
611            let envelope_size = 8;
612            let bytes_len = max_ordinal as usize * envelope_size;
613            #[allow(unused_variables)]
614            let offset = encoder.out_of_line_offset(bytes_len);
615            let mut _prev_end_offset: usize = 0;
616            if 1 > max_ordinal {
617                return Ok(());
618            }
619
620            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
621            // are envelope_size bytes.
622            let cur_offset: usize = (1 - 1) * envelope_size;
623
624            // Zero reserved fields.
625            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
626
627            // Safety:
628            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
629            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
630            //   envelope_size bytes, there is always sufficient room.
631            fidl::encoding::encode_in_envelope_optional::<u32, D>(
632                self.pointer_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
633                encoder,
634                offset + cur_offset,
635                depth,
636            )?;
637
638            _prev_end_offset = cur_offset + envelope_size;
639            if 2 > max_ordinal {
640                return Ok(());
641            }
642
643            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
644            // are envelope_size bytes.
645            let cur_offset: usize = (2 - 1) * envelope_size;
646
647            // Zero reserved fields.
648            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
649
650            // Safety:
651            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
652            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
653            //   envelope_size bytes, there is always sufficient room.
654            fidl::encoding::encode_in_envelope_optional::<EventPhase, D>(
655                self.phase.as_ref().map(<EventPhase as fidl::encoding::ValueTypeMarker>::borrow),
656                encoder,
657                offset + cur_offset,
658                depth,
659            )?;
660
661            _prev_end_offset = cur_offset + envelope_size;
662            if 3 > max_ordinal {
663                return Ok(());
664            }
665
666            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
667            // are envelope_size bytes.
668            let cur_offset: usize = (3 - 1) * envelope_size;
669
670            // Zero reserved fields.
671            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
672
673            // Safety:
674            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
675            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
676            //   envelope_size bytes, there is always sufficient room.
677            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 2>, D>(
678                self.position_in_viewport.as_ref().map(
679                    <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow,
680                ),
681                encoder,
682                offset + cur_offset,
683                depth,
684            )?;
685
686            _prev_end_offset = cur_offset + envelope_size;
687            if 4 > max_ordinal {
688                return Ok(());
689            }
690
691            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
692            // are envelope_size bytes.
693            let cur_offset: usize = (4 - 1) * envelope_size;
694
695            // Zero reserved fields.
696            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
697
698            // Safety:
699            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
700            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
701            //   envelope_size bytes, there is always sufficient room.
702            fidl::encoding::encode_in_envelope_optional::<i64, D>(
703                self.scroll_v.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
704                encoder,
705                offset + cur_offset,
706                depth,
707            )?;
708
709            _prev_end_offset = cur_offset + envelope_size;
710            if 5 > max_ordinal {
711                return Ok(());
712            }
713
714            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
715            // are envelope_size bytes.
716            let cur_offset: usize = (5 - 1) * envelope_size;
717
718            // Zero reserved fields.
719            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
720
721            // Safety:
722            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
723            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
724            //   envelope_size bytes, there is always sufficient room.
725            fidl::encoding::encode_in_envelope_optional::<i64, D>(
726                self.scroll_h.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
727                encoder,
728                offset + cur_offset,
729                depth,
730            )?;
731
732            _prev_end_offset = cur_offset + envelope_size;
733            if 6 > max_ordinal {
734                return Ok(());
735            }
736
737            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
738            // are envelope_size bytes.
739            let cur_offset: usize = (6 - 1) * envelope_size;
740
741            // Zero reserved fields.
742            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
743
744            // Safety:
745            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
746            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
747            //   envelope_size bytes, there is always sufficient room.
748            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
749                self.pressed_buttons.as_ref().map(
750                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
751                ),
752                encoder,
753                offset + cur_offset,
754                depth,
755            )?;
756
757            _prev_end_offset = cur_offset + envelope_size;
758            if 7 > max_ordinal {
759                return Ok(());
760            }
761
762            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
763            // are envelope_size bytes.
764            let cur_offset: usize = (7 - 1) * envelope_size;
765
766            // Zero reserved fields.
767            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
768
769            // Safety:
770            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
771            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
772            //   envelope_size bytes, there is always sufficient room.
773            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 2>, D>(
774                self.relative_motion.as_ref().map(
775                    <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow,
776                ),
777                encoder,
778                offset + cur_offset,
779                depth,
780            )?;
781
782            _prev_end_offset = cur_offset + envelope_size;
783            if 8 > max_ordinal {
784                return Ok(());
785            }
786
787            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
788            // are envelope_size bytes.
789            let cur_offset: usize = (8 - 1) * envelope_size;
790
791            // Zero reserved fields.
792            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
793
794            // Safety:
795            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
796            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
797            //   envelope_size bytes, there is always sufficient room.
798            fidl::encoding::encode_in_envelope_optional::<f64, D>(
799                self.scroll_v_physical_pixel
800                    .as_ref()
801                    .map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
802                encoder,
803                offset + cur_offset,
804                depth,
805            )?;
806
807            _prev_end_offset = cur_offset + envelope_size;
808            if 9 > max_ordinal {
809                return Ok(());
810            }
811
812            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
813            // are envelope_size bytes.
814            let cur_offset: usize = (9 - 1) * envelope_size;
815
816            // Zero reserved fields.
817            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
818
819            // Safety:
820            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
821            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
822            //   envelope_size bytes, there is always sufficient room.
823            fidl::encoding::encode_in_envelope_optional::<f64, D>(
824                self.scroll_h_physical_pixel
825                    .as_ref()
826                    .map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
827                encoder,
828                offset + cur_offset,
829                depth,
830            )?;
831
832            _prev_end_offset = cur_offset + envelope_size;
833            if 10 > max_ordinal {
834                return Ok(());
835            }
836
837            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
838            // are envelope_size bytes.
839            let cur_offset: usize = (10 - 1) * envelope_size;
840
841            // Zero reserved fields.
842            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
843
844            // Safety:
845            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
846            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
847            //   envelope_size bytes, there is always sufficient room.
848            fidl::encoding::encode_in_envelope_optional::<bool, D>(
849                self.is_precision_scroll
850                    .as_ref()
851                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
852                encoder,
853                offset + cur_offset,
854                depth,
855            )?;
856
857            _prev_end_offset = cur_offset + envelope_size;
858
859            Ok(())
860        }
861    }
862
863    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PointerSample {
864        #[inline(always)]
865        fn new_empty() -> Self {
866            Self::default()
867        }
868
869        unsafe fn decode(
870            &mut self,
871            decoder: &mut fidl::encoding::Decoder<'_, D>,
872            offset: usize,
873            mut depth: fidl::encoding::Depth,
874        ) -> fidl::Result<()> {
875            decoder.debug_check_bounds::<Self>(offset);
876            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
877                None => return Err(fidl::Error::NotNullable),
878                Some(len) => len,
879            };
880            // Calling decoder.out_of_line_offset(0) is not allowed.
881            if len == 0 {
882                return Ok(());
883            };
884            depth.increment()?;
885            let envelope_size = 8;
886            let bytes_len = len * envelope_size;
887            let offset = decoder.out_of_line_offset(bytes_len)?;
888            // Decode the envelope for each type.
889            let mut _next_ordinal_to_read = 0;
890            let mut next_offset = offset;
891            let end_offset = offset + bytes_len;
892            _next_ordinal_to_read += 1;
893            if next_offset >= end_offset {
894                return Ok(());
895            }
896
897            // Decode unknown envelopes for gaps in ordinals.
898            while _next_ordinal_to_read < 1 {
899                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
900                _next_ordinal_to_read += 1;
901                next_offset += envelope_size;
902            }
903
904            let next_out_of_line = decoder.next_out_of_line();
905            let handles_before = decoder.remaining_handles();
906            if let Some((inlined, num_bytes, num_handles)) =
907                fidl::encoding::decode_envelope_header(decoder, next_offset)?
908            {
909                let member_inline_size =
910                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
911                if inlined != (member_inline_size <= 4) {
912                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
913                }
914                let inner_offset;
915                let mut inner_depth = depth.clone();
916                if inlined {
917                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
918                    inner_offset = next_offset;
919                } else {
920                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
921                    inner_depth.increment()?;
922                }
923                let val_ref = self.pointer_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
924                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
925                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
926                {
927                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
928                }
929                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
930                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
931                }
932            }
933
934            next_offset += envelope_size;
935            _next_ordinal_to_read += 1;
936            if next_offset >= end_offset {
937                return Ok(());
938            }
939
940            // Decode unknown envelopes for gaps in ordinals.
941            while _next_ordinal_to_read < 2 {
942                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
943                _next_ordinal_to_read += 1;
944                next_offset += envelope_size;
945            }
946
947            let next_out_of_line = decoder.next_out_of_line();
948            let handles_before = decoder.remaining_handles();
949            if let Some((inlined, num_bytes, num_handles)) =
950                fidl::encoding::decode_envelope_header(decoder, next_offset)?
951            {
952                let member_inline_size =
953                    <EventPhase as fidl::encoding::TypeMarker>::inline_size(decoder.context);
954                if inlined != (member_inline_size <= 4) {
955                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
956                }
957                let inner_offset;
958                let mut inner_depth = depth.clone();
959                if inlined {
960                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
961                    inner_offset = next_offset;
962                } else {
963                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
964                    inner_depth.increment()?;
965                }
966                let val_ref = self.phase.get_or_insert_with(|| fidl::new_empty!(EventPhase, D));
967                fidl::decode!(EventPhase, D, val_ref, decoder, inner_offset, inner_depth)?;
968                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
969                {
970                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
971                }
972                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
973                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
974                }
975            }
976
977            next_offset += envelope_size;
978            _next_ordinal_to_read += 1;
979            if next_offset >= end_offset {
980                return Ok(());
981            }
982
983            // Decode unknown envelopes for gaps in ordinals.
984            while _next_ordinal_to_read < 3 {
985                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
986                _next_ordinal_to_read += 1;
987                next_offset += envelope_size;
988            }
989
990            let next_out_of_line = decoder.next_out_of_line();
991            let handles_before = decoder.remaining_handles();
992            if let Some((inlined, num_bytes, num_handles)) =
993                fidl::encoding::decode_envelope_header(decoder, next_offset)?
994            {
995                let member_inline_size =
996                    <fidl::encoding::Array<f32, 2> as fidl::encoding::TypeMarker>::inline_size(
997                        decoder.context,
998                    );
999                if inlined != (member_inline_size <= 4) {
1000                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1001                }
1002                let inner_offset;
1003                let mut inner_depth = depth.clone();
1004                if inlined {
1005                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1006                    inner_offset = next_offset;
1007                } else {
1008                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1009                    inner_depth.increment()?;
1010                }
1011                let val_ref = self
1012                    .position_in_viewport
1013                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 2>, D));
1014                fidl::decode!(fidl::encoding::Array<f32, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
1015                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1016                {
1017                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1018                }
1019                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1020                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1021                }
1022            }
1023
1024            next_offset += envelope_size;
1025            _next_ordinal_to_read += 1;
1026            if next_offset >= end_offset {
1027                return Ok(());
1028            }
1029
1030            // Decode unknown envelopes for gaps in ordinals.
1031            while _next_ordinal_to_read < 4 {
1032                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1033                _next_ordinal_to_read += 1;
1034                next_offset += envelope_size;
1035            }
1036
1037            let next_out_of_line = decoder.next_out_of_line();
1038            let handles_before = decoder.remaining_handles();
1039            if let Some((inlined, num_bytes, num_handles)) =
1040                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1041            {
1042                let member_inline_size =
1043                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1044                if inlined != (member_inline_size <= 4) {
1045                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1046                }
1047                let inner_offset;
1048                let mut inner_depth = depth.clone();
1049                if inlined {
1050                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1051                    inner_offset = next_offset;
1052                } else {
1053                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1054                    inner_depth.increment()?;
1055                }
1056                let val_ref = self.scroll_v.get_or_insert_with(|| fidl::new_empty!(i64, D));
1057                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
1058                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1059                {
1060                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1061                }
1062                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1063                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1064                }
1065            }
1066
1067            next_offset += envelope_size;
1068            _next_ordinal_to_read += 1;
1069            if next_offset >= end_offset {
1070                return Ok(());
1071            }
1072
1073            // Decode unknown envelopes for gaps in ordinals.
1074            while _next_ordinal_to_read < 5 {
1075                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1076                _next_ordinal_to_read += 1;
1077                next_offset += envelope_size;
1078            }
1079
1080            let next_out_of_line = decoder.next_out_of_line();
1081            let handles_before = decoder.remaining_handles();
1082            if let Some((inlined, num_bytes, num_handles)) =
1083                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1084            {
1085                let member_inline_size =
1086                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1087                if inlined != (member_inline_size <= 4) {
1088                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1089                }
1090                let inner_offset;
1091                let mut inner_depth = depth.clone();
1092                if inlined {
1093                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1094                    inner_offset = next_offset;
1095                } else {
1096                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1097                    inner_depth.increment()?;
1098                }
1099                let val_ref = self.scroll_h.get_or_insert_with(|| fidl::new_empty!(i64, D));
1100                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
1101                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1102                {
1103                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1104                }
1105                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1106                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1107                }
1108            }
1109
1110            next_offset += envelope_size;
1111            _next_ordinal_to_read += 1;
1112            if next_offset >= end_offset {
1113                return Ok(());
1114            }
1115
1116            // Decode unknown envelopes for gaps in ordinals.
1117            while _next_ordinal_to_read < 6 {
1118                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1119                _next_ordinal_to_read += 1;
1120                next_offset += envelope_size;
1121            }
1122
1123            let next_out_of_line = decoder.next_out_of_line();
1124            let handles_before = decoder.remaining_handles();
1125            if let Some((inlined, num_bytes, num_handles)) =
1126                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1127            {
1128                let member_inline_size =
1129                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
1130                        decoder.context,
1131                    );
1132                if inlined != (member_inline_size <= 4) {
1133                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1134                }
1135                let inner_offset;
1136                let mut inner_depth = depth.clone();
1137                if inlined {
1138                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1139                    inner_offset = next_offset;
1140                } else {
1141                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1142                    inner_depth.increment()?;
1143                }
1144                let val_ref = self
1145                    .pressed_buttons
1146                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
1147                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
1148                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1149                {
1150                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1151                }
1152                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1153                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1154                }
1155            }
1156
1157            next_offset += envelope_size;
1158            _next_ordinal_to_read += 1;
1159            if next_offset >= end_offset {
1160                return Ok(());
1161            }
1162
1163            // Decode unknown envelopes for gaps in ordinals.
1164            while _next_ordinal_to_read < 7 {
1165                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1166                _next_ordinal_to_read += 1;
1167                next_offset += envelope_size;
1168            }
1169
1170            let next_out_of_line = decoder.next_out_of_line();
1171            let handles_before = decoder.remaining_handles();
1172            if let Some((inlined, num_bytes, num_handles)) =
1173                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1174            {
1175                let member_inline_size =
1176                    <fidl::encoding::Array<f32, 2> as fidl::encoding::TypeMarker>::inline_size(
1177                        decoder.context,
1178                    );
1179                if inlined != (member_inline_size <= 4) {
1180                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1181                }
1182                let inner_offset;
1183                let mut inner_depth = depth.clone();
1184                if inlined {
1185                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1186                    inner_offset = next_offset;
1187                } else {
1188                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1189                    inner_depth.increment()?;
1190                }
1191                let val_ref = self
1192                    .relative_motion
1193                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 2>, D));
1194                fidl::decode!(fidl::encoding::Array<f32, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
1195                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1196                {
1197                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1198                }
1199                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1200                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1201                }
1202            }
1203
1204            next_offset += envelope_size;
1205            _next_ordinal_to_read += 1;
1206            if next_offset >= end_offset {
1207                return Ok(());
1208            }
1209
1210            // Decode unknown envelopes for gaps in ordinals.
1211            while _next_ordinal_to_read < 8 {
1212                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1213                _next_ordinal_to_read += 1;
1214                next_offset += envelope_size;
1215            }
1216
1217            let next_out_of_line = decoder.next_out_of_line();
1218            let handles_before = decoder.remaining_handles();
1219            if let Some((inlined, num_bytes, num_handles)) =
1220                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1221            {
1222                let member_inline_size =
1223                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1224                if inlined != (member_inline_size <= 4) {
1225                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1226                }
1227                let inner_offset;
1228                let mut inner_depth = depth.clone();
1229                if inlined {
1230                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1231                    inner_offset = next_offset;
1232                } else {
1233                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1234                    inner_depth.increment()?;
1235                }
1236                let val_ref =
1237                    self.scroll_v_physical_pixel.get_or_insert_with(|| fidl::new_empty!(f64, D));
1238                fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
1239                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1240                {
1241                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1242                }
1243                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1244                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1245                }
1246            }
1247
1248            next_offset += envelope_size;
1249            _next_ordinal_to_read += 1;
1250            if next_offset >= end_offset {
1251                return Ok(());
1252            }
1253
1254            // Decode unknown envelopes for gaps in ordinals.
1255            while _next_ordinal_to_read < 9 {
1256                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1257                _next_ordinal_to_read += 1;
1258                next_offset += envelope_size;
1259            }
1260
1261            let next_out_of_line = decoder.next_out_of_line();
1262            let handles_before = decoder.remaining_handles();
1263            if let Some((inlined, num_bytes, num_handles)) =
1264                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1265            {
1266                let member_inline_size =
1267                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1268                if inlined != (member_inline_size <= 4) {
1269                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1270                }
1271                let inner_offset;
1272                let mut inner_depth = depth.clone();
1273                if inlined {
1274                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1275                    inner_offset = next_offset;
1276                } else {
1277                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1278                    inner_depth.increment()?;
1279                }
1280                let val_ref =
1281                    self.scroll_h_physical_pixel.get_or_insert_with(|| fidl::new_empty!(f64, D));
1282                fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
1283                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1284                {
1285                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1286                }
1287                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1288                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1289                }
1290            }
1291
1292            next_offset += envelope_size;
1293            _next_ordinal_to_read += 1;
1294            if next_offset >= end_offset {
1295                return Ok(());
1296            }
1297
1298            // Decode unknown envelopes for gaps in ordinals.
1299            while _next_ordinal_to_read < 10 {
1300                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1301                _next_ordinal_to_read += 1;
1302                next_offset += envelope_size;
1303            }
1304
1305            let next_out_of_line = decoder.next_out_of_line();
1306            let handles_before = decoder.remaining_handles();
1307            if let Some((inlined, num_bytes, num_handles)) =
1308                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1309            {
1310                let member_inline_size =
1311                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1312                if inlined != (member_inline_size <= 4) {
1313                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1314                }
1315                let inner_offset;
1316                let mut inner_depth = depth.clone();
1317                if inlined {
1318                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1319                    inner_offset = next_offset;
1320                } else {
1321                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1322                    inner_depth.increment()?;
1323                }
1324                let val_ref =
1325                    self.is_precision_scroll.get_or_insert_with(|| fidl::new_empty!(bool, D));
1326                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1327                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1328                {
1329                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1330                }
1331                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1332                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1333                }
1334            }
1335
1336            next_offset += envelope_size;
1337
1338            // Decode the remaining unknown envelopes.
1339            while next_offset < end_offset {
1340                _next_ordinal_to_read += 1;
1341                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1342                next_offset += envelope_size;
1343            }
1344
1345            Ok(())
1346        }
1347    }
1348
1349    impl Viewport {
1350        #[inline(always)]
1351        fn max_ordinal_present(&self) -> u64 {
1352            if let Some(_) = self.viewport_to_context_transform {
1353                return 2;
1354            }
1355            if let Some(_) = self.extents {
1356                return 1;
1357            }
1358            0
1359        }
1360    }
1361
1362    impl fidl::encoding::ValueTypeMarker for Viewport {
1363        type Borrowed<'a> = &'a Self;
1364        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1365            value
1366        }
1367    }
1368
1369    unsafe impl fidl::encoding::TypeMarker for Viewport {
1370        type Owned = Self;
1371
1372        #[inline(always)]
1373        fn inline_align(_context: fidl::encoding::Context) -> usize {
1374            8
1375        }
1376
1377        #[inline(always)]
1378        fn inline_size(_context: fidl::encoding::Context) -> usize {
1379            16
1380        }
1381    }
1382
1383    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Viewport, D> for &Viewport {
1384        unsafe fn encode(
1385            self,
1386            encoder: &mut fidl::encoding::Encoder<'_, D>,
1387            offset: usize,
1388            mut depth: fidl::encoding::Depth,
1389        ) -> fidl::Result<()> {
1390            encoder.debug_check_bounds::<Viewport>(offset);
1391            // Vector header
1392            let max_ordinal: u64 = self.max_ordinal_present();
1393            encoder.write_num(max_ordinal, offset);
1394            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1395            // Calling encoder.out_of_line_offset(0) is not allowed.
1396            if max_ordinal == 0 {
1397                return Ok(());
1398            }
1399            depth.increment()?;
1400            let envelope_size = 8;
1401            let bytes_len = max_ordinal as usize * envelope_size;
1402            #[allow(unused_variables)]
1403            let offset = encoder.out_of_line_offset(bytes_len);
1404            let mut _prev_end_offset: usize = 0;
1405            if 1 > max_ordinal {
1406                return Ok(());
1407            }
1408
1409            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1410            // are envelope_size bytes.
1411            let cur_offset: usize = (1 - 1) * envelope_size;
1412
1413            // Zero reserved fields.
1414            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1415
1416            // Safety:
1417            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1418            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1419            //   envelope_size bytes, there is always sufficient room.
1420            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 2>, D>(
1421            self.extents.as_ref().map(<fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 2> as fidl::encoding::ValueTypeMarker>::borrow),
1422            encoder, offset + cur_offset, depth
1423        )?;
1424
1425            _prev_end_offset = cur_offset + envelope_size;
1426            if 2 > max_ordinal {
1427                return Ok(());
1428            }
1429
1430            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1431            // are envelope_size bytes.
1432            let cur_offset: usize = (2 - 1) * envelope_size;
1433
1434            // Zero reserved fields.
1435            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1436
1437            // Safety:
1438            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1439            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1440            //   envelope_size bytes, there is always sufficient room.
1441            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 9>, D>(
1442                self.viewport_to_context_transform.as_ref().map(
1443                    <fidl::encoding::Array<f32, 9> as fidl::encoding::ValueTypeMarker>::borrow,
1444                ),
1445                encoder,
1446                offset + cur_offset,
1447                depth,
1448            )?;
1449
1450            _prev_end_offset = cur_offset + envelope_size;
1451
1452            Ok(())
1453        }
1454    }
1455
1456    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Viewport {
1457        #[inline(always)]
1458        fn new_empty() -> Self {
1459            Self::default()
1460        }
1461
1462        unsafe fn decode(
1463            &mut self,
1464            decoder: &mut fidl::encoding::Decoder<'_, D>,
1465            offset: usize,
1466            mut depth: fidl::encoding::Depth,
1467        ) -> fidl::Result<()> {
1468            decoder.debug_check_bounds::<Self>(offset);
1469            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1470                None => return Err(fidl::Error::NotNullable),
1471                Some(len) => len,
1472            };
1473            // Calling decoder.out_of_line_offset(0) is not allowed.
1474            if len == 0 {
1475                return Ok(());
1476            };
1477            depth.increment()?;
1478            let envelope_size = 8;
1479            let bytes_len = len * envelope_size;
1480            let offset = decoder.out_of_line_offset(bytes_len)?;
1481            // Decode the envelope for each type.
1482            let mut _next_ordinal_to_read = 0;
1483            let mut next_offset = offset;
1484            let end_offset = offset + bytes_len;
1485            _next_ordinal_to_read += 1;
1486            if next_offset >= end_offset {
1487                return Ok(());
1488            }
1489
1490            // Decode unknown envelopes for gaps in ordinals.
1491            while _next_ordinal_to_read < 1 {
1492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1493                _next_ordinal_to_read += 1;
1494                next_offset += envelope_size;
1495            }
1496
1497            let next_out_of_line = decoder.next_out_of_line();
1498            let handles_before = decoder.remaining_handles();
1499            if let Some((inlined, num_bytes, num_handles)) =
1500                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1501            {
1502                let member_inline_size = <fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 2> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1503                if inlined != (member_inline_size <= 4) {
1504                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1505                }
1506                let inner_offset;
1507                let mut inner_depth = depth.clone();
1508                if inlined {
1509                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1510                    inner_offset = next_offset;
1511                } else {
1512                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1513                    inner_depth.increment()?;
1514                }
1515                let val_ref = self.extents.get_or_insert_with(|| {
1516                    fidl::new_empty!(fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 2>, D)
1517                });
1518                fidl::decode!(
1519                    fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 2>,
1520                    D,
1521                    val_ref,
1522                    decoder,
1523                    inner_offset,
1524                    inner_depth
1525                )?;
1526                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1527                {
1528                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1529                }
1530                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1531                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1532                }
1533            }
1534
1535            next_offset += envelope_size;
1536            _next_ordinal_to_read += 1;
1537            if next_offset >= end_offset {
1538                return Ok(());
1539            }
1540
1541            // Decode unknown envelopes for gaps in ordinals.
1542            while _next_ordinal_to_read < 2 {
1543                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1544                _next_ordinal_to_read += 1;
1545                next_offset += envelope_size;
1546            }
1547
1548            let next_out_of_line = decoder.next_out_of_line();
1549            let handles_before = decoder.remaining_handles();
1550            if let Some((inlined, num_bytes, num_handles)) =
1551                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1552            {
1553                let member_inline_size =
1554                    <fidl::encoding::Array<f32, 9> as fidl::encoding::TypeMarker>::inline_size(
1555                        decoder.context,
1556                    );
1557                if inlined != (member_inline_size <= 4) {
1558                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1559                }
1560                let inner_offset;
1561                let mut inner_depth = depth.clone();
1562                if inlined {
1563                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1564                    inner_offset = next_offset;
1565                } else {
1566                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1567                    inner_depth.increment()?;
1568                }
1569                let val_ref = self
1570                    .viewport_to_context_transform
1571                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 9>, D));
1572                fidl::decode!(fidl::encoding::Array<f32, 9>, D, val_ref, decoder, inner_offset, inner_depth)?;
1573                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1574                {
1575                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1576                }
1577                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1578                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1579                }
1580            }
1581
1582            next_offset += envelope_size;
1583
1584            // Decode the remaining unknown envelopes.
1585            while next_offset < end_offset {
1586                _next_ordinal_to_read += 1;
1587                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1588                next_offset += envelope_size;
1589            }
1590
1591            Ok(())
1592        }
1593    }
1594
1595    impl fidl::encoding::ValueTypeMarker for Data {
1596        type Borrowed<'a> = &'a Self;
1597        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1598            value
1599        }
1600    }
1601
1602    unsafe impl fidl::encoding::TypeMarker for Data {
1603        type Owned = Self;
1604
1605        #[inline(always)]
1606        fn inline_align(_context: fidl::encoding::Context) -> usize {
1607            8
1608        }
1609
1610        #[inline(always)]
1611        fn inline_size(_context: fidl::encoding::Context) -> usize {
1612            16
1613        }
1614    }
1615
1616    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Data, D> for &Data {
1617        #[inline]
1618        unsafe fn encode(
1619            self,
1620            encoder: &mut fidl::encoding::Encoder<'_, D>,
1621            offset: usize,
1622            _depth: fidl::encoding::Depth,
1623        ) -> fidl::Result<()> {
1624            encoder.debug_check_bounds::<Data>(offset);
1625            encoder.write_num::<u64>(self.ordinal(), offset);
1626            match self {
1627                Data::Viewport(ref val) => fidl::encoding::encode_in_envelope::<Viewport, D>(
1628                    <Viewport as fidl::encoding::ValueTypeMarker>::borrow(val),
1629                    encoder,
1630                    offset + 8,
1631                    _depth,
1632                ),
1633                Data::PointerSample(ref val) => {
1634                    fidl::encoding::encode_in_envelope::<PointerSample, D>(
1635                        <PointerSample as fidl::encoding::ValueTypeMarker>::borrow(val),
1636                        encoder,
1637                        offset + 8,
1638                        _depth,
1639                    )
1640                }
1641                Data::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
1642            }
1643        }
1644    }
1645
1646    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Data {
1647        #[inline(always)]
1648        fn new_empty() -> Self {
1649            Self::__SourceBreaking { unknown_ordinal: 0 }
1650        }
1651
1652        #[inline]
1653        unsafe fn decode(
1654            &mut self,
1655            decoder: &mut fidl::encoding::Decoder<'_, D>,
1656            offset: usize,
1657            mut depth: fidl::encoding::Depth,
1658        ) -> fidl::Result<()> {
1659            decoder.debug_check_bounds::<Self>(offset);
1660            #[allow(unused_variables)]
1661            let next_out_of_line = decoder.next_out_of_line();
1662            let handles_before = decoder.remaining_handles();
1663            let (ordinal, inlined, num_bytes, num_handles) =
1664                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
1665
1666            let member_inline_size = match ordinal {
1667                1 => <Viewport as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1668                2 => <PointerSample as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1669                0 => return Err(fidl::Error::UnknownUnionTag),
1670                _ => num_bytes as usize,
1671            };
1672
1673            if inlined != (member_inline_size <= 4) {
1674                return Err(fidl::Error::InvalidInlineBitInEnvelope);
1675            }
1676            let _inner_offset;
1677            if inlined {
1678                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
1679                _inner_offset = offset + 8;
1680            } else {
1681                depth.increment()?;
1682                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1683            }
1684            match ordinal {
1685                1 => {
1686                    #[allow(irrefutable_let_patterns)]
1687                    if let Data::Viewport(_) = self {
1688                        // Do nothing, read the value into the object
1689                    } else {
1690                        // Initialize `self` to the right variant
1691                        *self = Data::Viewport(fidl::new_empty!(Viewport, D));
1692                    }
1693                    #[allow(irrefutable_let_patterns)]
1694                    if let Data::Viewport(ref mut val) = self {
1695                        fidl::decode!(Viewport, D, val, decoder, _inner_offset, depth)?;
1696                    } else {
1697                        unreachable!()
1698                    }
1699                }
1700                2 => {
1701                    #[allow(irrefutable_let_patterns)]
1702                    if let Data::PointerSample(_) = self {
1703                        // Do nothing, read the value into the object
1704                    } else {
1705                        // Initialize `self` to the right variant
1706                        *self = Data::PointerSample(fidl::new_empty!(PointerSample, D));
1707                    }
1708                    #[allow(irrefutable_let_patterns)]
1709                    if let Data::PointerSample(ref mut val) = self {
1710                        fidl::decode!(PointerSample, D, val, decoder, _inner_offset, depth)?;
1711                    } else {
1712                        unreachable!()
1713                    }
1714                }
1715                #[allow(deprecated)]
1716                ordinal => {
1717                    for _ in 0..num_handles {
1718                        decoder.drop_next_handle()?;
1719                    }
1720                    *self = Data::__SourceBreaking { unknown_ordinal: ordinal };
1721                }
1722            }
1723            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
1724                return Err(fidl::Error::InvalidNumBytesInEnvelope);
1725            }
1726            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1727                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1728            }
1729            Ok(())
1730        }
1731    }
1732}
fidl_fuchsia_ui_pointerinjector__common/fidl_fuchsia_ui_pointerinjector__common.rs

fidl_fuchsia_ui_pointerinjector__common/
fidl_fuchsia_ui_pointerinjector__common.rs
