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

fidl_fuchsia_ui_pointerinjector_common/
fidl_fuchsia_ui_pointerinjector_common.rs
