(default)
( globals)

( globals)

cef_build_revision

 CEF_EXPORT int cef_build_revision();

Returns the CEF build revision of the libcef library.

cef_string_ascii_to_utf16

 CEF_EXPORT int cef_string_ascii_to_utf16( const char* src, size_t src_len, cef_string_utf16_t* output );

cef_string_ascii_to_wide

 CEF_EXPORT int cef_string_ascii_to_wide( const char* src, size_t src_len, cef_string_wide_t* output );

These functions convert an ASCII string, typically a hardcoded constant, to a Wide/UTF16 string. Use instead of the UTF8 conversion routines if you know the string is ASCII.

cef_string_list_alloc

 CEF_EXPORT cef_string_list_t cef_string_list_alloc();

Allocate a new string map.

cef_string_list_append

 CEF_EXPORT void cef_string_list_append( cef_string_list_t list, const cef_string_t* value );

Append a new value at the end of the string list.

cef_string_list_clear

 CEF_EXPORT void cef_string_list_clear( cef_string_list_t list );

Clear the string list.

cef_string_list_copy

 CEF_EXPORT cef_string_list_t cef_string_list_copy( cef_string_list_t list );

Creates a copy of an existing string list.

cef_string_list_free

 CEF_EXPORT void cef_string_list_free( cef_string_list_t list );

Free the string list.

cef_string_list_size

 CEF_EXPORT int cef_string_list_size( cef_string_list_t list );

Return the number of elements in the string list.

cef_string_list_value

 CEF_EXPORT int cef_string_list_value( cef_string_list_t list, int index, cef_string_t* value );

Retrieve the value at the specified zero-based string list index. Returns true (1) if the value was successfully retrieved.

cef_string_map_alloc

 CEF_EXPORT cef_string_map_t cef_string_map_alloc();

Allocate a new string map.

cef_string_map_append

 CEF_EXPORT int cef_string_map_append( cef_string_map_t map, const cef_string_t* key, const cef_string_t* value );

Append a new key/value pair at the end of the string map.

cef_string_map_clear

 CEF_EXPORT void cef_string_map_clear( cef_string_map_t map );

Clear the string map.

cef_string_map_find

 CEF_EXPORT int cef_string_map_find( cef_string_map_t map, const cef_string_t* key, cef_string_t* value );

Return the value assigned to the specified key.

cef_string_map_free

 CEF_EXPORT void cef_string_map_free( cef_string_map_t map );

Free the string map.

cef_string_map_key

 CEF_EXPORT int cef_string_map_key( cef_string_map_t map, int index, cef_string_t* key );

Return the key at the specified zero-based string map index.

cef_string_map_size

 CEF_EXPORT int cef_string_map_size( cef_string_map_t map );

Return the number of elements in the string map.

cef_string_map_value

 CEF_EXPORT int cef_string_map_value( cef_string_map_t map, int index, cef_string_t* value );

Return the value at the specified zero-based string map index.

cef_string_multimap_alloc

 CEF_EXPORT cef_string_multimap_t cef_string_multimap_alloc();

Allocate a new string multimap.

cef_string_multimap_append

 CEF_EXPORT int cef_string_multimap_append( cef_string_multimap_t map, const cef_string_t* key, const cef_string_t* value );

Append a new key/value pair at the end of the string multimap.

cef_string_multimap_clear

 CEF_EXPORT void cef_string_multimap_clear( cef_string_multimap_t map );

Clear the string multimap.

cef_string_multimap_enumerate

 CEF_EXPORT int cef_string_multimap_enumerate( cef_string_multimap_t map, const cef_string_t* key, int value_index, cef_string_t* value );

Return the value_index-th value with the specified key.

cef_string_multimap_find_count

 CEF_EXPORT int cef_string_multimap_find_count( cef_string_multimap_t map, const cef_string_t* key );

Return the number of values with the specified key.

cef_string_multimap_free

 CEF_EXPORT void cef_string_multimap_free( cef_string_multimap_t map );

Free the string multimap.

cef_string_multimap_key

 CEF_EXPORT int cef_string_multimap_key( cef_string_multimap_t map, int index, cef_string_t* key );

Return the key at the specified zero-based string multimap index.

cef_string_multimap_size

 CEF_EXPORT int cef_string_multimap_size( cef_string_multimap_t map );

Return the number of elements in the string multimap.

cef_string_multimap_value

 CEF_EXPORT int cef_string_multimap_value( cef_string_multimap_t map, int index, cef_string_t* value );

Return the value at the specified zero-based string multimap index.

