Struct Frame 

pub struct Frame { /* private fields */ }

Channel for the Frame interface (frame.yml).

Implementations

impl Frame

pub async fn eval_on_selector( &self, params: FrameEvalOnSelectorParams, ) -> Result<FrameEvalOnSelectorResult, ProtocolError>

Frame.evalOnSelector (“Evaluate”).

pub async fn eval_on_selector_all( &self, params: FrameEvalOnSelectorAllParams, ) -> Result<FrameEvalOnSelectorAllResult, ProtocolError>

Frame.evalOnSelectorAll (“Evaluate”).

pub async fn add_script_tag( &self, params: FrameAddScriptTagParams, ) -> Result<FrameAddScriptTagResult, ProtocolError>

Frame.addScriptTag (“Add script tag”).

pub async fn add_style_tag( &self, params: FrameAddStyleTagParams, ) -> Result<FrameAddStyleTagResult, ProtocolError>

Frame.addStyleTag (“Add style tag”).

pub async fn aria_snapshot( &self, params: FrameAriaSnapshotParams, ) -> Result<FrameAriaSnapshotResult, ProtocolError>

Frame.ariaSnapshot (“Aria snapshot”).

pub async fn aria_snapshot_json( &self, params: FrameAriaSnapshotJSONParams, ) -> Result<FrameAriaSnapshotJSONResult, ProtocolError>

Frame.ariaSnapshotJSON (“Aria snapshot JSON”).

pub async fn blur(&self, params: FrameBlurParams) -> Result<(), ProtocolError>

Frame.blur (“Blur”).

pub async fn check(&self, params: FrameCheckParams) -> Result<(), ProtocolError>

Frame.check (“Check”).

pub async fn click(&self, params: FrameClickParams) -> Result<(), ProtocolError>

Frame.click (“Click”).

pub async fn content(&self) -> Result<FrameContentResult, ProtocolError>

Frame.content (“Get content”).

pub async fn drag_and_drop( &self, params: FrameDragAndDropParams, ) -> Result<(), ProtocolError>

Frame.dragAndDrop (“Drag and drop”).

pub async fn drop(&self, params: FrameDropParams) -> Result<(), ProtocolError>

Frame.drop (“Drop files or data onto an element”).

pub async fn dblclick( &self, params: FrameDblclickParams, ) -> Result<(), ProtocolError>

Frame.dblclick (“Double click”).

pub async fn dispatch_event( &self, params: FrameDispatchEventParams, ) -> Result<(), ProtocolError>

Frame.dispatchEvent (“Dispatch “{type}”“).

pub async fn evaluate_expression( &self, params: FrameEvaluateExpressionParams, ) -> Result<FrameEvaluateExpressionResult, ProtocolError>

Frame.evaluateExpression (“Evaluate”).

pub async fn evaluate_expression_handle( &self, params: FrameEvaluateExpressionHandleParams, ) -> Result<FrameEvaluateExpressionHandleResult, ProtocolError>

Frame.evaluateExpressionHandle (“Evaluate”).

pub async fn fill(&self, params: FrameFillParams) -> Result<(), ProtocolError>

Frame.fill (“Fill “{value}”“).

pub async fn focus(&self, params: FrameFocusParams) -> Result<(), ProtocolError>

Frame.focus (“Focus”).

pub async fn frame_element( &self, ) -> Result<FrameFrameElementResult, ProtocolError>

Frame.frameElement (“Get frame element”).

pub async fn resolve_selector( &self, params: FrameResolveSelectorParams, ) -> Result<FrameResolveSelectorResult, ProtocolError>

Frame.resolveSelector (internal).

pub async fn highlight( &self, params: FrameHighlightParams, ) -> Result<(), ProtocolError>

Frame.highlight (internal).

pub async fn hide_highlight( &self, params: FrameHideHighlightParams, ) -> Result<(), ProtocolError>

Frame.hideHighlight (internal).

pub async fn get_attribute( &self, params: FrameGetAttributeParams, ) -> Result<FrameGetAttributeResult, ProtocolError>

Frame.getAttribute (“Get attribute “{name}”“).

pub async fn goto( &self, params: FrameGotoParams, ) -> Result<FrameGotoResult, ProtocolError>

Frame.goto (“Navigate”).

pub async fn hover(&self, params: FrameHoverParams) -> Result<(), ProtocolError>

Frame.hover (“Hover”).

pub async fn inner_html( &self, params: FrameInnerHTMLParams, ) -> Result<FrameInnerHTMLResult, ProtocolError>

Frame.innerHTML (“Get HTML”).

pub async fn inner_text( &self, params: FrameInnerTextParams, ) -> Result<FrameInnerTextResult, ProtocolError>

