internal unsafe override int set(cef_v8accessor_t* self, cef_string_t* name, cef_v8value_t* @object, cef_v8value_t* value, cef_string_t* exception) { var prop = this.dispatchTable.GetOrDefault(name); if (prop == null) return 0; var method = prop.SetMethod; if (method == null) return 0; var instance = this.instance; if (instance == null) { // TODO: self must be got from obj's userdata throw new NotImplementedException(); } try { method.Invoke(instance, 1, &value, null); } catch (Exception ex) { // TODO: how exceptions must be formatted ? cef_string_t.Copy(ex.ToString(), exception); } // TODO: this pointer must be typed cef_v8value_t.invoke_release((cef_base_t*)@object); cef_v8value_t.invoke_release((cef_base_t*)value); return 1; }
/// <summary> /// Called to get an accessor value. |name| is the name of the property /// being accessed. |object| is the This() object from V8's AccessorInfo /// structure. |retval| is the value to return for this property. Return /// true if handled. /// </summary> internal virtual int get(cef_v8accessor_t* self, /*const*/ cef_string_t* name, cef_v8value_t* @object, cef_v8value_t** retval, cef_string_t* exception) { ThrowIfObjectDisposed(); var m_name = cef_string_t.ToString(name); var m_obj = CefV8Value.From(@object); CefV8Value m_returnValue; string mException; var handled = this.Get(m_name, m_obj, out m_returnValue, out mException); if (handled) { if (mException != null) { cef_string_t.Copy(mException, exception); } else if (m_returnValue != null) { *retval = m_returnValue.GetNativePointerAndAddRef(); } } return handled ? 1 : 0; }
/// <summary> /// Called to retrieve proxy information for the specified |url|. /// </summary> private void get_proxy_for_url(cef_proxy_handler_t* self, /*const*/ cef_string_t* url, cef_proxy_info_t* proxy_info) { ThrowIfObjectDisposed(); string m_url = cef_string_t.ToString(url); CefProxyInfo m_info = CefProxyInfo.From(proxy_info); GetProxyForUrl(m_url, m_info); }
/// <summary> /// Sets the directory path that will be used for storing cookie data. If /// |path| is empty data will be stored in memory only. Returns false if /// cookies cannot be accessed. /// </summary> public bool SetStoragePath(string path) { fixed (char* path_str = path) { var m_path = new cef_string_t(path_str, path != null ? path.Length : 0); return cef_cookie_manager_t.invoke_set_storage_path(this.ptr, &m_path) != 0; } }
/// <summary> /// Sets a cookie given a valid URL and explicit user-provided cookie /// attributes. This function expects each attribute to be well-formed. It will /// check for disallowed characters (e.g. the ';' character is disallowed /// within the cookie value attribute) and will return false without setting /// the cookie if such characters are found. This method must be called on the /// IO thread. /// </summary> public bool SetCookie(string url, CefCookie cookie) { fixed (char* url_str = url) { var m_url = new cef_string_t(url_str, url != null ? url.Length : 0); return cef_cookie_manager_t.invoke_set_cookie(this.ptr, &m_url, cookie.GetNativeHandle()) != 0; } }
/// <summary> /// Moves the cursor to the specified file in the archive. /// If |caseSensitive| is true then the search will be case sensitive. /// Returns true if the cursor position was set successfully. /// </summary> public bool MoveToFile(string fileName, bool caseSensitive) { fixed (char* fileName_str = fileName) { var n_fileName = new cef_string_t(fileName_str, fileName != null ? fileName.Length : 0); return cef_zip_reader_t.invoke_move_to_file(this.ptr, &n_fileName, caseSensitive ? 1 : 0) != 0; } }
/// <summary> /// Set the response mime type. /// </summary> public void SetMimeType(string mimeType) { fixed (char* mimeType_str = mimeType) { var n_mimeType = new cef_string_t(mimeType_str, mimeType != null ? mimeType.Length : 0); cef_response_t.invoke_set_mime_type(this.ptr, &n_mimeType); } }
/// <summary> /// Called when the browser's zoom level has been set to |zoomLevel| for /// the given |url|. Return true (1) to indicate that the new setting has /// been handled. Return false (0) to use the browser's default zoom /// handling behavior. /// </summary> private int on_set_zoom_level(cef_zoom_handler_t* self, cef_browser_t* browser, /*const*/ cef_string_t* url, double zoomLevel) { ThrowIfObjectDisposed(); var m_browser = CefBrowser.From(browser); var m_url = cef_string_t.ToString(url); return OnSetZoomLevel(m_browser, m_url, zoomLevel) ? 1 : 0; }
/// <summary> /// Returns a complete URL based on the document base URL and the specified partial URL. /// </summary> public string GetCompleteURL(string partialUrl) { fixed (char* partialUrl_str = partialUrl) { var n_partialUrl = new cef_string_t(partialUrl_str, partialUrl != null ? partialUrl.Length : 0); var nResult = cef_domdocument_t.invoke_get_complete_url(this.ptr, &n_partialUrl); return cef_string_userfree.GetStringAndFree(nResult); } }
/// <summary> /// Creates a new cookie manager. If |path| is empty data will be stored in /// memory only. Returns NULL if creation fails. /// </summary> public static CefCookieManager CreateManager(string path) { fixed (char* path_str = path) { var m_path = new cef_string_t(path_str, path != null ? path.Length : 0); var m_cookie_manager = NativeMethods.cef_cookie_manager_create_manager(&m_path); return CefCookieManager.FromOrDefault(m_cookie_manager); } }
/// <summary> /// Called when a geolocation access request is canceled. /// |requesting_url| is the URL that originally requested permission and /// |request_id| is the unique ID for the permission request. /// </summary> private void on_cancel_geolocation_permission(cef_geolocation_handler_t* self, cef_browser_t* browser, /*const*/ cef_string_t* requesting_url, int request_id) { ThrowIfObjectDisposed(); var m_browser = CefBrowser.From(browser); var m_requestingUrl = cef_string_t.ToString(requesting_url); OnCancelGeolocationPermission(m_browser, m_requestingUrl, request_id); }
/// <summary> /// Returns the value of the attribute with the specified qualified name. /// </summary> public string GetAttribute(string qualifiedName) { fixed (char* qualifiedName_str = qualifiedName) { var n_qualifiedName = new cef_string_t(qualifiedName_str, qualifiedName != null ? qualifiedName.Length : 0); var nResult = cef_xml_reader_t.invoke_get_attribute_byqname(this.ptr, &n_qualifiedName); return cef_string_userfree.GetStringAndFree(nResult); } }
/// <summary> /// Get the value for the specified response header field. /// </summary> public string GetHeader(string name) { fixed (char* name_str = name) { var n_name = new cef_string_t(name_str, name != null ? name.Length : 0); var nResult = cef_response_t.invoke_get_header(this.ptr, &n_name); return cef_string_userfree.GetStringAndFree(nResult); } }
/// <summary> /// Create a new CefStreamWriter object for a file. /// </summary> public static CefStreamWriter Create(string fileName) { fixed (char* fileName_str = fileName) { var n_fileName = new cef_string_t(fileName_str, fileName != null ? fileName.Length : 0); return CefStreamWriter.From( NativeMethods.cef_stream_writer_create_for_file(&n_fileName) ); } }
/// <summary> /// Returns the document element with the specified ID value. /// </summary> public CefDomNode GetElementById(string id) { fixed (char* id_str = id) { var n_id = new cef_string_t(id_str, id != null ? id.Length : 0); return CefDomNode.From( cef_domdocument_t.invoke_get_element_by_id(this.ptr, &n_id) ); } }
/// <summary> /// Called when a frame's address has changed. /// </summary> private void on_address_change(cef_display_handler_t* self, cef_browser_t* browser, cef_frame_t* frame, /*const*/ cef_string_t* url) { ThrowIfObjectDisposed(); var m_browser = CefBrowser.From(browser); var m_frame = CefFrame.From(frame); var m_url = cef_string_t.ToString(url); this.OnAddressChange(m_browser, m_frame, m_url); }
/// <summary> /// Called when a page requests permission to access geolocation information. /// |requesting_url| is the URL requesting permission and |request_id| is the /// unique ID for the permission request. Call /// cef_geolocation_callback_t::Continue to allow or deny the permission /// request. /// </summary> private void on_request_geolocation_permission(cef_geolocation_handler_t* self, cef_browser_t* browser, /*const*/ cef_string_t* requesting_url, int request_id, cef_geolocation_callback_t* callback) { ThrowIfObjectDisposed(); var m_browser = CefBrowser.From(browser); var m_requestingUrl = cef_string_t.ToString(requesting_url); var m_callback = CefGeolocationCallback.From(callback); OnRequestGeolocationPermission(m_browser, m_requestingUrl, request_id, m_callback); }
/// <summary> /// Execute a string of JavaScript code in this frame. /// The |script_url| parameter is the URL where the script in question can be found, if any. /// The renderer may request this URL to show the developer the source of the error. /// The |start_line| parameter is the base line number to use for error reporting. /// </summary> public void ExecuteJavaScript(string jsCode, string scriptUrl, int startLine) { fixed (char* jsCode_str = jsCode) fixed (char* scriptUrl_str = scriptUrl) { var n_jsCode = new cef_string_t(jsCode_str, jsCode != null ? jsCode.Length : 0); var n_scriptUrl = new cef_string_t(scriptUrl_str, scriptUrl != null ? scriptUrl.Length : 0); cef_frame_t.invoke_execute_java_script(this.ptr, &n_jsCode, &n_scriptUrl, startLine); } }
public bool Append(string key, string value) { fixed (char* key_str = key) fixed (char* value_str = value) { var nKey = new cef_string_t(key_str, key != null ? key.Length : 0); var nValue = new cef_string_t(value_str, value != null ? value.Length : 0); return NativeMethods.cef_string_map_append(this.handle, &nKey, &nValue) != 0; } }
/// <summary> /// Delete all cookies that match the specified parameters. If both |url| and /// values |cookieName| are specified all host and domain cookies matching /// both will be deleted. If only |url| is specified all host cookies (but not /// domain cookies) irrespective of path will be deleted. If |url| is empty all /// cookies for all hosts and domains will be deleted. Returns false if a non- /// empty invalid URL is specified or if cookies cannot be accessed. This /// method must be called on the IO thread. /// </summary> public bool DeleteCookies(string url, string cookieName) { fixed (char* url_str = url) { var m_url = new cef_string_t(url_str, url != null ? url.Length : 0); fixed (char* cookieName_str = cookieName) { var m_cookieName = new cef_string_t(cookieName_str, cookieName != null ? cookieName.Length : 0); return cef_cookie_manager_t.invoke_delete_cookies(this.ptr, &m_url, &m_cookieName) != 0; } } }
/// <summary> /// Return a new scheme handler instance to handle the request. |browser| will /// be the browser window that initiated the request. If the request was /// initiated using the CefWebURLRequest API |browser| will be NULL. /// </summary> private cef_scheme_handler_t* create(cef_scheme_handler_factory_t* self, cef_browser_t* browser, /*const*/ cef_string_t* scheme_name, cef_request_t* request) { ThrowIfObjectDisposed(); var mBrowser = CefBrowser.FromOrDefault(browser); var m_schemeName = cef_string_t.ToString(scheme_name); var m_request = CefRequest.From(request); var handler = this.Create(mBrowser, m_schemeName, m_request); return handler.GetNativePointerAndAddRef(); }
/// <summary> /// Called to run a JavaScript alert message. Return false to display /// the default alert or true if you displayed a custom alert. /// </summary> private int on_jsalert(cef_jsdialog_handler_t* self, cef_browser_t* browser, cef_frame_t* frame, /*const*/ cef_string_t* message) { ThrowIfObjectDisposed(); var m_browser = CefBrowser.From(browser); var m_frame = CefFrame.From(frame); var m_message = cef_string_t.ToString(message); var handled = this.OnJSAlert(m_browser, m_frame, m_message); return handled ? 1 : 0; }
/// <summary> /// Called on the UI thread before a script extension is loaded. /// Return false to let the extension load normally. /// </summary> private int on_before_script_extension_load(cef_permission_handler_t* self, cef_browser_t* browser, cef_frame_t* frame, /*const*/ cef_string_t* extensionName) { ThrowIfObjectDisposed(); var m_browser = CefBrowser.From(browser); var m_frame = CefFrame.From(frame); var m_extensionName = cef_string_t.ToString(extensionName); var handled = this.OnBeforeScriptExtensionLoad(m_browser, m_frame, m_extensionName); return handled ? 1 : 0; }
/// <summary> /// Append a new key/value pair at the end of the string multimap. /// </summary> public void Append(string key, string value) { fixed (char* key_str = key) fixed (char* value_str = value) { var n_key = new cef_string_t(key_str, key != null ? key.Length : 0); var n_value = new cef_string_t(value_str, value != null ? value.Length : 0); var result = NativeMethods.cef_string_multimap_append(this.handle, &n_key, &n_value); if (result == 0) throw new InvalidOperationException("CefStringMultiMap.Append failed."); } }
/// <summary> /// Create a new CefXmlReader object. /// The returned object's methods can only be called from the thread that created the object. /// </summary> public static CefXmlReader Create(CefStreamReader stream, CefXmlEncodingType encodingType, string uri) { fixed (char* uri_str = uri) { var n_uri = new cef_string_t(uri_str, uri != null ? uri.Length : 0); return CefXmlReader.From( NativeMethods.cef_xml_reader_create( stream.GetNativePointerAndAddRef(), (cef_xml_encoding_type_t)encodingType, &n_uri) ); } }
/// <summary> /// Register a custom scheme. This method should not be called for the built-in /// HTTP, HTTPS, FILE, FTP, ABOUT and DATA schemes. /// /// If |is_standard| is true the scheme will be treated as a standard scheme. /// Standard schemes are subject to URL canonicalization and parsing rules as /// defined in the Common Internet Scheme Syntax RFC 1738 Section 3.1 available /// at http://www.ietf.org/rfc/rfc1738.txt /// /// In particular, the syntax for standard scheme URLs must be of the form: /// <pre> /// [scheme]://[username]:[password]@[host]:[port]/[url-path] /// </pre> /// Standard scheme URLs must have a host component that is a fully qualified /// domain name as defined in Section 3.5 of RFC 1034 [13] and Section 2.1 of /// RFC 1123. These URLs will be canonicalized to "scheme://host/path" in the /// simplest case and "scheme://*****:*****@host:port/path" in the most /// explicit case. For example, "scheme:host/path" and "scheme:///host/path" /// will both be canonicalized to "scheme://host/path". The origin of a /// standard scheme URL is the combination of scheme, host and port (i.e., /// "scheme://host:port" in the most explicit case). /// /// For non-standard scheme URLs only the "scheme:" component is parsed and /// canonicalized. The remainder of the URL will be passed to the handler /// as-is. For example, "scheme:///some%20text" will remain the same. /// Non-standard scheme URLs cannot be used as a target for form submission. /// /// If |is_local| is true the scheme will be treated as local (i.e., with the /// same security rules as those applied to "file" URLs). Normal pages cannot /// link to or access local URLs. Also, by default, local URLs can only perform /// XMLHttpRequest calls to the same URL (origin + path) that originated the /// request. To allow XMLHttpRequest calls from a local URL to other URLs with /// the same origin set the CefSettings.file_access_from_file_urls_allowed /// value to true. To allow XMLHttpRequest calls from a local URL to all /// origins set the CefSettings.universal_access_from_file_urls_allowed value /// to true. /// /// If |is_display_isolated| is true the scheme will be treated as display- /// isolated. This means that pages cannot display these URLs unless they are /// from the same scheme. For example, pages in another origin cannot create /// iframes or hyperlinks to URLs with this scheme. /// /// This function may be called on any thread. It should only be called once /// per unique |scheme_name| value. If |scheme_name| is already registered or /// if an error occurs this method will return false. /// </summary> public bool AddCustomScheme(string schemeName, bool isStandard, bool isLocal, bool isDisplayIsolated) { fixed (char* schemeName_str = schemeName) { var n_schemeName = new cef_string_t(schemeName_str, schemeName.Length); return cef_scheme_registrar_t.invoke_add_custom_scheme( this.ptr, &n_schemeName, isStandard ? 1 : 0, isLocal ? 1 : 0, isDisplayIsolated ? 1 : 0 ) != 0; } }
/// <summary> /// Retrieve response header information. If the response length is not /// known set |response_length| to -1 and ReadResponse() will be called /// until it returns false. If the response length is known set /// |response_length| to a positive value and ReadResponse() will be /// called until it returns false or the specified number of bytes have /// been read. Use the |response| object to set the mime type, http /// status code and other optional header values. /// To redirect the request to a new URL set |redirectUrl| to the new URL. /// </summary> private void get_response_headers(cef_scheme_handler_t* self, cef_response_t* response, long* response_length, cef_string_t* redirectUrl) { ThrowIfObjectDisposed(); var mResponse = CefResponse.From(response); long mResponseLength; string mRedirectUrl = null; this.GetResponseHeaders(mResponse, out mResponseLength, ref mRedirectUrl); *response_length = mResponseLength; if (mRedirectUrl != null) { cef_string_t.Copy(mRedirectUrl, redirectUrl); } }
/// <summary> /// Called when the browser wants to retrieve the zoom level for the /// given |url|. Return true (1) if |zoomLevel| has been set to the /// custom zoom level. Return false (0) for the browser's default zoom /// handling behavior. /// </summary> private int on_get_zoom_level(cef_zoom_handler_t* self, cef_browser_t* browser, /*const*/ cef_string_t* url, double* zoomLevel) { ThrowIfObjectDisposed(); var m_browser = CefBrowser.From(browser); var m_url = cef_string_t.ToString(url); double m_zoomLevel = 0; if (OnGetZoomLevel(m_browser, m_url, ref m_zoomLevel)) { *zoomLevel = m_zoomLevel; return 1; } else return 0; }
/// <summary> /// Called to optionally override the default text for a context menu /// item. |label| contains the default text and may be modified to /// substitute alternate text. /// </summary> private void get_menu_label(cef_menu_handler_t* self, cef_browser_t* browser, cef_menu_id_t menuId, cef_string_t* label) { ThrowIfObjectDisposed(); var m_browser = CefBrowser.From(browser); var m_menuId = (CefHandlerMenuId)menuId; var m_label = cef_string_t.ToString(label); var o_label = m_label; this.GetMenuLabel(m_browser, m_menuId, ref m_label); if ((object)m_label != (object)o_label) { cef_string_t.Copy(m_label, label); } }
/// <summary> /// Called when the browser fails to load a resource. |errorCode| is the /// error code number and |failedUrl| is the URL that failed to load. To /// provide custom error text assign the text to |errorText| and return /// true. Otherwise, return false for the default error text. See /// net\base\net_error_list.h for complete descriptions of the error /// codes. /// </summary> private int on_load_error(cef_load_handler_t* self, cef_browser_t* browser, cef_frame_t* frame, cef_handler_errorcode_t errorCode, /*const*/ cef_string_t* failedUrl, cef_string_t* errorText) { ThrowIfObjectDisposed(); var m_browser = CefBrowser.From(browser); var m_frame = CefFrame.From(frame); var m_failedUrl = cef_string_t.ToString(failedUrl); var m_errorText = cef_string_t.ToString(errorText); var c_errorText = m_errorText; var result = this.OnLoadError(m_browser, m_frame, (CefHandlerErrorCode)errorCode, m_failedUrl, ref m_errorText) ? 1 : 0; if ((object)c_errorText != (object)m_errorText) { cef_string_t.Copy(m_errorText, errorText); } return result; }
public static extern int cef_string_list_value(cef_string_list *list, int index, ref cef_string_t value);