cef_string_userfree_utf16_alloc

 CEF_EXPORT cef_string_userfree_utf16_t cef_string_userfree_utf16_alloc();

cef_string_userfree_utf16_free

 CEF_EXPORT void cef_string_userfree_utf16_free( cef_string_userfree_utf16_t str );

cef_string_userfree_utf8_alloc

 CEF_EXPORT cef_string_userfree_utf8_t cef_string_userfree_utf8_alloc();

cef_string_userfree_utf8_free

 CEF_EXPORT void cef_string_userfree_utf8_free( cef_string_userfree_utf8_t str );

cef_string_userfree_wide_alloc

 CEF_EXPORT cef_string_userfree_wide_t cef_string_userfree_wide_alloc();

These functions allocate a new string structure. They must be freed by calling the associated free function.

cef_string_userfree_wide_free

 CEF_EXPORT void cef_string_userfree_wide_free( cef_string_userfree_wide_t str );

These functions free the string structure allocated by the associated alloc function. Any string contents will first be cleared.

cef_string_utf16_clear

 CEF_EXPORT void cef_string_utf16_clear( cef_string_utf16_t* str );

cef_string_utf16_cmp

 CEF_EXPORT int cef_string_utf16_cmp( const cef_string_utf16_t* str1, const cef_string_utf16_t* str2 );

cef_string_utf16_set

 CEF_EXPORT int cef_string_utf16_set( const char16* src, size_t src_len, cef_string_utf16_t* output, int copy );

cef_string_utf16_to_utf8

 CEF_EXPORT int cef_string_utf16_to_utf8( const char16* src, size_t src_len, cef_string_utf8_t* output );

cef_string_utf16_to_wide

 CEF_EXPORT int cef_string_utf16_to_wide( const char16* src, size_t src_len, cef_string_wide_t* output );

cef_string_utf8_clear

 CEF_EXPORT void cef_string_utf8_clear( cef_string_utf8_t* str );

cef_string_utf8_cmp

 CEF_EXPORT int cef_string_utf8_cmp( const cef_string_utf8_t* str1, const cef_string_utf8_t* str2 );

cef_string_utf8_set

 CEF_EXPORT int cef_string_utf8_set( const char* src, size_t src_len, cef_string_utf8_t* output, int copy );

cef_string_utf8_to_utf16

 CEF_EXPORT int cef_string_utf8_to_utf16( const char* src, size_t src_len, cef_string_utf16_t* output );

cef_string_utf8_to_wide

 CEF_EXPORT int cef_string_utf8_to_wide( const char* src, size_t src_len, cef_string_wide_t* output );

cef_string_wide_clear

 CEF_EXPORT void cef_string_wide_clear( cef_string_wide_t* str );

These functions clear string values. The structure itself is not freed.

cef_string_wide_cmp

 CEF_EXPORT int cef_string_wide_cmp( const cef_string_wide_t* str1, const cef_string_wide_t* str2 );

These functions compare two string values with the same results as strcmp().

cef_string_wide_set

 CEF_EXPORT int cef_string_wide_set( const wchar_t* src, size_t src_len, cef_string_wide_t* output, int copy );

These functions set string values. If |copy| is true (1) the value will be copied instead of referenced. It is up to the user to properly manage the lifespan of references.

cef_string_wide_to_utf16

 CEF_EXPORT int cef_string_wide_to_utf16( const wchar_t* src, size_t src_len, cef_string_utf16_t* output );

cef_string_wide_to_utf8

 CEF_EXPORT int cef_string_wide_to_utf8( const wchar_t* src, size_t src_len, cef_string_utf8_t* output );

These functions convert between UTF-8, -16, and -32 strings. They are potentially slow so unnecessary conversions should be avoided. The best possible result will always be written to |output| with the boolean return value indicating whether the conversion is 100% valid.

cef_time_delta

 CEF_EXPORT int cef_time_delta( const cef_time_t* cef_time1, const cef_time_t* cef_time2, long long* delta );

Retrieve the delta in milliseconds between two time values.

cef_time_from_doublet

 CEF_EXPORT int cef_time_from_doublet( double time, cef_time_t* cef_time );

cef_time_from_timet

 CEF_EXPORT int cef_time_from_timet( time_t time, cef_time_t* cef_time );

cef_time_now

 CEF_EXPORT int cef_time_now( cef_time_t* cef_time );

Retrieve the current system time.

cef_time_to_doublet

 CEF_EXPORT int cef_time_to_doublet( const cef_time_t* cef_time, double* time );

Converts cef_time_t to/from a double which is the number of seconds since epoch (Jan 1, 1970). Webkit uses this format to represent time. A value of 0 means "not initialized". Returns true (1) on success and false (0) on failure.