Frame.innerText (“Get inner text”).

pub async fn input_value( &self, params: FrameInputValueParams, ) -> Result<FrameInputValueResult, ProtocolError>

Frame.inputValue (“Get input value”).

pub async fn is_checked( &self, params: FrameIsCheckedParams, ) -> Result<FrameIsCheckedResult, ProtocolError>

Frame.isChecked (“Is checked”).

pub async fn is_disabled( &self, params: FrameIsDisabledParams, ) -> Result<FrameIsDisabledResult, ProtocolError>

Frame.isDisabled (“Is disabled”).

pub async fn is_enabled( &self, params: FrameIsEnabledParams, ) -> Result<FrameIsEnabledResult, ProtocolError>

Frame.isEnabled (“Is enabled”).

pub async fn is_hidden( &self, params: FrameIsHiddenParams, ) -> Result<FrameIsHiddenResult, ProtocolError>

Frame.isHidden (“Is hidden”).

pub async fn is_visible( &self, params: FrameIsVisibleParams, ) -> Result<FrameIsVisibleResult, ProtocolError>

Frame.isVisible (“Is visible”).

pub async fn is_editable( &self, params: FrameIsEditableParams, ) -> Result<FrameIsEditableResult, ProtocolError>

Frame.isEditable (“Is editable”).

pub async fn press(&self, params: FramePressParams) -> Result<(), ProtocolError>

Frame.press (“Press “{key}”“).

pub async fn query_selector( &self, params: FrameQuerySelectorParams, ) -> Result<FrameQuerySelectorResult, ProtocolError>

Frame.querySelector (“Query selector”).

pub async fn query_selector_all( &self, params: FrameQuerySelectorAllParams, ) -> Result<FrameQuerySelectorAllResult, ProtocolError>

Frame.querySelectorAll (“Query selector all”).

pub async fn query_count( &self, params: FrameQueryCountParams, ) -> Result<FrameQueryCountResult, ProtocolError>

Frame.queryCount (“Query count”).

pub async fn select_option( &self, params: FrameSelectOptionParams, ) -> Result<FrameSelectOptionResult, ProtocolError>

Frame.selectOption (“Select option”).

pub async fn set_content( &self, params: FrameSetContentParams, ) -> Result<(), ProtocolError>

Frame.setContent (“Set content”).

pub async fn set_input_files( &self, params: FrameSetInputFilesParams, ) -> Result<(), ProtocolError>

Frame.setInputFiles (“Set input files”).

pub async fn tap(&self, params: FrameTapParams) -> Result<(), ProtocolError>

Frame.tap (“Tap”).

pub async fn text_content( &self, params: FrameTextContentParams, ) -> Result<FrameTextContentResult, ProtocolError>

Frame.textContent (“Get text content”).

pub async fn title(&self) -> Result<FrameTitleResult, ProtocolError>

Frame.title (“Get page title”).

pub async fn type(&self, params: FrameTypeParams) -> Result<(), ProtocolError>

Frame.type (“Type “{text}”“).

pub async fn uncheck( &self, params: FrameUncheckParams, ) -> Result<(), ProtocolError>

Frame.uncheck (“Uncheck”).

pub async fn wait_for_timeout( &self, params: FrameWaitForTimeoutParams, ) -> Result<(), ProtocolError>

Frame.waitForTimeout (“Wait for timeout”).

pub async fn wait_for_function( &self, params: FrameWaitForFunctionParams, ) -> Result<FrameWaitForFunctionResult, ProtocolError>

Frame.waitForFunction (“Wait for function”).

pub async fn wait_for_selector( &self, params: FrameWaitForSelectorParams, ) -> Result<FrameWaitForSelectorResult, ProtocolError>

Frame.waitForSelector (“Wait for selector”).

pub async fn expect( &self, params: FrameExpectParams, ) -> Result<(), ProtocolError>

Frame.expect (“Expect “{expression}”“).

Trait Implementations

impl ChannelType for Frame

const INTERFACE: &'static str = "Frame"

Interface name in the spec.

type Initializer = FrameInitializer

The initializer the driver sends in __create__.

type Event = FrameEvent

The events the interface can emit.

fn accepts(interface: &str) -> bool

Whether an object of interface can be used as this type (an ElementHandle is also a JSHandle).

fn from_channel(channel: Channel) -> Self

Wrap a channel.

fn channel(&self) -> &Channel

The underlying channel.

fn guid(&self) -> &str

The object’s guid.

fn initializer(&self) -> Result<Self::Initializer, ProtocolError>

The typed initializer the driver created this object with.

fn events(&self) -> EventStream<Self::Event>

Subscribe to this object’s events from now on.

impl Clone for Frame

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Frame

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.