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}
327
328pub mod registry_ordinals {
329    pub const REGISTER: u64 = 0x9f8410fe7326a00;
330}
331
332mod internal {
333    use super::*;
334    unsafe impl fidl::encoding::TypeMarker for DeviceType {
335        type Owned = Self;
336
337        #[inline(always)]
338        fn inline_align(_context: fidl::encoding::Context) -> usize {
339            std::mem::align_of::<u32>()
340        }
341
342        #[inline(always)]
343        fn inline_size(_context: fidl::encoding::Context) -> usize {
344            std::mem::size_of::<u32>()
345        }
346
347        #[inline(always)]
348        fn encode_is_copy() -> bool {
349            true
350        }
351
352        #[inline(always)]
353        fn decode_is_copy() -> bool {
354            false
355        }
356    }
357
358    impl fidl::encoding::ValueTypeMarker for DeviceType {
359        type Borrowed<'a> = Self;
360        #[inline(always)]
361        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
362            *value
363        }
364    }
365
366    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeviceType {
367        #[inline]
368        unsafe fn encode(
369            self,
370            encoder: &mut fidl::encoding::Encoder<'_, D>,
371            offset: usize,
372            _depth: fidl::encoding::Depth,
373        ) -> fidl::Result<()> {
374            encoder.debug_check_bounds::<Self>(offset);
375            encoder.write_num(self.into_primitive(), offset);
376            Ok(())
377        }
378    }
379
380    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceType {
381        #[inline(always)]
382        fn new_empty() -> Self {
383            Self::Touch
384        }
385
386        #[inline]
387        unsafe fn decode(
388            &mut self,
389            decoder: &mut fidl::encoding::Decoder<'_, D>,
390            offset: usize,
391            _depth: fidl::encoding::Depth,
392        ) -> fidl::Result<()> {
393            decoder.debug_check_bounds::<Self>(offset);
394            let prim = decoder.read_num::<u32>(offset);
395
396            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
397            Ok(())
398        }
399    }
400    unsafe impl fidl::encoding::TypeMarker for DispatchPolicy {
401        type Owned = Self;
402
403        #[inline(always)]
404        fn inline_align(_context: fidl::encoding::Context) -> usize {
405            std::mem::align_of::<u32>()
406        }
407
408        #[inline(always)]
409        fn inline_size(_context: fidl::encoding::Context) -> usize {
410            std::mem::size_of::<u32>()
411        }
412
413        #[inline(always)]
414        fn encode_is_copy() -> bool {
415            true
416        }
417
418        #[inline(always)]
419        fn decode_is_copy() -> bool {
420            false
421        }
422    }
423
424    impl fidl::encoding::ValueTypeMarker for DispatchPolicy {
425        type Borrowed<'a> = Self;
426        #[inline(always)]
427        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
428            *value
429        }
430    }
431
432    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DispatchPolicy {
433        #[inline]
434        unsafe fn encode(
435            self,
436            encoder: &mut fidl::encoding::Encoder<'_, D>,
437            offset: usize,
438            _depth: fidl::encoding::Depth,
439        ) -> fidl::Result<()> {
440            encoder.debug_check_bounds::<Self>(offset);
441            encoder.write_num(self.into_primitive(), offset);
442            Ok(())
443        }
444    }
445
446    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DispatchPolicy {
447        #[inline(always)]
448        fn new_empty() -> Self {
449            Self::ExclusiveTarget
450        }
451
452        #[inline]
453        unsafe fn decode(
454            &mut self,
455            decoder: &mut fidl::encoding::Decoder<'_, D>,
456            offset: usize,
457            _depth: fidl::encoding::Depth,
458        ) -> fidl::Result<()> {
459            decoder.debug_check_bounds::<Self>(offset);
460            let prim = decoder.read_num::<u32>(offset);
461
462            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
463            Ok(())
464        }
465    }
466    unsafe impl fidl::encoding::TypeMarker for EventPhase {
467        type Owned = Self;
468
469        #[inline(always)]
470        fn inline_align(_context: fidl::encoding::Context) -> usize {
471            std::mem::align_of::<u32>()
472        }
473
474        #[inline(always)]
475        fn inline_size(_context: fidl::encoding::Context) -> usize {
476            std::mem::size_of::<u32>()
477        }
478
479        #[inline(always)]
480        fn encode_is_copy() -> bool {
481            true
482        }
483
484        #[inline(always)]
485        fn decode_is_copy() -> bool {
486            false
487        }
488    }
489
490    impl fidl::encoding::ValueTypeMarker for EventPhase {
491        type Borrowed<'a> = Self;
492        #[inline(always)]
493        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
494            *value
495        }
496    }
497
498    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EventPhase {
499        #[inline]
500        unsafe fn encode(
501            self,
502            encoder: &mut fidl::encoding::Encoder<'_, D>,
503            offset: usize,
504            _depth: fidl::encoding::Depth,
505        ) -> fidl::Result<()> {
506            encoder.debug_check_bounds::<Self>(offset);
507            encoder.write_num(self.into_primitive(), offset);
508            Ok(())
509        }
510    }
511
512    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventPhase {
513        #[inline(always)]
514        fn new_empty() -> Self {
515            Self::Add
516        }
517
518        #[inline]
519        unsafe fn decode(
520            &mut self,
521            decoder: &mut fidl::encoding::Decoder<'_, D>,
522            offset: usize,
523            _depth: fidl::encoding::Depth,
524        ) -> fidl::Result<()> {
525            decoder.debug_check_bounds::<Self>(offset);
526            let prim = decoder.read_num::<u32>(offset);
527
528            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
529            Ok(())
530        }
531    }
532
533    impl PointerSample {
534        #[inline(always)]
535        fn max_ordinal_present(&self) -> u64 {
536            if let Some(_) = self.is_precision_scroll {
537                return 10;
538            }
539            if let Some(_) = self.scroll_h_physical_pixel {
540                return 9;
541            }
542            if let Some(_) = self.scroll_v_physical_pixel {
543                return 8;
544            }
545            if let Some(_) = self.relative_motion {
546                return 7;
547            }
548            if let Some(_) = self.pressed_buttons {
549                return 6;
550            }
551            if let Some(_) = self.scroll_h {
552                return 5;
553            }
554            if let Some(_) = self.scroll_v {
555                return 4;
556            }
557            if let Some(_) = self.position_in_viewport {
558                return 3;
559            }
560            if let Some(_) = self.phase {
561                return 2;
562            }
563            if let Some(_) = self.pointer_id {
564                return 1;
565            }
566            0
567        }
568    }
569
570    impl fidl::encoding::ValueTypeMarker for PointerSample {
571        type Borrowed<'a> = &'a Self;
572        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
573            value
574        }
575    }
576
577    unsafe impl fidl::encoding::TypeMarker for PointerSample {
578        type Owned = Self;
579
580        #[inline(always)]
581        fn inline_align(_context: fidl::encoding::Context) -> usize {
582            8
583        }
584
585        #[inline(always)]
586        fn inline_size(_context: fidl::encoding::Context) -> usize {
587            16
588        }
589    }
590
591    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PointerSample, D>
592        for &PointerSample
593    {
594        unsafe fn encode(
595            self,
596            encoder: &mut fidl::encoding::Encoder<'_, D>,
597            offset: usize,
598            mut depth: fidl::encoding::Depth,
599        ) -> fidl::Result<()> {
600            encoder.debug_check_bounds::<PointerSample>(offset);
601            // Vector header
602            let max_ordinal: u64 = self.max_ordinal_present();
603            encoder.write_num(max_ordinal, offset);
604            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
605            // Calling encoder.out_of_line_offset(0) is not allowed.
606            if max_ordinal == 0 {
607                return Ok(());
608            }
609            depth.increment()?;
610            let envelope_size = 8;
611            let bytes_len = max_ordinal as usize * envelope_size;
612            #[allow(unused_variables)]
613            let offset = encoder.out_of_line_offset(bytes_len);
614            let mut _prev_end_offset: usize = 0;
615            if 1 > max_ordinal {
616                return Ok(());
617            }
618
619            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
620            // are envelope_size bytes.
621            let cur_offset: usize = (1 - 1) * envelope_size;
622
623            // Zero reserved fields.
624            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
625
626            // Safety:
627            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
628            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
629            //   envelope_size bytes, there is always sufficient room.
630            fidl::encoding::encode_in_envelope_optional::<u32, D>(
631                self.pointer_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
632                encoder,
633                offset + cur_offset,
634                depth,
635            )?;
636
637            _prev_end_offset = cur_offset + envelope_size;
638            if 2 > max_ordinal {
639                return Ok(());
640            }
641
642            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
643            // are envelope_size bytes.
644            let cur_offset: usize = (2 - 1) * envelope_size;
645
646            // Zero reserved fields.
647            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
648
649            // Safety:
650            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
651            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
652            //   envelope_size bytes, there is always sufficient room.
653            fidl::encoding::encode_in_envelope_optional::<EventPhase, D>(
654                self.phase.as_ref().map(<EventPhase as fidl::encoding::ValueTypeMarker>::borrow),
655                encoder,
656                offset + cur_offset,
657                depth,
658            )?;
659
660            _prev_end_offset = cur_offset + envelope_size;
661            if 3 > max_ordinal {
662                return Ok(());
663            }
664
665            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
666            // are envelope_size bytes.
667            let cur_offset: usize = (3 - 1) * envelope_size;
668
669            // Zero reserved fields.
670            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
671
672            // Safety:
673            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
674            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
675            //   envelope_size bytes, there is always sufficient room.
676            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 2>, D>(
677                self.position_in_viewport.as_ref().map(
678                    <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow,
679                ),
680                encoder,
681                offset + cur_offset,
682                depth,
683            )?;
684
685            _prev_end_offset = cur_offset + envelope_size;
686            if 4 > max_ordinal {
687                return Ok(());
688            }
689
690            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
691            // are envelope_size bytes.
692            let cur_offset: usize = (4 - 1) * envelope_size;
693
694            // Zero reserved fields.
695            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
696
697            // Safety:
698            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
699            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
700            //   envelope_size bytes, there is always sufficient room.
701            fidl::encoding::encode_in_envelope_optional::<i64, D>(
702                self.scroll_v.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
703                encoder,
704                offset + cur_offset,
705                depth,
706            )?;
707
708            _prev_end_offset = cur_offset + envelope_size;
709            if 5 > max_ordinal {
710                return Ok(());
711            }
712
713            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
714            // are envelope_size bytes.
715            let cur_offset: usize = (5 - 1) * envelope_size;
716
717            // Zero reserved fields.
718            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
719
720            // Safety:
721            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
722            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
723            //   envelope_size bytes, there is always sufficient room.
724            fidl::encoding::encode_in_envelope_optional::<i64, D>(
725                self.scroll_h.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
726                encoder,
727                offset + cur_offset,
728                depth,
729            )?;
730
731            _prev_end_offset = cur_offset + envelope_size;
732            if 6 > max_ordinal {
733                return Ok(());
734            }
735
736            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
737            // are envelope_size bytes.
738            let cur_offset: usize = (6 - 1) * envelope_size;
739
740            // Zero reserved fields.
741            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
742
743            // Safety:
744            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
745            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
746            //   envelope_size bytes, there is always sufficient room.
747            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
748                self.pressed_buttons.as_ref().map(
749                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
750                ),
751                encoder,
752                offset + cur_offset,
753                depth,
754            )?;
755
756            _prev_end_offset = cur_offset + envelope_size;
757            if 7 > max_ordinal {
758                return Ok(());
759            }
760
761            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
762            // are envelope_size bytes.
763            let cur_offset: usize = (7 - 1) * envelope_size;
764
765            // Zero reserved fields.
766            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
767
768            // Safety:
769            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
770            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
771            //   envelope_size bytes, there is always sufficient room.
772            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 2>, D>(
773                self.relative_motion.as_ref().map(
774                    <fidl::encoding::Array<f32, 2> as fidl::encoding::ValueTypeMarker>::borrow,
775                ),
776                encoder,
777                offset + cur_offset,
778                depth,
779            )?;
780
781            _prev_end_offset = cur_offset + envelope_size;
782            if 8 > max_ordinal {
783                return Ok(());
784            }
785
786            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
787            // are envelope_size bytes.
788            let cur_offset: usize = (8 - 1) * envelope_size;
789
790            // Zero reserved fields.
791            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
792
793            // Safety:
794            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
795            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
796            //   envelope_size bytes, there is always sufficient room.
797            fidl::encoding::encode_in_envelope_optional::<f64, D>(
798                self.scroll_v_physical_pixel
799                    .as_ref()
800                    .map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
801                encoder,
802                offset + cur_offset,
803                depth,
804            )?;
805
806            _prev_end_offset = cur_offset + envelope_size;
807            if 9 > max_ordinal {
808                return Ok(());
809            }
810
811            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
812            // are envelope_size bytes.
813            let cur_offset: usize = (9 - 1) * envelope_size;
814
815            // Zero reserved fields.
816            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
817
818            // Safety:
819            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
820            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
821            //   envelope_size bytes, there is always sufficient room.
822            fidl::encoding::encode_in_envelope_optional::<f64, D>(
823                self.scroll_h_physical_pixel
824                    .as_ref()
825                    .map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
826                encoder,
827                offset + cur_offset,
828                depth,
829            )?;
830
831            _prev_end_offset = cur_offset + envelope_size;
832            if 10 > max_ordinal {
833                return Ok(());
834            }
835
836            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
837            // are envelope_size bytes.
838            let cur_offset: usize = (10 - 1) * envelope_size;
839
840            // Zero reserved fields.
841            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
842
843            // Safety:
844            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
845            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
846            //   envelope_size bytes, there is always sufficient room.
847            fidl::encoding::encode_in_envelope_optional::<bool, D>(
848                self.is_precision_scroll
849                    .as_ref()
850                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
851                encoder,
852                offset + cur_offset,
853                depth,
854            )?;
855
856            _prev_end_offset = cur_offset + envelope_size;
857
858            Ok(())
859        }
860    }
861
862    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PointerSample {
863        #[inline(always)]
864        fn new_empty() -> Self {
865            Self::default()
866        }
867
868        unsafe fn decode(
869            &mut self,
870            decoder: &mut fidl::encoding::Decoder<'_, D>,
871            offset: usize,
872            mut depth: fidl::encoding::Depth,
873        ) -> fidl::Result<()> {
874            decoder.debug_check_bounds::<Self>(offset);
875            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
876                None => return Err(fidl::Error::NotNullable),
877                Some(len) => len,
878            };
879            // Calling decoder.out_of_line_offset(0) is not allowed.
880            if len == 0 {
881                return Ok(());
882            };
883            depth.increment()?;
884            let envelope_size = 8;
885            let bytes_len = len * envelope_size;
886            let offset = decoder.out_of_line_offset(bytes_len)?;
887            // Decode the envelope for each type.
888            let mut _next_ordinal_to_read = 0;
889            let mut next_offset = offset;
890            let end_offset = offset + bytes_len;
891            _next_ordinal_to_read += 1;
892            if next_offset >= end_offset {
893                return Ok(());
894            }
895
896            // Decode unknown envelopes for gaps in ordinals.
897            while _next_ordinal_to_read < 1 {
898                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
899                _next_ordinal_to_read += 1;
900                next_offset += envelope_size;
901            }
902
903            let next_out_of_line = decoder.next_out_of_line();
904            let handles_before = decoder.remaining_handles();
905            if let Some((inlined, num_bytes, num_handles)) =
906                fidl::encoding::decode_envelope_header(decoder, next_offset)?
907            {
908                let member_inline_size =
909                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
910                if inlined != (member_inline_size <= 4) {
911                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
912                }
913                let inner_offset;
914                let mut inner_depth = depth.clone();
915                if inlined {
916                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
917                    inner_offset = next_offset;
918                } else {
919                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
920                    inner_depth.increment()?;
921                }
922                let val_ref = self.pointer_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
923                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
924                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
925                {
926                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
927                }
928                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
929                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
930                }
931            }
932
933            next_offset += envelope_size;
934            _next_ordinal_to_read += 1;
935            if next_offset >= end_offset {
936                return Ok(());
937            }
938
939            // Decode unknown envelopes for gaps in ordinals.
940            while _next_ordinal_to_read < 2 {
941                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
942                _next_ordinal_to_read += 1;
943                next_offset += envelope_size;
944            }
945
946            let next_out_of_line = decoder.next_out_of_line();
947            let handles_before = decoder.remaining_handles();
948            if let Some((inlined, num_bytes, num_handles)) =
949                fidl::encoding::decode_envelope_header(decoder, next_offset)?
950            {
951                let member_inline_size =
952                    <EventPhase as fidl::encoding::TypeMarker>::inline_size(decoder.context);
953                if inlined != (member_inline_size <= 4) {
954                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
955                }
956                let inner_offset;
957                let mut inner_depth = depth.clone();
958                if inlined {
959                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
960                    inner_offset = next_offset;
961                } else {
962                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
963                    inner_depth.increment()?;
964                }
965                let val_ref = self.phase.get_or_insert_with(|| fidl::new_empty!(EventPhase, D));
966                fidl::decode!(EventPhase, D, val_ref, decoder, inner_offset, inner_depth)?;
967                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
968                {
969                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
970                }
971                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
972                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
973                }
974            }
975
976            next_offset += envelope_size;
977            _next_ordinal_to_read += 1;
978            if next_offset >= end_offset {
979                return Ok(());
980            }
981
982            // Decode unknown envelopes for gaps in ordinals.
983            while _next_ordinal_to_read < 3 {
984                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
985                _next_ordinal_to_read += 1;
986                next_offset += envelope_size;
987            }
988
989            let next_out_of_line = decoder.next_out_of_line();
990            let handles_before = decoder.remaining_handles();
991            if let Some((inlined, num_bytes, num_handles)) =
992                fidl::encoding::decode_envelope_header(decoder, next_offset)?
993            {
994                let member_inline_size =
995                    <fidl::encoding::Array<f32, 2> as fidl::encoding::TypeMarker>::inline_size(
996                        decoder.context,
997                    );
998                if inlined != (member_inline_size <= 4) {
999                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1000                }
1001                let inner_offset;
1002                let mut inner_depth = depth.clone();
1003                if inlined {
1004                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1005                    inner_offset = next_offset;
1006                } else {
1007                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1008                    inner_depth.increment()?;
1009                }
1010                let val_ref = self
1011                    .position_in_viewport
1012                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 2>, D));
1013                fidl::decode!(fidl::encoding::Array<f32, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
1014                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1015                {
1016                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1017                }
1018                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1019                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1020                }
1021            }
1022
1023            next_offset += envelope_size;
1024            _next_ordinal_to_read += 1;
1025            if next_offset >= end_offset {
1026                return Ok(());
1027            }
1028
1029            // Decode unknown envelopes for gaps in ordinals.
1030            while _next_ordinal_to_read < 4 {
1031                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1032                _next_ordinal_to_read += 1;
1033                next_offset += envelope_size;
1034            }
1035
1036            let next_out_of_line = decoder.next_out_of_line();
1037            let handles_before = decoder.remaining_handles();
1038            if let Some((inlined, num_bytes, num_handles)) =
1039                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1040            {
1041                let member_inline_size =
1042                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1043                if inlined != (member_inline_size <= 4) {
1044                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1045                }
1046                let inner_offset;
1047                let mut inner_depth = depth.clone();
1048                if inlined {
1049                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1050                    inner_offset = next_offset;
1051                } else {
1052                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1053                    inner_depth.increment()?;
1054                }
1055                let val_ref = self.scroll_v.get_or_insert_with(|| fidl::new_empty!(i64, D));
1056                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
1057                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1058                {
1059                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1060                }
1061                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1062                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1063                }
1064            }
1065
1066            next_offset += envelope_size;
1067            _next_ordinal_to_read += 1;
1068            if next_offset >= end_offset {
1069                return Ok(());
1070            }
1071
1072            // Decode unknown envelopes for gaps in ordinals.
1073            while _next_ordinal_to_read < 5 {
1074                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1075                _next_ordinal_to_read += 1;
1076                next_offset += envelope_size;
1077            }
1078
1079            let next_out_of_line = decoder.next_out_of_line();
1080            let handles_before = decoder.remaining_handles();
1081            if let Some((inlined, num_bytes, num_handles)) =
1082                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1083            {
1084                let member_inline_size =
1085                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1086                if inlined != (member_inline_size <= 4) {
1087                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1088                }
1089                let inner_offset;
1090                let mut inner_depth = depth.clone();
1091                if inlined {
1092                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1093                    inner_offset = next_offset;
1094                } else {
1095                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1096                    inner_depth.increment()?;
1097                }
1098                let val_ref = self.scroll_h.get_or_insert_with(|| fidl::new_empty!(i64, D));
1099                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
1100                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1101                {
1102                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1103                }
1104                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1105                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1106                }
1107            }
1108
1109            next_offset += envelope_size;
1110            _next_ordinal_to_read += 1;
1111            if next_offset >= end_offset {
1112                return Ok(());
1113            }
1114
1115            // Decode unknown envelopes for gaps in ordinals.
1116            while _next_ordinal_to_read < 6 {
1117                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1118                _next_ordinal_to_read += 1;
1119                next_offset += envelope_size;
1120            }
1121
1122            let next_out_of_line = decoder.next_out_of_line();
1123            let handles_before = decoder.remaining_handles();
1124            if let Some((inlined, num_bytes, num_handles)) =
1125                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1126            {
1127                let member_inline_size =
1128                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
1129                        decoder.context,
1130                    );
1131                if inlined != (member_inline_size <= 4) {
1132                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1133                }
1134                let inner_offset;
1135                let mut inner_depth = depth.clone();
1136                if inlined {
1137                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1138                    inner_offset = next_offset;
1139                } else {
1140                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1141                    inner_depth.increment()?;
1142                }
1143                let val_ref = self
1144                    .pressed_buttons
1145                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
1146                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
1147                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1148                {
1149                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1150                }
1151                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1152                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1153                }
1154            }
1155
1156            next_offset += envelope_size;
1157            _next_ordinal_to_read += 1;
1158            if next_offset >= end_offset {
1159                return Ok(());
1160            }
1161
1162            // Decode unknown envelopes for gaps in ordinals.
1163            while _next_ordinal_to_read < 7 {
1164                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1165                _next_ordinal_to_read += 1;
1166                next_offset += envelope_size;
1167            }
1168
1169            let next_out_of_line = decoder.next_out_of_line();
1170            let handles_before = decoder.remaining_handles();
1171            if let Some((inlined, num_bytes, num_handles)) =
1172                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1173            {
1174                let member_inline_size =
1175                    <fidl::encoding::Array<f32, 2> as fidl::encoding::TypeMarker>::inline_size(
1176                        decoder.context,
1177                    );
1178                if inlined != (member_inline_size <= 4) {
1179                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1180                }
1181                let inner_offset;
1182                let mut inner_depth = depth.clone();
1183                if inlined {
1184                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1185                    inner_offset = next_offset;
1186                } else {
1187                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1188                    inner_depth.increment()?;
1189                }
1190                let val_ref = self
1191                    .relative_motion
1192                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 2>, D));
1193                fidl::decode!(fidl::encoding::Array<f32, 2>, D, val_ref, decoder, inner_offset, inner_depth)?;
1194                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1195                {
1196                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1197                }
1198                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1199                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1200                }
1201            }
1202
1203            next_offset += envelope_size;
1204            _next_ordinal_to_read += 1;
1205            if next_offset >= end_offset {
1206                return Ok(());
1207            }
1208
1209            // Decode unknown envelopes for gaps in ordinals.
1210            while _next_ordinal_to_read < 8 {
1211                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1212                _next_ordinal_to_read += 1;
1213                next_offset += envelope_size;
1214            }
1215
1216            let next_out_of_line = decoder.next_out_of_line();
1217            let handles_before = decoder.remaining_handles();
1218            if let Some((inlined, num_bytes, num_handles)) =
1219                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1220            {
1221                let member_inline_size =
1222                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1223                if inlined != (member_inline_size <= 4) {
1224                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1225                }
1226                let inner_offset;
1227                let mut inner_depth = depth.clone();
1228                if inlined {
1229                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1230                    inner_offset = next_offset;
1231                } else {
1232                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1233                    inner_depth.increment()?;
1234                }
1235                let val_ref =
1236                    self.scroll_v_physical_pixel.get_or_insert_with(|| fidl::new_empty!(f64, D));
1237                fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
1238                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1239                {
1240                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1241                }
1242                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1243                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1244                }
1245            }
1246
1247            next_offset += envelope_size;
1248            _next_ordinal_to_read += 1;
1249            if next_offset >= end_offset {
1250                return Ok(());
1251            }
1252
1253            // Decode unknown envelopes for gaps in ordinals.
1254            while _next_ordinal_to_read < 9 {
1255                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1256                _next_ordinal_to_read += 1;
1257                next_offset += envelope_size;
1258            }
1259
1260            let next_out_of_line = decoder.next_out_of_line();
1261            let handles_before = decoder.remaining_handles();
1262            if let Some((inlined, num_bytes, num_handles)) =
1263                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1264            {
1265                let member_inline_size =
1266                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1267                if inlined != (member_inline_size <= 4) {
1268                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1269                }
1270                let inner_offset;
1271                let mut inner_depth = depth.clone();
1272                if inlined {
1273                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1274                    inner_offset = next_offset;
1275                } else {
1276                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1277                    inner_depth.increment()?;
1278                }
1279                let val_ref =
1280                    self.scroll_h_physical_pixel.get_or_insert_with(|| fidl::new_empty!(f64, D));
1281                fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
1282                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1283                {
1284                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1285                }
1286                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1287                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1288                }
1289            }
1290
1291            next_offset += envelope_size;
1292            _next_ordinal_to_read += 1;
1293            if next_offset >= end_offset {
1294                return Ok(());
1295            }
1296
1297            // Decode unknown envelopes for gaps in ordinals.
1298            while _next_ordinal_to_read < 10 {
1299                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1300                _next_ordinal_to_read += 1;
1301                next_offset += envelope_size;
1302            }
1303
1304            let next_out_of_line = decoder.next_out_of_line();
1305            let handles_before = decoder.remaining_handles();
1306            if let Some((inlined, num_bytes, num_handles)) =
1307                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1308            {
1309                let member_inline_size =
1310                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1311                if inlined != (member_inline_size <= 4) {
1312                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1313                }
1314                let inner_offset;
1315                let mut inner_depth = depth.clone();
1316                if inlined {
1317                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1318                    inner_offset = next_offset;
1319                } else {
1320                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1321                    inner_depth.increment()?;
1322                }
1323                let val_ref =
1324                    self.is_precision_scroll.get_or_insert_with(|| fidl::new_empty!(bool, D));
1325                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1326                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1327                {
1328                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1329                }
1330                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1331                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1332                }
1333            }
1334
1335            next_offset += envelope_size;
1336
1337            // Decode the remaining unknown envelopes.
1338            while next_offset < end_offset {
1339                _next_ordinal_to_read += 1;
1340                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1341                next_offset += envelope_size;
1342            }
1343
1344            Ok(())
1345        }
1346    }
1347
1348    impl Viewport {
1349        #[inline(always)]
1350        fn max_ordinal_present(&self) -> u64 {
1351            if let Some(_) = self.viewport_to_context_transform {
1352                return 2;
1353            }
1354            if let Some(_) = self.extents {
1355                return 1;
1356            }
1357            0
1358        }
1359    }
1360
1361    impl fidl::encoding::ValueTypeMarker for Viewport {
1362        type Borrowed<'a> = &'a Self;
1363        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1364            value
1365        }
1366    }
1367
1368    unsafe impl fidl::encoding::TypeMarker for Viewport {
1369        type Owned = Self;
1370
1371        #[inline(always)]
1372        fn inline_align(_context: fidl::encoding::Context) -> usize {
1373            8
1374        }
1375
1376        #[inline(always)]
1377        fn inline_size(_context: fidl::encoding::Context) -> usize {
1378            16
1379        }
1380    }
1381
1382    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Viewport, D> for &Viewport {
1383        unsafe fn encode(
1384            self,
1385            encoder: &mut fidl::encoding::Encoder<'_, D>,
1386            offset: usize,
1387            mut depth: fidl::encoding::Depth,
1388        ) -> fidl::Result<()> {
1389            encoder.debug_check_bounds::<Viewport>(offset);
1390            // Vector header
1391            let max_ordinal: u64 = self.max_ordinal_present();
1392            encoder.write_num(max_ordinal, offset);
1393            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1394            // Calling encoder.out_of_line_offset(0) is not allowed.
1395            if max_ordinal == 0 {
1396                return Ok(());
1397            }
1398            depth.increment()?;
1399            let envelope_size = 8;
1400            let bytes_len = max_ordinal as usize * envelope_size;
1401            #[allow(unused_variables)]
1402            let offset = encoder.out_of_line_offset(bytes_len);
1403            let mut _prev_end_offset: usize = 0;
1404            if 1 > max_ordinal {
1405                return Ok(());
1406            }
1407
1408            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1409            // are envelope_size bytes.
1410            let cur_offset: usize = (1 - 1) * envelope_size;
1411
1412            // Zero reserved fields.
1413            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1414
1415            // Safety:
1416            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1417            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1418            //   envelope_size bytes, there is always sufficient room.
1419            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 2>, D>(
1420            self.extents.as_ref().map(<fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 2> as fidl::encoding::ValueTypeMarker>::borrow),
1421            encoder, offset + cur_offset, depth
1422        )?;
1423
1424            _prev_end_offset = cur_offset + envelope_size;
1425            if 2 > max_ordinal {
1426                return Ok(());
1427            }
1428
1429            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1430            // are envelope_size bytes.
1431            let cur_offset: usize = (2 - 1) * envelope_size;
1432
1433            // Zero reserved fields.
1434            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1435
1436            // Safety:
1437            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1438            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1439            //   envelope_size bytes, there is always sufficient room.
1440            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 9>, D>(
1441                self.viewport_to_context_transform.as_ref().map(
1442                    <fidl::encoding::Array<f32, 9> as fidl::encoding::ValueTypeMarker>::borrow,
1443                ),
1444                encoder,
1445                offset + cur_offset,
1446                depth,
1447            )?;
1448
1449            _prev_end_offset = cur_offset + envelope_size;
1450
1451            Ok(())
1452        }
1453    }
1454
1455    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Viewport {
1456        #[inline(always)]
1457        fn new_empty() -> Self {
1458            Self::default()
1459        }
1460
1461        unsafe fn decode(
1462            &mut self,
1463            decoder: &mut fidl::encoding::Decoder<'_, D>,
1464            offset: usize,
1465            mut depth: fidl::encoding::Depth,
1466        ) -> fidl::Result<()> {
1467            decoder.debug_check_bounds::<Self>(offset);
1468            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1469                None => return Err(fidl::Error::NotNullable),
1470                Some(len) => len,
1471            };
1472            // Calling decoder.out_of_line_offset(0) is not allowed.
1473            if len == 0 {
1474                return Ok(());
1475            };
1476            depth.increment()?;
1477            let envelope_size = 8;
1478            let bytes_len = len * envelope_size;
1479            let offset = decoder.out_of_line_offset(bytes_len)?;
1480            // Decode the envelope for each type.
1481            let mut _next_ordinal_to_read = 0;
1482            let mut next_offset = offset;
1483            let end_offset = offset + bytes_len;
1484            _next_ordinal_to_read += 1;
1485            if next_offset >= end_offset {
1486                return Ok(());
1487            }
1488
1489            // Decode unknown envelopes for gaps in ordinals.
1490            while _next_ordinal_to_read < 1 {
1491                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1492                _next_ordinal_to_read += 1;
1493                next_offset += envelope_size;
1494            }
1495
1496            let next_out_of_line = decoder.next_out_of_line();
1497            let handles_before = decoder.remaining_handles();
1498            if let Some((inlined, num_bytes, num_handles)) =
1499                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1500            {
1501                let member_inline_size = <fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 2> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1502                if inlined != (member_inline_size <= 4) {
1503                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1504                }
1505                let inner_offset;
1506                let mut inner_depth = depth.clone();
1507                if inlined {
1508                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1509                    inner_offset = next_offset;
1510                } else {
1511                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1512                    inner_depth.increment()?;
1513                }
1514                let val_ref = self.extents.get_or_insert_with(|| {
1515                    fidl::new_empty!(fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 2>, D)
1516                });
1517                fidl::decode!(
1518                    fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 2>,
1519                    D,
1520                    val_ref,
1521                    decoder,
1522                    inner_offset,
1523                    inner_depth
1524                )?;
1525                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1526                {
1527                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1528                }
1529                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1530                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1531                }
1532            }
1533
1534            next_offset += envelope_size;
1535            _next_ordinal_to_read += 1;
1536            if next_offset >= end_offset {
1537                return Ok(());
1538            }
1539
1540            // Decode unknown envelopes for gaps in ordinals.
1541            while _next_ordinal_to_read < 2 {
1542                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1543                _next_ordinal_to_read += 1;
1544                next_offset += envelope_size;
1545            }
1546
1547            let next_out_of_line = decoder.next_out_of_line();
1548            let handles_before = decoder.remaining_handles();
1549            if let Some((inlined, num_bytes, num_handles)) =
1550                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1551            {
1552                let member_inline_size =
1553                    <fidl::encoding::Array<f32, 9> as fidl::encoding::TypeMarker>::inline_size(
1554                        decoder.context,
1555                    );
1556                if inlined != (member_inline_size <= 4) {
1557                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1558                }
1559                let inner_offset;
1560                let mut inner_depth = depth.clone();
1561                if inlined {
1562                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1563                    inner_offset = next_offset;
1564                } else {
1565                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1566                    inner_depth.increment()?;
1567                }
1568                let val_ref = self
1569                    .viewport_to_context_transform
1570                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 9>, D));
1571                fidl::decode!(fidl::encoding::Array<f32, 9>, D, val_ref, decoder, inner_offset, inner_depth)?;
1572                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1573                {
1574                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1575                }
1576                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1577                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1578                }
1579            }
1580
1581            next_offset += envelope_size;
1582
1583            // Decode the remaining unknown envelopes.
1584            while next_offset < end_offset {
1585                _next_ordinal_to_read += 1;
1586                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1587                next_offset += envelope_size;
1588            }
1589
1590            Ok(())
1591        }
1592    }
1593
1594    impl fidl::encoding::ValueTypeMarker for Data {
1595        type Borrowed<'a> = &'a Self;
1596        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1597            value
1598        }
1599    }
1600
1601    unsafe impl fidl::encoding::TypeMarker for Data {
1602        type Owned = Self;
1603
1604        #[inline(always)]
1605        fn inline_align(_context: fidl::encoding::Context) -> usize {
1606            8
1607        }
1608
1609        #[inline(always)]
1610        fn inline_size(_context: fidl::encoding::Context) -> usize {
1611            16
1612        }
1613    }
1614
1615    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Data, D> for &Data {
1616        #[inline]
1617        unsafe fn encode(
1618            self,
1619            encoder: &mut fidl::encoding::Encoder<'_, D>,
1620            offset: usize,
1621            _depth: fidl::encoding::Depth,
1622        ) -> fidl::Result<()> {
1623            encoder.debug_check_bounds::<Data>(offset);
1624            encoder.write_num::<u64>(self.ordinal(), offset);
1625            match self {
1626                Data::Viewport(ref val) => fidl::encoding::encode_in_envelope::<Viewport, D>(
1627                    <Viewport as fidl::encoding::ValueTypeMarker>::borrow(val),
1628                    encoder,
1629                    offset + 8,
1630                    _depth,
1631                ),
1632                Data::PointerSample(ref val) => {
1633                    fidl::encoding::encode_in_envelope::<PointerSample, D>(
1634                        <PointerSample as fidl::encoding::ValueTypeMarker>::borrow(val),
1635                        encoder,
1636                        offset + 8,
1637                        _depth,
1638                    )
1639                }
1640                Data::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
1641            }
1642        }
1643    }
1644
1645    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Data {
1646        #[inline(always)]
1647        fn new_empty() -> Self {
1648            Self::__SourceBreaking { unknown_ordinal: 0 }
1649        }
1650
1651        #[inline]
1652        unsafe fn decode(
1653            &mut self,
1654            decoder: &mut fidl::encoding::Decoder<'_, D>,
1655            offset: usize,
1656            mut depth: fidl::encoding::Depth,
1657        ) -> fidl::Result<()> {
1658            decoder.debug_check_bounds::<Self>(offset);
1659            #[allow(unused_variables)]
1660            let next_out_of_line = decoder.next_out_of_line();
1661            let handles_before = decoder.remaining_handles();
1662            let (ordinal, inlined, num_bytes, num_handles) =
1663                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
1664
1665            let member_inline_size = match ordinal {
1666                1 => <Viewport as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1667                2 => <PointerSample as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1668                0 => return Err(fidl::Error::UnknownUnionTag),
1669                _ => num_bytes as usize,
1670            };
1671
1672            if inlined != (member_inline_size <= 4) {
1673                return Err(fidl::Error::InvalidInlineBitInEnvelope);
1674            }
1675            let _inner_offset;
1676            if inlined {
1677                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
1678                _inner_offset = offset + 8;
1679            } else {
1680                depth.increment()?;
1681                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1682            }
1683            match ordinal {
1684                1 => {
1685                    #[allow(irrefutable_let_patterns)]
1686                    if let Data::Viewport(_) = self {
1687                        // Do nothing, read the value into the object
1688                    } else {
1689                        // Initialize `self` to the right variant
1690                        *self = Data::Viewport(fidl::new_empty!(Viewport, D));
1691                    }
1692                    #[allow(irrefutable_let_patterns)]
1693                    if let Data::Viewport(ref mut val) = self {
1694                        fidl::decode!(Viewport, D, val, decoder, _inner_offset, depth)?;
1695                    } else {
1696                        unreachable!()
1697                    }
1698                }
1699                2 => {
1700                    #[allow(irrefutable_let_patterns)]
1701                    if let Data::PointerSample(_) = self {
1702                        // Do nothing, read the value into the object
1703                    } else {
1704                        // Initialize `self` to the right variant
1705                        *self = Data::PointerSample(fidl::new_empty!(PointerSample, D));
1706                    }
1707                    #[allow(irrefutable_let_patterns)]
1708                    if let Data::PointerSample(ref mut val) = self {
1709                        fidl::decode!(PointerSample, D, val, decoder, _inner_offset, depth)?;
1710                    } else {
1711                        unreachable!()
1712                    }
1713                }
1714                #[allow(deprecated)]
1715                ordinal => {
1716                    for _ in 0..num_handles {
1717                        decoder.drop_next_handle()?;
1718                    }
1719                    *self = Data::__SourceBreaking { unknown_ordinal: ordinal };
1720                }
1721            }
1722            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
1723                return Err(fidl::Error::InvalidNumBytesInEnvelope);
1724            }
1725            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1726                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1727            }
1728            Ok(())
1729        }
1730    }
1731}
fidl_fuchsia_ui_pointerinjector__common/fidl_fuchsia_ui_pointerinjector__common.rs

fidl_fuchsia_ui_pointerinjector__common/
fidl_fuchsia_ui_pointerinjector__common.rs