cef_time_to_timet

 CEF_EXPORT int cef_time_to_timet( const cef_time_t* cef_time, time_t* time );

Converts cef_time_t to/from time_t. Returns true (1) on success and false (0) on failure.

CefAddCrossOriginWhitelistEntry

 bool CefAddCrossOriginWhitelistEntry( const CefString& source_origin, const CefString& target_protocol, const CefString& target_domain, bool allow_target_subdomains );

Add an entry to the cross-origin access whitelist. The same-origin policy restricts how scripts hosted from different origins (scheme + domain + port) can communicate. By default, scripts can only access resources with the same origin. Scripts hosted on the HTTP and HTTPS schemes (but no other schemes) can use the "Access-Control-Allow-Origin" header to allow cross-origin requests. For example, https://source.example.com can make XMLHttpRequest requests on http://target.example.com if the http://target.example.com request returns an "Access-Control-Allow-Origin: https://source.example.com" response header. Scripts in separate frames or iframes and hosted from the same protocol and domain suffix can execute cross-origin JavaScript if both pages set the document.domain value to the same domain suffix. For example, scheme://foo.example.com and scheme://bar.example.com can communicate using JavaScript if both domains set document.domain="example.com". This method is used to allow access to origins that would otherwise violate the same-origin policy. Scripts hosted underneath the fully qualified |source_origin| URL (like http://www.example.com) will be allowed access to all resources hosted on the specified |target_protocol| and |target_domain|. If |target_domain| is non-empty and |allow_target_subdomains| if false only exact domain matches will be allowed. If |target_domain| is non-empty and |allow_target_subdomains| is true sub-domain matches will be allowed. If |target_domain| is empty and |allow_target_subdomains| if true all domains and IP addresses will be allowed. This method cannot be used to bypass the restrictions on local or display isolated schemes. See the comments on CefRegisterCustomScheme for more information. This function may be called on any thread. Returns false if |source_origin| is invalid or the whitelist cannot be accessed.

CefClearCrossOriginWhitelist

 bool CefClearCrossOriginWhitelist();

Remove all entries from the cross-origin access whitelist. Returns false if the whitelist cannot be accessed.

CefClearSchemeHandlerFactories

 bool CefClearSchemeHandlerFactories();

Clear all registered scheme handler factories. Returns false on error. This function may be called on any thread.

CefCreateURL

 bool CefCreateURL( const CefURLParts& parts, CefString& url );

Creates a URL from the specified |parts|, which must contain a non-empty spec or a non-empty host and path (at a minimum), but not both. Returns false if |parts| isn't initialized as described.

CefCurrentlyOn

 bool CefCurrentlyOn( CefThreadId threadId );

CEF maintains multiple internal threads that are used for handling different types of tasks. The UI thread creates the browser window and is used for all interaction with the WebKit rendering engine and V8 JavaScript engine (The UI thread will be the same as the main application thread if CefInitialize() is called with a CefSettings.multi_threaded_message_loop value of false.) The IO thread is used for handling schema and network requests. The FILE thread is used for the application cache and other miscellaneous activities. This function will return true if called on the specified thread.

CefDoMessageLoopWork

 void CefDoMessageLoopWork();

Perform a single iteration of CEF message loop processing. This function is used to integrate the CEF message loop into an existing application message loop. Care must be taken to balance performance against excessive CPU usage. This function should only be called on the main application thread and only if CefInitialize() is called with a CefSettings.multi_threaded_message_loop value of false. This function will not block.

CefGetGeolocation

 bool CefGetGeolocation( CefRefPtr< CefGetGeolocationCallback > callback );

Request a one-time geolocation update. This function bypasses any user permission checks so should only be used by code that is allowed to access location information.

CefGetWebPluginCount

 size_t CefGetWebPluginCount();

Returns the number of installed web plugins. This method must be called on the UI thread.

CefGetWebPluginInfo

 CefRefPtr< CefWebPluginInfo > CefGetWebPluginInfo( int index );

Returns information for web plugin at the specified zero-based index. This method must be called on the UI thread.

CefGetWebPluginInfo

 CefRefPtr< CefWebPluginInfo > CefGetWebPluginInfo( const CefString& name );

Returns information for web plugin with the specified name. This method must be called on the UI thread.

CefInitialize

 bool CefInitialize( const CefSettings& settings, CefRefPtr< CefApp > application );

This function should be called on the main application thread to initialize CEF when the application is started. The |application| parameter may be empty. A return value of true indicates that it succeeded and false indicates that it failed.

CefParseURL

 bool CefParseURL( const CefString& url, CefURLParts& parts );

