#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
clippy::approx_constant,
clippy::type_complexity,
clippy::unreadable_literal
)]
extern crate gio_sys as gio;
extern crate glib_sys as glib;
extern crate gobject_sys as gobject;
extern crate gtk_sys as gtk;
extern crate javascriptcore_sys as java_script_core;
extern crate libc;
extern crate soup_sys as soup;
#[allow(unused_imports)]
use libc::{
c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE,
};
#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};
pub type WebKitConsoleMessageLevel = c_int;
pub const WEBKIT_CONSOLE_MESSAGE_LEVEL_INFO: WebKitConsoleMessageLevel = 0;
pub const WEBKIT_CONSOLE_MESSAGE_LEVEL_LOG: WebKitConsoleMessageLevel = 1;
pub const WEBKIT_CONSOLE_MESSAGE_LEVEL_WARNING: WebKitConsoleMessageLevel = 2;
pub const WEBKIT_CONSOLE_MESSAGE_LEVEL_ERROR: WebKitConsoleMessageLevel = 3;
pub const WEBKIT_CONSOLE_MESSAGE_LEVEL_DEBUG: WebKitConsoleMessageLevel = 4;
pub type WebKitConsoleMessageSource = c_int;
pub const WEBKIT_CONSOLE_MESSAGE_SOURCE_JAVASCRIPT: WebKitConsoleMessageSource = 0;
pub const WEBKIT_CONSOLE_MESSAGE_SOURCE_NETWORK: WebKitConsoleMessageSource = 1;
pub const WEBKIT_CONSOLE_MESSAGE_SOURCE_CONSOLE_API: WebKitConsoleMessageSource = 2;
pub const WEBKIT_CONSOLE_MESSAGE_SOURCE_SECURITY: WebKitConsoleMessageSource = 3;
pub const WEBKIT_CONSOLE_MESSAGE_SOURCE_OTHER: WebKitConsoleMessageSource = 4;
pub type WebKitContextMenuAction = c_int;
pub const WEBKIT_CONTEXT_MENU_ACTION_NO_ACTION: WebKitContextMenuAction = 0;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_LINK: WebKitContextMenuAction = 1;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_LINK_IN_NEW_WINDOW: WebKitContextMenuAction = 2;
pub const WEBKIT_CONTEXT_MENU_ACTION_DOWNLOAD_LINK_TO_DISK: WebKitContextMenuAction = 3;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY_LINK_TO_CLIPBOARD: WebKitContextMenuAction = 4;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_IMAGE_IN_NEW_WINDOW: WebKitContextMenuAction = 5;
pub const WEBKIT_CONTEXT_MENU_ACTION_DOWNLOAD_IMAGE_TO_DISK: WebKitContextMenuAction = 6;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY_IMAGE_TO_CLIPBOARD: WebKitContextMenuAction = 7;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY_IMAGE_URL_TO_CLIPBOARD: WebKitContextMenuAction = 8;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_FRAME_IN_NEW_WINDOW: WebKitContextMenuAction = 9;
pub const WEBKIT_CONTEXT_MENU_ACTION_GO_BACK: WebKitContextMenuAction = 10;
pub const WEBKIT_CONTEXT_MENU_ACTION_GO_FORWARD: WebKitContextMenuAction = 11;
pub const WEBKIT_CONTEXT_MENU_ACTION_STOP: WebKitContextMenuAction = 12;
pub const WEBKIT_CONTEXT_MENU_ACTION_RELOAD: WebKitContextMenuAction = 13;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY: WebKitContextMenuAction = 14;
pub const WEBKIT_CONTEXT_MENU_ACTION_CUT: WebKitContextMenuAction = 15;
pub const WEBKIT_CONTEXT_MENU_ACTION_PASTE: WebKitContextMenuAction = 16;
pub const WEBKIT_CONTEXT_MENU_ACTION_DELETE: WebKitContextMenuAction = 17;
pub const WEBKIT_CONTEXT_MENU_ACTION_SELECT_ALL: WebKitContextMenuAction = 18;
pub const WEBKIT_CONTEXT_MENU_ACTION_INPUT_METHODS: WebKitContextMenuAction = 19;
pub const WEBKIT_CONTEXT_MENU_ACTION_UNICODE: WebKitContextMenuAction = 20;
pub const WEBKIT_CONTEXT_MENU_ACTION_SPELLING_GUESS: WebKitContextMenuAction = 21;
pub const WEBKIT_CONTEXT_MENU_ACTION_NO_GUESSES_FOUND: WebKitContextMenuAction = 22;
pub const WEBKIT_CONTEXT_MENU_ACTION_IGNORE_SPELLING: WebKitContextMenuAction = 23;
pub const WEBKIT_CONTEXT_MENU_ACTION_LEARN_SPELLING: WebKitContextMenuAction = 24;
pub const WEBKIT_CONTEXT_MENU_ACTION_IGNORE_GRAMMAR: WebKitContextMenuAction = 25;
pub const WEBKIT_CONTEXT_MENU_ACTION_FONT_MENU: WebKitContextMenuAction = 26;
pub const WEBKIT_CONTEXT_MENU_ACTION_BOLD: WebKitContextMenuAction = 27;
pub const WEBKIT_CONTEXT_MENU_ACTION_ITALIC: WebKitContextMenuAction = 28;
pub const WEBKIT_CONTEXT_MENU_ACTION_UNDERLINE: WebKitContextMenuAction = 29;
pub const WEBKIT_CONTEXT_MENU_ACTION_OUTLINE: WebKitContextMenuAction = 30;
pub const WEBKIT_CONTEXT_MENU_ACTION_INSPECT_ELEMENT: WebKitContextMenuAction = 31;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_VIDEO_IN_NEW_WINDOW: WebKitContextMenuAction = 32;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_AUDIO_IN_NEW_WINDOW: WebKitContextMenuAction = 33;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY_VIDEO_LINK_TO_CLIPBOARD: WebKitContextMenuAction = 34;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY_AUDIO_LINK_TO_CLIPBOARD: WebKitContextMenuAction = 35;
pub const WEBKIT_CONTEXT_MENU_ACTION_TOGGLE_MEDIA_CONTROLS: WebKitContextMenuAction = 36;
pub const WEBKIT_CONTEXT_MENU_ACTION_TOGGLE_MEDIA_LOOP: WebKitContextMenuAction = 37;
pub const WEBKIT_CONTEXT_MENU_ACTION_ENTER_VIDEO_FULLSCREEN: WebKitContextMenuAction = 38;
pub const WEBKIT_CONTEXT_MENU_ACTION_MEDIA_PLAY: WebKitContextMenuAction = 39;
pub const WEBKIT_CONTEXT_MENU_ACTION_MEDIA_PAUSE: WebKitContextMenuAction = 40;
pub const WEBKIT_CONTEXT_MENU_ACTION_MEDIA_MUTE: WebKitContextMenuAction = 41;
pub const WEBKIT_CONTEXT_MENU_ACTION_DOWNLOAD_VIDEO_TO_DISK: WebKitContextMenuAction = 42;
pub const WEBKIT_CONTEXT_MENU_ACTION_DOWNLOAD_AUDIO_TO_DISK: WebKitContextMenuAction = 43;
pub const WEBKIT_CONTEXT_MENU_ACTION_INSERT_EMOJI: WebKitContextMenuAction = 44;
pub const WEBKIT_CONTEXT_MENU_ACTION_CUSTOM: WebKitContextMenuAction = 10000;
pub type WebKitFormSubmissionStep = c_int;
pub const WEBKIT_FORM_SUBMISSION_WILL_SEND_DOM_EVENT: WebKitFormSubmissionStep = 0;
pub const WEBKIT_FORM_SUBMISSION_WILL_COMPLETE: WebKitFormSubmissionStep = 1;
pub const WEBKIT_DOM_CSS_RULE_CHARSET_RULE: c_int = 2;
pub const WEBKIT_DOM_CSS_RULE_FONT_FACE_RULE: c_int = 5;
pub const WEBKIT_DOM_CSS_RULE_IMPORT_RULE: c_int = 3;
pub const WEBKIT_DOM_CSS_RULE_MEDIA_RULE: c_int = 4;
pub const WEBKIT_DOM_CSS_RULE_PAGE_RULE: c_int = 6;
pub const WEBKIT_DOM_CSS_RULE_STYLE_RULE: c_int = 1;
pub const WEBKIT_DOM_CSS_RULE_UNKNOWN_RULE: c_int = 0;
pub const WEBKIT_DOM_CSS_VALUE_CSS_CUSTOM: c_int = 3;
pub const WEBKIT_DOM_CSS_VALUE_CSS_INHERIT: c_int = 0;
pub const WEBKIT_DOM_CSS_VALUE_CSS_PRIMITIVE_VALUE: c_int = 1;
pub const WEBKIT_DOM_CSS_VALUE_CSS_VALUE_LIST: c_int = 2;
pub const WEBKIT_DOM_ELEMENT_ALLOW_KEYBOARD_INPUT: c_int = 1;
pub const WEBKIT_DOM_EVENT_AT_TARGET: c_int = 2;
pub const WEBKIT_DOM_EVENT_BLUR: c_int = 8192;
pub const WEBKIT_DOM_EVENT_BUBBLING_PHASE: c_int = 3;
pub const WEBKIT_DOM_EVENT_CAPTURING_PHASE: c_int = 1;
pub const WEBKIT_DOM_EVENT_CHANGE: c_int = 32768;
pub const WEBKIT_DOM_EVENT_CLICK: c_int = 64;
pub const WEBKIT_DOM_EVENT_DBLCLICK: c_int = 128;
pub const WEBKIT_DOM_EVENT_DRAGDROP: c_int = 2048;
pub const WEBKIT_DOM_EVENT_FOCUS: c_int = 4096;
pub const WEBKIT_DOM_EVENT_KEYDOWN: c_int = 256;
pub const WEBKIT_DOM_EVENT_KEYPRESS: c_int = 1024;
pub const WEBKIT_DOM_EVENT_KEYUP: c_int = 512;
pub const WEBKIT_DOM_EVENT_MOUSEDOWN: c_int = 1;
pub const WEBKIT_DOM_EVENT_MOUSEDRAG: c_int = 32;
pub const WEBKIT_DOM_EVENT_MOUSEMOVE: c_int = 16;
pub const WEBKIT_DOM_EVENT_MOUSEOUT: c_int = 8;
pub const WEBKIT_DOM_EVENT_MOUSEOVER: c_int = 4;
pub const WEBKIT_DOM_EVENT_MOUSEUP: c_int = 2;
pub const WEBKIT_DOM_EVENT_NONE: c_int = 0;
pub const WEBKIT_DOM_EVENT_SELECT: c_int = 16384;
pub const WEBKIT_DOM_KEYBOARD_EVENT_KEY_LOCATION_LEFT: c_int = 1;
pub const WEBKIT_DOM_KEYBOARD_EVENT_KEY_LOCATION_NUMPAD: c_int = 3;
pub const WEBKIT_DOM_KEYBOARD_EVENT_KEY_LOCATION_RIGHT: c_int = 2;
pub const WEBKIT_DOM_KEYBOARD_EVENT_KEY_LOCATION_STANDARD: c_int = 0;
pub const WEBKIT_DOM_NODE_ATTRIBUTE_NODE: c_int = 2;
pub const WEBKIT_DOM_NODE_CDATA_SECTION_NODE: c_int = 4;
pub const WEBKIT_DOM_NODE_COMMENT_NODE: c_int = 8;
pub const WEBKIT_DOM_NODE_DOCUMENT_FRAGMENT_NODE: c_int = 11;
pub const WEBKIT_DOM_NODE_DOCUMENT_NODE: c_int = 9;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_CONTAINED_BY: c_int = 16;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_CONTAINS: c_int = 8;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_DISCONNECTED: c_int = 1;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_FOLLOWING: c_int = 4;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: c_int = 32;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_PRECEDING: c_int = 2;
pub const WEBKIT_DOM_NODE_DOCUMENT_TYPE_NODE: c_int = 10;
pub const WEBKIT_DOM_NODE_ELEMENT_NODE: c_int = 1;
pub const WEBKIT_DOM_NODE_ENTITY_NODE: c_int = 6;
pub const WEBKIT_DOM_NODE_ENTITY_REFERENCE_NODE: c_int = 5;
pub const WEBKIT_DOM_NODE_FILTER_ACCEPT: c_int = 1;
pub const WEBKIT_DOM_NODE_FILTER_REJECT: c_int = 2;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_ALL: c_uint = 4294967295;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_ATTRIBUTE: c_int = 2;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_CDATA_SECTION: c_int = 8;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_COMMENT: c_int = 128;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_DOCUMENT: c_int = 256;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_DOCUMENT_FRAGMENT: c_int = 1024;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_DOCUMENT_TYPE: c_int = 512;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_ELEMENT: c_int = 1;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_ENTITY: c_int = 32;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_ENTITY_REFERENCE: c_int = 16;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_NOTATION: c_int = 2048;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_PROCESSING_INSTRUCTION: c_int = 64;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_TEXT: c_int = 4;
pub const WEBKIT_DOM_NODE_FILTER_SKIP: c_int = 3;
pub const WEBKIT_DOM_NODE_PROCESSING_INSTRUCTION_NODE: c_int = 7;
pub const WEBKIT_DOM_NODE_TEXT_NODE: c_int = 3;
pub const WEBKIT_DOM_RANGE_END_TO_END: c_int = 2;
pub const WEBKIT_DOM_RANGE_END_TO_START: c_int = 3;
pub const WEBKIT_DOM_RANGE_NODE_AFTER: c_int = 1;
pub const WEBKIT_DOM_RANGE_NODE_BEFORE: c_int = 0;
pub const WEBKIT_DOM_RANGE_NODE_BEFORE_AND_AFTER: c_int = 2;
pub const WEBKIT_DOM_RANGE_NODE_INSIDE: c_int = 3;
pub const WEBKIT_DOM_RANGE_START_TO_END: c_int = 1;
pub const WEBKIT_DOM_RANGE_START_TO_START: c_int = 0;
pub const WEBKIT_DOM_XPATH_RESULT_ANY_TYPE: c_int = 0;
pub const WEBKIT_DOM_XPATH_RESULT_ANY_UNORDERED_NODE_TYPE: c_int = 8;
pub const WEBKIT_DOM_XPATH_RESULT_BOOLEAN_TYPE: c_int = 3;
pub const WEBKIT_DOM_XPATH_RESULT_FIRST_ORDERED_NODE_TYPE: c_int = 9;
pub const WEBKIT_DOM_XPATH_RESULT_NUMBER_TYPE: c_int = 1;
pub const WEBKIT_DOM_XPATH_RESULT_ORDERED_NODE_ITERATOR_TYPE: c_int = 5;
pub const WEBKIT_DOM_XPATH_RESULT_ORDERED_NODE_SNAPSHOT_TYPE: c_int = 7;
pub const WEBKIT_DOM_XPATH_RESULT_STRING_TYPE: c_int = 2;
pub const WEBKIT_DOM_XPATH_RESULT_UNORDERED_NODE_ITERATOR_TYPE: c_int = 4;
pub const WEBKIT_DOM_XPATH_RESULT_UNORDERED_NODE_SNAPSHOT_TYPE: c_int = 6;
pub type WebKitHitTestResultContext = c_uint;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT: WebKitHitTestResultContext = 2;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK: WebKitHitTestResultContext = 4;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE: WebKitHitTestResultContext = 8;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA: WebKitHitTestResultContext = 16;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE: WebKitHitTestResultContext = 32;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_SCROLLBAR: WebKitHitTestResultContext = 64;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_SELECTION: WebKitHitTestResultContext = 128;
pub type WebKitWebExtensionInitializeFunction =
Option<unsafe extern "C" fn(*mut WebKitWebExtension)>;
pub type WebKitWebExtensionInitializeWithUserDataFunction =
Option<unsafe extern "C" fn(*mut WebKitWebExtension, *const glib::GVariant)>;
#[repr(C)]
pub struct WebKitConsoleMessage(c_void);
impl ::std::fmt::Debug for WebKitConsoleMessage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitConsoleMessage @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitContextMenuClass {
pub parent_class: gobject::GObjectClass,
pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}
impl ::std::fmt::Debug for WebKitContextMenuClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitContextMenuClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_webkit_reserved0", &self._webkit_reserved0)
.field("_webkit_reserved1", &self._webkit_reserved1)
.field("_webkit_reserved2", &self._webkit_reserved2)
.field("_webkit_reserved3", &self._webkit_reserved3)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitContextMenuItemClass {
pub parent_class: gobject::GInitiallyUnownedClass,
pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}
impl ::std::fmt::Debug for WebKitContextMenuItemClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitContextMenuItemClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.field("_webkit_reserved0", &self._webkit_reserved0)
.field("_webkit_reserved1", &self._webkit_reserved1)
.field("_webkit_reserved2", &self._webkit_reserved2)
.field("_webkit_reserved3", &self._webkit_reserved3)
.finish()
}
}
#[repr(C)]
pub struct _WebKitContextMenuItemPrivate(c_void);
pub type WebKitContextMenuItemPrivate = *mut _WebKitContextMenuItemPrivate;
#[repr(C)]
pub struct _WebKitContextMenuPrivate(c_void);
pub type WebKitContextMenuPrivate = *mut _WebKitContextMenuPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMAttrClass {
pub parent_class: WebKitDOMNodeClass,
}
impl ::std::fmt::Debug for WebKitDOMAttrClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMAttrClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMBlobClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMBlobClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMBlobClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCDATASectionClass {
pub parent_class: WebKitDOMTextClass,
}
impl ::std::fmt::Debug for WebKitDOMCDATASectionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMCDATASectionClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCSSRuleClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMCSSRuleClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMCSSRuleClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCSSRuleListClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMCSSRuleListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMCSSRuleListClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCSSStyleDeclarationClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMCSSStyleDeclarationClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMCSSStyleDeclarationClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCSSStyleSheetClass {
pub parent_class: WebKitDOMStyleSheetClass,
}
impl ::std::fmt::Debug for WebKitDOMCSSStyleSheetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMCSSStyleSheetClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCSSValueClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMCSSValueClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMCSSValueClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCharacterDataClass {
pub parent_class: WebKitDOMNodeClass,
}
impl ::std::fmt::Debug for WebKitDOMCharacterDataClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMCharacterDataClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMClientRectClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMClientRectClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMClientRectClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMClientRectListClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMClientRectListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMClientRectListClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCommentClass {
pub parent_class: WebKitDOMCharacterDataClass,
}
impl ::std::fmt::Debug for WebKitDOMCommentClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMCommentClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDOMImplementationClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMDOMImplementationClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMDOMImplementationClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDOMSelectionClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMDOMSelectionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMDOMSelectionClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDOMTokenListClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMDOMTokenListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMDOMTokenListClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDOMWindowClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMDOMWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMDOMWindowClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDocumentClass {
pub parent_class: WebKitDOMNodeClass,
}
impl ::std::fmt::Debug for WebKitDOMDocumentClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMDocumentClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDocumentFragmentClass {
pub parent_class: WebKitDOMNodeClass,
}
impl ::std::fmt::Debug for WebKitDOMDocumentFragmentClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMDocumentFragmentClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDocumentTypeClass {
pub parent_class: WebKitDOMNodeClass,
}
impl ::std::fmt::Debug for WebKitDOMDocumentTypeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMDocumentTypeClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMElementClass {
pub parent_class: WebKitDOMNodeClass,
}
impl ::std::fmt::Debug for WebKitDOMElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMElementClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMEntityReferenceClass {
pub parent_class: WebKitDOMNodeClass,
}
impl ::std::fmt::Debug for WebKitDOMEntityReferenceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMEntityReferenceClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMEventClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMEventClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMEventClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMEventTargetIface {
pub gIface: gobject::GTypeInterface,
pub dispatch_event: Option<
unsafe extern "C" fn(
*mut WebKitDOMEventTarget,
*mut WebKitDOMEvent,
*mut *mut glib::GError,
) -> gboolean,
>,
pub add_event_listener: Option<
unsafe extern "C" fn(
*mut WebKitDOMEventTarget,
*const c_char,
*mut gobject::GClosure,
gboolean,
) -> gboolean,
>,
pub remove_event_listener: Option<
unsafe extern "C" fn(
*mut WebKitDOMEventTarget,
*const c_char,
*mut gobject::GClosure,
gboolean,
) -> gboolean,
>,
pub _webkitdom_reserved0: Option<unsafe extern "C" fn()>,
pub _webkitdom_reserved1: Option<unsafe extern "C" fn()>,
pub _webkitdom_reserved2: Option<unsafe extern "C" fn()>,
pub _webkitdom_reserved3: Option<unsafe extern "C" fn()>,
}
impl ::std::fmt::Debug for WebKitDOMEventTargetIface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMEventTargetIface @ {:?}",
self as *const _
))
.field("gIface", &self.gIface)
.field("dispatch_event", &self.dispatch_event)
.field("add_event_listener", &self.add_event_listener)
.field("remove_event_listener", &self.remove_event_listener)
.field("_webkitdom_reserved0", &self._webkitdom_reserved0)
.field("_webkitdom_reserved1", &self._webkitdom_reserved1)
.field("_webkitdom_reserved2", &self._webkitdom_reserved2)
.field("_webkitdom_reserved3", &self._webkitdom_reserved3)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMFileClass {
pub parent_class: WebKitDOMBlobClass,
}
impl ::std::fmt::Debug for WebKitDOMFileClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMFileClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMFileListClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMFileListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMFileListClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLAnchorElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLAnchorElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLAnchorElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLAppletElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLAppletElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLAppletElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLAreaElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLAreaElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLAreaElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLBRElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLBRElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLBRElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLBaseElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLBaseElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLBaseElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLBaseFontElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLBaseFontElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLBaseFontElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLBodyElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLBodyElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLBodyElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLButtonElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLButtonElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLButtonElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLCanvasElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLCanvasElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLCanvasElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLCollectionClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLCollectionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLCollectionClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLDListElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLDListElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLDListElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLDirectoryElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLDirectoryElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLDirectoryElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLDivElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLDivElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLDivElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLDocumentClass {
pub parent_class: WebKitDOMDocumentClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLDocumentClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLDocumentClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLElementClass {
pub parent_class: WebKitDOMElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLEmbedElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLEmbedElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLEmbedElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLFieldSetElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLFieldSetElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLFieldSetElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLFontElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLFontElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLFontElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLFormElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLFormElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLFormElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLFrameElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLFrameElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLFrameElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLFrameSetElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLFrameSetElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLFrameSetElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLHRElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLHRElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLHRElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLHeadElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLHeadElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLHeadElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLHeadingElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLHeadingElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLHeadingElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLHtmlElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLHtmlElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLHtmlElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLIFrameElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLIFrameElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLIFrameElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLImageElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLImageElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLImageElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLInputElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLInputElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLInputElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLLIElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLLIElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLLIElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLLabelElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLLabelElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLLabelElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLLegendElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLLegendElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLLegendElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLLinkElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLLinkElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLLinkElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLMapElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLMapElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLMapElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLMarqueeElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLMarqueeElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLMarqueeElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLMenuElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLMenuElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLMenuElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLMetaElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLMetaElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLMetaElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLModElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLModElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLModElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLOListElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLOListElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLOListElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLObjectElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLObjectElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLObjectElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLOptGroupElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLOptGroupElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLOptGroupElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLOptionElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLOptionElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLOptionElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLOptionsCollectionClass {
pub parent_class: WebKitDOMHTMLCollectionClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLOptionsCollectionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLOptionsCollectionClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLParagraphElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLParagraphElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLParagraphElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLParamElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLParamElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLParamElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLPreElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLPreElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLPreElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLQuoteElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLQuoteElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLQuoteElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLScriptElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLScriptElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLScriptElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLSelectElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLSelectElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLSelectElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLStyleElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLStyleElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLStyleElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableCaptionElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableCaptionElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableCaptionElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableCellElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableCellElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableCellElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableColElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableColElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableColElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableRowElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableRowElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableRowElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableSectionElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableSectionElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableSectionElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTextAreaElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTextAreaElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTextAreaElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTitleElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTitleElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTitleElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLUListElementClass {
pub parent_class: WebKitDOMHTMLElementClass,
}
impl ::std::fmt::Debug for WebKitDOMHTMLUListElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLUListElementClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMKeyboardEventClass {
pub parent_class: WebKitDOMUIEventClass,
}
impl ::std::fmt::Debug for WebKitDOMKeyboardEventClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMKeyboardEventClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMMediaListClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMMediaListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMMediaListClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMMouseEventClass {
pub parent_class: WebKitDOMUIEventClass,
}
impl ::std::fmt::Debug for WebKitDOMMouseEventClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMMouseEventClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMNamedNodeMapClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMNamedNodeMapClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMNamedNodeMapClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMNodeClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMNodeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMNodeClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMNodeFilterIface {
pub gIface: gobject::GTypeInterface,
pub accept_node:
Option<unsafe extern "C" fn(*mut WebKitDOMNodeFilter, *mut WebKitDOMNode) -> c_short>,
pub _webkitdom_reserved0: Option<unsafe extern "C" fn()>,
pub _webkitdom_reserved1: Option<unsafe extern "C" fn()>,
pub _webkitdom_reserved2: Option<unsafe extern "C" fn()>,
pub _webkitdom_reserved3: Option<unsafe extern "C" fn()>,
}
impl ::std::fmt::Debug for WebKitDOMNodeFilterIface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMNodeFilterIface @ {:?}",
self as *const _
))
.field("gIface", &self.gIface)
.field("accept_node", &self.accept_node)
.field("_webkitdom_reserved0", &self._webkitdom_reserved0)
.field("_webkitdom_reserved1", &self._webkitdom_reserved1)
.field("_webkitdom_reserved2", &self._webkitdom_reserved2)
.field("_webkitdom_reserved3", &self._webkitdom_reserved3)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMNodeIteratorClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMNodeIteratorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMNodeIteratorClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMNodeListClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMNodeListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMNodeListClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMObjectClass {
pub parentClass: gobject::GObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMObjectClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMObjectClass @ {:?}", self as *const _))
.field("parentClass", &self.parentClass)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMProcessingInstructionClass {
pub parent_class: WebKitDOMCharacterDataClass,
}
impl ::std::fmt::Debug for WebKitDOMProcessingInstructionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMProcessingInstructionClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMRangeClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMRangeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMRangeClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMStyleSheetClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMStyleSheetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMStyleSheetClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMStyleSheetListClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMStyleSheetListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMStyleSheetListClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMTextClass {
pub parent_class: WebKitDOMCharacterDataClass,
}
impl ::std::fmt::Debug for WebKitDOMTextClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMTextClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMTreeWalkerClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMTreeWalkerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMTreeWalkerClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMUIEventClass {
pub parent_class: WebKitDOMEventClass,
}
impl ::std::fmt::Debug for WebKitDOMUIEventClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMUIEventClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMWheelEventClass {
pub parent_class: WebKitDOMMouseEventClass,
}
impl ::std::fmt::Debug for WebKitDOMWheelEventClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMWheelEventClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMXPathExpressionClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMXPathExpressionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMXPathExpressionClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMXPathNSResolverIface {
pub gIface: gobject::GTypeInterface,
pub lookup_namespace_uri:
Option<unsafe extern "C" fn(*mut WebKitDOMXPathNSResolver, *const c_char) -> *mut c_char>,
pub _webkitdom_reserved0: Option<unsafe extern "C" fn()>,
pub _webkitdom_reserved1: Option<unsafe extern "C" fn()>,
pub _webkitdom_reserved2: Option<unsafe extern "C" fn()>,
pub _webkitdom_reserved3: Option<unsafe extern "C" fn()>,
}
impl ::std::fmt::Debug for WebKitDOMXPathNSResolverIface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMXPathNSResolverIface @ {:?}",
self as *const _
))
.field("gIface", &self.gIface)
.field("lookup_namespace_uri", &self.lookup_namespace_uri)
.field("_webkitdom_reserved0", &self._webkitdom_reserved0)
.field("_webkitdom_reserved1", &self._webkitdom_reserved1)
.field("_webkitdom_reserved2", &self._webkitdom_reserved2)
.field("_webkitdom_reserved3", &self._webkitdom_reserved3)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMXPathResultClass {
pub parent_class: WebKitDOMObjectClass,
}
impl ::std::fmt::Debug for WebKitDOMXPathResultClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMXPathResultClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitFrameClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for WebKitFrameClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitFrameClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _WebKitFramePrivate(c_void);
pub type WebKitFramePrivate = *mut _WebKitFramePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitHitTestResultClass {
pub parent_class: gobject::GObjectClass,
pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}
impl ::std::fmt::Debug for WebKitHitTestResultClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitHitTestResultClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.field("_webkit_reserved0", &self._webkit_reserved0)
.field("_webkit_reserved1", &self._webkit_reserved1)
.field("_webkit_reserved2", &self._webkit_reserved2)
.field("_webkit_reserved3", &self._webkit_reserved3)
.finish()
}
}
#[repr(C)]
pub struct _WebKitHitTestResultPrivate(c_void);
pub type WebKitHitTestResultPrivate = *mut _WebKitHitTestResultPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitScriptWorldClass {
pub parent_class: gobject::GObjectClass,
pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}
impl ::std::fmt::Debug for WebKitScriptWorldClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitScriptWorldClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_webkit_reserved0", &self._webkit_reserved0)
.field("_webkit_reserved1", &self._webkit_reserved1)
.field("_webkit_reserved2", &self._webkit_reserved2)
.field("_webkit_reserved3", &self._webkit_reserved3)
.finish()
}
}
#[repr(C)]
pub struct _WebKitScriptWorldPrivate(c_void);
pub type WebKitScriptWorldPrivate = *mut _WebKitScriptWorldPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitURIRequestClass {
pub parent_class: gobject::GObjectClass,
pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}
impl ::std::fmt::Debug for WebKitURIRequestClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitURIRequestClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_webkit_reserved0", &self._webkit_reserved0)
.field("_webkit_reserved1", &self._webkit_reserved1)
.field("_webkit_reserved2", &self._webkit_reserved2)
.field("_webkit_reserved3", &self._webkit_reserved3)
.finish()
}
}
#[repr(C)]
pub struct _WebKitURIRequestPrivate(c_void);
pub type WebKitURIRequestPrivate = *mut _WebKitURIRequestPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitURIResponseClass {
pub parent_class: gobject::GObjectClass,
pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}
impl ::std::fmt::Debug for WebKitURIResponseClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitURIResponseClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_webkit_reserved0", &self._webkit_reserved0)
.field("_webkit_reserved1", &self._webkit_reserved1)
.field("_webkit_reserved2", &self._webkit_reserved2)
.field("_webkit_reserved3", &self._webkit_reserved3)
.finish()
}
}
#[repr(C)]
pub struct _WebKitURIResponsePrivate(c_void);
pub type WebKitURIResponsePrivate = *mut _WebKitURIResponsePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitWebEditorClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for WebKitWebEditorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitWebEditorClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _WebKitWebEditorPrivate(c_void);
pub type WebKitWebEditorPrivate = *mut _WebKitWebEditorPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitWebExtensionClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for WebKitWebExtensionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitWebExtensionClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _WebKitWebExtensionPrivate(c_void);
pub type WebKitWebExtensionPrivate = *mut _WebKitWebExtensionPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitWebHitTestResultClass {
pub parent_class: WebKitHitTestResultClass,
pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}
impl ::std::fmt::Debug for WebKitWebHitTestResultClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitWebHitTestResultClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.field("_webkit_reserved0", &self._webkit_reserved0)
.field("_webkit_reserved1", &self._webkit_reserved1)
.field("_webkit_reserved2", &self._webkit_reserved2)
.field("_webkit_reserved3", &self._webkit_reserved3)
.finish()
}
}
#[repr(C)]
pub struct _WebKitWebHitTestResultPrivate(c_void);
pub type WebKitWebHitTestResultPrivate = *mut _WebKitWebHitTestResultPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitWebPageClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for WebKitWebPageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitWebPageClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _WebKitWebPagePrivate(c_void);
pub type WebKitWebPagePrivate = *mut _WebKitWebPagePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _WebKitContextMenu {
pub parent: gobject::GObject,
pub priv_: *mut WebKitContextMenuPrivate,
}
impl ::std::fmt::Debug for _WebKitContextMenu {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("_WebKitContextMenu @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _WebKitContextMenuItem {
pub parent: gobject::GInitiallyUnowned,
pub priv_: *mut WebKitContextMenuItemPrivate,
}
impl ::std::fmt::Debug for _WebKitContextMenuItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("_WebKitContextMenuItem @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
pub struct WebKitContextMenu(c_void);
impl ::std::fmt::Debug for WebKitContextMenu {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitContextMenu @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct WebKitContextMenuItem(c_void);
impl ::std::fmt::Debug for WebKitContextMenuItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitContextMenuItem @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMAttr {
pub parent_instance: WebKitDOMNode,
}
impl ::std::fmt::Debug for WebKitDOMAttr {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMAttr @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMBlob {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMBlob {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMBlob @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCDATASection {
pub parent_instance: WebKitDOMText,
}
impl ::std::fmt::Debug for WebKitDOMCDATASection {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMCDATASection @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCSSRule {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMCSSRule {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMCSSRule @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCSSRuleList {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMCSSRuleList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMCSSRuleList @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCSSStyleDeclaration {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMCSSStyleDeclaration {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMCSSStyleDeclaration @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCSSStyleSheet {
pub parent_instance: WebKitDOMStyleSheet,
}
impl ::std::fmt::Debug for WebKitDOMCSSStyleSheet {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMCSSStyleSheet @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCSSValue {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMCSSValue {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMCSSValue @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMCharacterData {
pub parent_instance: WebKitDOMNode,
}
impl ::std::fmt::Debug for WebKitDOMCharacterData {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMCharacterData @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMClientRect {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMClientRect {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMClientRect @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMClientRectList {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMClientRectList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMClientRectList @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMComment {
pub parent_instance: WebKitDOMCharacterData,
}
impl ::std::fmt::Debug for WebKitDOMComment {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMComment @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDOMImplementation {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMDOMImplementation {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMDOMImplementation @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDOMSelection {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMDOMSelection {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMDOMSelection @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDOMTokenList {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMDOMTokenList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMDOMTokenList @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDOMWindow {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMDOMWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMDOMWindow @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDocument {
pub parent_instance: WebKitDOMNode,
}
impl ::std::fmt::Debug for WebKitDOMDocument {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMDocument @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDocumentFragment {
pub parent_instance: WebKitDOMNode,
}
impl ::std::fmt::Debug for WebKitDOMDocumentFragment {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMDocumentFragment @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMDocumentType {
pub parent_instance: WebKitDOMNode,
}
impl ::std::fmt::Debug for WebKitDOMDocumentType {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMDocumentType @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMElement {
pub parent_instance: WebKitDOMNode,
}
impl ::std::fmt::Debug for WebKitDOMElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMElement @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMEntityReference {
pub parent_instance: WebKitDOMNode,
}
impl ::std::fmt::Debug for WebKitDOMEntityReference {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMEntityReference @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMEvent {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMEvent @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMFile {
pub parent_instance: WebKitDOMBlob,
}
impl ::std::fmt::Debug for WebKitDOMFile {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMFile @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMFileList {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMFileList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMFileList @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLAnchorElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLAnchorElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLAnchorElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLAppletElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLAppletElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLAppletElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLAreaElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLAreaElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLAreaElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLBRElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLBRElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMHTMLBRElement @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLBaseElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLBaseElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLBaseElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLBaseFontElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLBaseFontElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLBaseFontElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLBodyElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLBodyElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLBodyElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLButtonElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLButtonElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLButtonElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLCanvasElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLCanvasElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLCanvasElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLCollection {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMHTMLCollection {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMHTMLCollection @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLDListElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLDListElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLDListElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLDirectoryElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLDirectoryElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLDirectoryElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLDivElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLDivElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMHTMLDivElement @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLDocument {
pub parent_instance: WebKitDOMDocument,
}
impl ::std::fmt::Debug for WebKitDOMHTMLDocument {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMHTMLDocument @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLElement {
pub parent_instance: WebKitDOMElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMHTMLElement @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLEmbedElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLEmbedElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLEmbedElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLFieldSetElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLFieldSetElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLFieldSetElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLFontElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLFontElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLFontElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLFormElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLFormElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLFormElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLFrameElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLFrameElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLFrameElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLFrameSetElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLFrameSetElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLFrameSetElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLHRElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLHRElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMHTMLHRElement @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLHeadElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLHeadElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLHeadElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLHeadingElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLHeadingElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLHeadingElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLHtmlElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLHtmlElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLHtmlElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLIFrameElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLIFrameElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLIFrameElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLImageElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLImageElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLImageElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLInputElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLInputElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLInputElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLLIElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLLIElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMHTMLLIElement @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLLabelElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLLabelElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLLabelElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLLegendElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLLegendElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLLegendElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLLinkElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLLinkElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLLinkElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLMapElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLMapElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMHTMLMapElement @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLMarqueeElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLMarqueeElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLMarqueeElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLMenuElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLMenuElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLMenuElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLMetaElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLMetaElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLMetaElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLModElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLModElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMHTMLModElement @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLOListElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLOListElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLOListElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLObjectElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLObjectElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLObjectElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLOptGroupElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLOptGroupElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLOptGroupElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLOptionElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLOptionElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLOptionElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLOptionsCollection {
pub parent_instance: WebKitDOMHTMLCollection,
}
impl ::std::fmt::Debug for WebKitDOMHTMLOptionsCollection {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLOptionsCollection @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLParagraphElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLParagraphElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLParagraphElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLParamElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLParamElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLParamElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLPreElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLPreElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMHTMLPreElement @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLQuoteElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLQuoteElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLQuoteElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLScriptElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLScriptElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLScriptElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLSelectElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLSelectElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLSelectElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLStyleElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLStyleElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLStyleElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableCaptionElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableCaptionElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableCaptionElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableCellElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableCellElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableCellElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableColElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableColElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableColElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableRowElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableRowElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableRowElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTableSectionElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTableSectionElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTableSectionElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTextAreaElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTextAreaElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTextAreaElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLTitleElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLTitleElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLTitleElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMHTMLUListElement {
pub parent_instance: WebKitDOMHTMLElement,
}
impl ::std::fmt::Debug for WebKitDOMHTMLUListElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMHTMLUListElement @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMKeyboardEvent {
pub parent_instance: WebKitDOMUIEvent,
}
impl ::std::fmt::Debug for WebKitDOMKeyboardEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMKeyboardEvent @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMMediaList {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMMediaList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMMediaList @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMMouseEvent {
pub parent_instance: WebKitDOMUIEvent,
}
impl ::std::fmt::Debug for WebKitDOMMouseEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMMouseEvent @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMNamedNodeMap {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMNamedNodeMap {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMNamedNodeMap @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMNode {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMNode @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMNodeIterator {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMNodeIterator {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMNodeIterator @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMNodeList {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMNodeList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMNodeList @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMObject {
pub parentInstance: gobject::GObject,
pub coreObject: gpointer,
}
impl ::std::fmt::Debug for WebKitDOMObject {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMObject @ {:?}", self as *const _))
.field("parentInstance", &self.parentInstance)
.field("coreObject", &self.coreObject)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMProcessingInstruction {
pub parent_instance: WebKitDOMCharacterData,
}
impl ::std::fmt::Debug for WebKitDOMProcessingInstruction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMProcessingInstruction @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMRange {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMRange {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMRange @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMStyleSheet {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMStyleSheet {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMStyleSheet @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMStyleSheetList {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMStyleSheetList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMStyleSheetList @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMText {
pub parent_instance: WebKitDOMCharacterData,
}
impl ::std::fmt::Debug for WebKitDOMText {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMText @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMTreeWalker {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMTreeWalker {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMTreeWalker @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMUIEvent {
pub parent_instance: WebKitDOMEvent,
}
impl ::std::fmt::Debug for WebKitDOMUIEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMUIEvent @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMWheelEvent {
pub parent_instance: WebKitDOMMouseEvent,
}
impl ::std::fmt::Debug for WebKitDOMWheelEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMWheelEvent @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMXPathExpression {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMXPathExpression {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"WebKitDOMXPathExpression @ {:?}",
self as *const _
))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitDOMXPathResult {
pub parent_instance: WebKitDOMObject,
}
impl ::std::fmt::Debug for WebKitDOMXPathResult {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitDOMXPathResult @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitFrame {
pub parent: gobject::GObject,
pub priv_: *mut WebKitFramePrivate,
}
impl ::std::fmt::Debug for WebKitFrame {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitFrame @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitHitTestResult {
pub parent: gobject::GObject,
pub priv_: *mut WebKitHitTestResultPrivate,
}
impl ::std::fmt::Debug for WebKitHitTestResult {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitHitTestResult @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitScriptWorld {
pub parent: gobject::GObject,
pub priv_: *mut WebKitScriptWorldPrivate,
}
impl ::std::fmt::Debug for WebKitScriptWorld {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitScriptWorld @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitURIRequest {
pub parent: gobject::GObject,
pub priv_: *mut WebKitURIRequestPrivate,
}
impl ::std::fmt::Debug for WebKitURIRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitURIRequest @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitURIResponse {
pub parent: gobject::GObject,
pub priv_: *mut WebKitURIResponsePrivate,
}
impl ::std::fmt::Debug for WebKitURIResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitURIResponse @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitWebEditor {
pub parent: gobject::GObject,
pub priv_: *mut WebKitWebEditorPrivate,
}
impl ::std::fmt::Debug for WebKitWebEditor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitWebEditor @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitWebExtension {
pub parent: gobject::GObject,
pub priv_: *mut WebKitWebExtensionPrivate,
}
impl ::std::fmt::Debug for WebKitWebExtension {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitWebExtension @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitWebHitTestResult {
pub parent: WebKitHitTestResult,
pub priv_: *mut WebKitWebHitTestResultPrivate,
}
impl ::std::fmt::Debug for WebKitWebHitTestResult {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitWebHitTestResult @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WebKitWebPage {
pub parent: gobject::GObject,
pub priv_: *mut WebKitWebPagePrivate,
}
impl ::std::fmt::Debug for WebKitWebPage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("WebKitWebPage @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
pub struct WebKitDOMEventTarget(c_void);
impl ::std::fmt::Debug for WebKitDOMEventTarget {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "WebKitDOMEventTarget @ {:?}", self as *const _)
}
}
#[repr(C)]
pub struct WebKitDOMNodeFilter(c_void);
impl ::std::fmt::Debug for WebKitDOMNodeFilter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "WebKitDOMNodeFilter @ {:?}", self as *const _)
}
}
#[repr(C)]
pub struct WebKitDOMXPathNSResolver(c_void);
impl ::std::fmt::Debug for WebKitDOMXPathNSResolver {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "WebKitDOMXPathNSResolver @ {:?}", self as *const _)
}
}
extern "C" {
pub fn webkit_console_message_level_get_type() -> GType;
pub fn webkit_console_message_source_get_type() -> GType;
pub fn webkit_form_submission_step_get_type() -> GType;
pub fn webkit_console_message_get_type() -> GType;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_console_message_copy(
console_message: *mut WebKitConsoleMessage,
) -> *mut WebKitConsoleMessage;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_console_message_free(console_message: *mut WebKitConsoleMessage);
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_console_message_get_level(
console_message: *mut WebKitConsoleMessage,
) -> WebKitConsoleMessageLevel;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_console_message_get_line(console_message: *mut WebKitConsoleMessage) -> c_uint;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_console_message_get_source(
console_message: *mut WebKitConsoleMessage,
) -> WebKitConsoleMessageSource;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_console_message_get_source_id(
console_message: *mut WebKitConsoleMessage,
) -> *const c_char;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_console_message_get_text(
console_message: *mut WebKitConsoleMessage,
) -> *const c_char;
pub fn webkit_context_menu_get_type() -> GType;
pub fn webkit_context_menu_new() -> *mut WebKitContextMenu;
pub fn webkit_context_menu_new_with_items(items: *mut glib::GList) -> *mut WebKitContextMenu;
pub fn webkit_context_menu_append(
menu: *mut WebKitContextMenu,
item: *mut WebKitContextMenuItem,
);
pub fn webkit_context_menu_first(menu: *mut WebKitContextMenu) -> *mut WebKitContextMenuItem;
pub fn webkit_context_menu_get_item_at_position(
menu: *mut WebKitContextMenu,
position: c_uint,
) -> *mut WebKitContextMenuItem;
pub fn webkit_context_menu_get_items(menu: *mut WebKitContextMenu) -> *mut glib::GList;
pub fn webkit_context_menu_get_n_items(menu: *mut WebKitContextMenu) -> c_uint;
#[cfg(any(feature = "v2_8", feature = "dox"))]
pub fn webkit_context_menu_get_user_data(menu: *mut WebKitContextMenu) -> *mut glib::GVariant;
pub fn webkit_context_menu_insert(
menu: *mut WebKitContextMenu,
item: *mut WebKitContextMenuItem,
position: c_int,
);
pub fn webkit_context_menu_last(menu: *mut WebKitContextMenu) -> *mut WebKitContextMenuItem;
pub fn webkit_context_menu_move_item(
menu: *mut WebKitContextMenu,
item: *mut WebKitContextMenuItem,
position: c_int,
);
pub fn webkit_context_menu_prepend(
menu: *mut WebKitContextMenu,
item: *mut WebKitContextMenuItem,
);
pub fn webkit_context_menu_remove(
menu: *mut WebKitContextMenu,
item: *mut WebKitContextMenuItem,
);
pub fn webkit_context_menu_remove_all(menu: *mut WebKitContextMenu);
#[cfg(any(feature = "v2_8", feature = "dox"))]
pub fn webkit_context_menu_set_user_data(
menu: *mut WebKitContextMenu,
user_data: *mut glib::GVariant,
);
pub fn webkit_context_menu_item_get_type() -> GType;
pub fn webkit_context_menu_item_new(action: *mut gtk::GtkAction) -> *mut WebKitContextMenuItem;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_context_menu_item_new_from_gaction(
action: *mut gio::GAction,
label: *const c_char,
target: *mut glib::GVariant,
) -> *mut WebKitContextMenuItem;
pub fn webkit_context_menu_item_new_from_stock_action(
action: WebKitContextMenuAction,
) -> *mut WebKitContextMenuItem;
pub fn webkit_context_menu_item_new_from_stock_action_with_label(
action: WebKitContextMenuAction,
label: *const c_char,
) -> *mut WebKitContextMenuItem;
pub fn webkit_context_menu_item_new_separator() -> *mut WebKitContextMenuItem;
pub fn webkit_context_menu_item_new_with_submenu(
label: *const c_char,
submenu: *mut WebKitContextMenu,
) -> *mut WebKitContextMenuItem;
pub fn webkit_context_menu_item_get_action(
item: *mut WebKitContextMenuItem,
) -> *mut gtk::GtkAction;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_context_menu_item_get_gaction(
item: *mut WebKitContextMenuItem,
) -> *mut gio::GAction;
pub fn webkit_context_menu_item_get_stock_action(
item: *mut WebKitContextMenuItem,
) -> WebKitContextMenuAction;
pub fn webkit_context_menu_item_get_submenu(
item: *mut WebKitContextMenuItem,
) -> *mut WebKitContextMenu;
pub fn webkit_context_menu_item_is_separator(item: *mut WebKitContextMenuItem) -> gboolean;
pub fn webkit_context_menu_item_set_submenu(
item: *mut WebKitContextMenuItem,
submenu: *mut WebKitContextMenu,
);
pub fn webkit_dom_attr_get_type() -> GType;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_attr_get_local_name(self_: *mut WebKitDOMAttr) -> *mut c_char;
pub fn webkit_dom_attr_get_name(self_: *mut WebKitDOMAttr) -> *mut c_char;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_attr_get_namespace_uri(self_: *mut WebKitDOMAttr) -> *mut c_char;
pub fn webkit_dom_attr_get_owner_element(self_: *mut WebKitDOMAttr) -> *mut WebKitDOMElement;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_attr_get_prefix(self_: *mut WebKitDOMAttr) -> *mut c_char;
pub fn webkit_dom_attr_get_specified(self_: *mut WebKitDOMAttr) -> gboolean;
pub fn webkit_dom_attr_get_value(self_: *mut WebKitDOMAttr) -> *mut c_char;
pub fn webkit_dom_attr_set_value(
self_: *mut WebKitDOMAttr,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_blob_get_type() -> GType;
pub fn webkit_dom_blob_get_size(self_: *mut WebKitDOMBlob) -> u64;
pub fn webkit_dom_cdata_section_get_type() -> GType;
pub fn webkit_dom_css_rule_get_type() -> GType;
pub fn webkit_dom_css_rule_get_css_text(self_: *mut WebKitDOMCSSRule) -> *mut c_char;
pub fn webkit_dom_css_rule_get_parent_rule(
self_: *mut WebKitDOMCSSRule,
) -> *mut WebKitDOMCSSRule;
pub fn webkit_dom_css_rule_get_parent_style_sheet(
self_: *mut WebKitDOMCSSRule,
) -> *mut WebKitDOMCSSStyleSheet;
pub fn webkit_dom_css_rule_get_rule_type(self_: *mut WebKitDOMCSSRule) -> c_ushort;
pub fn webkit_dom_css_rule_set_css_text(
self_: *mut WebKitDOMCSSRule,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_css_rule_list_get_type() -> GType;
pub fn webkit_dom_css_rule_list_get_length(self_: *mut WebKitDOMCSSRuleList) -> c_ulong;
pub fn webkit_dom_css_rule_list_item(
self_: *mut WebKitDOMCSSRuleList,
index: c_ulong,
) -> *mut WebKitDOMCSSRule;
pub fn webkit_dom_css_style_declaration_get_type() -> GType;
pub fn webkit_dom_css_style_declaration_get_css_text(
self_: *mut WebKitDOMCSSStyleDeclaration,
) -> *mut c_char;
pub fn webkit_dom_css_style_declaration_get_length(
self_: *mut WebKitDOMCSSStyleDeclaration,
) -> c_ulong;
pub fn webkit_dom_css_style_declaration_get_parent_rule(
self_: *mut WebKitDOMCSSStyleDeclaration,
) -> *mut WebKitDOMCSSRule;
pub fn webkit_dom_css_style_declaration_get_property_priority(
self_: *mut WebKitDOMCSSStyleDeclaration,
propertyName: *const c_char,
) -> *mut c_char;
pub fn webkit_dom_css_style_declaration_get_property_shorthand(
self_: *mut WebKitDOMCSSStyleDeclaration,
propertyName: *const c_char,
) -> *mut c_char;
pub fn webkit_dom_css_style_declaration_get_property_value(
self_: *mut WebKitDOMCSSStyleDeclaration,
propertyName: *const c_char,
) -> *mut c_char;
pub fn webkit_dom_css_style_declaration_is_property_implicit(
self_: *mut WebKitDOMCSSStyleDeclaration,
propertyName: *const c_char,
) -> gboolean;
pub fn webkit_dom_css_style_declaration_item(
self_: *mut WebKitDOMCSSStyleDeclaration,
index: c_ulong,
) -> *mut c_char;
pub fn webkit_dom_css_style_declaration_remove_property(
self_: *mut WebKitDOMCSSStyleDeclaration,
propertyName: *const c_char,
error: *mut *mut glib::GError,
) -> *mut c_char;
pub fn webkit_dom_css_style_declaration_set_css_text(
self_: *mut WebKitDOMCSSStyleDeclaration,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_css_style_declaration_set_property(
self_: *mut WebKitDOMCSSStyleDeclaration,
propertyName: *const c_char,
value: *const c_char,
priority: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_css_style_sheet_get_type() -> GType;
pub fn webkit_dom_css_style_sheet_add_rule(
self_: *mut WebKitDOMCSSStyleSheet,
selector: *const c_char,
style: *const c_char,
index: c_ulong,
error: *mut *mut glib::GError,
) -> c_long;
pub fn webkit_dom_css_style_sheet_delete_rule(
self_: *mut WebKitDOMCSSStyleSheet,
index: c_ulong,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_css_style_sheet_get_css_rules(
self_: *mut WebKitDOMCSSStyleSheet,
) -> *mut WebKitDOMCSSRuleList;
pub fn webkit_dom_css_style_sheet_get_owner_rule(
self_: *mut WebKitDOMCSSStyleSheet,
) -> *mut WebKitDOMCSSRule;
pub fn webkit_dom_css_style_sheet_get_rules(
self_: *mut WebKitDOMCSSStyleSheet,
) -> *mut WebKitDOMCSSRuleList;
pub fn webkit_dom_css_style_sheet_insert_rule(
self_: *mut WebKitDOMCSSStyleSheet,
rule: *const c_char,
index: c_ulong,
error: *mut *mut glib::GError,
) -> c_ulong;
pub fn webkit_dom_css_style_sheet_remove_rule(
self_: *mut WebKitDOMCSSStyleSheet,
index: c_ulong,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_css_value_get_type() -> GType;
pub fn webkit_dom_css_value_get_css_text(self_: *mut WebKitDOMCSSValue) -> *mut c_char;
pub fn webkit_dom_css_value_get_css_value_type(self_: *mut WebKitDOMCSSValue) -> c_ushort;
pub fn webkit_dom_css_value_set_css_text(
self_: *mut WebKitDOMCSSValue,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_character_data_get_type() -> GType;
pub fn webkit_dom_character_data_append_data(
self_: *mut WebKitDOMCharacterData,
data: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_character_data_delete_data(
self_: *mut WebKitDOMCharacterData,
offset: c_ulong,
length: c_ulong,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_character_data_get_data(self_: *mut WebKitDOMCharacterData) -> *mut c_char;
pub fn webkit_dom_character_data_get_length(self_: *mut WebKitDOMCharacterData) -> c_ulong;
pub fn webkit_dom_character_data_insert_data(
self_: *mut WebKitDOMCharacterData,
offset: c_ulong,
data: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_character_data_replace_data(
self_: *mut WebKitDOMCharacterData,
offset: c_ulong,
length: c_ulong,
data: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_character_data_set_data(
self_: *mut WebKitDOMCharacterData,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_character_data_substring_data(
self_: *mut WebKitDOMCharacterData,
offset: c_ulong,
length: c_ulong,
error: *mut *mut glib::GError,
) -> *mut c_char;
pub fn webkit_dom_client_rect_get_type() -> GType;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_dom_client_rect_get_bottom(self_: *mut WebKitDOMClientRect) -> c_float;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_dom_client_rect_get_height(self_: *mut WebKitDOMClientRect) -> c_float;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_dom_client_rect_get_left(self_: *mut WebKitDOMClientRect) -> c_float;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_dom_client_rect_get_right(self_: *mut WebKitDOMClientRect) -> c_float;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_dom_client_rect_get_top(self_: *mut WebKitDOMClientRect) -> c_float;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_dom_client_rect_get_width(self_: *mut WebKitDOMClientRect) -> c_float;
pub fn webkit_dom_client_rect_list_get_type() -> GType;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_dom_client_rect_list_get_length(self_: *mut WebKitDOMClientRectList) -> c_ulong;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_dom_client_rect_list_item(
self_: *mut WebKitDOMClientRectList,
index: c_ulong,
) -> *mut WebKitDOMClientRect;
pub fn webkit_dom_comment_get_type() -> GType;
pub fn webkit_dom_dom_implementation_get_type() -> GType;
pub fn webkit_dom_dom_implementation_create_css_style_sheet(
self_: *mut WebKitDOMDOMImplementation,
title: *const c_char,
media: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMCSSStyleSheet;
pub fn webkit_dom_dom_implementation_create_document(
self_: *mut WebKitDOMDOMImplementation,
namespaceURI: *const c_char,
qualifiedName: *const c_char,
doctype: *mut WebKitDOMDocumentType,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMDocument;
pub fn webkit_dom_dom_implementation_create_document_type(
self_: *mut WebKitDOMDOMImplementation,
qualifiedName: *const c_char,
publicId: *const c_char,
systemId: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMDocumentType;
pub fn webkit_dom_dom_implementation_create_html_document(
self_: *mut WebKitDOMDOMImplementation,
title: *const c_char,
) -> *mut WebKitDOMHTMLDocument;
pub fn webkit_dom_dom_implementation_has_feature(
self_: *mut WebKitDOMDOMImplementation,
feature: *const c_char,
version: *const c_char,
) -> gboolean;
pub fn webkit_dom_dom_selection_get_type() -> GType;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_add_range(
self_: *mut WebKitDOMDOMSelection,
range: *mut WebKitDOMRange,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_collapse(
self_: *mut WebKitDOMDOMSelection,
node: *mut WebKitDOMNode,
offset: c_ulong,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_collapse_to_end(
self_: *mut WebKitDOMDOMSelection,
error: *mut *mut glib::GError,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_collapse_to_start(
self_: *mut WebKitDOMDOMSelection,
error: *mut *mut glib::GError,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_contains_node(
self_: *mut WebKitDOMDOMSelection,
node: *mut WebKitDOMNode,
allowPartial: gboolean,
) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_delete_from_document(self_: *mut WebKitDOMDOMSelection);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_empty(self_: *mut WebKitDOMDOMSelection);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_extend(
self_: *mut WebKitDOMDOMSelection,
node: *mut WebKitDOMNode,
offset: c_ulong,
error: *mut *mut glib::GError,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_anchor_node(
self_: *mut WebKitDOMDOMSelection,
) -> *mut WebKitDOMNode;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_anchor_offset(self_: *mut WebKitDOMDOMSelection)
-> c_ulong;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_base_node(
self_: *mut WebKitDOMDOMSelection,
) -> *mut WebKitDOMNode;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_base_offset(self_: *mut WebKitDOMDOMSelection) -> c_ulong;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_extent_node(
self_: *mut WebKitDOMDOMSelection,
) -> *mut WebKitDOMNode;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_extent_offset(self_: *mut WebKitDOMDOMSelection)
-> c_ulong;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_focus_node(
self_: *mut WebKitDOMDOMSelection,
) -> *mut WebKitDOMNode;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_focus_offset(self_: *mut WebKitDOMDOMSelection) -> c_ulong;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_is_collapsed(self_: *mut WebKitDOMDOMSelection)
-> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_range_at(
self_: *mut WebKitDOMDOMSelection,
index: c_ulong,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMRange;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_range_count(self_: *mut WebKitDOMDOMSelection) -> c_ulong;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_get_selection_type(
self_: *mut WebKitDOMDOMSelection,
) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_modify(
self_: *mut WebKitDOMDOMSelection,
alter: *const c_char,
direction: *const c_char,
granularity: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_remove_all_ranges(self_: *mut WebKitDOMDOMSelection);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_select_all_children(
self_: *mut WebKitDOMDOMSelection,
node: *mut WebKitDOMNode,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_set_base_and_extent(
self_: *mut WebKitDOMDOMSelection,
baseNode: *mut WebKitDOMNode,
baseOffset: c_ulong,
extentNode: *mut WebKitDOMNode,
extentOffset: c_ulong,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_selection_set_position(
self_: *mut WebKitDOMDOMSelection,
node: *mut WebKitDOMNode,
offset: c_ulong,
);
pub fn webkit_dom_dom_token_list_get_type() -> GType;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_token_list_add(
self_: *mut WebKitDOMDOMTokenList,
error: *mut *mut glib::GError,
...
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_token_list_contains(
self_: *mut WebKitDOMDOMTokenList,
token: *const c_char,
) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_token_list_get_length(self_: *mut WebKitDOMDOMTokenList) -> c_ulong;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_token_list_get_value(self_: *mut WebKitDOMDOMTokenList) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_token_list_item(
self_: *mut WebKitDOMDOMTokenList,
index: c_ulong,
) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_token_list_remove(
self_: *mut WebKitDOMDOMTokenList,
error: *mut *mut glib::GError,
...
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_token_list_replace(
self_: *mut WebKitDOMDOMTokenList,
token: *const c_char,
newToken: *const c_char,
error: *mut *mut glib::GError,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_token_list_set_value(
self_: *mut WebKitDOMDOMTokenList,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_token_list_toggle(
self_: *mut WebKitDOMDOMTokenList,
token: *const c_char,
force: gboolean,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn webkit_dom_dom_window_get_type() -> GType;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_alert(self_: *mut WebKitDOMDOMWindow, message: *const c_char);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_blur(self_: *mut WebKitDOMDOMWindow);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_capture_events(self_: *mut WebKitDOMDOMWindow);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_close(self_: *mut WebKitDOMDOMWindow);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_confirm(
self_: *mut WebKitDOMDOMWindow,
message: *const c_char,
) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_find(
self_: *mut WebKitDOMDOMWindow,
string: *const c_char,
caseSensitive: gboolean,
backwards: gboolean,
wrap: gboolean,
wholeWord: gboolean,
searchInFrames: gboolean,
showDialog: gboolean,
) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_focus(self_: *mut WebKitDOMDOMWindow);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_closed(self_: *mut WebKitDOMDOMWindow) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_computed_style(
self_: *mut WebKitDOMDOMWindow,
element: *mut WebKitDOMElement,
pseudoElement: *const c_char,
) -> *mut WebKitDOMCSSStyleDeclaration;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_default_status(self_: *mut WebKitDOMDOMWindow) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_device_pixel_ratio(self_: *mut WebKitDOMDOMWindow)
-> c_double;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_document(
self_: *mut WebKitDOMDOMWindow,
) -> *mut WebKitDOMDocument;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_frame_element(
self_: *mut WebKitDOMDOMWindow,
) -> *mut WebKitDOMElement;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_frames(
self_: *mut WebKitDOMDOMWindow,
) -> *mut WebKitDOMDOMWindow;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_inner_height(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_inner_width(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_length(self_: *mut WebKitDOMDOMWindow) -> c_ulong;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_name(self_: *mut WebKitDOMDOMWindow) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_offscreen_buffering(
self_: *mut WebKitDOMDOMWindow,
) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_opener(
self_: *mut WebKitDOMDOMWindow,
) -> *mut WebKitDOMDOMWindow;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_orientation(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_outer_height(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_outer_width(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_page_x_offset(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_page_y_offset(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_parent(
self_: *mut WebKitDOMDOMWindow,
) -> *mut WebKitDOMDOMWindow;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_screen_left(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_screen_top(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_screen_x(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_screen_y(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_scroll_x(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_scroll_y(self_: *mut WebKitDOMDOMWindow) -> c_long;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_selection(
self_: *mut WebKitDOMDOMWindow,
) -> *mut WebKitDOMDOMSelection;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_self(
self_: *mut WebKitDOMDOMWindow,
) -> *mut WebKitDOMDOMWindow;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_status(self_: *mut WebKitDOMDOMWindow) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_top(self_: *mut WebKitDOMDOMWindow)
-> *mut WebKitDOMDOMWindow;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_get_window(
self_: *mut WebKitDOMDOMWindow,
) -> *mut WebKitDOMDOMWindow;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_move_by(self_: *mut WebKitDOMDOMWindow, x: c_float, y: c_float);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_move_to(self_: *mut WebKitDOMDOMWindow, x: c_float, y: c_float);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_print(self_: *mut WebKitDOMDOMWindow);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_prompt(
self_: *mut WebKitDOMDOMWindow,
message: *const c_char,
defaultValue: *const c_char,
) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_release_events(self_: *mut WebKitDOMDOMWindow);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_resize_by(self_: *mut WebKitDOMDOMWindow, x: c_float, y: c_float);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_resize_to(
self_: *mut WebKitDOMDOMWindow,
width: c_float,
height: c_float,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_scroll_by(
self_: *mut WebKitDOMDOMWindow,
x: c_double,
y: c_double,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_scroll_to(
self_: *mut WebKitDOMDOMWindow,
x: c_double,
y: c_double,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_set_default_status(
self_: *mut WebKitDOMDOMWindow,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_set_name(self_: *mut WebKitDOMDOMWindow, value: *const c_char);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_set_status(self_: *mut WebKitDOMDOMWindow, value: *const c_char);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_dom_window_stop(self_: *mut WebKitDOMDOMWindow);
pub fn webkit_dom_dom_window_webkit_message_handlers_post_message(
window: *mut WebKitDOMDOMWindow,
handler: *const c_char,
message: *const c_char,
) -> gboolean;
pub fn webkit_dom_document_get_type() -> GType;
pub fn webkit_dom_document_adopt_node(
self_: *mut WebKitDOMDocument,
source: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_caret_range_from_point(
self_: *mut WebKitDOMDocument,
x: c_long,
y: c_long,
) -> *mut WebKitDOMRange;
pub fn webkit_dom_document_create_attribute(
self_: *mut WebKitDOMDocument,
name: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMAttr;
pub fn webkit_dom_document_create_attribute_ns(
self_: *mut WebKitDOMDocument,
namespaceURI: *const c_char,
qualifiedName: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMAttr;
pub fn webkit_dom_document_create_cdata_section(
self_: *mut WebKitDOMDocument,
data: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMCDATASection;
pub fn webkit_dom_document_create_comment(
self_: *mut WebKitDOMDocument,
data: *const c_char,
) -> *mut WebKitDOMComment;
pub fn webkit_dom_document_create_css_style_declaration(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMCSSStyleDeclaration;
pub fn webkit_dom_document_create_document_fragment(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMDocumentFragment;
pub fn webkit_dom_document_create_element(
self_: *mut WebKitDOMDocument,
tagName: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_create_element_ns(
self_: *mut WebKitDOMDocument,
namespaceURI: *const c_char,
qualifiedName: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_create_entity_reference(
self_: *mut WebKitDOMDocument,
name: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMEntityReference;
pub fn webkit_dom_document_create_event(
self_: *mut WebKitDOMDocument,
eventType: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMEvent;
pub fn webkit_dom_document_create_expression(
self_: *mut WebKitDOMDocument,
expression: *const c_char,
resolver: *mut WebKitDOMXPathNSResolver,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMXPathExpression;
pub fn webkit_dom_document_create_node_iterator(
self_: *mut WebKitDOMDocument,
root: *mut WebKitDOMNode,
whatToShow: c_ulong,
filter: *mut WebKitDOMNodeFilter,
expandEntityReferences: gboolean,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNodeIterator;
pub fn webkit_dom_document_create_ns_resolver(
self_: *mut WebKitDOMDocument,
nodeResolver: *mut WebKitDOMNode,
) -> *mut WebKitDOMXPathNSResolver;
pub fn webkit_dom_document_create_processing_instruction(
self_: *mut WebKitDOMDocument,
target: *const c_char,
data: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMProcessingInstruction;
pub fn webkit_dom_document_create_range(self_: *mut WebKitDOMDocument) -> *mut WebKitDOMRange;
pub fn webkit_dom_document_create_text_node(
self_: *mut WebKitDOMDocument,
data: *const c_char,
) -> *mut WebKitDOMText;
pub fn webkit_dom_document_create_tree_walker(
self_: *mut WebKitDOMDocument,
root: *mut WebKitDOMNode,
whatToShow: c_ulong,
filter: *mut WebKitDOMNodeFilter,
expandEntityReferences: gboolean,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMTreeWalker;
pub fn webkit_dom_document_element_from_point(
self_: *mut WebKitDOMDocument,
x: c_long,
y: c_long,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_evaluate(
self_: *mut WebKitDOMDocument,
expression: *const c_char,
contextNode: *mut WebKitDOMNode,
resolver: *mut WebKitDOMXPathNSResolver,
type_: c_ushort,
inResult: *mut WebKitDOMXPathResult,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMXPathResult;
pub fn webkit_dom_document_exec_command(
self_: *mut WebKitDOMDocument,
command: *const c_char,
userInterface: gboolean,
value: *const c_char,
) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_exit_pointer_lock(self_: *mut WebKitDOMDocument);
pub fn webkit_dom_document_get_active_element(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_get_anchors(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_document_get_applets(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_document_get_body(self_: *mut WebKitDOMDocument)
-> *mut WebKitDOMHTMLElement;
pub fn webkit_dom_document_get_character_set(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_charset(self_: *mut WebKitDOMDocument) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_child_element_count(self_: *mut WebKitDOMDocument) -> c_ulong;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_children(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLCollection;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_document_get_compat_mode(self_: *mut WebKitDOMDocument) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_content_type(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_cookie(
self_: *mut WebKitDOMDocument,
error: *mut *mut glib::GError,
) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_current_script(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLScriptElement;
pub fn webkit_dom_document_get_default_charset(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_default_view(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMDOMWindow;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_document_get_design_mode(self_: *mut WebKitDOMDocument) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_dir(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_doctype(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMDocumentType;
pub fn webkit_dom_document_get_document_element(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_get_document_uri(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_domain(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_element_by_id(
self_: *mut WebKitDOMDocument,
elementId: *const c_char,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_get_elements_by_class_name(
self_: *mut WebKitDOMDocument,
class_name: *const c_char,
) -> *mut WebKitDOMNodeList;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_dom_document_get_elements_by_class_name_as_html_collection(
self_: *mut WebKitDOMDocument,
classNames: *const c_char,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_document_get_elements_by_name(
self_: *mut WebKitDOMDocument,
elementName: *const c_char,
) -> *mut WebKitDOMNodeList;
pub fn webkit_dom_document_get_elements_by_tag_name(
self_: *mut WebKitDOMDocument,
tag_name: *const c_char,
) -> *mut WebKitDOMNodeList;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_dom_document_get_elements_by_tag_name_as_html_collection(
self_: *mut WebKitDOMDocument,
tagname: *const c_char,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_document_get_elements_by_tag_name_ns(
self_: *mut WebKitDOMDocument,
namespace_uri: *const c_char,
tag_name: *const c_char,
) -> *mut WebKitDOMNodeList;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_dom_document_get_elements_by_tag_name_ns_as_html_collection(
self_: *mut WebKitDOMDocument,
namespaceURI: *const c_char,
localName: *const c_char,
) -> *mut WebKitDOMHTMLCollection;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_document_get_embeds(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLCollection;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_first_element_child(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_get_forms(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_document_get_head(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLHeadElement;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_hidden(self_: *mut WebKitDOMDocument) -> gboolean;
pub fn webkit_dom_document_get_images(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_document_get_implementation(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMDOMImplementation;
pub fn webkit_dom_document_get_input_encoding(self_: *mut WebKitDOMDocument) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_last_element_child(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_get_last_modified(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_links(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLCollection;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_origin(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_override_style(
self_: *mut WebKitDOMDocument,
element: *mut WebKitDOMElement,
pseudoElement: *const c_char,
) -> *mut WebKitDOMCSSStyleDeclaration;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_document_get_plugins(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLCollection;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_pointer_lock_element(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_get_preferred_stylesheet_set(
self_: *mut WebKitDOMDocument,
) -> *mut c_char;
pub fn webkit_dom_document_get_ready_state(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_referrer(self_: *mut WebKitDOMDocument) -> *mut c_char;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_document_get_scripts(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMHTMLCollection;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_scrolling_element(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_get_selected_stylesheet_set(
self_: *mut WebKitDOMDocument,
) -> *mut c_char;
pub fn webkit_dom_document_get_style_sheets(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMStyleSheetList;
pub fn webkit_dom_document_get_title(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_url(self_: *mut WebKitDOMDocument) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_visibility_state(self_: *mut WebKitDOMDocument) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_webkit_current_fullscreen_element(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMElement;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_webkit_fullscreen_element(
self_: *mut WebKitDOMDocument,
) -> *mut WebKitDOMElement;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_webkit_fullscreen_enabled(
self_: *mut WebKitDOMDocument,
) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_webkit_fullscreen_keyboard_input_allowed(
self_: *mut WebKitDOMDocument,
) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_get_webkit_is_fullscreen(self_: *mut WebKitDOMDocument) -> gboolean;
pub fn webkit_dom_document_get_xml_encoding(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_get_xml_standalone(self_: *mut WebKitDOMDocument) -> gboolean;
pub fn webkit_dom_document_get_xml_version(self_: *mut WebKitDOMDocument) -> *mut c_char;
pub fn webkit_dom_document_has_focus(self_: *mut WebKitDOMDocument) -> gboolean;
pub fn webkit_dom_document_import_node(
self_: *mut WebKitDOMDocument,
importedNode: *mut WebKitDOMNode,
deep: gboolean,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_document_query_command_enabled(
self_: *mut WebKitDOMDocument,
command: *const c_char,
) -> gboolean;
pub fn webkit_dom_document_query_command_indeterm(
self_: *mut WebKitDOMDocument,
command: *const c_char,
) -> gboolean;
pub fn webkit_dom_document_query_command_state(
self_: *mut WebKitDOMDocument,
command: *const c_char,
) -> gboolean;
pub fn webkit_dom_document_query_command_supported(
self_: *mut WebKitDOMDocument,
command: *const c_char,
) -> gboolean;
pub fn webkit_dom_document_query_command_value(
self_: *mut WebKitDOMDocument,
command: *const c_char,
) -> *mut c_char;
pub fn webkit_dom_document_query_selector(
self_: *mut WebKitDOMDocument,
selectors: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_document_query_selector_all(
self_: *mut WebKitDOMDocument,
selectors: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNodeList;
pub fn webkit_dom_document_set_body(
self_: *mut WebKitDOMDocument,
value: *mut WebKitDOMHTMLElement,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_document_set_charset(self_: *mut WebKitDOMDocument, value: *const c_char);
pub fn webkit_dom_document_set_cookie(
self_: *mut WebKitDOMDocument,
value: *const c_char,
error: *mut *mut glib::GError,
);
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_document_set_design_mode(self_: *mut WebKitDOMDocument, value: *const c_char);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_set_dir(self_: *mut WebKitDOMDocument, value: *const c_char);
pub fn webkit_dom_document_set_document_uri(
self_: *mut WebKitDOMDocument,
value: *const c_char,
);
pub fn webkit_dom_document_set_selected_stylesheet_set(
self_: *mut WebKitDOMDocument,
value: *const c_char,
);
pub fn webkit_dom_document_set_title(self_: *mut WebKitDOMDocument, value: *const c_char);
pub fn webkit_dom_document_set_xml_standalone(
self_: *mut WebKitDOMDocument,
value: gboolean,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_document_set_xml_version(
self_: *mut WebKitDOMDocument,
value: *const c_char,
error: *mut *mut glib::GError,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_webkit_cancel_fullscreen(self_: *mut WebKitDOMDocument);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_webkit_exit_fullscreen(self_: *mut WebKitDOMDocument);
pub fn webkit_dom_document_fragment_get_type() -> GType;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_fragment_get_child_element_count(
self_: *mut WebKitDOMDocumentFragment,
) -> c_ulong;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_fragment_get_children(
self_: *mut WebKitDOMDocumentFragment,
) -> *mut WebKitDOMHTMLCollection;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_fragment_get_element_by_id(
self_: *mut WebKitDOMDocumentFragment,
elementId: *const c_char,
) -> *mut WebKitDOMElement;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_fragment_get_first_element_child(
self_: *mut WebKitDOMDocumentFragment,
) -> *mut WebKitDOMElement;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_fragment_get_last_element_child(
self_: *mut WebKitDOMDocumentFragment,
) -> *mut WebKitDOMElement;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_fragment_query_selector(
self_: *mut WebKitDOMDocumentFragment,
selectors: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMElement;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_document_fragment_query_selector_all(
self_: *mut WebKitDOMDocumentFragment,
selectors: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNodeList;
pub fn webkit_dom_document_type_get_type() -> GType;
pub fn webkit_dom_document_type_get_entities(
self_: *mut WebKitDOMDocumentType,
) -> *mut WebKitDOMNamedNodeMap;
pub fn webkit_dom_document_type_get_internal_subset(
self_: *mut WebKitDOMDocumentType,
) -> *mut c_char;
pub fn webkit_dom_document_type_get_name(self_: *mut WebKitDOMDocumentType) -> *mut c_char;
pub fn webkit_dom_document_type_get_notations(
self_: *mut WebKitDOMDocumentType,
) -> *mut WebKitDOMNamedNodeMap;
pub fn webkit_dom_document_type_get_public_id(self_: *mut WebKitDOMDocumentType)
-> *mut c_char;
pub fn webkit_dom_document_type_get_system_id(self_: *mut WebKitDOMDocumentType)
-> *mut c_char;
pub fn webkit_dom_element_get_type() -> GType;
pub fn webkit_dom_element_blur(self_: *mut WebKitDOMElement);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_element_closest(
self_: *mut WebKitDOMElement,
selectors: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_element_focus(self_: *mut WebKitDOMElement);
pub fn webkit_dom_element_get_attribute(
self_: *mut WebKitDOMElement,
name: *const c_char,
) -> *mut c_char;
pub fn webkit_dom_element_get_attribute_node(
self_: *mut WebKitDOMElement,
name: *const c_char,
) -> *mut WebKitDOMAttr;
pub fn webkit_dom_element_get_attribute_node_ns(
self_: *mut WebKitDOMElement,
namespaceURI: *const c_char,
localName: *const c_char,
) -> *mut WebKitDOMAttr;
pub fn webkit_dom_element_get_attribute_ns(
self_: *mut WebKitDOMElement,
namespaceURI: *const c_char,
localName: *const c_char,
) -> *mut c_char;
pub fn webkit_dom_element_get_attributes(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMNamedNodeMap;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_dom_element_get_bounding_client_rect(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMClientRect;
pub fn webkit_dom_element_get_child_element_count(self_: *mut WebKitDOMElement) -> c_ulong;
#[cfg(any(feature = "v2_10", feature = "dox"))]
pub fn webkit_dom_element_get_children(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMHTMLCollection;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_element_get_class_list(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMDOMTokenList;
pub fn webkit_dom_element_get_class_name(self_: *mut WebKitDOMElement) -> *mut c_char;
pub fn webkit_dom_element_get_client_height(self_: *mut WebKitDOMElement) -> c_double;
pub fn webkit_dom_element_get_client_left(self_: *mut WebKitDOMElement) -> c_double;
#[cfg(any(feature = "v2_18", feature = "dox"))]
pub fn webkit_dom_element_get_client_rects(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMClientRectList;
pub fn webkit_dom_element_get_client_top(self_: *mut WebKitDOMElement) -> c_double;
pub fn webkit_dom_element_get_client_width(self_: *mut WebKitDOMElement) -> c_double;
pub fn webkit_dom_element_get_elements_by_class_name(
self_: *mut WebKitDOMElement,
class_name: *const c_char,
) -> *mut WebKitDOMNodeList;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_dom_element_get_elements_by_class_name_as_html_collection(
self_: *mut WebKitDOMElement,
name: *const c_char,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_element_get_elements_by_tag_name(
self_: *mut WebKitDOMElement,
tag_name: *const c_char,
) -> *mut WebKitDOMNodeList;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_dom_element_get_elements_by_tag_name_as_html_collection(
self_: *mut WebKitDOMElement,
name: *const c_char,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_element_get_elements_by_tag_name_ns(
self_: *mut WebKitDOMElement,
namespace_uri: *const c_char,
tag_name: *const c_char,
) -> *mut WebKitDOMNodeList;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_dom_element_get_elements_by_tag_name_ns_as_html_collection(
self_: *mut WebKitDOMElement,
namespaceURI: *const c_char,
localName: *const c_char,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_element_get_first_element_child(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_element_get_id(self_: *mut WebKitDOMElement) -> *mut c_char;
#[cfg(any(feature = "v2_8", feature = "dox"))]
pub fn webkit_dom_element_get_inner_html(self_: *mut WebKitDOMElement) -> *mut c_char;
pub fn webkit_dom_element_get_last_element_child(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMElement;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_element_get_local_name(self_: *mut WebKitDOMElement) -> *mut c_char;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_element_get_namespace_uri(self_: *mut WebKitDOMElement) -> *mut c_char;
pub fn webkit_dom_element_get_next_element_sibling(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_element_get_offset_height(self_: *mut WebKitDOMElement) -> c_double;
pub fn webkit_dom_element_get_offset_left(self_: *mut WebKitDOMElement) -> c_double;
pub fn webkit_dom_element_get_offset_parent(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_element_get_offset_top(self_: *mut WebKitDOMElement) -> c_double;
pub fn webkit_dom_element_get_offset_width(self_: *mut WebKitDOMElement) -> c_double;
#[cfg(any(feature = "v2_8", feature = "dox"))]
pub fn webkit_dom_element_get_outer_html(self_: *mut WebKitDOMElement) -> *mut c_char;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_element_get_prefix(self_: *mut WebKitDOMElement) -> *mut c_char;
pub fn webkit_dom_element_get_previous_element_sibling(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_element_get_scroll_height(self_: *mut WebKitDOMElement) -> c_long;
pub fn webkit_dom_element_get_scroll_left(self_: *mut WebKitDOMElement) -> c_long;
pub fn webkit_dom_element_get_scroll_top(self_: *mut WebKitDOMElement) -> c_long;
pub fn webkit_dom_element_get_scroll_width(self_: *mut WebKitDOMElement) -> c_long;
pub fn webkit_dom_element_get_style(
self_: *mut WebKitDOMElement,
) -> *mut WebKitDOMCSSStyleDeclaration;
pub fn webkit_dom_element_get_tag_name(self_: *mut WebKitDOMElement) -> *mut c_char;
pub fn webkit_dom_element_get_webkit_region_overset(
self_: *mut WebKitDOMElement,
) -> *mut c_char;
pub fn webkit_dom_element_has_attribute(
self_: *mut WebKitDOMElement,
name: *const c_char,
) -> gboolean;
pub fn webkit_dom_element_has_attribute_ns(
self_: *mut WebKitDOMElement,
namespaceURI: *const c_char,
localName: *const c_char,
) -> gboolean;
pub fn webkit_dom_element_has_attributes(self_: *mut WebKitDOMElement) -> gboolean;
pub fn webkit_dom_element_html_input_element_get_auto_filled(
element: *mut WebKitDOMElement,
) -> gboolean;
#[cfg(any(feature = "v2_22", feature = "dox"))]
pub fn webkit_dom_element_html_input_element_is_user_edited(
element: *mut WebKitDOMElement,
) -> gboolean;
#[cfg(any(feature = "v2_22", feature = "dox"))]
pub fn webkit_dom_element_html_input_element_set_auto_filled(
element: *mut WebKitDOMElement,
auto_filled: gboolean,
);
#[cfg(any(feature = "v2_22", feature = "dox"))]
pub fn webkit_dom_element_html_input_element_set_editing_value(
element: *mut WebKitDOMElement,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_element_insert_adjacent_element(
self_: *mut WebKitDOMElement,
where_: *const c_char,
element: *mut WebKitDOMElement,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMElement;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_element_insert_adjacent_html(
self_: *mut WebKitDOMElement,
where_: *const c_char,
html: *const c_char,
error: *mut *mut glib::GError,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_element_insert_adjacent_text(
self_: *mut WebKitDOMElement,
where_: *const c_char,
text: *const c_char,
error: *mut *mut glib::GError,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_element_matches(
self_: *mut WebKitDOMElement,
selectors: *const c_char,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn webkit_dom_element_query_selector(
self_: *mut WebKitDOMElement,
selectors: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMElement;
pub fn webkit_dom_element_query_selector_all(
self_: *mut WebKitDOMElement,
selectors: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNodeList;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_element_remove(self_: *mut WebKitDOMElement, error: *mut *mut glib::GError);
pub fn webkit_dom_element_remove_attribute(self_: *mut WebKitDOMElement, name: *const c_char);
pub fn webkit_dom_element_remove_attribute_node(
self_: *mut WebKitDOMElement,
oldAttr: *mut WebKitDOMAttr,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMAttr;
pub fn webkit_dom_element_remove_attribute_ns(
self_: *mut WebKitDOMElement,
namespaceURI: *const c_char,
localName: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_element_request_pointer_lock(self_: *mut WebKitDOMElement);
pub fn webkit_dom_element_scroll_by_lines(self_: *mut WebKitDOMElement, lines: c_long);
pub fn webkit_dom_element_scroll_by_pages(self_: *mut WebKitDOMElement, pages: c_long);
pub fn webkit_dom_element_scroll_into_view(
self_: *mut WebKitDOMElement,
alignWithTop: gboolean,
);
pub fn webkit_dom_element_scroll_into_view_if_needed(
self_: *mut WebKitDOMElement,
centerIfNeeded: gboolean,
);
pub fn webkit_dom_element_set_attribute(
self_: *mut WebKitDOMElement,
name: *const c_char,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_element_set_attribute_node(
self_: *mut WebKitDOMElement,
newAttr: *mut WebKitDOMAttr,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMAttr;
pub fn webkit_dom_element_set_attribute_node_ns(
self_: *mut WebKitDOMElement,
newAttr: *mut WebKitDOMAttr,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMAttr;
pub fn webkit_dom_element_set_attribute_ns(
self_: *mut WebKitDOMElement,
namespaceURI: *const c_char,
qualifiedName: *const c_char,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_element_set_class_name(self_: *mut WebKitDOMElement, value: *const c_char);
pub fn webkit_dom_element_set_id(self_: *mut WebKitDOMElement, value: *const c_char);
#[cfg(any(feature = "v2_8", feature = "dox"))]
pub fn webkit_dom_element_set_inner_html(
self_: *mut WebKitDOMElement,
value: *const c_char,
error: *mut *mut glib::GError,
);
#[cfg(any(feature = "v2_8", feature = "dox"))]
pub fn webkit_dom_element_set_outer_html(
self_: *mut WebKitDOMElement,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_element_set_scroll_left(self_: *mut WebKitDOMElement, value: c_long);
pub fn webkit_dom_element_set_scroll_top(self_: *mut WebKitDOMElement, value: c_long);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_element_webkit_matches_selector(
self_: *mut WebKitDOMElement,
selectors: *const c_char,
error: *mut *mut glib::GError,
) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_element_webkit_request_fullscreen(self_: *mut WebKitDOMElement);
pub fn webkit_dom_entity_reference_get_type() -> GType;
pub fn webkit_dom_event_get_type() -> GType;
pub fn webkit_dom_event_get_bubbles(self_: *mut WebKitDOMEvent) -> gboolean;
pub fn webkit_dom_event_get_cancel_bubble(self_: *mut WebKitDOMEvent) -> gboolean;
pub fn webkit_dom_event_get_cancelable(self_: *mut WebKitDOMEvent) -> gboolean;
pub fn webkit_dom_event_get_current_target(
self_: *mut WebKitDOMEvent,
) -> *mut WebKitDOMEventTarget;
pub fn webkit_dom_event_get_event_phase(self_: *mut WebKitDOMEvent) -> c_ushort;
pub fn webkit_dom_event_get_event_type(self_: *mut WebKitDOMEvent) -> *mut c_char;
pub fn webkit_dom_event_get_return_value(self_: *mut WebKitDOMEvent) -> gboolean;
pub fn webkit_dom_event_get_src_element(
self_: *mut WebKitDOMEvent,
) -> *mut WebKitDOMEventTarget;
pub fn webkit_dom_event_get_target(self_: *mut WebKitDOMEvent) -> *mut WebKitDOMEventTarget;
pub fn webkit_dom_event_get_time_stamp(self_: *mut WebKitDOMEvent) -> u32;
pub fn webkit_dom_event_init_event(
self_: *mut WebKitDOMEvent,
eventTypeArg: *const c_char,
canBubbleArg: gboolean,
cancelableArg: gboolean,
);
pub fn webkit_dom_event_prevent_default(self_: *mut WebKitDOMEvent);
pub fn webkit_dom_event_set_cancel_bubble(self_: *mut WebKitDOMEvent, value: gboolean);
pub fn webkit_dom_event_set_return_value(self_: *mut WebKitDOMEvent, value: gboolean);
pub fn webkit_dom_event_stop_propagation(self_: *mut WebKitDOMEvent);
pub fn webkit_dom_file_get_type() -> GType;
pub fn webkit_dom_file_get_name(self_: *mut WebKitDOMFile) -> *mut c_char;
pub fn webkit_dom_file_list_get_type() -> GType;
pub fn webkit_dom_file_list_get_length(self_: *mut WebKitDOMFileList) -> c_ulong;
pub fn webkit_dom_file_list_item(
self_: *mut WebKitDOMFileList,
index: c_ulong,
) -> *mut WebKitDOMFile;
pub fn webkit_dom_html_anchor_element_get_type() -> GType;
pub fn webkit_dom_html_anchor_element_get_charset(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_coords(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_hash(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_host(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_hostname(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_href(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_hreflang(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_name(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_pathname(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_port(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_protocol(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_rel(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_rev(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_search(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_shape(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_target(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_text(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_get_type_attr(
self_: *mut WebKitDOMHTMLAnchorElement,
) -> *mut c_char;
pub fn webkit_dom_html_anchor_element_set_charset(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_coords(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_hash(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_host(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_hostname(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_href(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_hreflang(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_name(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_pathname(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_port(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_protocol(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_rel(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_rev(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_search(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_shape(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_target(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_anchor_element_set_text(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_anchor_element_set_type_attr(
self_: *mut WebKitDOMHTMLAnchorElement,
value: *const c_char,
);
pub fn webkit_dom_html_applet_element_get_type() -> GType;
pub fn webkit_dom_html_applet_element_get_align(
self_: *mut WebKitDOMHTMLAppletElement,
) -> *mut c_char;
pub fn webkit_dom_html_applet_element_get_alt(
self_: *mut WebKitDOMHTMLAppletElement,
) -> *mut c_char;
pub fn webkit_dom_html_applet_element_get_archive(
self_: *mut WebKitDOMHTMLAppletElement,
) -> *mut c_char;
pub fn webkit_dom_html_applet_element_get_code(
self_: *mut WebKitDOMHTMLAppletElement,
) -> *mut c_char;
pub fn webkit_dom_html_applet_element_get_code_base(
self_: *mut WebKitDOMHTMLAppletElement,
) -> *mut c_char;
pub fn webkit_dom_html_applet_element_get_height(
self_: *mut WebKitDOMHTMLAppletElement,
) -> *mut c_char;
pub fn webkit_dom_html_applet_element_get_hspace(
self_: *mut WebKitDOMHTMLAppletElement,
) -> c_long;
pub fn webkit_dom_html_applet_element_get_name(
self_: *mut WebKitDOMHTMLAppletElement,
) -> *mut c_char;
pub fn webkit_dom_html_applet_element_get_object(
self_: *mut WebKitDOMHTMLAppletElement,
) -> *mut c_char;
pub fn webkit_dom_html_applet_element_get_vspace(
self_: *mut WebKitDOMHTMLAppletElement,
) -> c_long;
pub fn webkit_dom_html_applet_element_get_width(
self_: *mut WebKitDOMHTMLAppletElement,
) -> *mut c_char;
pub fn webkit_dom_html_applet_element_set_align(
self_: *mut WebKitDOMHTMLAppletElement,
value: *const c_char,
);
pub fn webkit_dom_html_applet_element_set_alt(
self_: *mut WebKitDOMHTMLAppletElement,
value: *const c_char,
);
pub fn webkit_dom_html_applet_element_set_archive(
self_: *mut WebKitDOMHTMLAppletElement,
value: *const c_char,
);
pub fn webkit_dom_html_applet_element_set_code(
self_: *mut WebKitDOMHTMLAppletElement,
value: *const c_char,
);
pub fn webkit_dom_html_applet_element_set_code_base(
self_: *mut WebKitDOMHTMLAppletElement,
value: *const c_char,
);
pub fn webkit_dom_html_applet_element_set_height(
self_: *mut WebKitDOMHTMLAppletElement,
value: *const c_char,
);
pub fn webkit_dom_html_applet_element_set_hspace(
self_: *mut WebKitDOMHTMLAppletElement,
value: c_long,
);
pub fn webkit_dom_html_applet_element_set_name(
self_: *mut WebKitDOMHTMLAppletElement,
value: *const c_char,
);
pub fn webkit_dom_html_applet_element_set_object(
self_: *mut WebKitDOMHTMLAppletElement,
value: *const c_char,
);
pub fn webkit_dom_html_applet_element_set_vspace(
self_: *mut WebKitDOMHTMLAppletElement,
value: c_long,
);
pub fn webkit_dom_html_applet_element_set_width(
self_: *mut WebKitDOMHTMLAppletElement,
value: *const c_char,
);
pub fn webkit_dom_html_area_element_get_type() -> GType;
pub fn webkit_dom_html_area_element_get_alt(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_coords(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_hash(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_host(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_hostname(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_href(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_no_href(
self_: *mut WebKitDOMHTMLAreaElement,
) -> gboolean;
pub fn webkit_dom_html_area_element_get_pathname(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_port(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_protocol(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_search(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_shape(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_get_target(
self_: *mut WebKitDOMHTMLAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_area_element_set_alt(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
pub fn webkit_dom_html_area_element_set_coords(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
pub fn webkit_dom_html_area_element_set_hash(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_area_element_set_host(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_area_element_set_hostname(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
pub fn webkit_dom_html_area_element_set_href(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
pub fn webkit_dom_html_area_element_set_no_href(
self_: *mut WebKitDOMHTMLAreaElement,
value: gboolean,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_area_element_set_pathname(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_area_element_set_port(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_area_element_set_protocol(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_area_element_set_search(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
pub fn webkit_dom_html_area_element_set_shape(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
pub fn webkit_dom_html_area_element_set_target(
self_: *mut WebKitDOMHTMLAreaElement,
value: *const c_char,
);
pub fn webkit_dom_html_br_element_get_type() -> GType;
pub fn webkit_dom_html_br_element_get_clear(self_: *mut WebKitDOMHTMLBRElement) -> *mut c_char;
pub fn webkit_dom_html_br_element_set_clear(
self_: *mut WebKitDOMHTMLBRElement,
value: *const c_char,
);
pub fn webkit_dom_html_base_element_get_type() -> GType;
pub fn webkit_dom_html_base_element_get_href(
self_: *mut WebKitDOMHTMLBaseElement,
) -> *mut c_char;
pub fn webkit_dom_html_base_element_get_target(
self_: *mut WebKitDOMHTMLBaseElement,
) -> *mut c_char;
pub fn webkit_dom_html_base_element_set_href(
self_: *mut WebKitDOMHTMLBaseElement,
value: *const c_char,
);
pub fn webkit_dom_html_base_element_set_target(
self_: *mut WebKitDOMHTMLBaseElement,
value: *const c_char,
);
pub fn webkit_dom_html_base_font_element_get_type() -> GType;
pub fn webkit_dom_html_base_font_element_get_color(
self_: *mut WebKitDOMHTMLBaseFontElement,
) -> *mut c_char;
pub fn webkit_dom_html_base_font_element_get_face(
self_: *mut WebKitDOMHTMLBaseFontElement,
) -> *mut c_char;
pub fn webkit_dom_html_base_font_element_get_size(
self_: *mut WebKitDOMHTMLBaseFontElement,
) -> c_long;
pub fn webkit_dom_html_base_font_element_set_color(
self_: *mut WebKitDOMHTMLBaseFontElement,
value: *const c_char,
);
pub fn webkit_dom_html_base_font_element_set_face(
self_: *mut WebKitDOMHTMLBaseFontElement,
value: *const c_char,
);
pub fn webkit_dom_html_base_font_element_set_size(
self_: *mut WebKitDOMHTMLBaseFontElement,
value: c_long,
);
pub fn webkit_dom_html_body_element_get_type() -> GType;
pub fn webkit_dom_html_body_element_get_a_link(
self_: *mut WebKitDOMHTMLBodyElement,
) -> *mut c_char;
pub fn webkit_dom_html_body_element_get_background(
self_: *mut WebKitDOMHTMLBodyElement,
) -> *mut c_char;
pub fn webkit_dom_html_body_element_get_bg_color(
self_: *mut WebKitDOMHTMLBodyElement,
) -> *mut c_char;
pub fn webkit_dom_html_body_element_get_link(
self_: *mut WebKitDOMHTMLBodyElement,
) -> *mut c_char;
pub fn webkit_dom_html_body_element_get_text(
self_: *mut WebKitDOMHTMLBodyElement,
) -> *mut c_char;
pub fn webkit_dom_html_body_element_get_v_link(
self_: *mut WebKitDOMHTMLBodyElement,
) -> *mut c_char;
pub fn webkit_dom_html_body_element_set_a_link(
self_: *mut WebKitDOMHTMLBodyElement,
value: *const c_char,
);
pub fn webkit_dom_html_body_element_set_background(
self_: *mut WebKitDOMHTMLBodyElement,
value: *const c_char,
);
pub fn webkit_dom_html_body_element_set_bg_color(
self_: *mut WebKitDOMHTMLBodyElement,
value: *const c_char,
);
pub fn webkit_dom_html_body_element_set_link(
self_: *mut WebKitDOMHTMLBodyElement,
value: *const c_char,
);
pub fn webkit_dom_html_body_element_set_text(
self_: *mut WebKitDOMHTMLBodyElement,
value: *const c_char,
);
pub fn webkit_dom_html_body_element_set_v_link(
self_: *mut WebKitDOMHTMLBodyElement,
value: *const c_char,
);
pub fn webkit_dom_html_button_element_get_type() -> GType;
pub fn webkit_dom_html_button_element_get_autofocus(
self_: *mut WebKitDOMHTMLButtonElement,
) -> gboolean;
pub fn webkit_dom_html_button_element_get_button_type(
self_: *mut WebKitDOMHTMLButtonElement,
) -> *mut c_char;
pub fn webkit_dom_html_button_element_get_disabled(
self_: *mut WebKitDOMHTMLButtonElement,
) -> gboolean;
pub fn webkit_dom_html_button_element_get_form(
self_: *mut WebKitDOMHTMLButtonElement,
) -> *mut WebKitDOMHTMLFormElement;
pub fn webkit_dom_html_button_element_get_name(
self_: *mut WebKitDOMHTMLButtonElement,
) -> *mut c_char;
pub fn webkit_dom_html_button_element_get_value(
self_: *mut WebKitDOMHTMLButtonElement,
) -> *mut c_char;
pub fn webkit_dom_html_button_element_get_will_validate(
self_: *mut WebKitDOMHTMLButtonElement,
) -> gboolean;
pub fn webkit_dom_html_button_element_set_autofocus(
self_: *mut WebKitDOMHTMLButtonElement,
value: gboolean,
);
pub fn webkit_dom_html_button_element_set_button_type(
self_: *mut WebKitDOMHTMLButtonElement,
value: *const c_char,
);
pub fn webkit_dom_html_button_element_set_disabled(
self_: *mut WebKitDOMHTMLButtonElement,
value: gboolean,
);
pub fn webkit_dom_html_button_element_set_name(
self_: *mut WebKitDOMHTMLButtonElement,
value: *const c_char,
);
pub fn webkit_dom_html_button_element_set_value(
self_: *mut WebKitDOMHTMLButtonElement,
value: *const c_char,
);
pub fn webkit_dom_html_canvas_element_get_type() -> GType;
pub fn webkit_dom_html_canvas_element_get_height(
self_: *mut WebKitDOMHTMLCanvasElement,
) -> c_long;
pub fn webkit_dom_html_canvas_element_get_width(
self_: *mut WebKitDOMHTMLCanvasElement,
) -> c_long;
pub fn webkit_dom_html_canvas_element_set_height(
self_: *mut WebKitDOMHTMLCanvasElement,
value: c_long,
);
pub fn webkit_dom_html_canvas_element_set_width(
self_: *mut WebKitDOMHTMLCanvasElement,
value: c_long,
);
pub fn webkit_dom_html_collection_get_type() -> GType;
pub fn webkit_dom_html_collection_get_length(self_: *mut WebKitDOMHTMLCollection) -> c_ulong;
pub fn webkit_dom_html_collection_item(
self_: *mut WebKitDOMHTMLCollection,
index: c_ulong,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_html_collection_named_item(
self_: *mut WebKitDOMHTMLCollection,
name: *const c_char,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_html_d_list_element_get_type() -> GType;
pub fn webkit_dom_html_d_list_element_get_compact(
self_: *mut WebKitDOMHTMLDListElement,
) -> gboolean;
pub fn webkit_dom_html_d_list_element_set_compact(
self_: *mut WebKitDOMHTMLDListElement,
value: gboolean,
);
pub fn webkit_dom_html_directory_element_get_type() -> GType;
pub fn webkit_dom_html_directory_element_get_compact(
self_: *mut WebKitDOMHTMLDirectoryElement,
) -> gboolean;
pub fn webkit_dom_html_directory_element_set_compact(
self_: *mut WebKitDOMHTMLDirectoryElement,
value: gboolean,
);
pub fn webkit_dom_html_div_element_get_type() -> GType;
pub fn webkit_dom_html_div_element_get_align(
self_: *mut WebKitDOMHTMLDivElement,
) -> *mut c_char;
pub fn webkit_dom_html_div_element_set_align(
self_: *mut WebKitDOMHTMLDivElement,
value: *const c_char,
);
pub fn webkit_dom_html_document_get_type() -> GType;
pub fn webkit_dom_html_document_capture_events(self_: *mut WebKitDOMHTMLDocument);
pub fn webkit_dom_html_document_clear(self_: *mut WebKitDOMHTMLDocument);
pub fn webkit_dom_html_document_close(self_: *mut WebKitDOMHTMLDocument);
pub fn webkit_dom_html_document_get_alink_color(
self_: *mut WebKitDOMHTMLDocument,
) -> *mut c_char;
pub fn webkit_dom_html_document_get_bg_color(self_: *mut WebKitDOMHTMLDocument) -> *mut c_char;
pub fn webkit_dom_html_document_get_compat_mode(
self_: *mut WebKitDOMHTMLDocument,
) -> *mut c_char;
pub fn webkit_dom_html_document_get_design_mode(
self_: *mut WebKitDOMHTMLDocument,
) -> *mut c_char;
pub fn webkit_dom_html_document_get_dir(self_: *mut WebKitDOMHTMLDocument) -> *mut c_char;
pub fn webkit_dom_html_document_get_embeds(
self_: *mut WebKitDOMHTMLDocument,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_html_document_get_fg_color(self_: *mut WebKitDOMHTMLDocument) -> *mut c_char;
pub fn webkit_dom_html_document_get_height(self_: *mut WebKitDOMHTMLDocument) -> c_long;
pub fn webkit_dom_html_document_get_link_color(
self_: *mut WebKitDOMHTMLDocument,
) -> *mut c_char;
pub fn webkit_dom_html_document_get_plugins(
self_: *mut WebKitDOMHTMLDocument,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_html_document_get_scripts(
self_: *mut WebKitDOMHTMLDocument,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_html_document_get_vlink_color(
self_: *mut WebKitDOMHTMLDocument,
) -> *mut c_char;
pub fn webkit_dom_html_document_get_width(self_: *mut WebKitDOMHTMLDocument) -> c_long;
pub fn webkit_dom_html_document_release_events(self_: *mut WebKitDOMHTMLDocument);
pub fn webkit_dom_html_document_set_alink_color(
self_: *mut WebKitDOMHTMLDocument,
value: *const c_char,
);
pub fn webkit_dom_html_document_set_bg_color(
self_: *mut WebKitDOMHTMLDocument,
value: *const c_char,
);
pub fn webkit_dom_html_document_set_design_mode(
self_: *mut WebKitDOMHTMLDocument,
value: *const c_char,
);
pub fn webkit_dom_html_document_set_dir(
self_: *mut WebKitDOMHTMLDocument,
value: *const c_char,
);
pub fn webkit_dom_html_document_set_fg_color(
self_: *mut WebKitDOMHTMLDocument,
value: *const c_char,
);
pub fn webkit_dom_html_document_set_link_color(
self_: *mut WebKitDOMHTMLDocument,
value: *const c_char,
);
pub fn webkit_dom_html_document_set_vlink_color(
self_: *mut WebKitDOMHTMLDocument,
value: *const c_char,
);
pub fn webkit_dom_html_element_get_type() -> GType;
pub fn webkit_dom_html_element_click(self_: *mut WebKitDOMHTMLElement);
pub fn webkit_dom_html_element_get_access_key(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
pub fn webkit_dom_html_element_get_children(
self_: *mut WebKitDOMHTMLElement,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_html_element_get_content_editable(
self_: *mut WebKitDOMHTMLElement,
) -> *mut c_char;
pub fn webkit_dom_html_element_get_dir(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_element_get_draggable(self_: *mut WebKitDOMHTMLElement) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_element_get_hidden(self_: *mut WebKitDOMHTMLElement) -> gboolean;
pub fn webkit_dom_html_element_get_inner_html(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
pub fn webkit_dom_html_element_get_inner_text(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
pub fn webkit_dom_html_element_get_is_content_editable(
self_: *mut WebKitDOMHTMLElement,
) -> gboolean;
pub fn webkit_dom_html_element_get_lang(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
pub fn webkit_dom_html_element_get_outer_html(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
pub fn webkit_dom_html_element_get_outer_text(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_element_get_spellcheck(self_: *mut WebKitDOMHTMLElement) -> gboolean;
pub fn webkit_dom_html_element_get_tab_index(self_: *mut WebKitDOMHTMLElement) -> c_long;
pub fn webkit_dom_html_element_get_title(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_element_get_translate(self_: *mut WebKitDOMHTMLElement) -> gboolean;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_element_get_webkitdropzone(
self_: *mut WebKitDOMHTMLElement,
) -> *mut c_char;
pub fn webkit_dom_html_element_set_access_key(
self_: *mut WebKitDOMHTMLElement,
value: *const c_char,
);
pub fn webkit_dom_html_element_set_content_editable(
self_: *mut WebKitDOMHTMLElement,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_element_set_dir(self_: *mut WebKitDOMHTMLElement, value: *const c_char);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_element_set_draggable(self_: *mut WebKitDOMHTMLElement, value: gboolean);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_element_set_hidden(self_: *mut WebKitDOMHTMLElement, value: gboolean);
pub fn webkit_dom_html_element_set_inner_html(
self_: *mut WebKitDOMHTMLElement,
contents: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_element_set_inner_text(
self_: *mut WebKitDOMHTMLElement,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_element_set_lang(self_: *mut WebKitDOMHTMLElement, value: *const c_char);
pub fn webkit_dom_html_element_set_outer_html(
self_: *mut WebKitDOMHTMLElement,
contents: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_element_set_outer_text(
self_: *mut WebKitDOMHTMLElement,
value: *const c_char,
error: *mut *mut glib::GError,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_element_set_spellcheck(
self_: *mut WebKitDOMHTMLElement,
value: gboolean,
);
pub fn webkit_dom_html_element_set_tab_index(self_: *mut WebKitDOMHTMLElement, value: c_long);
pub fn webkit_dom_html_element_set_title(
self_: *mut WebKitDOMHTMLElement,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_element_set_translate(self_: *mut WebKitDOMHTMLElement, value: gboolean);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_element_set_webkitdropzone(
self_: *mut WebKitDOMHTMLElement,
value: *const c_char,
);
pub fn webkit_dom_html_embed_element_get_type() -> GType;
pub fn webkit_dom_html_embed_element_get_align(
self_: *mut WebKitDOMHTMLEmbedElement,
) -> *mut c_char;
pub fn webkit_dom_html_embed_element_get_height(
self_: *mut WebKitDOMHTMLEmbedElement,
) -> c_long;
pub fn webkit_dom_html_embed_element_get_name(
self_: *mut WebKitDOMHTMLEmbedElement,
) -> *mut c_char;
pub fn webkit_dom_html_embed_element_get_src(
self_: *mut WebKitDOMHTMLEmbedElement,
) -> *mut c_char;
pub fn webkit_dom_html_embed_element_get_type_attr(
self_: *mut WebKitDOMHTMLEmbedElement,
) -> *mut c_char;
pub fn webkit_dom_html_embed_element_get_width(self_: *mut WebKitDOMHTMLEmbedElement)
-> c_long;
pub fn webkit_dom_html_embed_element_set_align(
self_: *mut WebKitDOMHTMLEmbedElement,
value: *const c_char,
);
pub fn webkit_dom_html_embed_element_set_height(
self_: *mut WebKitDOMHTMLEmbedElement,
value: c_long,
);
pub fn webkit_dom_html_embed_element_set_name(
self_: *mut WebKitDOMHTMLEmbedElement,
value: *const c_char,
);
pub fn webkit_dom_html_embed_element_set_src(
self_: *mut WebKitDOMHTMLEmbedElement,
value: *const c_char,
);
pub fn webkit_dom_html_embed_element_set_type_attr(
self_: *mut WebKitDOMHTMLEmbedElement,
value: *const c_char,
);
pub fn webkit_dom_html_embed_element_set_width(
self_: *mut WebKitDOMHTMLEmbedElement,
value: c_long,
);
pub fn webkit_dom_html_field_set_element_get_type() -> GType;
pub fn webkit_dom_html_field_set_element_get_form(
self_: *mut WebKitDOMHTMLFieldSetElement,
) -> *mut WebKitDOMHTMLFormElement;
pub fn webkit_dom_html_font_element_get_type() -> GType;
pub fn webkit_dom_html_font_element_get_color(
self_: *mut WebKitDOMHTMLFontElement,
) -> *mut c_char;
pub fn webkit_dom_html_font_element_get_face(
self_: *mut WebKitDOMHTMLFontElement,
) -> *mut c_char;
pub fn webkit_dom_html_font_element_get_size(
self_: *mut WebKitDOMHTMLFontElement,
) -> *mut c_char;
pub fn webkit_dom_html_font_element_set_color(
self_: *mut WebKitDOMHTMLFontElement,
value: *const c_char,
);
pub fn webkit_dom_html_font_element_set_face(
self_: *mut WebKitDOMHTMLFontElement,
value: *const c_char,
);
pub fn webkit_dom_html_font_element_set_size(
self_: *mut WebKitDOMHTMLFontElement,
value: *const c_char,
);
pub fn webkit_dom_html_form_element_get_type() -> GType;
pub fn webkit_dom_html_form_element_get_accept_charset(
self_: *mut WebKitDOMHTMLFormElement,
) -> *mut c_char;
pub fn webkit_dom_html_form_element_get_action(
self_: *mut WebKitDOMHTMLFormElement,
) -> *mut c_char;
pub fn webkit_dom_html_form_element_get_elements(
self_: *mut WebKitDOMHTMLFormElement,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_html_form_element_get_encoding(
self_: *mut WebKitDOMHTMLFormElement,
) -> *mut c_char;
pub fn webkit_dom_html_form_element_get_enctype(
self_: *mut WebKitDOMHTMLFormElement,
) -> *mut c_char;
pub fn webkit_dom_html_form_element_get_length(self_: *mut WebKitDOMHTMLFormElement) -> c_long;
pub fn webkit_dom_html_form_element_get_method(
self_: *mut WebKitDOMHTMLFormElement,
) -> *mut c_char;
pub fn webkit_dom_html_form_element_get_name(
self_: *mut WebKitDOMHTMLFormElement,
) -> *mut c_char;
pub fn webkit_dom_html_form_element_get_target(
self_: *mut WebKitDOMHTMLFormElement,
) -> *mut c_char;
pub fn webkit_dom_html_form_element_reset(self_: *mut WebKitDOMHTMLFormElement);
pub fn webkit_dom_html_form_element_set_accept_charset(
self_: *mut WebKitDOMHTMLFormElement,
value: *const c_char,
);
pub fn webkit_dom_html_form_element_set_action(
self_: *mut WebKitDOMHTMLFormElement,
value: *const c_char,
);
pub fn webkit_dom_html_form_element_set_encoding(
self_: *mut WebKitDOMHTMLFormElement,
value: *const c_char,
);
pub fn webkit_dom_html_form_element_set_enctype(
self_: *mut WebKitDOMHTMLFormElement,
value: *const c_char,
);
pub fn webkit_dom_html_form_element_set_method(
self_: *mut WebKitDOMHTMLFormElement,
value: *const c_char,
);
pub fn webkit_dom_html_form_element_set_name(
self_: *mut WebKitDOMHTMLFormElement,
value: *const c_char,
);
pub fn webkit_dom_html_form_element_set_target(
self_: *mut WebKitDOMHTMLFormElement,
value: *const c_char,
);
pub fn webkit_dom_html_form_element_submit(self_: *mut WebKitDOMHTMLFormElement);
pub fn webkit_dom_html_frame_element_get_type() -> GType;
pub fn webkit_dom_html_frame_element_get_content_document(
self_: *mut WebKitDOMHTMLFrameElement,
) -> *mut WebKitDOMDocument;
pub fn webkit_dom_html_frame_element_get_content_window(
self_: *mut WebKitDOMHTMLFrameElement,
) -> *mut WebKitDOMDOMWindow;
pub fn webkit_dom_html_frame_element_get_frame_border(
self_: *mut WebKitDOMHTMLFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_frame_element_get_height(
self_: *mut WebKitDOMHTMLFrameElement,
) -> c_long;
pub fn webkit_dom_html_frame_element_get_long_desc(
self_: *mut WebKitDOMHTMLFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_frame_element_get_margin_height(
self_: *mut WebKitDOMHTMLFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_frame_element_get_margin_width(
self_: *mut WebKitDOMHTMLFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_frame_element_get_name(
self_: *mut WebKitDOMHTMLFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_frame_element_get_no_resize(
self_: *mut WebKitDOMHTMLFrameElement,
) -> gboolean;
pub fn webkit_dom_html_frame_element_get_scrolling(
self_: *mut WebKitDOMHTMLFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_frame_element_get_src(
self_: *mut WebKitDOMHTMLFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_frame_element_get_width(self_: *mut WebKitDOMHTMLFrameElement)
-> c_long;
pub fn webkit_dom_html_frame_element_set_frame_border(
self_: *mut WebKitDOMHTMLFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_frame_element_set_long_desc(
self_: *mut WebKitDOMHTMLFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_frame_element_set_margin_height(
self_: *mut WebKitDOMHTMLFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_frame_element_set_margin_width(
self_: *mut WebKitDOMHTMLFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_frame_element_set_name(
self_: *mut WebKitDOMHTMLFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_frame_element_set_no_resize(
self_: *mut WebKitDOMHTMLFrameElement,
value: gboolean,
);
pub fn webkit_dom_html_frame_element_set_scrolling(
self_: *mut WebKitDOMHTMLFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_frame_element_set_src(
self_: *mut WebKitDOMHTMLFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_frame_set_element_get_type() -> GType;
pub fn webkit_dom_html_frame_set_element_get_cols(
self_: *mut WebKitDOMHTMLFrameSetElement,
) -> *mut c_char;
pub fn webkit_dom_html_frame_set_element_get_rows(
self_: *mut WebKitDOMHTMLFrameSetElement,
) -> *mut c_char;
pub fn webkit_dom_html_frame_set_element_set_cols(
self_: *mut WebKitDOMHTMLFrameSetElement,
value: *const c_char,
);
pub fn webkit_dom_html_frame_set_element_set_rows(
self_: *mut WebKitDOMHTMLFrameSetElement,
value: *const c_char,
);
pub fn webkit_dom_html_hr_element_get_type() -> GType;
pub fn webkit_dom_html_hr_element_get_align(self_: *mut WebKitDOMHTMLHRElement) -> *mut c_char;
pub fn webkit_dom_html_hr_element_get_no_shade(self_: *mut WebKitDOMHTMLHRElement) -> gboolean;
pub fn webkit_dom_html_hr_element_get_size(self_: *mut WebKitDOMHTMLHRElement) -> *mut c_char;
pub fn webkit_dom_html_hr_element_get_width(self_: *mut WebKitDOMHTMLHRElement) -> *mut c_char;
pub fn webkit_dom_html_hr_element_set_align(
self_: *mut WebKitDOMHTMLHRElement,
value: *const c_char,
);
pub fn webkit_dom_html_hr_element_set_no_shade(
self_: *mut WebKitDOMHTMLHRElement,
value: gboolean,
);
pub fn webkit_dom_html_hr_element_set_size(
self_: *mut WebKitDOMHTMLHRElement,
value: *const c_char,
);
pub fn webkit_dom_html_hr_element_set_width(
self_: *mut WebKitDOMHTMLHRElement,
value: *const c_char,
);
pub fn webkit_dom_html_head_element_get_type() -> GType;
pub fn webkit_dom_html_head_element_get_profile(
self_: *mut WebKitDOMHTMLHeadElement,
) -> *mut c_char;
pub fn webkit_dom_html_head_element_set_profile(
self_: *mut WebKitDOMHTMLHeadElement,
value: *const c_char,
);
pub fn webkit_dom_html_heading_element_get_type() -> GType;
pub fn webkit_dom_html_heading_element_get_align(
self_: *mut WebKitDOMHTMLHeadingElement,
) -> *mut c_char;
pub fn webkit_dom_html_heading_element_set_align(
self_: *mut WebKitDOMHTMLHeadingElement,
value: *const c_char,
);
pub fn webkit_dom_html_html_element_get_type() -> GType;
pub fn webkit_dom_html_html_element_get_version(
self_: *mut WebKitDOMHTMLHtmlElement,
) -> *mut c_char;
pub fn webkit_dom_html_html_element_set_version(
self_: *mut WebKitDOMHTMLHtmlElement,
value: *const c_char,
);
pub fn webkit_dom_html_iframe_element_get_type() -> GType;
pub fn webkit_dom_html_iframe_element_get_align(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_iframe_element_get_content_document(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut WebKitDOMDocument;
pub fn webkit_dom_html_iframe_element_get_content_window(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut WebKitDOMDOMWindow;
pub fn webkit_dom_html_iframe_element_get_frame_border(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_iframe_element_get_height(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_iframe_element_get_long_desc(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_iframe_element_get_margin_height(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_iframe_element_get_margin_width(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_iframe_element_get_name(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_iframe_element_get_scrolling(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_iframe_element_get_src(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_iframe_element_get_width(
self_: *mut WebKitDOMHTMLIFrameElement,
) -> *mut c_char;
pub fn webkit_dom_html_iframe_element_set_align(
self_: *mut WebKitDOMHTMLIFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_iframe_element_set_frame_border(
self_: *mut WebKitDOMHTMLIFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_iframe_element_set_height(
self_: *mut WebKitDOMHTMLIFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_iframe_element_set_long_desc(
self_: *mut WebKitDOMHTMLIFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_iframe_element_set_margin_height(
self_: *mut WebKitDOMHTMLIFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_iframe_element_set_margin_width(
self_: *mut WebKitDOMHTMLIFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_iframe_element_set_name(
self_: *mut WebKitDOMHTMLIFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_iframe_element_set_scrolling(
self_: *mut WebKitDOMHTMLIFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_iframe_element_set_src(
self_: *mut WebKitDOMHTMLIFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_iframe_element_set_width(
self_: *mut WebKitDOMHTMLIFrameElement,
value: *const c_char,
);
pub fn webkit_dom_html_image_element_get_type() -> GType;
pub fn webkit_dom_html_image_element_get_align(
self_: *mut WebKitDOMHTMLImageElement,
) -> *mut c_char;
pub fn webkit_dom_html_image_element_get_alt(
self_: *mut WebKitDOMHTMLImageElement,
) -> *mut c_char;
pub fn webkit_dom_html_image_element_get_border(
self_: *mut WebKitDOMHTMLImageElement,
) -> *mut c_char;
pub fn webkit_dom_html_image_element_get_complete(
self_: *mut WebKitDOMHTMLImageElement,
) -> gboolean;
pub fn webkit_dom_html_image_element_get_height(
self_: *mut WebKitDOMHTMLImageElement,
) -> c_long;
pub fn webkit_dom_html_image_element_get_hspace(
self_: *mut WebKitDOMHTMLImageElement,
) -> c_long;
pub fn webkit_dom_html_image_element_get_is_map(
self_: *mut WebKitDOMHTMLImageElement,
) -> gboolean;
pub fn webkit_dom_html_image_element_get_long_desc(
self_: *mut WebKitDOMHTMLImageElement,
) -> *mut c_char;
pub fn webkit_dom_html_image_element_get_lowsrc(
self_: *mut WebKitDOMHTMLImageElement,
) -> *mut c_char;
pub fn webkit_dom_html_image_element_get_name(
self_: *mut WebKitDOMHTMLImageElement,
) -> *mut c_char;
pub fn webkit_dom_html_image_element_get_natural_height(
self_: *mut WebKitDOMHTMLImageElement,
) -> c_long;
pub fn webkit_dom_html_image_element_get_natural_width(
self_: *mut WebKitDOMHTMLImageElement,
) -> c_long;
pub fn webkit_dom_html_image_element_get_src(
self_: *mut WebKitDOMHTMLImageElement,
) -> *mut c_char;
pub fn webkit_dom_html_image_element_get_use_map(
self_: *mut WebKitDOMHTMLImageElement,
) -> *mut c_char;
pub fn webkit_dom_html_image_element_get_vspace(
self_: *mut WebKitDOMHTMLImageElement,
) -> c_long;
pub fn webkit_dom_html_image_element_get_width(self_: *mut WebKitDOMHTMLImageElement)
-> c_long;
pub fn webkit_dom_html_image_element_get_x(self_: *mut WebKitDOMHTMLImageElement) -> c_long;
pub fn webkit_dom_html_image_element_get_y(self_: *mut WebKitDOMHTMLImageElement) -> c_long;
pub fn webkit_dom_html_image_element_set_align(
self_: *mut WebKitDOMHTMLImageElement,
value: *const c_char,
);
pub fn webkit_dom_html_image_element_set_alt(
self_: *mut WebKitDOMHTMLImageElement,
value: *const c_char,
);
pub fn webkit_dom_html_image_element_set_border(
self_: *mut WebKitDOMHTMLImageElement,
value: *const c_char,
);
pub fn webkit_dom_html_image_element_set_height(
self_: *mut WebKitDOMHTMLImageElement,
value: c_long,
);
pub fn webkit_dom_html_image_element_set_hspace(
self_: *mut WebKitDOMHTMLImageElement,
value: c_long,
);
pub fn webkit_dom_html_image_element_set_is_map(
self_: *mut WebKitDOMHTMLImageElement,
value: gboolean,
);
pub fn webkit_dom_html_image_element_set_long_desc(
self_: *mut WebKitDOMHTMLImageElement,
value: *const c_char,
);
pub fn webkit_dom_html_image_element_set_lowsrc(
self_: *mut WebKitDOMHTMLImageElement,
value: *const c_char,
);
pub fn webkit_dom_html_image_element_set_name(
self_: *mut WebKitDOMHTMLImageElement,
value: *const c_char,
);
pub fn webkit_dom_html_image_element_set_src(
self_: *mut WebKitDOMHTMLImageElement,
value: *const c_char,
);
pub fn webkit_dom_html_image_element_set_use_map(
self_: *mut WebKitDOMHTMLImageElement,
value: *const c_char,
);
pub fn webkit_dom_html_image_element_set_vspace(
self_: *mut WebKitDOMHTMLImageElement,
value: c_long,
);
pub fn webkit_dom_html_image_element_set_width(
self_: *mut WebKitDOMHTMLImageElement,
value: c_long,
);
pub fn webkit_dom_html_input_element_get_type() -> GType;
pub fn webkit_dom_html_input_element_get_accept(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut c_char;
pub fn webkit_dom_html_input_element_get_align(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut c_char;
pub fn webkit_dom_html_input_element_get_alt(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_input_element_get_auto_filled(
self_: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
pub fn webkit_dom_html_input_element_get_autofocus(
self_: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
pub fn webkit_dom_html_input_element_get_capture(
self_: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_html_input_element_get_capture_type(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut c_char;
pub fn webkit_dom_html_input_element_get_checked(
self_: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
pub fn webkit_dom_html_input_element_get_default_checked(
self_: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
pub fn webkit_dom_html_input_element_get_default_value(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut c_char;
pub fn webkit_dom_html_input_element_get_disabled(
self_: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
pub fn webkit_dom_html_input_element_get_files(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut WebKitDOMFileList;
pub fn webkit_dom_html_input_element_get_form(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut WebKitDOMHTMLFormElement;
pub fn webkit_dom_html_input_element_get_height(
self_: *mut WebKitDOMHTMLInputElement,
) -> c_ulong;
pub fn webkit_dom_html_input_element_get_indeterminate(
self_: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
pub fn webkit_dom_html_input_element_get_input_type(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut c_char;
pub fn webkit_dom_html_input_element_get_max_length(
self_: *mut WebKitDOMHTMLInputElement,
) -> c_long;
pub fn webkit_dom_html_input_element_get_multiple(
self_: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
pub fn webkit_dom_html_input_element_get_name(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_input_element_get_read_only(
self_: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
pub fn webkit_dom_html_input_element_get_size(self_: *mut WebKitDOMHTMLInputElement)
-> c_ulong;
pub fn webkit_dom_html_input_element_get_src(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut c_char;
pub fn webkit_dom_html_input_element_get_use_map(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut c_char;
pub fn webkit_dom_html_input_element_get_value(
self_: *mut WebKitDOMHTMLInputElement,
) -> *mut c_char;
pub fn webkit_dom_html_input_element_get_width(
self_: *mut WebKitDOMHTMLInputElement,
) -> c_ulong;
pub fn webkit_dom_html_input_element_get_will_validate(
self_: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
pub fn webkit_dom_html_input_element_is_edited(
input: *mut WebKitDOMHTMLInputElement,
) -> gboolean;
pub fn webkit_dom_html_input_element_select(self_: *mut WebKitDOMHTMLInputElement);
pub fn webkit_dom_html_input_element_set_accept(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
pub fn webkit_dom_html_input_element_set_align(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
pub fn webkit_dom_html_input_element_set_alt(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_input_element_set_auto_filled(
self_: *mut WebKitDOMHTMLInputElement,
value: gboolean,
);
pub fn webkit_dom_html_input_element_set_autofocus(
self_: *mut WebKitDOMHTMLInputElement,
value: gboolean,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_input_element_set_capture_type(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
pub fn webkit_dom_html_input_element_set_checked(
self_: *mut WebKitDOMHTMLInputElement,
value: gboolean,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_input_element_set_default_checked(
self_: *mut WebKitDOMHTMLInputElement,
value: gboolean,
);
pub fn webkit_dom_html_input_element_set_default_value(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
pub fn webkit_dom_html_input_element_set_disabled(
self_: *mut WebKitDOMHTMLInputElement,
value: gboolean,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_input_element_set_editing_value(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
pub fn webkit_dom_html_input_element_set_files(
self_: *mut WebKitDOMHTMLInputElement,
value: *mut WebKitDOMFileList,
);
pub fn webkit_dom_html_input_element_set_height(
self_: *mut WebKitDOMHTMLInputElement,
value: c_ulong,
);
pub fn webkit_dom_html_input_element_set_indeterminate(
self_: *mut WebKitDOMHTMLInputElement,
value: gboolean,
);
pub fn webkit_dom_html_input_element_set_input_type(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
pub fn webkit_dom_html_input_element_set_max_length(
self_: *mut WebKitDOMHTMLInputElement,
value: c_long,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_input_element_set_multiple(
self_: *mut WebKitDOMHTMLInputElement,
value: gboolean,
);
pub fn webkit_dom_html_input_element_set_name(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
pub fn webkit_dom_html_input_element_set_read_only(
self_: *mut WebKitDOMHTMLInputElement,
value: gboolean,
);
pub fn webkit_dom_html_input_element_set_size(
self_: *mut WebKitDOMHTMLInputElement,
value: c_ulong,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_input_element_set_src(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
pub fn webkit_dom_html_input_element_set_use_map(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
pub fn webkit_dom_html_input_element_set_value(
self_: *mut WebKitDOMHTMLInputElement,
value: *const c_char,
);
pub fn webkit_dom_html_input_element_set_width(
self_: *mut WebKitDOMHTMLInputElement,
value: c_ulong,
);
pub fn webkit_dom_html_li_element_get_type() -> GType;
pub fn webkit_dom_html_li_element_get_type_attr(
self_: *mut WebKitDOMHTMLLIElement,
) -> *mut c_char;
pub fn webkit_dom_html_li_element_get_value(self_: *mut WebKitDOMHTMLLIElement) -> c_long;
pub fn webkit_dom_html_li_element_set_type_attr(
self_: *mut WebKitDOMHTMLLIElement,
value: *const c_char,
);
pub fn webkit_dom_html_li_element_set_value(self_: *mut WebKitDOMHTMLLIElement, value: c_long);
pub fn webkit_dom_html_label_element_get_type() -> GType;
pub fn webkit_dom_html_label_element_get_form(
self_: *mut WebKitDOMHTMLLabelElement,
) -> *mut WebKitDOMHTMLFormElement;
pub fn webkit_dom_html_label_element_get_html_for(
self_: *mut WebKitDOMHTMLLabelElement,
) -> *mut c_char;
pub fn webkit_dom_html_label_element_set_html_for(
self_: *mut WebKitDOMHTMLLabelElement,
value: *const c_char,
);
pub fn webkit_dom_html_legend_element_get_type() -> GType;
pub fn webkit_dom_html_legend_element_get_align(
self_: *mut WebKitDOMHTMLLegendElement,
) -> *mut c_char;
pub fn webkit_dom_html_legend_element_get_form(
self_: *mut WebKitDOMHTMLLegendElement,
) -> *mut WebKitDOMHTMLFormElement;
pub fn webkit_dom_html_legend_element_set_align(
self_: *mut WebKitDOMHTMLLegendElement,
value: *const c_char,
);
pub fn webkit_dom_html_link_element_get_type() -> GType;
pub fn webkit_dom_html_link_element_get_charset(
self_: *mut WebKitDOMHTMLLinkElement,
) -> *mut c_char;
pub fn webkit_dom_html_link_element_get_disabled(
self_: *mut WebKitDOMHTMLLinkElement,
) -> gboolean;
pub fn webkit_dom_html_link_element_get_href(
self_: *mut WebKitDOMHTMLLinkElement,
) -> *mut c_char;
pub fn webkit_dom_html_link_element_get_hreflang(
self_: *mut WebKitDOMHTMLLinkElement,
) -> *mut c_char;
pub fn webkit_dom_html_link_element_get_media(
self_: *mut WebKitDOMHTMLLinkElement,
) -> *mut c_char;
pub fn webkit_dom_html_link_element_get_rel(
self_: *mut WebKitDOMHTMLLinkElement,
) -> *mut c_char;
pub fn webkit_dom_html_link_element_get_rev(
self_: *mut WebKitDOMHTMLLinkElement,
) -> *mut c_char;
pub fn webkit_dom_html_link_element_get_sheet(
self_: *mut WebKitDOMHTMLLinkElement,
) -> *mut WebKitDOMStyleSheet;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_link_element_get_sizes(
self_: *mut WebKitDOMHTMLLinkElement,
) -> *mut WebKitDOMDOMTokenList;
pub fn webkit_dom_html_link_element_get_target(
self_: *mut WebKitDOMHTMLLinkElement,
) -> *mut c_char;
pub fn webkit_dom_html_link_element_get_type_attr(
self_: *mut WebKitDOMHTMLLinkElement,
) -> *mut c_char;
pub fn webkit_dom_html_link_element_set_charset(
self_: *mut WebKitDOMHTMLLinkElement,
value: *const c_char,
);
pub fn webkit_dom_html_link_element_set_disabled(
self_: *mut WebKitDOMHTMLLinkElement,
value: gboolean,
);
pub fn webkit_dom_html_link_element_set_href(
self_: *mut WebKitDOMHTMLLinkElement,
value: *const c_char,
);
pub fn webkit_dom_html_link_element_set_hreflang(
self_: *mut WebKitDOMHTMLLinkElement,
value: *const c_char,
);
pub fn webkit_dom_html_link_element_set_media(
self_: *mut WebKitDOMHTMLLinkElement,
value: *const c_char,
);
pub fn webkit_dom_html_link_element_set_rel(
self_: *mut WebKitDOMHTMLLinkElement,
value: *const c_char,
);
pub fn webkit_dom_html_link_element_set_rev(
self_: *mut WebKitDOMHTMLLinkElement,
value: *const c_char,
);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_link_element_set_sizes(
self_: *mut WebKitDOMHTMLLinkElement,
value: *const c_char,
);
pub fn webkit_dom_html_link_element_set_target(
self_: *mut WebKitDOMHTMLLinkElement,
value: *const c_char,
);
pub fn webkit_dom_html_link_element_set_type_attr(
self_: *mut WebKitDOMHTMLLinkElement,
value: *const c_char,
);
pub fn webkit_dom_html_map_element_get_type() -> GType;
pub fn webkit_dom_html_map_element_get_areas(
self_: *mut WebKitDOMHTMLMapElement,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_html_map_element_get_name(self_: *mut WebKitDOMHTMLMapElement)
-> *mut c_char;
pub fn webkit_dom_html_map_element_set_name(
self_: *mut WebKitDOMHTMLMapElement,
value: *const c_char,
);
pub fn webkit_dom_html_marquee_element_get_type() -> GType;
pub fn webkit_dom_html_marquee_element_start(self_: *mut WebKitDOMHTMLMarqueeElement);
pub fn webkit_dom_html_marquee_element_stop(self_: *mut WebKitDOMHTMLMarqueeElement);
pub fn webkit_dom_html_menu_element_get_type() -> GType;
pub fn webkit_dom_html_menu_element_get_compact(
self_: *mut WebKitDOMHTMLMenuElement,
) -> gboolean;
pub fn webkit_dom_html_menu_element_set_compact(
self_: *mut WebKitDOMHTMLMenuElement,
value: gboolean,
);
pub fn webkit_dom_html_meta_element_get_type() -> GType;
pub fn webkit_dom_html_meta_element_get_content(
self_: *mut WebKitDOMHTMLMetaElement,
) -> *mut c_char;
pub fn webkit_dom_html_meta_element_get_http_equiv(
self_: *mut WebKitDOMHTMLMetaElement,
) -> *mut c_char;
pub fn webkit_dom_html_meta_element_get_name(
self_: *mut WebKitDOMHTMLMetaElement,
) -> *mut c_char;
pub fn webkit_dom_html_meta_element_get_scheme(
self_: *mut WebKitDOMHTMLMetaElement,
) -> *mut c_char;
pub fn webkit_dom_html_meta_element_set_content(
self_: *mut WebKitDOMHTMLMetaElement,
value: *const c_char,
);
pub fn webkit_dom_html_meta_element_set_http_equiv(
self_: *mut WebKitDOMHTMLMetaElement,
value: *const c_char,
);
pub fn webkit_dom_html_meta_element_set_name(
self_: *mut WebKitDOMHTMLMetaElement,
value: *const c_char,
);
pub fn webkit_dom_html_meta_element_set_scheme(
self_: *mut WebKitDOMHTMLMetaElement,
value: *const c_char,
);
pub fn webkit_dom_html_mod_element_get_type() -> GType;
pub fn webkit_dom_html_mod_element_get_cite(self_: *mut WebKitDOMHTMLModElement)
-> *mut c_char;
pub fn webkit_dom_html_mod_element_get_date_time(
self_: *mut WebKitDOMHTMLModElement,
) -> *mut c_char;
pub fn webkit_dom_html_mod_element_set_cite(
self_: *mut WebKitDOMHTMLModElement,
value: *const c_char,
);
pub fn webkit_dom_html_mod_element_set_date_time(
self_: *mut WebKitDOMHTMLModElement,
value: *const c_char,
);
pub fn webkit_dom_html_o_list_element_get_type() -> GType;
pub fn webkit_dom_html_o_list_element_get_compact(
self_: *mut WebKitDOMHTMLOListElement,
) -> gboolean;
pub fn webkit_dom_html_o_list_element_get_start(
self_: *mut WebKitDOMHTMLOListElement,
) -> c_long;
pub fn webkit_dom_html_o_list_element_get_type_attr(
self_: *mut WebKitDOMHTMLOListElement,
) -> *mut c_char;
pub fn webkit_dom_html_o_list_element_set_compact(
self_: *mut WebKitDOMHTMLOListElement,
value: gboolean,
);
pub fn webkit_dom_html_o_list_element_set_start(
self_: *mut WebKitDOMHTMLOListElement,
value: c_long,
);
pub fn webkit_dom_html_o_list_element_set_type_attr(
self_: *mut WebKitDOMHTMLOListElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_get_type() -> GType;
pub fn webkit_dom_html_object_element_get_align(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_archive(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_border(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_code(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_code_base(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_code_type(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_content_document(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut WebKitDOMDocument;
pub fn webkit_dom_html_object_element_get_data(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_declare(
self_: *mut WebKitDOMHTMLObjectElement,
) -> gboolean;
pub fn webkit_dom_html_object_element_get_form(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut WebKitDOMHTMLFormElement;
pub fn webkit_dom_html_object_element_get_height(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_hspace(
self_: *mut WebKitDOMHTMLObjectElement,
) -> c_long;
pub fn webkit_dom_html_object_element_get_name(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_standby(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_type_attr(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_use_map(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_get_vspace(
self_: *mut WebKitDOMHTMLObjectElement,
) -> c_long;
pub fn webkit_dom_html_object_element_get_width(
self_: *mut WebKitDOMHTMLObjectElement,
) -> *mut c_char;
pub fn webkit_dom_html_object_element_set_align(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_archive(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_border(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_code(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_code_base(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_code_type(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_data(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_declare(
self_: *mut WebKitDOMHTMLObjectElement,
value: gboolean,
);
pub fn webkit_dom_html_object_element_set_height(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_hspace(
self_: *mut WebKitDOMHTMLObjectElement,
value: c_long,
);
pub fn webkit_dom_html_object_element_set_name(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_standby(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_type_attr(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_use_map(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_object_element_set_vspace(
self_: *mut WebKitDOMHTMLObjectElement,
value: c_long,
);
pub fn webkit_dom_html_object_element_set_width(
self_: *mut WebKitDOMHTMLObjectElement,
value: *const c_char,
);
pub fn webkit_dom_html_opt_group_element_get_type() -> GType;
pub fn webkit_dom_html_opt_group_element_get_disabled(
self_: *mut WebKitDOMHTMLOptGroupElement,
) -> gboolean;
pub fn webkit_dom_html_opt_group_element_get_label(
self_: *mut WebKitDOMHTMLOptGroupElement,
) -> *mut c_char;
pub fn webkit_dom_html_opt_group_element_set_disabled(
self_: *mut WebKitDOMHTMLOptGroupElement,
value: gboolean,
);
pub fn webkit_dom_html_opt_group_element_set_label(
self_: *mut WebKitDOMHTMLOptGroupElement,
value: *const c_char,
);
pub fn webkit_dom_html_option_element_get_type() -> GType;
pub fn webkit_dom_html_option_element_get_default_selected(
self_: *mut WebKitDOMHTMLOptionElement,
) -> gboolean;
pub fn webkit_dom_html_option_element_get_disabled(
self_: *mut WebKitDOMHTMLOptionElement,
) -> gboolean;
pub fn webkit_dom_html_option_element_get_form(
self_: *mut WebKitDOMHTMLOptionElement,
) -> *mut WebKitDOMHTMLFormElement;
pub fn webkit_dom_html_option_element_get_index(
self_: *mut WebKitDOMHTMLOptionElement,
) -> c_long;
pub fn webkit_dom_html_option_element_get_label(
self_: *mut WebKitDOMHTMLOptionElement,
) -> *mut c_char;
pub fn webkit_dom_html_option_element_get_selected(
self_: *mut WebKitDOMHTMLOptionElement,
) -> gboolean;
pub fn webkit_dom_html_option_element_get_text(
self_: *mut WebKitDOMHTMLOptionElement,
) -> *mut c_char;
pub fn webkit_dom_html_option_element_get_value(
self_: *mut WebKitDOMHTMLOptionElement,
) -> *mut c_char;
pub fn webkit_dom_html_option_element_set_default_selected(
self_: *mut WebKitDOMHTMLOptionElement,
value: gboolean,
);
pub fn webkit_dom_html_option_element_set_disabled(
self_: *mut WebKitDOMHTMLOptionElement,
value: gboolean,
);
pub fn webkit_dom_html_option_element_set_label(
self_: *mut WebKitDOMHTMLOptionElement,
value: *const c_char,
);
pub fn webkit_dom_html_option_element_set_selected(
self_: *mut WebKitDOMHTMLOptionElement,
value: gboolean,
);
pub fn webkit_dom_html_option_element_set_value(
self_: *mut WebKitDOMHTMLOptionElement,
value: *const c_char,
);
pub fn webkit_dom_html_options_collection_get_type() -> GType;
pub fn webkit_dom_html_options_collection_get_length(
self_: *mut WebKitDOMHTMLOptionsCollection,
) -> c_ulong;
pub fn webkit_dom_html_options_collection_get_selected_index(
self_: *mut WebKitDOMHTMLOptionsCollection,
) -> c_long;
pub fn webkit_dom_html_options_collection_named_item(
self_: *mut WebKitDOMHTMLOptionsCollection,
name: *const c_char,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_html_options_collection_set_selected_index(
self_: *mut WebKitDOMHTMLOptionsCollection,
value: c_long,
);
pub fn webkit_dom_html_paragraph_element_get_type() -> GType;
pub fn webkit_dom_html_paragraph_element_get_align(
self_: *mut WebKitDOMHTMLParagraphElement,
) -> *mut c_char;
pub fn webkit_dom_html_paragraph_element_set_align(
self_: *mut WebKitDOMHTMLParagraphElement,
value: *const c_char,
);
pub fn webkit_dom_html_param_element_get_type() -> GType;
pub fn webkit_dom_html_param_element_get_name(
self_: *mut WebKitDOMHTMLParamElement,
) -> *mut c_char;
pub fn webkit_dom_html_param_element_get_type_attr(
self_: *mut WebKitDOMHTMLParamElement,
) -> *mut c_char;
pub fn webkit_dom_html_param_element_get_value(
self_: *mut WebKitDOMHTMLParamElement,
) -> *mut c_char;
pub fn webkit_dom_html_param_element_get_value_type(
self_: *mut WebKitDOMHTMLParamElement,
) -> *mut c_char;
pub fn webkit_dom_html_param_element_set_name(
self_: *mut WebKitDOMHTMLParamElement,
value: *const c_char,
);
pub fn webkit_dom_html_param_element_set_type_attr(
self_: *mut WebKitDOMHTMLParamElement,
value: *const c_char,
);
pub fn webkit_dom_html_param_element_set_value(
self_: *mut WebKitDOMHTMLParamElement,
value: *const c_char,
);
pub fn webkit_dom_html_param_element_set_value_type(
self_: *mut WebKitDOMHTMLParamElement,
value: *const c_char,
);
pub fn webkit_dom_html_pre_element_get_type() -> GType;
pub fn webkit_dom_html_pre_element_get_width(self_: *mut WebKitDOMHTMLPreElement) -> c_long;
pub fn webkit_dom_html_pre_element_get_wrap(self_: *mut WebKitDOMHTMLPreElement) -> gboolean;
pub fn webkit_dom_html_pre_element_set_width(
self_: *mut WebKitDOMHTMLPreElement,
value: c_long,
);
pub fn webkit_dom_html_pre_element_set_wrap(
self_: *mut WebKitDOMHTMLPreElement,
value: gboolean,
);
pub fn webkit_dom_html_quote_element_get_type() -> GType;
pub fn webkit_dom_html_quote_element_get_cite(
self_: *mut WebKitDOMHTMLQuoteElement,
) -> *mut c_char;
pub fn webkit_dom_html_quote_element_set_cite(
self_: *mut WebKitDOMHTMLQuoteElement,
value: *const c_char,
);
pub fn webkit_dom_html_script_element_get_type() -> GType;
pub fn webkit_dom_html_script_element_get_charset(
self_: *mut WebKitDOMHTMLScriptElement,
) -> *mut c_char;
pub fn webkit_dom_html_script_element_get_defer(
self_: *mut WebKitDOMHTMLScriptElement,
) -> gboolean;
pub fn webkit_dom_html_script_element_get_event(
self_: *mut WebKitDOMHTMLScriptElement,
) -> *mut c_char;
pub fn webkit_dom_html_script_element_get_html_for(
self_: *mut WebKitDOMHTMLScriptElement,
) -> *mut c_char;
pub fn webkit_dom_html_script_element_get_src(
self_: *mut WebKitDOMHTMLScriptElement,
) -> *mut c_char;
pub fn webkit_dom_html_script_element_get_text(
self_: *mut WebKitDOMHTMLScriptElement,
) -> *mut c_char;
pub fn webkit_dom_html_script_element_get_type_attr(
self_: *mut WebKitDOMHTMLScriptElement,
) -> *mut c_char;
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_html_script_element_set_charset(
self_: *mut WebKitDOMHTMLScriptElement,
value: *const c_char,
);
pub fn webkit_dom_html_script_element_set_defer(
self_: *mut WebKitDOMHTMLScriptElement,
value: gboolean,
);
pub fn webkit_dom_html_script_element_set_event(
self_: *mut WebKitDOMHTMLScriptElement,
value: *const c_char,
);
pub fn webkit_dom_html_script_element_set_html_for(
self_: *mut WebKitDOMHTMLScriptElement,
value: *const c_char,
);
pub fn webkit_dom_html_script_element_set_src(
self_: *mut WebKitDOMHTMLScriptElement,
value: *const c_char,
);
pub fn webkit_dom_html_script_element_set_text(
self_: *mut WebKitDOMHTMLScriptElement,
value: *const c_char,
);
pub fn webkit_dom_html_script_element_set_type_attr(
self_: *mut WebKitDOMHTMLScriptElement,
value: *const c_char,
);
pub fn webkit_dom_html_select_element_get_type() -> GType;
pub fn webkit_dom_html_select_element_add(
self_: *mut WebKitDOMHTMLSelectElement,
element: *mut WebKitDOMHTMLElement,
before: *mut WebKitDOMHTMLElement,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_select_element_get_autofocus(
self_: *mut WebKitDOMHTMLSelectElement,
) -> gboolean;
pub fn webkit_dom_html_select_element_get_disabled(
self_: *mut WebKitDOMHTMLSelectElement,
) -> gboolean;
pub fn webkit_dom_html_select_element_get_form(
self_: *mut WebKitDOMHTMLSelectElement,
) -> *mut WebKitDOMHTMLFormElement;
pub fn webkit_dom_html_select_element_get_length(
self_: *mut WebKitDOMHTMLSelectElement,
) -> c_ulong;
pub fn webkit_dom_html_select_element_get_multiple(
self_: *mut WebKitDOMHTMLSelectElement,
) -> gboolean;
pub fn webkit_dom_html_select_element_get_name(
self_: *mut WebKitDOMHTMLSelectElement,
) -> *mut c_char;
pub fn webkit_dom_html_select_element_get_options(
self_: *mut WebKitDOMHTMLSelectElement,
) -> *mut WebKitDOMHTMLOptionsCollection;
pub fn webkit_dom_html_select_element_get_select_type(
self_: *mut WebKitDOMHTMLSelectElement,
) -> *mut c_char;
pub fn webkit_dom_html_select_element_get_selected_index(
self_: *mut WebKitDOMHTMLSelectElement,
) -> c_long;
pub fn webkit_dom_html_select_element_get_size(
self_: *mut WebKitDOMHTMLSelectElement,
) -> c_long;
pub fn webkit_dom_html_select_element_get_value(
self_: *mut WebKitDOMHTMLSelectElement,
) -> *mut c_char;
pub fn webkit_dom_html_select_element_get_will_validate(
self_: *mut WebKitDOMHTMLSelectElement,
) -> gboolean;
pub fn webkit_dom_html_select_element_item(
self_: *mut WebKitDOMHTMLSelectElement,
index: c_ulong,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_html_select_element_named_item(
self_: *mut WebKitDOMHTMLSelectElement,
name: *const c_char,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_html_select_element_remove(
self_: *mut WebKitDOMHTMLSelectElement,
index: c_long,
);
pub fn webkit_dom_html_select_element_set_autofocus(
self_: *mut WebKitDOMHTMLSelectElement,
value: gboolean,
);
pub fn webkit_dom_html_select_element_set_disabled(
self_: *mut WebKitDOMHTMLSelectElement,
value: gboolean,
);
pub fn webkit_dom_html_select_element_set_length(
self_: *mut WebKitDOMHTMLSelectElement,
value: c_ulong,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_select_element_set_multiple(
self_: *mut WebKitDOMHTMLSelectElement,
value: gboolean,
);
pub fn webkit_dom_html_select_element_set_name(
self_: *mut WebKitDOMHTMLSelectElement,
value: *const c_char,
);
pub fn webkit_dom_html_select_element_set_selected_index(
self_: *mut WebKitDOMHTMLSelectElement,
value: c_long,
);
pub fn webkit_dom_html_select_element_set_size(
self_: *mut WebKitDOMHTMLSelectElement,
value: c_long,
);
pub fn webkit_dom_html_select_element_set_value(
self_: *mut WebKitDOMHTMLSelectElement,
value: *const c_char,
);
pub fn webkit_dom_html_style_element_get_type() -> GType;
pub fn webkit_dom_html_style_element_get_disabled(
self_: *mut WebKitDOMHTMLStyleElement,
) -> gboolean;
pub fn webkit_dom_html_style_element_get_media(
self_: *mut WebKitDOMHTMLStyleElement,
) -> *mut c_char;
pub fn webkit_dom_html_style_element_get_sheet(
self_: *mut WebKitDOMHTMLStyleElement,
) -> *mut WebKitDOMStyleSheet;
pub fn webkit_dom_html_style_element_get_type_attr(
self_: *mut WebKitDOMHTMLStyleElement,
) -> *mut c_char;
pub fn webkit_dom_html_style_element_set_disabled(
self_: *mut WebKitDOMHTMLStyleElement,
value: gboolean,
);
pub fn webkit_dom_html_style_element_set_media(
self_: *mut WebKitDOMHTMLStyleElement,
value: *const c_char,
);
pub fn webkit_dom_html_style_element_set_type_attr(
self_: *mut WebKitDOMHTMLStyleElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_caption_element_get_type() -> GType;
pub fn webkit_dom_html_table_caption_element_get_align(
self_: *mut WebKitDOMHTMLTableCaptionElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_caption_element_set_align(
self_: *mut WebKitDOMHTMLTableCaptionElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_get_type() -> GType;
pub fn webkit_dom_html_table_cell_element_get_abbr(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_get_align(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_get_axis(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_get_bg_color(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_get_cell_index(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> c_long;
pub fn webkit_dom_html_table_cell_element_get_ch(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_get_ch_off(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_get_col_span(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> c_long;
pub fn webkit_dom_html_table_cell_element_get_headers(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_get_height(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_get_no_wrap(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> gboolean;
pub fn webkit_dom_html_table_cell_element_get_row_span(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> c_long;
pub fn webkit_dom_html_table_cell_element_get_scope(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_get_v_align(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_get_width(
self_: *mut WebKitDOMHTMLTableCellElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_cell_element_set_abbr(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_set_align(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_set_axis(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_set_bg_color(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_set_ch(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_set_ch_off(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_set_col_span(
self_: *mut WebKitDOMHTMLTableCellElement,
value: c_long,
);
pub fn webkit_dom_html_table_cell_element_set_headers(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_set_height(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_set_no_wrap(
self_: *mut WebKitDOMHTMLTableCellElement,
value: gboolean,
);
pub fn webkit_dom_html_table_cell_element_set_row_span(
self_: *mut WebKitDOMHTMLTableCellElement,
value: c_long,
);
pub fn webkit_dom_html_table_cell_element_set_scope(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_set_v_align(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_cell_element_set_width(
self_: *mut WebKitDOMHTMLTableCellElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_col_element_get_type() -> GType;
pub fn webkit_dom_html_table_col_element_get_align(
self_: *mut WebKitDOMHTMLTableColElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_col_element_get_ch(
self_: *mut WebKitDOMHTMLTableColElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_col_element_get_ch_off(
self_: *mut WebKitDOMHTMLTableColElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_col_element_get_span(
self_: *mut WebKitDOMHTMLTableColElement,
) -> c_long;
pub fn webkit_dom_html_table_col_element_get_v_align(
self_: *mut WebKitDOMHTMLTableColElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_col_element_get_width(
self_: *mut WebKitDOMHTMLTableColElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_col_element_set_align(
self_: *mut WebKitDOMHTMLTableColElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_col_element_set_ch(
self_: *mut WebKitDOMHTMLTableColElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_col_element_set_ch_off(
self_: *mut WebKitDOMHTMLTableColElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_col_element_set_span(
self_: *mut WebKitDOMHTMLTableColElement,
value: c_long,
);
pub fn webkit_dom_html_table_col_element_set_v_align(
self_: *mut WebKitDOMHTMLTableColElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_col_element_set_width(
self_: *mut WebKitDOMHTMLTableColElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_element_get_type() -> GType;
pub fn webkit_dom_html_table_element_create_caption(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut WebKitDOMHTMLElement;
pub fn webkit_dom_html_table_element_create_t_foot(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut WebKitDOMHTMLElement;
pub fn webkit_dom_html_table_element_create_t_head(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut WebKitDOMHTMLElement;
pub fn webkit_dom_html_table_element_delete_caption(self_: *mut WebKitDOMHTMLTableElement);
pub fn webkit_dom_html_table_element_delete_row(
self_: *mut WebKitDOMHTMLTableElement,
index: c_long,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_table_element_delete_t_foot(self_: *mut WebKitDOMHTMLTableElement);
pub fn webkit_dom_html_table_element_delete_t_head(self_: *mut WebKitDOMHTMLTableElement);
pub fn webkit_dom_html_table_element_get_align(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_element_get_bg_color(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_element_get_border(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_element_get_caption(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut WebKitDOMHTMLTableCaptionElement;
pub fn webkit_dom_html_table_element_get_cell_padding(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_element_get_cell_spacing(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_element_get_rows(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_html_table_element_get_rules(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_element_get_summary(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_element_get_t_bodies(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_html_table_element_get_t_foot(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut WebKitDOMHTMLTableSectionElement;
pub fn webkit_dom_html_table_element_get_t_head(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut WebKitDOMHTMLTableSectionElement;
pub fn webkit_dom_html_table_element_get_width(
self_: *mut WebKitDOMHTMLTableElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_element_insert_row(
self_: *mut WebKitDOMHTMLTableElement,
index: c_long,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMHTMLElement;
pub fn webkit_dom_html_table_element_set_align(
self_: *mut WebKitDOMHTMLTableElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_element_set_bg_color(
self_: *mut WebKitDOMHTMLTableElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_element_set_border(
self_: *mut WebKitDOMHTMLTableElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_element_set_caption(
self_: *mut WebKitDOMHTMLTableElement,
value: *mut WebKitDOMHTMLTableCaptionElement,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_table_element_set_cell_padding(
self_: *mut WebKitDOMHTMLTableElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_element_set_cell_spacing(
self_: *mut WebKitDOMHTMLTableElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_element_set_rules(
self_: *mut WebKitDOMHTMLTableElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_element_set_summary(
self_: *mut WebKitDOMHTMLTableElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_element_set_t_foot(
self_: *mut WebKitDOMHTMLTableElement,
value: *mut WebKitDOMHTMLTableSectionElement,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_table_element_set_t_head(
self_: *mut WebKitDOMHTMLTableElement,
value: *mut WebKitDOMHTMLTableSectionElement,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_table_element_set_width(
self_: *mut WebKitDOMHTMLTableElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_row_element_get_type() -> GType;
pub fn webkit_dom_html_table_row_element_delete_cell(
self_: *mut WebKitDOMHTMLTableRowElement,
index: c_long,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_table_row_element_get_align(
self_: *mut WebKitDOMHTMLTableRowElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_row_element_get_bg_color(
self_: *mut WebKitDOMHTMLTableRowElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_row_element_get_cells(
self_: *mut WebKitDOMHTMLTableRowElement,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_html_table_row_element_get_ch(
self_: *mut WebKitDOMHTMLTableRowElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_row_element_get_ch_off(
self_: *mut WebKitDOMHTMLTableRowElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_row_element_get_row_index(
self_: *mut WebKitDOMHTMLTableRowElement,
) -> c_long;
pub fn webkit_dom_html_table_row_element_get_section_row_index(
self_: *mut WebKitDOMHTMLTableRowElement,
) -> c_long;
pub fn webkit_dom_html_table_row_element_get_v_align(
self_: *mut WebKitDOMHTMLTableRowElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_row_element_insert_cell(
self_: *mut WebKitDOMHTMLTableRowElement,
index: c_long,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMHTMLElement;
pub fn webkit_dom_html_table_row_element_set_align(
self_: *mut WebKitDOMHTMLTableRowElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_row_element_set_bg_color(
self_: *mut WebKitDOMHTMLTableRowElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_row_element_set_ch(
self_: *mut WebKitDOMHTMLTableRowElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_row_element_set_ch_off(
self_: *mut WebKitDOMHTMLTableRowElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_row_element_set_v_align(
self_: *mut WebKitDOMHTMLTableRowElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_section_element_get_type() -> GType;
pub fn webkit_dom_html_table_section_element_delete_row(
self_: *mut WebKitDOMHTMLTableSectionElement,
index: c_long,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_html_table_section_element_get_align(
self_: *mut WebKitDOMHTMLTableSectionElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_section_element_get_ch(
self_: *mut WebKitDOMHTMLTableSectionElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_section_element_get_ch_off(
self_: *mut WebKitDOMHTMLTableSectionElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_section_element_get_rows(
self_: *mut WebKitDOMHTMLTableSectionElement,
) -> *mut WebKitDOMHTMLCollection;
pub fn webkit_dom_html_table_section_element_get_v_align(
self_: *mut WebKitDOMHTMLTableSectionElement,
) -> *mut c_char;
pub fn webkit_dom_html_table_section_element_insert_row(
self_: *mut WebKitDOMHTMLTableSectionElement,
index: c_long,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMHTMLElement;
pub fn webkit_dom_html_table_section_element_set_align(
self_: *mut WebKitDOMHTMLTableSectionElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_section_element_set_ch(
self_: *mut WebKitDOMHTMLTableSectionElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_section_element_set_ch_off(
self_: *mut WebKitDOMHTMLTableSectionElement,
value: *const c_char,
);
pub fn webkit_dom_html_table_section_element_set_v_align(
self_: *mut WebKitDOMHTMLTableSectionElement,
value: *const c_char,
);
pub fn webkit_dom_html_text_area_element_get_type() -> GType;
pub fn webkit_dom_html_text_area_element_get_area_type(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_text_area_element_get_autofocus(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> gboolean;
pub fn webkit_dom_html_text_area_element_get_cols(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> c_long;
pub fn webkit_dom_html_text_area_element_get_default_value(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_text_area_element_get_disabled(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> gboolean;
pub fn webkit_dom_html_text_area_element_get_form(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> *mut WebKitDOMHTMLFormElement;
pub fn webkit_dom_html_text_area_element_get_name(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_text_area_element_get_read_only(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> gboolean;
pub fn webkit_dom_html_text_area_element_get_rows(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> c_long;
pub fn webkit_dom_html_text_area_element_get_selection_end(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> c_long;
pub fn webkit_dom_html_text_area_element_get_selection_start(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> c_long;
pub fn webkit_dom_html_text_area_element_get_value(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> *mut c_char;
pub fn webkit_dom_html_text_area_element_get_will_validate(
self_: *mut WebKitDOMHTMLTextAreaElement,
) -> gboolean;
pub fn webkit_dom_html_text_area_element_is_edited(
input: *mut WebKitDOMHTMLTextAreaElement,
) -> gboolean;
pub fn webkit_dom_html_text_area_element_select(self_: *mut WebKitDOMHTMLTextAreaElement);
pub fn webkit_dom_html_text_area_element_set_autofocus(
self_: *mut WebKitDOMHTMLTextAreaElement,
value: gboolean,
);
pub fn webkit_dom_html_text_area_element_set_cols(
self_: *mut WebKitDOMHTMLTextAreaElement,
value: c_long,
);
pub fn webkit_dom_html_text_area_element_set_default_value(
self_: *mut WebKitDOMHTMLTextAreaElement,
value: *const c_char,
);
pub fn webkit_dom_html_text_area_element_set_disabled(
self_: *mut WebKitDOMHTMLTextAreaElement,
value: gboolean,
);
pub fn webkit_dom_html_text_area_element_set_name(
self_: *mut WebKitDOMHTMLTextAreaElement,
value: *const c_char,
);
pub fn webkit_dom_html_text_area_element_set_read_only(
self_: *mut WebKitDOMHTMLTextAreaElement,
value: gboolean,
);
pub fn webkit_dom_html_text_area_element_set_rows(
self_: *mut WebKitDOMHTMLTextAreaElement,
value: c_long,
);
pub fn webkit_dom_html_text_area_element_set_selection_end(
self_: *mut WebKitDOMHTMLTextAreaElement,
value: c_long,
);
pub fn webkit_dom_html_text_area_element_set_selection_range(
self_: *mut WebKitDOMHTMLTextAreaElement,
start: c_long,
end: c_long,
direction: *const c_char,
);
pub fn webkit_dom_html_text_area_element_set_selection_start(
self_: *mut WebKitDOMHTMLTextAreaElement,
value: c_long,
);
pub fn webkit_dom_html_text_area_element_set_value(
self_: *mut WebKitDOMHTMLTextAreaElement,
value: *const c_char,
);
pub fn webkit_dom_html_title_element_get_type() -> GType;
pub fn webkit_dom_html_title_element_get_text(
self_: *mut WebKitDOMHTMLTitleElement,
) -> *mut c_char;
pub fn webkit_dom_html_title_element_set_text(
self_: *mut WebKitDOMHTMLTitleElement,
value: *const c_char,
);
pub fn webkit_dom_html_u_list_element_get_type() -> GType;
pub fn webkit_dom_html_u_list_element_get_compact(
self_: *mut WebKitDOMHTMLUListElement,
) -> gboolean;
pub fn webkit_dom_html_u_list_element_get_type_attr(
self_: *mut WebKitDOMHTMLUListElement,
) -> *mut c_char;
pub fn webkit_dom_html_u_list_element_set_compact(
self_: *mut WebKitDOMHTMLUListElement,
value: gboolean,
);
pub fn webkit_dom_html_u_list_element_set_type_attr(
self_: *mut WebKitDOMHTMLUListElement,
value: *const c_char,
);
pub fn webkit_dom_keyboard_event_get_type() -> GType;
pub fn webkit_dom_keyboard_event_get_alt_graph_key(
self_: *mut WebKitDOMKeyboardEvent,
) -> gboolean;
pub fn webkit_dom_keyboard_event_get_alt_key(self_: *mut WebKitDOMKeyboardEvent) -> gboolean;
pub fn webkit_dom_keyboard_event_get_ctrl_key(self_: *mut WebKitDOMKeyboardEvent) -> gboolean;
pub fn webkit_dom_keyboard_event_get_key_identifier(
self_: *mut WebKitDOMKeyboardEvent,
) -> *mut c_char;
pub fn webkit_dom_keyboard_event_get_key_location(
self_: *mut WebKitDOMKeyboardEvent,
) -> c_ulong;
pub fn webkit_dom_keyboard_event_get_meta_key(self_: *mut WebKitDOMKeyboardEvent) -> gboolean;
pub fn webkit_dom_keyboard_event_get_modifier_state(
self_: *mut WebKitDOMKeyboardEvent,
keyIdentifierArg: *const c_char,
) -> gboolean;
pub fn webkit_dom_keyboard_event_get_shift_key(self_: *mut WebKitDOMKeyboardEvent) -> gboolean;
pub fn webkit_dom_keyboard_event_init_keyboard_event(
self_: *mut WebKitDOMKeyboardEvent,
type_: *const c_char,
canBubble: gboolean,
cancelable: gboolean,
view: *mut WebKitDOMDOMWindow,
keyIdentifier: *const c_char,
location: c_ulong,
ctrlKey: gboolean,
altKey: gboolean,
shiftKey: gboolean,
metaKey: gboolean,
altGraphKey: gboolean,
);
pub fn webkit_dom_media_list_get_type() -> GType;
pub fn webkit_dom_media_list_append_medium(
self_: *mut WebKitDOMMediaList,
newMedium: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_media_list_delete_medium(
self_: *mut WebKitDOMMediaList,
oldMedium: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_media_list_get_length(self_: *mut WebKitDOMMediaList) -> c_ulong;
pub fn webkit_dom_media_list_get_media_text(self_: *mut WebKitDOMMediaList) -> *mut c_char;
pub fn webkit_dom_media_list_item(
self_: *mut WebKitDOMMediaList,
index: c_ulong,
) -> *mut c_char;
pub fn webkit_dom_media_list_set_media_text(
self_: *mut WebKitDOMMediaList,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_mouse_event_get_type() -> GType;
pub fn webkit_dom_mouse_event_get_alt_key(self_: *mut WebKitDOMMouseEvent) -> gboolean;
pub fn webkit_dom_mouse_event_get_button(self_: *mut WebKitDOMMouseEvent) -> c_ushort;
pub fn webkit_dom_mouse_event_get_client_x(self_: *mut WebKitDOMMouseEvent) -> c_long;
pub fn webkit_dom_mouse_event_get_client_y(self_: *mut WebKitDOMMouseEvent) -> c_long;
pub fn webkit_dom_mouse_event_get_ctrl_key(self_: *mut WebKitDOMMouseEvent) -> gboolean;
pub fn webkit_dom_mouse_event_get_from_element(
self_: *mut WebKitDOMMouseEvent,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_mouse_event_get_meta_key(self_: *mut WebKitDOMMouseEvent) -> gboolean;
pub fn webkit_dom_mouse_event_get_offset_x(self_: *mut WebKitDOMMouseEvent) -> c_long;
pub fn webkit_dom_mouse_event_get_offset_y(self_: *mut WebKitDOMMouseEvent) -> c_long;
pub fn webkit_dom_mouse_event_get_related_target(
self_: *mut WebKitDOMMouseEvent,
) -> *mut WebKitDOMEventTarget;
pub fn webkit_dom_mouse_event_get_screen_x(self_: *mut WebKitDOMMouseEvent) -> c_long;
pub fn webkit_dom_mouse_event_get_screen_y(self_: *mut WebKitDOMMouseEvent) -> c_long;
pub fn webkit_dom_mouse_event_get_shift_key(self_: *mut WebKitDOMMouseEvent) -> gboolean;
pub fn webkit_dom_mouse_event_get_to_element(
self_: *mut WebKitDOMMouseEvent,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_mouse_event_get_x(self_: *mut WebKitDOMMouseEvent) -> c_long;
pub fn webkit_dom_mouse_event_get_y(self_: *mut WebKitDOMMouseEvent) -> c_long;
pub fn webkit_dom_mouse_event_init_mouse_event(
self_: *mut WebKitDOMMouseEvent,
type_: *const c_char,
canBubble: gboolean,
cancelable: gboolean,
view: *mut WebKitDOMDOMWindow,
detail: c_long,
screenX: c_long,
screenY: c_long,
clientX: c_long,
clientY: c_long,
ctrlKey: gboolean,
altKey: gboolean,
shiftKey: gboolean,
metaKey: gboolean,
button: c_ushort,
relatedTarget: *mut WebKitDOMEventTarget,
);
pub fn webkit_dom_named_node_map_get_type() -> GType;
pub fn webkit_dom_named_node_map_get_length(self_: *mut WebKitDOMNamedNodeMap) -> c_ulong;
pub fn webkit_dom_named_node_map_get_named_item(
self_: *mut WebKitDOMNamedNodeMap,
name: *const c_char,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_named_node_map_get_named_item_ns(
self_: *mut WebKitDOMNamedNodeMap,
namespaceURI: *const c_char,
localName: *const c_char,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_named_node_map_item(
self_: *mut WebKitDOMNamedNodeMap,
index: c_ulong,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_named_node_map_remove_named_item(
self_: *mut WebKitDOMNamedNodeMap,
name: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_named_node_map_remove_named_item_ns(
self_: *mut WebKitDOMNamedNodeMap,
namespaceURI: *const c_char,
localName: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_named_node_map_set_named_item(
self_: *mut WebKitDOMNamedNodeMap,
node: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_named_node_map_set_named_item_ns(
self_: *mut WebKitDOMNamedNodeMap,
node: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_get_type() -> GType;
#[cfg(any(feature = "v2_22", feature = "dox"))]
pub fn webkit_dom_node_for_js_value(
value: *mut java_script_core::JSCValue,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_append_child(
self_: *mut WebKitDOMNode,
newChild: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_clone_node(
self_: *mut WebKitDOMNode,
deep: gboolean,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
#[cfg(any(feature = "v2_14", feature = "dox"))]
pub fn webkit_dom_node_clone_node_with_error(
self_: *mut WebKitDOMNode,
deep: gboolean,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_compare_document_position(
self_: *mut WebKitDOMNode,
other: *mut WebKitDOMNode,
) -> c_ushort;
pub fn webkit_dom_node_contains(
self_: *mut WebKitDOMNode,
other: *mut WebKitDOMNode,
) -> gboolean;
pub fn webkit_dom_node_get_base_uri(self_: *mut WebKitDOMNode) -> *mut c_char;
pub fn webkit_dom_node_get_child_nodes(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNodeList;
pub fn webkit_dom_node_get_first_child(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_get_last_child(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_get_local_name(self_: *mut WebKitDOMNode) -> *mut c_char;
pub fn webkit_dom_node_get_namespace_uri(self_: *mut WebKitDOMNode) -> *mut c_char;
pub fn webkit_dom_node_get_next_sibling(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_get_node_name(self_: *mut WebKitDOMNode) -> *mut c_char;
pub fn webkit_dom_node_get_node_type(self_: *mut WebKitDOMNode) -> c_ushort;
pub fn webkit_dom_node_get_node_value(self_: *mut WebKitDOMNode) -> *mut c_char;
pub fn webkit_dom_node_get_owner_document(self_: *mut WebKitDOMNode) -> *mut WebKitDOMDocument;
pub fn webkit_dom_node_get_parent_element(self_: *mut WebKitDOMNode) -> *mut WebKitDOMElement;
pub fn webkit_dom_node_get_parent_node(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_get_prefix(self_: *mut WebKitDOMNode) -> *mut c_char;
pub fn webkit_dom_node_get_previous_sibling(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_get_text_content(self_: *mut WebKitDOMNode) -> *mut c_char;
pub fn webkit_dom_node_has_child_nodes(self_: *mut WebKitDOMNode) -> gboolean;
pub fn webkit_dom_node_insert_before(
self_: *mut WebKitDOMNode,
newChild: *mut WebKitDOMNode,
refChild: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_is_default_namespace(
self_: *mut WebKitDOMNode,
namespaceURI: *const c_char,
) -> gboolean;
pub fn webkit_dom_node_is_equal_node(
self_: *mut WebKitDOMNode,
other: *mut WebKitDOMNode,
) -> gboolean;
pub fn webkit_dom_node_is_same_node(
self_: *mut WebKitDOMNode,
other: *mut WebKitDOMNode,
) -> gboolean;
pub fn webkit_dom_node_is_supported(
self_: *mut WebKitDOMNode,
feature: *const c_char,
version: *const c_char,
) -> gboolean;
pub fn webkit_dom_node_lookup_namespace_uri(
self_: *mut WebKitDOMNode,
prefix: *const c_char,
) -> *mut c_char;
pub fn webkit_dom_node_lookup_prefix(
self_: *mut WebKitDOMNode,
namespaceURI: *const c_char,
) -> *mut c_char;
pub fn webkit_dom_node_normalize(self_: *mut WebKitDOMNode);
pub fn webkit_dom_node_remove_child(
self_: *mut WebKitDOMNode,
oldChild: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_replace_child(
self_: *mut WebKitDOMNode,
newChild: *mut WebKitDOMNode,
oldChild: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_set_node_value(
self_: *mut WebKitDOMNode,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_node_set_prefix(
self_: *mut WebKitDOMNode,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_node_set_text_content(
self_: *mut WebKitDOMNode,
value: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_node_iterator_get_type() -> GType;
pub fn webkit_dom_node_iterator_detach(self_: *mut WebKitDOMNodeIterator);
pub fn webkit_dom_node_iterator_get_expand_entity_references(
self_: *mut WebKitDOMNodeIterator,
) -> gboolean;
pub fn webkit_dom_node_iterator_get_filter(
self_: *mut WebKitDOMNodeIterator,
) -> *mut WebKitDOMNodeFilter;
pub fn webkit_dom_node_iterator_get_pointer_before_reference_node(
self_: *mut WebKitDOMNodeIterator,
) -> gboolean;
pub fn webkit_dom_node_iterator_get_reference_node(
self_: *mut WebKitDOMNodeIterator,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_iterator_get_root(
self_: *mut WebKitDOMNodeIterator,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_iterator_get_what_to_show(self_: *mut WebKitDOMNodeIterator) -> c_ulong;
pub fn webkit_dom_node_iterator_next_node(
self_: *mut WebKitDOMNodeIterator,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_iterator_previous_node(
self_: *mut WebKitDOMNodeIterator,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_node_list_get_type() -> GType;
pub fn webkit_dom_node_list_get_length(self_: *mut WebKitDOMNodeList) -> c_ulong;
pub fn webkit_dom_node_list_item(
self_: *mut WebKitDOMNodeList,
index: c_ulong,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_object_get_type() -> GType;
pub fn webkit_dom_processing_instruction_get_type() -> GType;
pub fn webkit_dom_processing_instruction_get_sheet(
self_: *mut WebKitDOMProcessingInstruction,
) -> *mut WebKitDOMStyleSheet;
pub fn webkit_dom_processing_instruction_get_target(
self_: *mut WebKitDOMProcessingInstruction,
) -> *mut c_char;
pub fn webkit_dom_range_get_type() -> GType;
pub fn webkit_dom_range_clone_contents(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMDocumentFragment;
pub fn webkit_dom_range_clone_range(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMRange;
pub fn webkit_dom_range_collapse(
self_: *mut WebKitDOMRange,
toStart: gboolean,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_compare_boundary_points(
self_: *mut WebKitDOMRange,
how: c_ushort,
sourceRange: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> c_short;
pub fn webkit_dom_range_compare_node(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
) -> c_short;
pub fn webkit_dom_range_compare_point(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
offset: c_long,
error: *mut *mut glib::GError,
) -> c_short;
pub fn webkit_dom_range_create_contextual_fragment(
self_: *mut WebKitDOMRange,
html: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMDocumentFragment;
pub fn webkit_dom_range_delete_contents(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_detach(self_: *mut WebKitDOMRange, error: *mut *mut glib::GError);
#[cfg(any(feature = "v2_16", feature = "dox"))]
pub fn webkit_dom_range_expand(
self_: *mut WebKitDOMRange,
unit: *const c_char,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_extract_contents(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMDocumentFragment;
pub fn webkit_dom_range_get_collapsed(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn webkit_dom_range_get_common_ancestor_container(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_range_get_end_container(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_range_get_end_offset(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> c_long;
pub fn webkit_dom_range_get_start_container(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_range_get_start_offset(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> c_long;
pub fn webkit_dom_range_get_text(self_: *mut WebKitDOMRange) -> *mut c_char;
pub fn webkit_dom_range_insert_node(
self_: *mut WebKitDOMRange,
newNode: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_intersects_node(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn webkit_dom_range_is_point_in_range(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
offset: c_long,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn webkit_dom_range_select_node(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_select_node_contents(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_set_end(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
offset: c_long,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_set_end_after(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_set_end_before(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_set_start(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
offset: c_long,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_set_start_after(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_set_start_before(
self_: *mut WebKitDOMRange,
refNode: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_surround_contents(
self_: *mut WebKitDOMRange,
newParent: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_range_to_string(
self_: *mut WebKitDOMRange,
error: *mut *mut glib::GError,
) -> *mut c_char;
pub fn webkit_dom_style_sheet_get_type() -> GType;
pub fn webkit_dom_style_sheet_get_content_type(self_: *mut WebKitDOMStyleSheet) -> *mut c_char;
pub fn webkit_dom_style_sheet_get_disabled(self_: *mut WebKitDOMStyleSheet) -> gboolean;
pub fn webkit_dom_style_sheet_get_href(self_: *mut WebKitDOMStyleSheet) -> *mut c_char;
pub fn webkit_dom_style_sheet_get_media(
self_: *mut WebKitDOMStyleSheet,
) -> *mut WebKitDOMMediaList;
pub fn webkit_dom_style_sheet_get_owner_node(
self_: *mut WebKitDOMStyleSheet,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_style_sheet_get_parent_style_sheet(
self_: *mut WebKitDOMStyleSheet,
) -> *mut WebKitDOMStyleSheet;
pub fn webkit_dom_style_sheet_get_title(self_: *mut WebKitDOMStyleSheet) -> *mut c_char;
pub fn webkit_dom_style_sheet_set_disabled(self_: *mut WebKitDOMStyleSheet, value: gboolean);
pub fn webkit_dom_style_sheet_list_get_type() -> GType;
pub fn webkit_dom_style_sheet_list_get_length(self_: *mut WebKitDOMStyleSheetList) -> c_ulong;
pub fn webkit_dom_style_sheet_list_item(
self_: *mut WebKitDOMStyleSheetList,
index: c_ulong,
) -> *mut WebKitDOMStyleSheet;
pub fn webkit_dom_text_get_type() -> GType;
pub fn webkit_dom_text_get_whole_text(self_: *mut WebKitDOMText) -> *mut c_char;
pub fn webkit_dom_text_replace_whole_text(
self_: *mut WebKitDOMText,
content: *const c_char,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMText;
pub fn webkit_dom_text_split_text(
self_: *mut WebKitDOMText,
offset: c_ulong,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMText;
pub fn webkit_dom_tree_walker_get_type() -> GType;
pub fn webkit_dom_tree_walker_first_child(
self_: *mut WebKitDOMTreeWalker,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_tree_walker_get_current_node(
self_: *mut WebKitDOMTreeWalker,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_tree_walker_get_expand_entity_references(
self_: *mut WebKitDOMTreeWalker,
) -> gboolean;
pub fn webkit_dom_tree_walker_get_filter(
self_: *mut WebKitDOMTreeWalker,
) -> *mut WebKitDOMNodeFilter;
pub fn webkit_dom_tree_walker_get_root(self_: *mut WebKitDOMTreeWalker) -> *mut WebKitDOMNode;
pub fn webkit_dom_tree_walker_get_what_to_show(self_: *mut WebKitDOMTreeWalker) -> c_ulong;
pub fn webkit_dom_tree_walker_last_child(self_: *mut WebKitDOMTreeWalker)
-> *mut WebKitDOMNode;
pub fn webkit_dom_tree_walker_next_node(self_: *mut WebKitDOMTreeWalker) -> *mut WebKitDOMNode;
pub fn webkit_dom_tree_walker_next_sibling(
self_: *mut WebKitDOMTreeWalker,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_tree_walker_parent_node(
self_: *mut WebKitDOMTreeWalker,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_tree_walker_previous_node(
self_: *mut WebKitDOMTreeWalker,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_tree_walker_previous_sibling(
self_: *mut WebKitDOMTreeWalker,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_tree_walker_set_current_node(
self_: *mut WebKitDOMTreeWalker,
value: *mut WebKitDOMNode,
error: *mut *mut glib::GError,
);
pub fn webkit_dom_ui_event_get_type() -> GType;
pub fn webkit_dom_ui_event_get_char_code(self_: *mut WebKitDOMUIEvent) -> c_long;
pub fn webkit_dom_ui_event_get_detail(self_: *mut WebKitDOMUIEvent) -> c_long;
pub fn webkit_dom_ui_event_get_key_code(self_: *mut WebKitDOMUIEvent) -> c_long;
pub fn webkit_dom_ui_event_get_layer_x(self_: *mut WebKitDOMUIEvent) -> c_long;
pub fn webkit_dom_ui_event_get_layer_y(self_: *mut WebKitDOMUIEvent) -> c_long;
pub fn webkit_dom_ui_event_get_page_x(self_: *mut WebKitDOMUIEvent) -> c_long;
pub fn webkit_dom_ui_event_get_page_y(self_: *mut WebKitDOMUIEvent) -> c_long;
pub fn webkit_dom_ui_event_get_view(self_: *mut WebKitDOMUIEvent) -> *mut WebKitDOMDOMWindow;
pub fn webkit_dom_ui_event_init_ui_event(
self_: *mut WebKitDOMUIEvent,
type_: *const c_char,
canBubble: gboolean,
cancelable: gboolean,
view: *mut WebKitDOMDOMWindow,
detail: c_long,
);
pub fn webkit_dom_wheel_event_get_type() -> GType;
pub fn webkit_dom_wheel_event_get_wheel_delta(self_: *mut WebKitDOMWheelEvent) -> c_long;
pub fn webkit_dom_wheel_event_get_wheel_delta_x(self_: *mut WebKitDOMWheelEvent) -> c_long;
pub fn webkit_dom_wheel_event_get_wheel_delta_y(self_: *mut WebKitDOMWheelEvent) -> c_long;
pub fn webkit_dom_wheel_event_init_wheel_event(
self_: *mut WebKitDOMWheelEvent,
wheelDeltaX: c_long,
wheelDeltaY: c_long,
view: *mut WebKitDOMDOMWindow,
screenX: c_long,
screenY: c_long,
clientX: c_long,
clientY: c_long,
ctrlKey: gboolean,
altKey: gboolean,
shiftKey: gboolean,
metaKey: gboolean,
);
pub fn webkit_dom_xpath_expression_get_type() -> GType;
pub fn webkit_dom_xpath_expression_evaluate(
self_: *mut WebKitDOMXPathExpression,
contextNode: *mut WebKitDOMNode,
type_: c_ushort,
inResult: *mut WebKitDOMXPathResult,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMXPathResult;
pub fn webkit_dom_xpath_result_get_type() -> GType;
pub fn webkit_dom_xpath_result_get_boolean_value(
self_: *mut WebKitDOMXPathResult,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn webkit_dom_xpath_result_get_invalid_iterator_state(
self_: *mut WebKitDOMXPathResult,
) -> gboolean;
pub fn webkit_dom_xpath_result_get_number_value(
self_: *mut WebKitDOMXPathResult,
error: *mut *mut glib::GError,
) -> c_double;
pub fn webkit_dom_xpath_result_get_result_type(self_: *mut WebKitDOMXPathResult) -> c_ushort;
pub fn webkit_dom_xpath_result_get_single_node_value(
self_: *mut WebKitDOMXPathResult,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_xpath_result_get_snapshot_length(
self_: *mut WebKitDOMXPathResult,
error: *mut *mut glib::GError,
) -> c_ulong;
pub fn webkit_dom_xpath_result_get_string_value(
self_: *mut WebKitDOMXPathResult,
error: *mut *mut glib::GError,
) -> *mut c_char;
pub fn webkit_dom_xpath_result_iterate_next(
self_: *mut WebKitDOMXPathResult,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_dom_xpath_result_snapshot_item(
self_: *mut WebKitDOMXPathResult,
index: c_ulong,
error: *mut *mut glib::GError,
) -> *mut WebKitDOMNode;
pub fn webkit_frame_get_type() -> GType;
#[cfg(any(feature = "v2_26", feature = "dox"))]
pub fn webkit_frame_get_id(frame: *mut WebKitFrame) -> u64;
pub fn webkit_frame_get_javascript_context_for_script_world(
frame: *mut WebKitFrame,
world: *mut WebKitScriptWorld,
) -> java_script_core::JSGlobalContextRef;
pub fn webkit_frame_get_javascript_global_context(
frame: *mut WebKitFrame,
) -> java_script_core::JSGlobalContextRef;
#[cfg(any(feature = "v2_22", feature = "dox"))]
pub fn webkit_frame_get_js_context(
frame: *mut WebKitFrame,
) -> *mut java_script_core::JSCContext;
#[cfg(any(feature = "v2_22", feature = "dox"))]
pub fn webkit_frame_get_js_context_for_script_world(
frame: *mut WebKitFrame,
world: *mut WebKitScriptWorld,
) -> *mut java_script_core::JSCContext;
#[cfg(any(feature = "v2_22", feature = "dox"))]
pub fn webkit_frame_get_js_value_for_dom_object(
frame: *mut WebKitFrame,
dom_object: *mut WebKitDOMObject,
) -> *mut java_script_core::JSCValue;
#[cfg(any(feature = "v2_22", feature = "dox"))]
pub fn webkit_frame_get_js_value_for_dom_object_in_script_world(
frame: *mut WebKitFrame,
dom_object: *mut WebKitDOMObject,
world: *mut WebKitScriptWorld,
) -> *mut java_script_core::JSCValue;
pub fn webkit_frame_get_uri(frame: *mut WebKitFrame) -> *const c_char;
pub fn webkit_frame_is_main_frame(frame: *mut WebKitFrame) -> gboolean;
pub fn webkit_hit_test_result_get_type() -> GType;
pub fn webkit_hit_test_result_context_is_editable(
hit_test_result: *mut WebKitHitTestResult,
) -> gboolean;
pub fn webkit_hit_test_result_context_is_image(
hit_test_result: *mut WebKitHitTestResult,
) -> gboolean;
pub fn webkit_hit_test_result_context_is_link(
hit_test_result: *mut WebKitHitTestResult,
) -> gboolean;
pub fn webkit_hit_test_result_context_is_media(
hit_test_result: *mut WebKitHitTestResult,
) -> gboolean;
pub fn webkit_hit_test_result_context_is_scrollbar(
hit_test_result: *mut WebKitHitTestResult,
) -> gboolean;
#[cfg(any(feature = "v2_8", feature = "dox"))]
pub fn webkit_hit_test_result_context_is_selection(
hit_test_result: *mut WebKitHitTestResult,
) -> gboolean;
pub fn webkit_hit_test_result_get_context(hit_test_result: *mut WebKitHitTestResult) -> c_uint;
pub fn webkit_hit_test_result_get_image_uri(
hit_test_result: *mut WebKitHitTestResult,
) -> *const c_char;
pub fn webkit_hit_test_result_get_link_label(
hit_test_result: *mut WebKitHitTestResult,
) -> *const c_char;
pub fn webkit_hit_test_result_get_link_title(
hit_test_result: *mut WebKitHitTestResult,
) -> *const c_char;
pub fn webkit_hit_test_result_get_link_uri(
hit_test_result: *mut WebKitHitTestResult,
) -> *const c_char;
pub fn webkit_hit_test_result_get_media_uri(
hit_test_result: *mut WebKitHitTestResult,
) -> *const c_char;
pub fn webkit_script_world_get_type() -> GType;
pub fn webkit_script_world_new() -> *mut WebKitScriptWorld;
#[cfg(any(feature = "v2_22", feature = "dox"))]
pub fn webkit_script_world_new_with_name(name: *const c_char) -> *mut WebKitScriptWorld;
pub fn webkit_script_world_get_default() -> *mut WebKitScriptWorld;
#[cfg(any(feature = "v2_22", feature = "dox"))]
pub fn webkit_script_world_get_name(world: *mut WebKitScriptWorld) -> *const c_char;
pub fn webkit_uri_request_get_type() -> GType;
pub fn webkit_uri_request_new(uri: *const c_char) -> *mut WebKitURIRequest;
pub fn webkit_uri_request_get_http_headers(
request: *mut WebKitURIRequest,
) -> *mut soup::SoupMessageHeaders;
#[cfg(any(feature = "v2_12", feature = "dox"))]
pub fn webkit_uri_request_get_http_method(request: *mut WebKitURIRequest) -> *const c_char;
pub fn webkit_uri_request_get_uri(request: *mut WebKitURIRequest) -> *const c_char;
pub fn webkit_uri_request_set_uri(request: *mut WebKitURIRequest, uri: *const c_char);
pub fn webkit_uri_response_get_type() -> GType;
pub fn webkit_uri_response_get_content_length(response: *mut WebKitURIResponse) -> u64;
#[cfg(any(feature = "v2_6", feature = "dox"))]
pub fn webkit_uri_response_get_http_headers(
response: *mut WebKitURIResponse,
) -> *mut soup::SoupMessageHeaders;
pub fn webkit_uri_response_get_mime_type(response: *mut WebKitURIResponse) -> *const c_char;
pub fn webkit_uri_response_get_status_code(response: *mut WebKitURIResponse) -> c_uint;
pub fn webkit_uri_response_get_suggested_filename(
response: *mut WebKitURIResponse,
) -> *const c_char;
pub fn webkit_uri_response_get_uri(response: *mut WebKitURIResponse) -> *const c_char;
pub fn webkit_web_editor_get_type() -> GType;
#[cfg(any(feature = "v2_10", feature = "dox"))]
pub fn webkit_web_editor_get_page(editor: *mut WebKitWebEditor) -> *mut WebKitWebPage;
pub fn webkit_web_extension_get_type() -> GType;
pub fn webkit_web_extension_get_page(
extension: *mut WebKitWebExtension,
page_id: u64,
) -> *mut WebKitWebPage;
pub fn webkit_web_hit_test_result_get_type() -> GType;
#[cfg(any(feature = "v2_8", feature = "dox"))]
pub fn webkit_web_hit_test_result_get_node(
hit_test_result: *mut WebKitWebHitTestResult,
) -> *mut WebKitDOMNode;
pub fn webkit_web_page_get_type() -> GType;
pub fn webkit_web_page_get_dom_document(web_page: *mut WebKitWebPage)
-> *mut WebKitDOMDocument;
#[cfg(any(feature = "v2_10", feature = "dox"))]
pub fn webkit_web_page_get_editor(web_page: *mut WebKitWebPage) -> *mut WebKitWebEditor;
pub fn webkit_web_page_get_id(web_page: *mut WebKitWebPage) -> u64;
pub fn webkit_web_page_get_main_frame(web_page: *mut WebKitWebPage) -> *mut WebKitFrame;
pub fn webkit_web_page_get_uri(web_page: *mut WebKitWebPage) -> *const c_char;
pub fn webkit_dom_event_target_get_type() -> GType;
pub fn webkit_dom_event_target_add_event_listener(
target: *mut WebKitDOMEventTarget,
event_name: *const c_char,
handler: gobject::GCallback,
use_capture: gboolean,
user_data: gpointer,
) -> gboolean;
pub fn webkit_dom_event_target_add_event_listener_with_closure(
target: *mut WebKitDOMEventTarget,
event_name: *const c_char,
handler: *mut gobject::GClosure,
use_capture: gboolean,
) -> gboolean;
pub fn webkit_dom_event_target_dispatch_event(
target: *mut WebKitDOMEventTarget,
event: *mut WebKitDOMEvent,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn webkit_dom_event_target_remove_event_listener(
target: *mut WebKitDOMEventTarget,
event_name: *const c_char,
handler: gobject::GCallback,
use_capture: gboolean,
) -> gboolean;
pub fn webkit_dom_event_target_remove_event_listener_with_closure(
target: *mut WebKitDOMEventTarget,
event_name: *const c_char,
handler: *mut gobject::GClosure,
use_capture: gboolean,
) -> gboolean;
pub fn webkit_dom_node_filter_get_type() -> GType;
pub fn webkit_dom_node_filter_accept_node(
filter: *mut WebKitDOMNodeFilter,
node: *mut WebKitDOMNode,
) -> c_short;
pub fn webkit_dom_xpath_ns_resolver_get_type() -> GType;
pub fn webkit_dom_xpath_ns_resolver_lookup_namespace_uri(
resolver: *mut WebKitDOMXPathNSResolver,
prefix: *const c_char,
) -> *mut c_char;
}