Struct script::dom::gamepad::Gamepad

#[repr(C)]
pub struct Gamepad {

    reflector_: Reflector,
    gamepad_id: u32,
    id: String,
    index: Cell<i32>,
    connected: Cell<bool>,
    timestamp: Cell<f64>,
    mapping_type: String,
    axes: HeapBufferSource<Float64>,
    buttons: Dom<GamepadButtonList>,
    pose: Option<Dom<GamepadPose>>,
    hand: GamepadHand,
    axis_bounds: (f64, f64),
    button_bounds: (f64, f64),
    exposed: Cell<bool>,
    vibration_actuator: Dom<GamepadHapticActuator>,
}

Fields

reflector_: Reflector

gamepad_id: u32

id: String

index: Cell<i32>

connected: Cell<bool>

timestamp: Cell<f64>

mapping_type: String

axes: HeapBufferSource<Float64>

buttons: Dom<GamepadButtonList>

pose: Option<Dom<GamepadPose>>

hand: GamepadHand

axis_bounds: (f64, f64)

button_bounds: (f64, f64)

exposed: Cell<bool>

vibration_actuator: Dom<GamepadHapticActuator>

Implementations

impl Gamepad

fn __assert_parent_type(&self)

impl Gamepad

fn new_inherited( gamepad_id: u32, id: String, index: i32, connected: bool, timestamp: f64, mapping_type: String, buttons: &GamepadButtonList, pose: Option<&GamepadPose>, hand: GamepadHand, axis_bounds: (f64, f64), button_bounds: (f64, f64), vibration_actuator: &GamepadHapticActuator, ) -> Gamepad

pub fn new( global: &GlobalScope, gamepad_id: u32, id: String, mapping_type: String, axis_bounds: (f64, f64), button_bounds: (f64, f64), supported_haptic_effects: GamepadSupportedHapticEffects, xr: bool, can_gc: CanGc, ) -> Root<Dom<Gamepad>>

fn new_with_proto( global: &GlobalScope, gamepad_id: u32, id: String, mapping_type: String, axis_bounds: (f64, f64), button_bounds: (f64, f64), supported_haptic_effects: GamepadSupportedHapticEffects, xr: bool, can_gc: CanGc, ) -> Root<Dom<Gamepad>>

When we construct a new gamepad, we initialize the number of buttons and axes corresponding to the “standard” gamepad mapping. The spec says UAs may do this for fingerprint mitigation, and it also happens to simplify implementation https://www.w3.org/TR/gamepad/#fingerprinting-mitigation

impl Gamepad

pub fn gamepad_id(&self) -> u32

pub fn update_connected( &self, connected: bool, has_gesture: bool, can_gc: CanGc, )

pub fn index(&self) -> i32

pub fn update_index(&self, index: i32)

pub fn update_timestamp(&self, timestamp: f64)

pub fn notify_event(&self, event_type: GamepadEventType, can_gc: CanGc)

fn init_axes(&self)

Initialize the number of axes in the “standard” gamepad mapping. https://www.w3.org/TR/gamepad/#dfn-initializing-axes

pub fn map_and_normalize_axes(&self, axis_index: usize, value: f64)

https://www.w3.org/TR/gamepad/#dfn-map-and-normalize-axes

pub fn map_and_normalize_buttons(&self, button_index: usize, value: f64)

https://www.w3.org/TR/gamepad/#dfn-map-and-normalize-buttons

pub fn exposed(&self) -> bool

https://www.w3.org/TR/gamepad/#dfn-exposed

pub fn set_exposed(&self, exposed: bool)

https://www.w3.org/TR/gamepad/#dfn-exposed

pub fn vibration_actuator(&self) -> &GamepadHapticActuator

Trait Implementations

impl DomObject for Gamepad

fn reflector(&self) -> &Reflector

Returns the receiver’s reflector.

fn global(&self) -> Root<Dom<GlobalScope>>

where Self: Sized,

Returns the global scope of the realm that the DomObject was created in.

impl DomObjectWrap for Gamepad

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::GamepadBinding::Gamepad_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gamepad::Gamepad>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gamepad::Gamepad>>}

Function pointer to the general wrap function type

impl GamepadMethods for Gamepad

fn Id(&self) -> DOMString

fn Index(&self) -> i32

fn Connected(&self) -> bool

fn Timestamp(&self) -> Finite<f64>

fn Mapping(&self) -> DOMString

fn Axes(&self, _cx: JSContext) -> Float64Array

fn Buttons(&self) -> Root<Dom<GamepadButtonList>>

fn VibrationActuator(&self) -> Root<Dom<GamepadHapticActuator>>

fn Hand(&self) -> GamepadHand

fn GetPose(&self) -> Option<Root<Dom<GamepadPose>>>

impl HasParent for Gamepad

fn as_parent(&self) -> &Reflector

This is used in a type assertion to ensure that the source and webidls agree as to what the parent type is

type Parent = Reflector

impl IDLInterface for Gamepad

fn derives(class: &'static DOMClass) -> bool

Returns whether the given DOM class derives that interface.

impl MallocSizeOf for Gamepad

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl MutDomObject for Gamepad

unsafe fn init_reflector(&self, obj: *mut JSObject)

Initializes the Reflector

impl PartialEq for Gamepad

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToJSValConvertible for Gamepad

unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue<'_>)

Convert self to a JSVal. JSAPI failure causes a panic.

impl Traceable for Gamepad

unsafe fn trace(&self, tracer: *mut JSTracer)

Trace self.

impl Eq for Gamepad