# DO NOT EDIT THIS FILE!
|
#
|
# This file is generated from the CDP specification. If you need to make
|
# changes, edit the generator and regenerate all of the modules.
|
#
|
# CDP domain: Input
|
from __future__ import annotations
|
from .util import event_class, T_JSON_DICT
|
from dataclasses import dataclass
|
import enum
|
import typing
|
|
@dataclass
|
class TouchPoint:
|
#: X coordinate of the event relative to the main frame's viewport in CSS pixels.
|
x: float
|
|
#: Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to
|
#: the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
|
y: float
|
|
#: X radius of the touch area (default: 1.0).
|
radius_x: typing.Optional[float] = None
|
|
#: Y radius of the touch area (default: 1.0).
|
radius_y: typing.Optional[float] = None
|
|
#: Rotation angle (default: 0.0).
|
rotation_angle: typing.Optional[float] = None
|
|
#: Force (default: 1.0).
|
force: typing.Optional[float] = None
|
|
#: The normalized tangential pressure, which has a range of [-1,1] (default: 0).
|
tangential_pressure: typing.Optional[float] = None
|
|
#: The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0)
|
tilt_x: typing.Optional[int] = None
|
|
#: The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0).
|
tilt_y: typing.Optional[int] = None
|
|
#: The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0).
|
twist: typing.Optional[int] = None
|
|
#: Identifier used to track touch sources between events, must be unique within an event.
|
id_: typing.Optional[float] = None
|
|
def to_json(self):
|
json = dict()
|
json['x'] = self.x
|
json['y'] = self.y
|
if self.radius_x is not None:
|
json['radiusX'] = self.radius_x
|
if self.radius_y is not None:
|
json['radiusY'] = self.radius_y
|
if self.rotation_angle is not None:
|
json['rotationAngle'] = self.rotation_angle
|
if self.force is not None:
|
json['force'] = self.force
|
if self.tangential_pressure is not None:
|
json['tangentialPressure'] = self.tangential_pressure
|
if self.tilt_x is not None:
|
json['tiltX'] = self.tilt_x
|
if self.tilt_y is not None:
|
json['tiltY'] = self.tilt_y
|
if self.twist is not None:
|
json['twist'] = self.twist
|
if self.id_ is not None:
|
json['id'] = self.id_
|
return json
|
|
@classmethod
|
def from_json(cls, json):
|
return cls(
|
x=float(json['x']),
|
y=float(json['y']),
|
radius_x=float(json['radiusX']) if 'radiusX' in json else None,
|
radius_y=float(json['radiusY']) if 'radiusY' in json else None,
|
rotation_angle=float(json['rotationAngle']) if 'rotationAngle' in json else None,
|
force=float(json['force']) if 'force' in json else None,
|
tangential_pressure=float(json['tangentialPressure']) if 'tangentialPressure' in json else None,
|
tilt_x=int(json['tiltX']) if 'tiltX' in json else None,
|
tilt_y=int(json['tiltY']) if 'tiltY' in json else None,
|
twist=int(json['twist']) if 'twist' in json else None,
|
id_=float(json['id']) if 'id' in json else None,
|
)
|
|
|
class GestureSourceType(enum.Enum):
|
DEFAULT = "default"
|
TOUCH = "touch"
|
MOUSE = "mouse"
|
|
def to_json(self):
|
return self.value
|
|
@classmethod
|
def from_json(cls, json):
|
return cls(json)
|
|
|
class MouseButton(enum.Enum):
|
NONE = "none"
|
LEFT = "left"
|
MIDDLE = "middle"
|
RIGHT = "right"
|
BACK = "back"
|
FORWARD = "forward"
|
|
def to_json(self):
|
return self.value
|
|
@classmethod
|
def from_json(cls, json):
|
return cls(json)
|
|
|
class TimeSinceEpoch(float):
|
'''
|
UTC time in seconds, counted from January 1, 1970.
|
'''
|
def to_json(self) -> float:
|
return self
|
|
@classmethod
|
def from_json(cls, json: float) -> TimeSinceEpoch:
|
return cls(json)
|
|
def __repr__(self):
|
return 'TimeSinceEpoch({})'.format(super().__repr__())
|
|
|
@dataclass
|
class DragDataItem:
|
#: Mime type of the dragged data.
|
mime_type: str
|
|
#: Depending of the value of ``mimeType``, it contains the dragged link,
|
#: text, HTML markup or any other data.
|
data: str
|
|
#: Title associated with a link. Only valid when ``mimeType`` == "text/uri-list".
|
title: typing.Optional[str] = None
|
|
#: Stores the base URL for the contained markup. Only valid when ``mimeType``
|
#: == "text/html".
|
base_url: typing.Optional[str] = None
|
|
def to_json(self):
|
json = dict()
|
json['mimeType'] = self.mime_type
|
json['data'] = self.data
|
if self.title is not None:
|
json['title'] = self.title
|
if self.base_url is not None:
|
json['baseURL'] = self.base_url
|
return json
|
|
@classmethod
|
def from_json(cls, json):
|
return cls(
|
mime_type=str(json['mimeType']),
|
data=str(json['data']),
|
title=str(json['title']) if 'title' in json else None,
|
base_url=str(json['baseURL']) if 'baseURL' in json else None,
|
)
|
|
|
@dataclass
|
class DragData:
|
items: typing.List[DragDataItem]
|
|
#: Bit field representing allowed drag operations. Copy = 1, Link = 2, Move = 16
|
drag_operations_mask: int
|
|
#: List of filenames that should be included when dropping
|
files: typing.Optional[typing.List[str]] = None
|
|
def to_json(self):
|
json = dict()
|
json['items'] = [i.to_json() for i in self.items]
|
json['dragOperationsMask'] = self.drag_operations_mask
|
if self.files is not None:
|
json['files'] = [i for i in self.files]
|
return json
|
|
@classmethod
|
def from_json(cls, json):
|
return cls(
|
items=[DragDataItem.from_json(i) for i in json['items']],
|
drag_operations_mask=int(json['dragOperationsMask']),
|
files=[str(i) for i in json['files']] if 'files' in json else None,
|
)
|
|
|
def dispatch_drag_event(
|
type_: str,
|
x: float,
|
y: float,
|
data: DragData,
|
modifiers: typing.Optional[int] = None
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
Dispatches a drag event into the page.
|
|
**EXPERIMENTAL**
|
|
:param type_: Type of the drag event.
|
:param x: X coordinate of the event relative to the main frame's viewport in CSS pixels.
|
:param y: Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
|
:param data:
|
:param modifiers: *(Optional)* Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
|
'''
|
params: T_JSON_DICT = dict()
|
params['type'] = type_
|
params['x'] = x
|
params['y'] = y
|
params['data'] = data.to_json()
|
if modifiers is not None:
|
params['modifiers'] = modifiers
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.dispatchDragEvent',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def dispatch_key_event(
|
type_: str,
|
modifiers: typing.Optional[int] = None,
|
timestamp: typing.Optional[TimeSinceEpoch] = None,
|
text: typing.Optional[str] = None,
|
unmodified_text: typing.Optional[str] = None,
|
key_identifier: typing.Optional[str] = None,
|
code: typing.Optional[str] = None,
|
key: typing.Optional[str] = None,
|
windows_virtual_key_code: typing.Optional[int] = None,
|
native_virtual_key_code: typing.Optional[int] = None,
|
auto_repeat: typing.Optional[bool] = None,
|
is_keypad: typing.Optional[bool] = None,
|
is_system_key: typing.Optional[bool] = None,
|
location: typing.Optional[int] = None,
|
commands: typing.Optional[typing.List[str]] = None
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
Dispatches a key event to the page.
|
|
:param type_: Type of the key event.
|
:param modifiers: *(Optional)* Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
|
:param timestamp: *(Optional)* Time at which the event occurred.
|
:param text: *(Optional)* Text as generated by processing a virtual key code with a keyboard layout. Not needed for for ```keyUp```` and ````rawKeyDown```` events (default: "")
|
:param unmodified_text: *(Optional)* Text that would have been generated by the keyboard if no modifiers were pressed (except for shift). Useful for shortcut (accelerator) key handling (default: "").
|
:param key_identifier: *(Optional)* Unique key identifier (e.g., 'U+0041') (default: "").
|
:param code: *(Optional)* Unique DOM defined string value for each physical key (e.g., 'KeyA') (default: "").
|
:param key: *(Optional)* Unique DOM defined string value describing the meaning of the key in the context of active modifiers, keyboard layout, etc (e.g., 'AltGr') (default: "").
|
:param windows_virtual_key_code: *(Optional)* Windows virtual key code (default: 0).
|
:param native_virtual_key_code: *(Optional)* Native virtual key code (default: 0).
|
:param auto_repeat: *(Optional)* Whether the event was generated from auto repeat (default: false).
|
:param is_keypad: *(Optional)* Whether the event was generated from the keypad (default: false).
|
:param is_system_key: *(Optional)* Whether the event was a system key event (default: false).
|
:param location: *(Optional)* Whether the event was from the left or right side of the keyboard. 1=Left, 2=Right (default: 0).
|
:param commands: **(EXPERIMENTAL)** *(Optional)* Editing commands to send with the key event (e.g., 'selectAll') (default: []). These are related to but not equal the command names used in ````document.execCommand``` and NSStandardKeyBindingResponding. See https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/editing/commands/editor_command_names.h for valid command names.
|
'''
|
params: T_JSON_DICT = dict()
|
params['type'] = type_
|
if modifiers is not None:
|
params['modifiers'] = modifiers
|
if timestamp is not None:
|
params['timestamp'] = timestamp.to_json()
|
if text is not None:
|
params['text'] = text
|
if unmodified_text is not None:
|
params['unmodifiedText'] = unmodified_text
|
if key_identifier is not None:
|
params['keyIdentifier'] = key_identifier
|
if code is not None:
|
params['code'] = code
|
if key is not None:
|
params['key'] = key
|
if windows_virtual_key_code is not None:
|
params['windowsVirtualKeyCode'] = windows_virtual_key_code
|
if native_virtual_key_code is not None:
|
params['nativeVirtualKeyCode'] = native_virtual_key_code
|
if auto_repeat is not None:
|
params['autoRepeat'] = auto_repeat
|
if is_keypad is not None:
|
params['isKeypad'] = is_keypad
|
if is_system_key is not None:
|
params['isSystemKey'] = is_system_key
|
if location is not None:
|
params['location'] = location
|
if commands is not None:
|
params['commands'] = [i for i in commands]
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.dispatchKeyEvent',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def insert_text(
|
text: str
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
This method emulates inserting text that doesn't come from a key press,
|
for example an emoji keyboard or an IME.
|
|
**EXPERIMENTAL**
|
|
:param text: The text to insert.
|
'''
|
params: T_JSON_DICT = dict()
|
params['text'] = text
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.insertText',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def ime_set_composition(
|
text: str,
|
selection_start: int,
|
selection_end: int,
|
replacement_start: typing.Optional[int] = None,
|
replacement_end: typing.Optional[int] = None
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
This method sets the current candidate text for ime.
|
Use imeCommitComposition to commit the final text.
|
Use imeSetComposition with empty string as text to cancel composition.
|
|
**EXPERIMENTAL**
|
|
:param text: The text to insert
|
:param selection_start: selection start
|
:param selection_end: selection end
|
:param replacement_start: *(Optional)* replacement start
|
:param replacement_end: *(Optional)* replacement end
|
'''
|
params: T_JSON_DICT = dict()
|
params['text'] = text
|
params['selectionStart'] = selection_start
|
params['selectionEnd'] = selection_end
|
if replacement_start is not None:
|
params['replacementStart'] = replacement_start
|
if replacement_end is not None:
|
params['replacementEnd'] = replacement_end
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.imeSetComposition',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def dispatch_mouse_event(
|
type_: str,
|
x: float,
|
y: float,
|
modifiers: typing.Optional[int] = None,
|
timestamp: typing.Optional[TimeSinceEpoch] = None,
|
button: typing.Optional[MouseButton] = None,
|
buttons: typing.Optional[int] = None,
|
click_count: typing.Optional[int] = None,
|
force: typing.Optional[float] = None,
|
tangential_pressure: typing.Optional[float] = None,
|
tilt_x: typing.Optional[int] = None,
|
tilt_y: typing.Optional[int] = None,
|
twist: typing.Optional[int] = None,
|
delta_x: typing.Optional[float] = None,
|
delta_y: typing.Optional[float] = None,
|
pointer_type: typing.Optional[str] = None
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
Dispatches a mouse event to the page.
|
|
:param type_: Type of the mouse event.
|
:param x: X coordinate of the event relative to the main frame's viewport in CSS pixels.
|
:param y: Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
|
:param modifiers: *(Optional)* Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
|
:param timestamp: *(Optional)* Time at which the event occurred.
|
:param button: *(Optional)* Mouse button (default: "none").
|
:param buttons: *(Optional)* A number indicating which buttons are pressed on the mouse when a mouse event is triggered. Left=1, Right=2, Middle=4, Back=8, Forward=16, None=0.
|
:param click_count: *(Optional)* Number of times the mouse button was clicked (default: 0).
|
:param force: **(EXPERIMENTAL)** *(Optional)* The normalized pressure, which has a range of [0,1] (default: 0).
|
:param tangential_pressure: **(EXPERIMENTAL)** *(Optional)* The normalized tangential pressure, which has a range of [-1,1] (default: 0).
|
:param tilt_x: **(EXPERIMENTAL)** *(Optional)* The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0).
|
:param tilt_y: **(EXPERIMENTAL)** *(Optional)* The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0).
|
:param twist: **(EXPERIMENTAL)** *(Optional)* The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0).
|
:param delta_x: *(Optional)* X delta in CSS pixels for mouse wheel event (default: 0).
|
:param delta_y: *(Optional)* Y delta in CSS pixels for mouse wheel event (default: 0).
|
:param pointer_type: *(Optional)* Pointer type (default: "mouse").
|
'''
|
params: T_JSON_DICT = dict()
|
params['type'] = type_
|
params['x'] = x
|
params['y'] = y
|
if modifiers is not None:
|
params['modifiers'] = modifiers
|
if timestamp is not None:
|
params['timestamp'] = timestamp.to_json()
|
if button is not None:
|
params['button'] = button.to_json()
|
if buttons is not None:
|
params['buttons'] = buttons
|
if click_count is not None:
|
params['clickCount'] = click_count
|
if force is not None:
|
params['force'] = force
|
if tangential_pressure is not None:
|
params['tangentialPressure'] = tangential_pressure
|
if tilt_x is not None:
|
params['tiltX'] = tilt_x
|
if tilt_y is not None:
|
params['tiltY'] = tilt_y
|
if twist is not None:
|
params['twist'] = twist
|
if delta_x is not None:
|
params['deltaX'] = delta_x
|
if delta_y is not None:
|
params['deltaY'] = delta_y
|
if pointer_type is not None:
|
params['pointerType'] = pointer_type
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.dispatchMouseEvent',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def dispatch_touch_event(
|
type_: str,
|
touch_points: typing.List[TouchPoint],
|
modifiers: typing.Optional[int] = None,
|
timestamp: typing.Optional[TimeSinceEpoch] = None
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
Dispatches a touch event to the page.
|
|
:param type_: Type of the touch event. TouchEnd and TouchCancel must not contain any touch points, while TouchStart and TouchMove must contains at least one.
|
:param touch_points: Active touch points on the touch device. One event per any changed point (compared to previous touch event in a sequence) is generated, emulating pressing/moving/releasing points one by one.
|
:param modifiers: *(Optional)* Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
|
:param timestamp: *(Optional)* Time at which the event occurred.
|
'''
|
params: T_JSON_DICT = dict()
|
params['type'] = type_
|
params['touchPoints'] = [i.to_json() for i in touch_points]
|
if modifiers is not None:
|
params['modifiers'] = modifiers
|
if timestamp is not None:
|
params['timestamp'] = timestamp.to_json()
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.dispatchTouchEvent',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def emulate_touch_from_mouse_event(
|
type_: str,
|
x: int,
|
y: int,
|
button: MouseButton,
|
timestamp: typing.Optional[TimeSinceEpoch] = None,
|
delta_x: typing.Optional[float] = None,
|
delta_y: typing.Optional[float] = None,
|
modifiers: typing.Optional[int] = None,
|
click_count: typing.Optional[int] = None
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
Emulates touch event from the mouse event parameters.
|
|
**EXPERIMENTAL**
|
|
:param type_: Type of the mouse event.
|
:param x: X coordinate of the mouse pointer in DIP.
|
:param y: Y coordinate of the mouse pointer in DIP.
|
:param button: Mouse button. Only "none", "left", "right" are supported.
|
:param timestamp: *(Optional)* Time at which the event occurred (default: current time).
|
:param delta_x: *(Optional)* X delta in DIP for mouse wheel event (default: 0).
|
:param delta_y: *(Optional)* Y delta in DIP for mouse wheel event (default: 0).
|
:param modifiers: *(Optional)* Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
|
:param click_count: *(Optional)* Number of times the mouse button was clicked (default: 0).
|
'''
|
params: T_JSON_DICT = dict()
|
params['type'] = type_
|
params['x'] = x
|
params['y'] = y
|
params['button'] = button.to_json()
|
if timestamp is not None:
|
params['timestamp'] = timestamp.to_json()
|
if delta_x is not None:
|
params['deltaX'] = delta_x
|
if delta_y is not None:
|
params['deltaY'] = delta_y
|
if modifiers is not None:
|
params['modifiers'] = modifiers
|
if click_count is not None:
|
params['clickCount'] = click_count
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.emulateTouchFromMouseEvent',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def set_ignore_input_events(
|
ignore: bool
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
Ignores input events (useful while auditing page).
|
|
:param ignore: Ignores input events processing when set to true.
|
'''
|
params: T_JSON_DICT = dict()
|
params['ignore'] = ignore
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.setIgnoreInputEvents',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def set_intercept_drags(
|
enabled: bool
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
Prevents default drag and drop behavior and instead emits ``Input.dragIntercepted`` events.
|
Drag and drop behavior can be directly controlled via ``Input.dispatchDragEvent``.
|
|
**EXPERIMENTAL**
|
|
:param enabled:
|
'''
|
params: T_JSON_DICT = dict()
|
params['enabled'] = enabled
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.setInterceptDrags',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def synthesize_pinch_gesture(
|
x: float,
|
y: float,
|
scale_factor: float,
|
relative_speed: typing.Optional[int] = None,
|
gesture_source_type: typing.Optional[GestureSourceType] = None
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
Synthesizes a pinch gesture over a time period by issuing appropriate touch events.
|
|
**EXPERIMENTAL**
|
|
:param x: X coordinate of the start of the gesture in CSS pixels.
|
:param y: Y coordinate of the start of the gesture in CSS pixels.
|
:param scale_factor: Relative scale factor after zooming (>1.0 zooms in, <1.0 zooms out).
|
:param relative_speed: *(Optional)* Relative pointer speed in pixels per second (default: 800).
|
:param gesture_source_type: *(Optional)* Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).
|
'''
|
params: T_JSON_DICT = dict()
|
params['x'] = x
|
params['y'] = y
|
params['scaleFactor'] = scale_factor
|
if relative_speed is not None:
|
params['relativeSpeed'] = relative_speed
|
if gesture_source_type is not None:
|
params['gestureSourceType'] = gesture_source_type.to_json()
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.synthesizePinchGesture',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def synthesize_scroll_gesture(
|
x: float,
|
y: float,
|
x_distance: typing.Optional[float] = None,
|
y_distance: typing.Optional[float] = None,
|
x_overscroll: typing.Optional[float] = None,
|
y_overscroll: typing.Optional[float] = None,
|
prevent_fling: typing.Optional[bool] = None,
|
speed: typing.Optional[int] = None,
|
gesture_source_type: typing.Optional[GestureSourceType] = None,
|
repeat_count: typing.Optional[int] = None,
|
repeat_delay_ms: typing.Optional[int] = None,
|
interaction_marker_name: typing.Optional[str] = None
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
Synthesizes a scroll gesture over a time period by issuing appropriate touch events.
|
|
**EXPERIMENTAL**
|
|
:param x: X coordinate of the start of the gesture in CSS pixels.
|
:param y: Y coordinate of the start of the gesture in CSS pixels.
|
:param x_distance: *(Optional)* The distance to scroll along the X axis (positive to scroll left).
|
:param y_distance: *(Optional)* The distance to scroll along the Y axis (positive to scroll up).
|
:param x_overscroll: *(Optional)* The number of additional pixels to scroll back along the X axis, in addition to the given distance.
|
:param y_overscroll: *(Optional)* The number of additional pixels to scroll back along the Y axis, in addition to the given distance.
|
:param prevent_fling: *(Optional)* Prevent fling (default: true).
|
:param speed: *(Optional)* Swipe speed in pixels per second (default: 800).
|
:param gesture_source_type: *(Optional)* Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).
|
:param repeat_count: *(Optional)* The number of times to repeat the gesture (default: 0).
|
:param repeat_delay_ms: *(Optional)* The number of milliseconds delay between each repeat. (default: 250).
|
:param interaction_marker_name: *(Optional)* The name of the interaction markers to generate, if not empty (default: "").
|
'''
|
params: T_JSON_DICT = dict()
|
params['x'] = x
|
params['y'] = y
|
if x_distance is not None:
|
params['xDistance'] = x_distance
|
if y_distance is not None:
|
params['yDistance'] = y_distance
|
if x_overscroll is not None:
|
params['xOverscroll'] = x_overscroll
|
if y_overscroll is not None:
|
params['yOverscroll'] = y_overscroll
|
if prevent_fling is not None:
|
params['preventFling'] = prevent_fling
|
if speed is not None:
|
params['speed'] = speed
|
if gesture_source_type is not None:
|
params['gestureSourceType'] = gesture_source_type.to_json()
|
if repeat_count is not None:
|
params['repeatCount'] = repeat_count
|
if repeat_delay_ms is not None:
|
params['repeatDelayMs'] = repeat_delay_ms
|
if interaction_marker_name is not None:
|
params['interactionMarkerName'] = interaction_marker_name
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.synthesizeScrollGesture',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
def synthesize_tap_gesture(
|
x: float,
|
y: float,
|
duration: typing.Optional[int] = None,
|
tap_count: typing.Optional[int] = None,
|
gesture_source_type: typing.Optional[GestureSourceType] = None
|
) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
|
'''
|
Synthesizes a tap gesture over a time period by issuing appropriate touch events.
|
|
**EXPERIMENTAL**
|
|
:param x: X coordinate of the start of the gesture in CSS pixels.
|
:param y: Y coordinate of the start of the gesture in CSS pixels.
|
:param duration: *(Optional)* Duration between touchdown and touchup events in ms (default: 50).
|
:param tap_count: *(Optional)* Number of times to perform the tap (e.g. 2 for double tap, default: 1).
|
:param gesture_source_type: *(Optional)* Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).
|
'''
|
params: T_JSON_DICT = dict()
|
params['x'] = x
|
params['y'] = y
|
if duration is not None:
|
params['duration'] = duration
|
if tap_count is not None:
|
params['tapCount'] = tap_count
|
if gesture_source_type is not None:
|
params['gestureSourceType'] = gesture_source_type.to_json()
|
cmd_dict: T_JSON_DICT = {
|
'method': 'Input.synthesizeTapGesture',
|
'params': params,
|
}
|
json = yield cmd_dict
|
|
|
@event_class('Input.dragIntercepted')
|
@dataclass
|
class DragIntercepted:
|
'''
|
**EXPERIMENTAL**
|
|
Emitted only when ``Input.setInterceptDrags`` is enabled. Use this data with ``Input.dispatchDragEvent`` to
|
restore normal drag and drop behavior.
|
'''
|
data: DragData
|
|
@classmethod
|
def from_json(cls, json: T_JSON_DICT) -> DragIntercepted:
|
return cls(
|
data=DragData.from_json(json['data'])
|
)
|
