cyf
1188 lines
43 KiB
C#
1188 lines
43 KiB
C#
//
|
|
// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
|
|
//
|
|
namespace Cef3.Interop
|
|
{
|
|
using System;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Runtime.InteropServices;
|
|
using System.Security;
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = libcef.ALIGN)]
|
|
[SuppressMessage("Microsoft.Design", "CA1049:TypesThatOwnNativeResourcesShouldBeDisposable")]
|
|
internal unsafe struct cef_v8value_t
|
|
{
|
|
internal cef_base_t _base;
|
|
internal IntPtr _is_valid;
|
|
internal IntPtr _is_undefined;
|
|
internal IntPtr _is_null;
|
|
internal IntPtr _is_bool;
|
|
internal IntPtr _is_int;
|
|
internal IntPtr _is_uint;
|
|
internal IntPtr _is_double;
|
|
internal IntPtr _is_date;
|
|
internal IntPtr _is_string;
|
|
internal IntPtr _is_object;
|
|
internal IntPtr _is_array;
|
|
internal IntPtr _is_function;
|
|
internal IntPtr _is_same;
|
|
internal IntPtr _get_bool_value;
|
|
internal IntPtr _get_int_value;
|
|
internal IntPtr _get_uint_value;
|
|
internal IntPtr _get_double_value;
|
|
internal IntPtr _get_date_value;
|
|
internal IntPtr _get_string_value;
|
|
internal IntPtr _is_user_created;
|
|
internal IntPtr _has_exception;
|
|
internal IntPtr _get_exception;
|
|
internal IntPtr _clear_exception;
|
|
internal IntPtr _will_rethrow_exceptions;
|
|
internal IntPtr _set_rethrow_exceptions;
|
|
internal IntPtr _has_value_bykey;
|
|
internal IntPtr _has_value_byindex;
|
|
internal IntPtr _delete_value_bykey;
|
|
internal IntPtr _delete_value_byindex;
|
|
internal IntPtr _get_value_bykey;
|
|
internal IntPtr _get_value_byindex;
|
|
internal IntPtr _set_value_bykey;
|
|
internal IntPtr _set_value_byindex;
|
|
internal IntPtr _set_value_byaccessor;
|
|
internal IntPtr _get_keys;
|
|
internal IntPtr _set_user_data;
|
|
internal IntPtr _get_user_data;
|
|
internal IntPtr _get_externally_allocated_memory;
|
|
internal IntPtr _adjust_externally_allocated_memory;
|
|
internal IntPtr _get_array_length;
|
|
internal IntPtr _get_function_name;
|
|
internal IntPtr _get_function_handler;
|
|
internal IntPtr _execute_function;
|
|
internal IntPtr _execute_function_with_context;
|
|
|
|
// CreateUndefined
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_undefined", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_undefined();
|
|
|
|
// CreateNull
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_null", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_null();
|
|
|
|
// CreateBool
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_bool", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_bool(int value);
|
|
|
|
// CreateInt
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_int", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_int(int value);
|
|
|
|
// CreateUInt
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_uint", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_uint(uint value);
|
|
|
|
// CreateDouble
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_double", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_double(double value);
|
|
|
|
// CreateDate
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_date", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_date(cef_time_t* date);
|
|
|
|
// CreateString
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_string", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_string(cef_string_t* value);
|
|
|
|
// CreateObject
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_object", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_object(cef_v8accessor_t* accessor);
|
|
|
|
// CreateArray
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_array", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_array(int length);
|
|
|
|
// CreateFunction
|
|
[DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_function", CallingConvention = libcef.CEF_CALL)]
|
|
public static extern cef_v8value_t* create_function(cef_string_t* name, cef_v8handler_t* handler);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate void add_ref_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int release_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int has_one_ref_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_valid_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_undefined_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_null_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_bool_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_int_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_uint_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_double_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_date_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_string_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_object_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_array_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_function_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_same_delegate(cef_v8value_t* self, cef_v8value_t* that);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int get_bool_value_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int get_int_value_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate uint get_uint_value_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate double get_double_value_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate cef_time_t get_date_value_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate cef_string_userfree* get_string_value_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int is_user_created_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int has_exception_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate cef_v8exception_t* get_exception_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int clear_exception_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int will_rethrow_exceptions_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int set_rethrow_exceptions_delegate(cef_v8value_t* self, int rethrow);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int has_value_bykey_delegate(cef_v8value_t* self, cef_string_t* key);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int has_value_byindex_delegate(cef_v8value_t* self, int index);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int delete_value_bykey_delegate(cef_v8value_t* self, cef_string_t* key);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int delete_value_byindex_delegate(cef_v8value_t* self, int index);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate cef_v8value_t* get_value_bykey_delegate(cef_v8value_t* self, cef_string_t* key);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate cef_v8value_t* get_value_byindex_delegate(cef_v8value_t* self, int index);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int set_value_bykey_delegate(cef_v8value_t* self, cef_string_t* key, cef_v8value_t* value, CefV8PropertyAttribute attribute);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int set_value_byindex_delegate(cef_v8value_t* self, int index, cef_v8value_t* value);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int set_value_byaccessor_delegate(cef_v8value_t* self, cef_string_t* key, CefV8AccessControl settings, CefV8PropertyAttribute attribute);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int get_keys_delegate(cef_v8value_t* self, cef_string_list* keys);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int set_user_data_delegate(cef_v8value_t* self, cef_base_t* user_data);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate cef_base_t* get_user_data_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int get_externally_allocated_memory_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int adjust_externally_allocated_memory_delegate(cef_v8value_t* self, int change_in_bytes);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate int get_array_length_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate cef_string_userfree* get_function_name_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate cef_v8handler_t* get_function_handler_delegate(cef_v8value_t* self);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate cef_v8value_t* execute_function_delegate(cef_v8value_t* self, cef_v8value_t* @object, UIntPtr argumentsCount, cef_v8value_t** arguments);
|
|
|
|
[UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
|
|
#if !DEBUG
|
|
[SuppressUnmanagedCodeSecurity]
|
|
#endif
|
|
private delegate cef_v8value_t* execute_function_with_context_delegate(cef_v8value_t* self, cef_v8context_t* context, cef_v8value_t* @object, UIntPtr argumentsCount, cef_v8value_t** arguments);
|
|
|
|
// AddRef
|
|
private static IntPtr _p0;
|
|
private static add_ref_delegate _d0;
|
|
|
|
public static void add_ref(cef_v8value_t* self)
|
|
{
|
|
add_ref_delegate d;
|
|
var p = self->_base._add_ref;
|
|
if (p == _p0) { d = _d0; }
|
|
else
|
|
{
|
|
d = (add_ref_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(add_ref_delegate));
|
|
if (_p0 == IntPtr.Zero) { _d0 = d; _p0 = p; }
|
|
}
|
|
d(self);
|
|
}
|
|
|
|
// Release
|
|
private static IntPtr _p1;
|
|
private static release_delegate _d1;
|
|
|
|
public static int release(cef_v8value_t* self)
|
|
{
|
|
release_delegate d;
|
|
var p = self->_base._release;
|
|
if (p == _p1) { d = _d1; }
|
|
else
|
|
{
|
|
d = (release_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(release_delegate));
|
|
if (_p1 == IntPtr.Zero) { _d1 = d; _p1 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// HasOneRef
|
|
private static IntPtr _p2;
|
|
private static has_one_ref_delegate _d2;
|
|
|
|
public static int has_one_ref(cef_v8value_t* self)
|
|
{
|
|
has_one_ref_delegate d;
|
|
var p = self->_base._has_one_ref;
|
|
if (p == _p2) { d = _d2; }
|
|
else
|
|
{
|
|
d = (has_one_ref_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_one_ref_delegate));
|
|
if (_p2 == IntPtr.Zero) { _d2 = d; _p2 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsValid
|
|
private static IntPtr _p3;
|
|
private static is_valid_delegate _d3;
|
|
|
|
public static int is_valid(cef_v8value_t* self)
|
|
{
|
|
is_valid_delegate d;
|
|
var p = self->_is_valid;
|
|
if (p == _p3) { d = _d3; }
|
|
else
|
|
{
|
|
d = (is_valid_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_valid_delegate));
|
|
if (_p3 == IntPtr.Zero) { _d3 = d; _p3 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsUndefined
|
|
private static IntPtr _p4;
|
|
private static is_undefined_delegate _d4;
|
|
|
|
public static int is_undefined(cef_v8value_t* self)
|
|
{
|
|
is_undefined_delegate d;
|
|
var p = self->_is_undefined;
|
|
if (p == _p4) { d = _d4; }
|
|
else
|
|
{
|
|
d = (is_undefined_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_undefined_delegate));
|
|
if (_p4 == IntPtr.Zero) { _d4 = d; _p4 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsNull
|
|
private static IntPtr _p5;
|
|
private static is_null_delegate _d5;
|
|
|
|
public static int is_null(cef_v8value_t* self)
|
|
{
|
|
is_null_delegate d;
|
|
var p = self->_is_null;
|
|
if (p == _p5) { d = _d5; }
|
|
else
|
|
{
|
|
d = (is_null_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_null_delegate));
|
|
if (_p5 == IntPtr.Zero) { _d5 = d; _p5 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsBool
|
|
private static IntPtr _p6;
|
|
private static is_bool_delegate _d6;
|
|
|
|
public static int is_bool(cef_v8value_t* self)
|
|
{
|
|
is_bool_delegate d;
|
|
var p = self->_is_bool;
|
|
if (p == _p6) { d = _d6; }
|
|
else
|
|
{
|
|
d = (is_bool_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_bool_delegate));
|
|
if (_p6 == IntPtr.Zero) { _d6 = d; _p6 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsInt
|
|
private static IntPtr _p7;
|
|
private static is_int_delegate _d7;
|
|
|
|
public static int is_int(cef_v8value_t* self)
|
|
{
|
|
is_int_delegate d;
|
|
var p = self->_is_int;
|
|
if (p == _p7) { d = _d7; }
|
|
else
|
|
{
|
|
d = (is_int_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_int_delegate));
|
|
if (_p7 == IntPtr.Zero) { _d7 = d; _p7 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsUInt
|
|
private static IntPtr _p8;
|
|
private static is_uint_delegate _d8;
|
|
|
|
public static int is_uint(cef_v8value_t* self)
|
|
{
|
|
is_uint_delegate d;
|
|
var p = self->_is_uint;
|
|
if (p == _p8) { d = _d8; }
|
|
else
|
|
{
|
|
d = (is_uint_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_uint_delegate));
|
|
if (_p8 == IntPtr.Zero) { _d8 = d; _p8 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsDouble
|
|
private static IntPtr _p9;
|
|
private static is_double_delegate _d9;
|
|
|
|
public static int is_double(cef_v8value_t* self)
|
|
{
|
|
is_double_delegate d;
|
|
var p = self->_is_double;
|
|
if (p == _p9) { d = _d9; }
|
|
else
|
|
{
|
|
d = (is_double_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_double_delegate));
|
|
if (_p9 == IntPtr.Zero) { _d9 = d; _p9 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsDate
|
|
private static IntPtr _pa;
|
|
private static is_date_delegate _da;
|
|
|
|
public static int is_date(cef_v8value_t* self)
|
|
{
|
|
is_date_delegate d;
|
|
var p = self->_is_date;
|
|
if (p == _pa) { d = _da; }
|
|
else
|
|
{
|
|
d = (is_date_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_date_delegate));
|
|
if (_pa == IntPtr.Zero) { _da = d; _pa = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsString
|
|
private static IntPtr _pb;
|
|
private static is_string_delegate _db;
|
|
|
|
public static int is_string(cef_v8value_t* self)
|
|
{
|
|
is_string_delegate d;
|
|
var p = self->_is_string;
|
|
if (p == _pb) { d = _db; }
|
|
else
|
|
{
|
|
d = (is_string_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_string_delegate));
|
|
if (_pb == IntPtr.Zero) { _db = d; _pb = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsObject
|
|
private static IntPtr _pc;
|
|
private static is_object_delegate _dc;
|
|
|
|
public static int is_object(cef_v8value_t* self)
|
|
{
|
|
is_object_delegate d;
|
|
var p = self->_is_object;
|
|
if (p == _pc) { d = _dc; }
|
|
else
|
|
{
|
|
d = (is_object_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_object_delegate));
|
|
if (_pc == IntPtr.Zero) { _dc = d; _pc = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsArray
|
|
private static IntPtr _pd;
|
|
private static is_array_delegate _dd;
|
|
|
|
public static int is_array(cef_v8value_t* self)
|
|
{
|
|
is_array_delegate d;
|
|
var p = self->_is_array;
|
|
if (p == _pd) { d = _dd; }
|
|
else
|
|
{
|
|
d = (is_array_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_array_delegate));
|
|
if (_pd == IntPtr.Zero) { _dd = d; _pd = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsFunction
|
|
private static IntPtr _pe;
|
|
private static is_function_delegate _de;
|
|
|
|
public static int is_function(cef_v8value_t* self)
|
|
{
|
|
is_function_delegate d;
|
|
var p = self->_is_function;
|
|
if (p == _pe) { d = _de; }
|
|
else
|
|
{
|
|
d = (is_function_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_function_delegate));
|
|
if (_pe == IntPtr.Zero) { _de = d; _pe = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsSame
|
|
private static IntPtr _pf;
|
|
private static is_same_delegate _df;
|
|
|
|
public static int is_same(cef_v8value_t* self, cef_v8value_t* that)
|
|
{
|
|
is_same_delegate d;
|
|
var p = self->_is_same;
|
|
if (p == _pf) { d = _df; }
|
|
else
|
|
{
|
|
d = (is_same_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_same_delegate));
|
|
if (_pf == IntPtr.Zero) { _df = d; _pf = p; }
|
|
}
|
|
return d(self, that);
|
|
}
|
|
|
|
// GetBoolValue
|
|
private static IntPtr _p10;
|
|
private static get_bool_value_delegate _d10;
|
|
|
|
public static int get_bool_value(cef_v8value_t* self)
|
|
{
|
|
get_bool_value_delegate d;
|
|
var p = self->_get_bool_value;
|
|
if (p == _p10) { d = _d10; }
|
|
else
|
|
{
|
|
d = (get_bool_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_bool_value_delegate));
|
|
if (_p10 == IntPtr.Zero) { _d10 = d; _p10 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// GetIntValue
|
|
private static IntPtr _p11;
|
|
private static get_int_value_delegate _d11;
|
|
|
|
public static int get_int_value(cef_v8value_t* self)
|
|
{
|
|
get_int_value_delegate d;
|
|
var p = self->_get_int_value;
|
|
if (p == _p11) { d = _d11; }
|
|
else
|
|
{
|
|
d = (get_int_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_int_value_delegate));
|
|
if (_p11 == IntPtr.Zero) { _d11 = d; _p11 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// GetUIntValue
|
|
private static IntPtr _p12;
|
|
private static get_uint_value_delegate _d12;
|
|
|
|
public static uint get_uint_value(cef_v8value_t* self)
|
|
{
|
|
get_uint_value_delegate d;
|
|
var p = self->_get_uint_value;
|
|
if (p == _p12) { d = _d12; }
|
|
else
|
|
{
|
|
d = (get_uint_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_uint_value_delegate));
|
|
if (_p12 == IntPtr.Zero) { _d12 = d; _p12 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// GetDoubleValue
|
|
private static IntPtr _p13;
|
|
private static get_double_value_delegate _d13;
|
|
|
|
public static double get_double_value(cef_v8value_t* self)
|
|
{
|
|
get_double_value_delegate d;
|
|
var p = self->_get_double_value;
|
|
if (p == _p13) { d = _d13; }
|
|
else
|
|
{
|
|
d = (get_double_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_double_value_delegate));
|
|
if (_p13 == IntPtr.Zero) { _d13 = d; _p13 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// GetDateValue
|
|
private static IntPtr _p14;
|
|
private static get_date_value_delegate _d14;
|
|
|
|
public static cef_time_t get_date_value(cef_v8value_t* self)
|
|
{
|
|
get_date_value_delegate d;
|
|
var p = self->_get_date_value;
|
|
if (p == _p14) { d = _d14; }
|
|
else
|
|
{
|
|
d = (get_date_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_date_value_delegate));
|
|
if (_p14 == IntPtr.Zero) { _d14 = d; _p14 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// GetStringValue
|
|
private static IntPtr _p15;
|
|
private static get_string_value_delegate _d15;
|
|
|
|
public static cef_string_userfree* get_string_value(cef_v8value_t* self)
|
|
{
|
|
get_string_value_delegate d;
|
|
var p = self->_get_string_value;
|
|
if (p == _p15) { d = _d15; }
|
|
else
|
|
{
|
|
d = (get_string_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_string_value_delegate));
|
|
if (_p15 == IntPtr.Zero) { _d15 = d; _p15 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// IsUserCreated
|
|
private static IntPtr _p16;
|
|
private static is_user_created_delegate _d16;
|
|
|
|
public static int is_user_created(cef_v8value_t* self)
|
|
{
|
|
is_user_created_delegate d;
|
|
var p = self->_is_user_created;
|
|
if (p == _p16) { d = _d16; }
|
|
else
|
|
{
|
|
d = (is_user_created_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_user_created_delegate));
|
|
if (_p16 == IntPtr.Zero) { _d16 = d; _p16 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// HasException
|
|
private static IntPtr _p17;
|
|
private static has_exception_delegate _d17;
|
|
|
|
public static int has_exception(cef_v8value_t* self)
|
|
{
|
|
has_exception_delegate d;
|
|
var p = self->_has_exception;
|
|
if (p == _p17) { d = _d17; }
|
|
else
|
|
{
|
|
d = (has_exception_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_exception_delegate));
|
|
if (_p17 == IntPtr.Zero) { _d17 = d; _p17 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// GetException
|
|
private static IntPtr _p18;
|
|
private static get_exception_delegate _d18;
|
|
|
|
public static cef_v8exception_t* get_exception(cef_v8value_t* self)
|
|
{
|
|
get_exception_delegate d;
|
|
var p = self->_get_exception;
|
|
if (p == _p18) { d = _d18; }
|
|
else
|
|
{
|
|
d = (get_exception_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_exception_delegate));
|
|
if (_p18 == IntPtr.Zero) { _d18 = d; _p18 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// ClearException
|
|
private static IntPtr _p19;
|
|
private static clear_exception_delegate _d19;
|
|
|
|
public static int clear_exception(cef_v8value_t* self)
|
|
{
|
|
clear_exception_delegate d;
|
|
var p = self->_clear_exception;
|
|
if (p == _p19) { d = _d19; }
|
|
else
|
|
{
|
|
d = (clear_exception_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(clear_exception_delegate));
|
|
if (_p19 == IntPtr.Zero) { _d19 = d; _p19 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// WillRethrowExceptions
|
|
private static IntPtr _p1a;
|
|
private static will_rethrow_exceptions_delegate _d1a;
|
|
|
|
public static int will_rethrow_exceptions(cef_v8value_t* self)
|
|
{
|
|
will_rethrow_exceptions_delegate d;
|
|
var p = self->_will_rethrow_exceptions;
|
|
if (p == _p1a) { d = _d1a; }
|
|
else
|
|
{
|
|
d = (will_rethrow_exceptions_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(will_rethrow_exceptions_delegate));
|
|
if (_p1a == IntPtr.Zero) { _d1a = d; _p1a = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// SetRethrowExceptions
|
|
private static IntPtr _p1b;
|
|
private static set_rethrow_exceptions_delegate _d1b;
|
|
|
|
public static int set_rethrow_exceptions(cef_v8value_t* self, int rethrow)
|
|
{
|
|
set_rethrow_exceptions_delegate d;
|
|
var p = self->_set_rethrow_exceptions;
|
|
if (p == _p1b) { d = _d1b; }
|
|
else
|
|
{
|
|
d = (set_rethrow_exceptions_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_rethrow_exceptions_delegate));
|
|
if (_p1b == IntPtr.Zero) { _d1b = d; _p1b = p; }
|
|
}
|
|
return d(self, rethrow);
|
|
}
|
|
|
|
// HasValue
|
|
private static IntPtr _p1c;
|
|
private static has_value_bykey_delegate _d1c;
|
|
|
|
public static int has_value_bykey(cef_v8value_t* self, cef_string_t* key)
|
|
{
|
|
has_value_bykey_delegate d;
|
|
var p = self->_has_value_bykey;
|
|
if (p == _p1c) { d = _d1c; }
|
|
else
|
|
{
|
|
d = (has_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_value_bykey_delegate));
|
|
if (_p1c == IntPtr.Zero) { _d1c = d; _p1c = p; }
|
|
}
|
|
return d(self, key);
|
|
}
|
|
|
|
// HasValue
|
|
private static IntPtr _p1d;
|
|
private static has_value_byindex_delegate _d1d;
|
|
|
|
public static int has_value_byindex(cef_v8value_t* self, int index)
|
|
{
|
|
has_value_byindex_delegate d;
|
|
var p = self->_has_value_byindex;
|
|
if (p == _p1d) { d = _d1d; }
|
|
else
|
|
{
|
|
d = (has_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_value_byindex_delegate));
|
|
if (_p1d == IntPtr.Zero) { _d1d = d; _p1d = p; }
|
|
}
|
|
return d(self, index);
|
|
}
|
|
|
|
// DeleteValue
|
|
private static IntPtr _p1e;
|
|
private static delete_value_bykey_delegate _d1e;
|
|
|
|
public static int delete_value_bykey(cef_v8value_t* self, cef_string_t* key)
|
|
{
|
|
delete_value_bykey_delegate d;
|
|
var p = self->_delete_value_bykey;
|
|
if (p == _p1e) { d = _d1e; }
|
|
else
|
|
{
|
|
d = (delete_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(delete_value_bykey_delegate));
|
|
if (_p1e == IntPtr.Zero) { _d1e = d; _p1e = p; }
|
|
}
|
|
return d(self, key);
|
|
}
|
|
|
|
// DeleteValue
|
|
private static IntPtr _p1f;
|
|
private static delete_value_byindex_delegate _d1f;
|
|
|
|
public static int delete_value_byindex(cef_v8value_t* self, int index)
|
|
{
|
|
delete_value_byindex_delegate d;
|
|
var p = self->_delete_value_byindex;
|
|
if (p == _p1f) { d = _d1f; }
|
|
else
|
|
{
|
|
d = (delete_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(delete_value_byindex_delegate));
|
|
if (_p1f == IntPtr.Zero) { _d1f = d; _p1f = p; }
|
|
}
|
|
return d(self, index);
|
|
}
|
|
|
|
// GetValue
|
|
private static IntPtr _p20;
|
|
private static get_value_bykey_delegate _d20;
|
|
|
|
public static cef_v8value_t* get_value_bykey(cef_v8value_t* self, cef_string_t* key)
|
|
{
|
|
get_value_bykey_delegate d;
|
|
var p = self->_get_value_bykey;
|
|
if (p == _p20) { d = _d20; }
|
|
else
|
|
{
|
|
d = (get_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_value_bykey_delegate));
|
|
if (_p20 == IntPtr.Zero) { _d20 = d; _p20 = p; }
|
|
}
|
|
return d(self, key);
|
|
}
|
|
|
|
// GetValue
|
|
private static IntPtr _p21;
|
|
private static get_value_byindex_delegate _d21;
|
|
|
|
public static cef_v8value_t* get_value_byindex(cef_v8value_t* self, int index)
|
|
{
|
|
get_value_byindex_delegate d;
|
|
var p = self->_get_value_byindex;
|
|
if (p == _p21) { d = _d21; }
|
|
else
|
|
{
|
|
d = (get_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_value_byindex_delegate));
|
|
if (_p21 == IntPtr.Zero) { _d21 = d; _p21 = p; }
|
|
}
|
|
return d(self, index);
|
|
}
|
|
|
|
// SetValue
|
|
private static IntPtr _p22;
|
|
private static set_value_bykey_delegate _d22;
|
|
|
|
public static int set_value_bykey(cef_v8value_t* self, cef_string_t* key, cef_v8value_t* value, CefV8PropertyAttribute attribute)
|
|
{
|
|
set_value_bykey_delegate d;
|
|
var p = self->_set_value_bykey;
|
|
if (p == _p22) { d = _d22; }
|
|
else
|
|
{
|
|
d = (set_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_value_bykey_delegate));
|
|
if (_p22 == IntPtr.Zero) { _d22 = d; _p22 = p; }
|
|
}
|
|
return d(self, key, value, attribute);
|
|
}
|
|
|
|
// SetValue
|
|
private static IntPtr _p23;
|
|
private static set_value_byindex_delegate _d23;
|
|
|
|
public static int set_value_byindex(cef_v8value_t* self, int index, cef_v8value_t* value)
|
|
{
|
|
set_value_byindex_delegate d;
|
|
var p = self->_set_value_byindex;
|
|
if (p == _p23) { d = _d23; }
|
|
else
|
|
{
|
|
d = (set_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_value_byindex_delegate));
|
|
if (_p23 == IntPtr.Zero) { _d23 = d; _p23 = p; }
|
|
}
|
|
return d(self, index, value);
|
|
}
|
|
|
|
// SetValue
|
|
private static IntPtr _p24;
|
|
private static set_value_byaccessor_delegate _d24;
|
|
|
|
public static int set_value_byaccessor(cef_v8value_t* self, cef_string_t* key, CefV8AccessControl settings, CefV8PropertyAttribute attribute)
|
|
{
|
|
set_value_byaccessor_delegate d;
|
|
var p = self->_set_value_byaccessor;
|
|
if (p == _p24) { d = _d24; }
|
|
else
|
|
{
|
|
d = (set_value_byaccessor_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_value_byaccessor_delegate));
|
|
if (_p24 == IntPtr.Zero) { _d24 = d; _p24 = p; }
|
|
}
|
|
return d(self, key, settings, attribute);
|
|
}
|
|
|
|
// GetKeys
|
|
private static IntPtr _p25;
|
|
private static get_keys_delegate _d25;
|
|
|
|
public static int get_keys(cef_v8value_t* self, cef_string_list* keys)
|
|
{
|
|
get_keys_delegate d;
|
|
var p = self->_get_keys;
|
|
if (p == _p25) { d = _d25; }
|
|
else
|
|
{
|
|
d = (get_keys_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_keys_delegate));
|
|
if (_p25 == IntPtr.Zero) { _d25 = d; _p25 = p; }
|
|
}
|
|
return d(self, keys);
|
|
}
|
|
|
|
// SetUserData
|
|
private static IntPtr _p26;
|
|
private static set_user_data_delegate _d26;
|
|
|
|
public static int set_user_data(cef_v8value_t* self, cef_base_t* user_data)
|
|
{
|
|
set_user_data_delegate d;
|
|
var p = self->_set_user_data;
|
|
if (p == _p26) { d = _d26; }
|
|
else
|
|
{
|
|
d = (set_user_data_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_user_data_delegate));
|
|
if (_p26 == IntPtr.Zero) { _d26 = d; _p26 = p; }
|
|
}
|
|
return d(self, user_data);
|
|
}
|
|
|
|
// GetUserData
|
|
private static IntPtr _p27;
|
|
private static get_user_data_delegate _d27;
|
|
|
|
public static cef_base_t* get_user_data(cef_v8value_t* self)
|
|
{
|
|
get_user_data_delegate d;
|
|
var p = self->_get_user_data;
|
|
if (p == _p27) { d = _d27; }
|
|
else
|
|
{
|
|
d = (get_user_data_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_user_data_delegate));
|
|
if (_p27 == IntPtr.Zero) { _d27 = d; _p27 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// GetExternallyAllocatedMemory
|
|
private static IntPtr _p28;
|
|
private static get_externally_allocated_memory_delegate _d28;
|
|
|
|
public static int get_externally_allocated_memory(cef_v8value_t* self)
|
|
{
|
|
get_externally_allocated_memory_delegate d;
|
|
var p = self->_get_externally_allocated_memory;
|
|
if (p == _p28) { d = _d28; }
|
|
else
|
|
{
|
|
d = (get_externally_allocated_memory_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_externally_allocated_memory_delegate));
|
|
if (_p28 == IntPtr.Zero) { _d28 = d; _p28 = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// AdjustExternallyAllocatedMemory
|
|
private static IntPtr _p29;
|
|
private static adjust_externally_allocated_memory_delegate _d29;
|
|
|
|
public static int adjust_externally_allocated_memory(cef_v8value_t* self, int change_in_bytes)
|
|
{
|
|
adjust_externally_allocated_memory_delegate d;
|
|
var p = self->_adjust_externally_allocated_memory;
|
|
if (p == _p29) { d = _d29; }
|
|
else
|
|
{
|
|
d = (adjust_externally_allocated_memory_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(adjust_externally_allocated_memory_delegate));
|
|
if (_p29 == IntPtr.Zero) { _d29 = d; _p29 = p; }
|
|
}
|
|
return d(self, change_in_bytes);
|
|
}
|
|
|
|
// GetArrayLength
|
|
private static IntPtr _p2a;
|
|
private static get_array_length_delegate _d2a;
|
|
|
|
public static int get_array_length(cef_v8value_t* self)
|
|
{
|
|
get_array_length_delegate d;
|
|
var p = self->_get_array_length;
|
|
if (p == _p2a) { d = _d2a; }
|
|
else
|
|
{
|
|
d = (get_array_length_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_array_length_delegate));
|
|
if (_p2a == IntPtr.Zero) { _d2a = d; _p2a = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// GetFunctionName
|
|
private static IntPtr _p2b;
|
|
private static get_function_name_delegate _d2b;
|
|
|
|
public static cef_string_userfree* get_function_name(cef_v8value_t* self)
|
|
{
|
|
get_function_name_delegate d;
|
|
var p = self->_get_function_name;
|
|
if (p == _p2b) { d = _d2b; }
|
|
else
|
|
{
|
|
d = (get_function_name_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_function_name_delegate));
|
|
if (_p2b == IntPtr.Zero) { _d2b = d; _p2b = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// GetFunctionHandler
|
|
private static IntPtr _p2c;
|
|
private static get_function_handler_delegate _d2c;
|
|
|
|
public static cef_v8handler_t* get_function_handler(cef_v8value_t* self)
|
|
{
|
|
get_function_handler_delegate d;
|
|
var p = self->_get_function_handler;
|
|
if (p == _p2c) { d = _d2c; }
|
|
else
|
|
{
|
|
d = (get_function_handler_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_function_handler_delegate));
|
|
if (_p2c == IntPtr.Zero) { _d2c = d; _p2c = p; }
|
|
}
|
|
return d(self);
|
|
}
|
|
|
|
// ExecuteFunction
|
|
private static IntPtr _p2d;
|
|
private static execute_function_delegate _d2d;
|
|
|
|
public static cef_v8value_t* execute_function(cef_v8value_t* self, cef_v8value_t* @object, UIntPtr argumentsCount, cef_v8value_t** arguments)
|
|
{
|
|
execute_function_delegate d;
|
|
var p = self->_execute_function;
|
|
if (p == _p2d) { d = _d2d; }
|
|
else
|
|
{
|
|
d = (execute_function_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(execute_function_delegate));
|
|
if (_p2d == IntPtr.Zero) { _d2d = d; _p2d = p; }
|
|
}
|
|
return d(self, @object, argumentsCount, arguments);
|
|
}
|
|
|
|
// ExecuteFunctionWithContext
|
|
private static IntPtr _p2e;
|
|
private static execute_function_with_context_delegate _d2e;
|
|
|
|
public static cef_v8value_t* execute_function_with_context(cef_v8value_t* self, cef_v8context_t* context, cef_v8value_t* @object, UIntPtr argumentsCount, cef_v8value_t** arguments)
|
|
{
|
|
execute_function_with_context_delegate d;
|
|
var p = self->_execute_function_with_context;
|
|
if (p == _p2e) { d = _d2e; }
|
|
else
|
|
{
|
|
d = (execute_function_with_context_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(execute_function_with_context_delegate));
|
|
if (_p2e == IntPtr.Zero) { _d2e = d; _p2e = p; }
|
|
}
|
|
return d(self, context, @object, argumentsCount, arguments);
|
|
}
|
|
|
|
}
|
|
}
|