Parse the specified |url| into its component parts. Returns false if the URL is empty or invalid.

CefPostDelayedTask

 bool CefPostDelayedTask( CefThreadId threadId, CefRefPtr< CefTask > task, int64 delay_ms );

Post a task for delayed execution on the specified thread. This function may be called on any thread.

CefPostTask

 bool CefPostTask( CefThreadId threadId, CefRefPtr< CefTask > task );

Post a task for execution on the specified thread. This function may be called on any thread.

CefQuitMessageLoop

 void CefQuitMessageLoop();

Quit the CEF message loop that was started by calling CefRunMessageLoop(). This function should only be called on the main application thread and only if CefRunMessageLoop() was used.

CefRegisterExtension

 bool CefRegisterExtension( const CefString& extension_name, const CefString& javascript_code, CefRefPtr< CefV8Handler > handler );

Register a new V8 extension with the specified JavaScript extension code and handler. Functions implemented by the handler are prototyped using the keyword 'native'. The calling of a native function is restricted to the scope in which the prototype of the native function is defined. This function may be called on any thread. Example JavaScript extension code:

  // create the 'example' global object if it doesn't already exist.
  if (!example)
    example = {};
  // create the 'example.test' global object if it doesn't already exist.
  if (!example.test)
    example.test = {};
  (function() {
    // Define the function 'example.test.myfunction'.
    example.test.myfunction = function() {
      // Call CefV8Handler::Execute() with the function name 'MyFunction'
      // and no arguments.
      native function MyFunction();
      return MyFunction();
    };
    // Define the getter function for parameter 'example.test.myparam'.
    example.test.__defineGetter__('myparam', function() {
      // Call CefV8Handler::Execute() with the function name 'GetMyParam'
      // and no arguments.
      native function GetMyParam();
      return GetMyParam();
    });
    // Define the setter function for parameter 'example.test.myparam'.
    example.test.__defineSetter__('myparam', function(b) {
      // Call CefV8Handler::Execute() with the function name 'SetMyParam'
      // and a single argument.
      native function SetMyParam();
      if(b) SetMyParam(b);
    });
    // Extension definitions can also contain normal JavaScript variables
    // and functions.
    var myint = 0;
    example.test.increment = function() {
      myint += 1;
      return myint;
    };
  })();

Example usage in the page:

  // Call the function.
  example.test.myfunction();
  // Set the parameter.
  example.test.myparam = value;
  // Get the parameter.
  value = example.test.myparam;
  // Call another function.
  example.test.increment();

CefRegisterPlugin

 bool CefRegisterPlugin( const CefPluginInfo& plugin_info );

Register a plugin with the system.

CefRegisterSchemeHandlerFactory

 bool CefRegisterSchemeHandlerFactory( const CefString& scheme_name, const CefString& domain_name, CefRefPtr< CefSchemeHandlerFactory > factory );

Register a scheme handler factory for the specified |scheme_name| and optional |domain_name|. An empty |domain_name| value for a standard scheme will cause the factory to match all domain names. The |domain_name| value will be ignored for non-standard schemes. If |scheme_name| is a built-in scheme and no handler is returned by |factory| then the built-in scheme handler factory will be called. If |scheme_name| is a custom scheme the CefRegisterCustomScheme() function should be called for that scheme. This function may be called multiple times to change or remove the factory that matches the specified |scheme_name| and optional |domain_name|. Returns false if an error occurs. This function may be called on any thread.

CefRemoveCrossOriginWhitelistEntry

 bool CefRemoveCrossOriginWhitelistEntry( const CefString& source_origin, const CefString& target_protocol, const CefString& target_domain, bool allow_target_subdomains );

Remove an entry from the cross-origin access whitelist. Returns false if |source_origin| is invalid or the whitelist cannot be accessed.

CefRunMessageLoop

 void CefRunMessageLoop();

Run the CEF message loop. Use this function instead of an application- provided message loop to get the best balance between performance and CPU usage. This function should only be called on the main application thread and only if CefInitialize() is called with a CefSettings.multi_threaded_message_loop value of false. This function will block until a quit message is received by the system.

CefSetOSModalLoop

 void CefSetOSModalLoop( bool osModalLoop );

Set to true before calling Windows APIs like TrackPopupMenu that enter a modal message loop. Set to false after exiting the modal message loop.

CefShutdown

 void CefShutdown();

This function should be called on the main application thread to shut down CEF before the application exits.

operator!=

 inline bool operator!=( const CefRect& a, const CefRect& b );

operator==

 inline bool operator==( const CefRect& a, const CefRect& b );