pascal/CEF4Delphi
1
0
Fork 0
mirror of https://github.com/salvadordf/CEF4Delphi.git synced 2025-06-02 21:57:37 +02:00
Code Issues Actions Releases Activity

Update to CEF 3.3396.1777.g636f29b

Browse Source 
More GlobalCEFApp checks in uCEFMiscFunctions.pas
This commit is contained in:
Salvador Díaz Fau 2018-06-11 09:01:38 +02:00
parent ac8a3358fa
commit bde2aeef85
2 changed files with 306 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
source/uCEFApplication.pas
View File

@ -61,13 +61,13 @@ uses
const const
CEF_SUPPORTED_VERSION_MAJOR = 3; CEF_SUPPORTED_VERSION_MAJOR = 3;
CEF_SUPPORTED_VERSION_MINOR = 3396; CEF_SUPPORTED_VERSION_MINOR = 3396;
CEF_SUPPORTED_VERSION_RELEASE = 1775; CEF_SUPPORTED_VERSION_RELEASE = 1777;
CEF_SUPPORTED_VERSION_BUILD = 0; CEF_SUPPORTED_VERSION_BUILD = 0;
CEF_CHROMEELF_VERSION_MAJOR = 67; CEF_CHROMEELF_VERSION_MAJOR = 67;
CEF_CHROMEELF_VERSION_MINOR = 0; CEF_CHROMEELF_VERSION_MINOR = 0;
CEF_CHROMEELF_VERSION_RELEASE = 3396; CEF_CHROMEELF_VERSION_RELEASE = 3396;
CEF_CHROMEELF_VERSION_BUILD = 62; CEF_CHROMEELF_VERSION_BUILD = 79;
LIBCEF_DLL = 'libcef.dll'; LIBCEF_DLL = 'libcef.dll';
CHROMEELF_DLL = 'chrome_elf.dll'; CHROMEELF_DLL = 'chrome_elf.dll';

379
source/uCEFMiscFunctions.pas
View File

@ -265,9 +265,14 @@ begin
end; end;
function CefStringClearAndGet(var str: TCefString): ustring; function CefStringClearAndGet(var str: TCefString): ustring;
begin
if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
begin begin
Result := CefString(@str); Result := CefString(@str);
cef_string_utf16_clear(@str); cef_string_utf16_clear(@str);
end
else
Result := '';
end; end;
function CefGetObject(ptr: Pointer): TObject; {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} function CefGetObject(ptr: Pointer): TObject; {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF}
@ -306,17 +311,19 @@ end;
procedure CefStringFree(const str: PCefString); procedure CefStringFree(const str: PCefString);
begin begin
if (str <> nil) then cef_string_utf16_clear(str); if (str <> nil) and (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
cef_string_utf16_clear(str);
end; end;
procedure CefStringSet(const str: PCefString; const value: ustring); procedure CefStringSet(const str: PCefString; const value: ustring);
begin begin
if (str <> nil) then cef_string_utf16_set(PWideChar(value), Length(value), str, 1); if (str <> nil) and (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
cef_string_utf16_set(PWideChar(value), Length(value), str, 1);
end; end;
function CefStringFreeAndGet(const str: PCefStringUserFree): ustring; function CefStringFreeAndGet(const str: PCefStringUserFree): ustring;
begin begin
if (str <> nil) then if (str <> nil) and (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
begin begin
Result := CefString(PCefString(str)); Result := CefString(PCefString(str));
cef_string_userfree_utf16_free(str); cef_string_userfree_utf16_free(str);
@ -328,7 +335,8 @@ end;
function CefStringAlloc(const str: ustring): TCefString; function CefStringAlloc(const str: ustring): TCefString;
begin begin
FillChar(Result, SizeOf(Result), 0); FillChar(Result, SizeOf(Result), 0);
if (str <> '') then cef_string_wide_to_utf16(PWideChar(str), Length(str), @Result); if (str <> '') and (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
cef_string_wide_to_utf16(PWideChar(str), Length(str), @Result);
end; end;
procedure _free_string(str: PChar16); stdcall; procedure _free_string(str: PChar16); stdcall;
@ -337,30 +345,42 @@ begin
end; end;
function CefUserFreeString(const str: ustring): PCefStringUserFree; function CefUserFreeString(const str: ustring): PCefStringUserFree;
begin
if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
begin begin
Result := cef_string_userfree_utf16_alloc(); Result := cef_string_userfree_utf16_alloc();
Result^.length := Length(str); Result^.length := Length(str);
GetMem(Result^.str, Result^.length * SizeOf(TCefChar)); GetMem(Result^.str, Result^.length * SizeOf(TCefChar));
Move(PCefChar(str)^, Result^.str^, Result^.length * SizeOf(TCefChar)); Move(PCefChar(str)^, Result^.str^, Result^.length * SizeOf(TCefChar));
Result^.dtor := @_free_string; Result^.dtor := @_free_string;
end
else
Result := nil;
end; end;
function CefRegisterExtension(const name, code: ustring; const Handler: ICefv8Handler): Boolean; function CefRegisterExtension(const name, code: ustring; const Handler: ICefv8Handler): Boolean;
var var
n, c : TCefString; TempName, TempCode : TCefString;
begin begin
n := CefString(name); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
c := CefString(code); begin
Result := cef_register_extension(@n, @c, CefGetData(handler)) <> 0; TempName := CefString(name);
TempCode := CefString(code);
Result := cef_register_extension(@TempName, @TempCode, CefGetData(handler)) <> 0;
end
else
Result := False;
end; end;
procedure CefPostTask(ThreadId: TCefThreadId; const task: ICefTask); procedure CefPostTask(ThreadId: TCefThreadId; const task: ICefTask);
begin begin
if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
cef_post_task(ThreadId, CefGetData(task)); cef_post_task(ThreadId, CefGetData(task));
end; end;
procedure CefPostDelayedTask(ThreadId: TCefThreadId; const task: ICefTask; delayMs: Int64); procedure CefPostDelayedTask(ThreadId: TCefThreadId; const task: ICefTask; delayMs: Int64);
begin begin
if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
cef_post_delayed_task(ThreadId, CefGetData(task), delayMs); cef_post_delayed_task(ThreadId, CefGetData(task), delayMs);
end; end;
@ -390,40 +410,52 @@ end;
function CefTimeToDateTime(const dt: TCefTime): TDateTime; function CefTimeToDateTime(const dt: TCefTime): TDateTime;
var var
st: TSystemTime; TempTime : TSystemTime;
begin begin
st := CefTimeToSystemTime(dt); TempTime := CefTimeToSystemTime(dt);
SystemTimeToTzSpecificLocalTime(nil, @st, @st); SystemTimeToTzSpecificLocalTime(nil, @TempTime, @TempTime);
Result := SystemTimeToDateTime(st); Result := SystemTimeToDateTime(TempTime);
end; end;
function DateTimeToCefTime(dt: TDateTime): TCefTime; function DateTimeToCefTime(dt: TDateTime): TCefTime;
var var
st: TSystemTime; TempTime : TSystemTime;
begin begin
DateTimeToSystemTime(dt, st); DateTimeToSystemTime(dt, TempTime);
TzSpecificLocalTimeToSystemTime(nil, @st, @st); TzSpecificLocalTimeToSystemTime(nil, @TempTime, @TempTime);
Result := SystemTimeToCefTime(st); Result := SystemTimeToCefTime(TempTime);
end; end;
function cef_string_wide_copy(const src: PWideChar; src_len: NativeUInt; output: PCefStringWide): Integer; function cef_string_wide_copy(const src: PWideChar; src_len: NativeUInt; output: PCefStringWide): Integer;
begin begin
Result := cef_string_wide_set(src, src_len, output, ord(True)); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := cef_string_wide_set(src, src_len, output, ord(True))
else
Result := 0;
end; end;
function cef_string_utf8_copy(const src: PAnsiChar; src_len: NativeUInt; output: PCefStringUtf8): Integer; function cef_string_utf8_copy(const src: PAnsiChar; src_len: NativeUInt; output: PCefStringUtf8): Integer;
begin begin
Result := cef_string_utf8_set(src, src_len, output, ord(True)); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := cef_string_utf8_set(src, src_len, output, ord(True))
else
Result := 0;
end; end;
function cef_string_utf16_copy(const src: PChar16; src_len: NativeUInt; output: PCefStringUtf16): Integer; function cef_string_utf16_copy(const src: PChar16; src_len: NativeUInt; output: PCefStringUtf16): Integer;
begin begin
Result := cef_string_utf16_set(src, src_len, output, ord(True)); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := cef_string_utf16_set(src, src_len, output, ord(True))
else
Result := 0;
end; end;
function cef_string_copy(const src: PCefChar; src_len: NativeUInt; output: PCefString): Integer; function cef_string_copy(const src: PCefChar; src_len: NativeUInt; output: PCefString): Integer;
begin begin
Result := cef_string_utf16_set(src, src_len, output, ord(True)); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := cef_string_utf16_set(src, src_len, output, ord(True))
else
Result := 0;
end; end;
{$IFDEF MSWINDOWS} {$IFDEF MSWINDOWS}
@ -552,27 +584,36 @@ end;
function CefIsCertStatusError(Status : TCefCertStatus) : boolean; function CefIsCertStatusError(Status : TCefCertStatus) : boolean;
begin begin
Result := (cef_is_cert_status_error(Status) <> 0); Result := (GlobalCEFApp <> nil) and
GlobalCEFApp.LibLoaded and
(cef_is_cert_status_error(Status) <> 0);
end; end;
function CefIsCertStatusMinorError(Status : TCefCertStatus) : boolean; function CefIsCertStatusMinorError(Status : TCefCertStatus) : boolean;
begin begin
Result := (cef_is_cert_status_minor_error(Status) <> 0); Result := (GlobalCEFApp <> nil) and
GlobalCEFApp.LibLoaded and
(cef_is_cert_status_minor_error(Status) <> 0);
end; end;
function CefCrashReportingEnabled : boolean; function CefCrashReportingEnabled : boolean;
begin begin
Result := (cef_crash_reporting_enabled() <> 0); Result := (GlobalCEFApp <> nil) and
GlobalCEFApp.LibLoaded and
(cef_crash_reporting_enabled() <> 0);
end; end;
procedure CefSetCrashKeyValue(const aKey, aValue : ustring); procedure CefSetCrashKeyValue(const aKey, aValue : ustring);
var var
TempKey, TempValue : TCefString; TempKey, TempValue : TCefString;
begin
if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
begin begin
TempKey := CefString(aKey); TempKey := CefString(aKey);
TempValue := CefString(aValue); TempValue := CefString(aValue);
cef_set_crash_key_value(@TempKey, @TempValue); cef_set_crash_key_value(@TempKey, @TempValue);
end; end;
end;
procedure CefLog(const aFile : string; aLine, aSeverity : integer; const aMessage : string); procedure CefLog(const aFile : string; aLine, aSeverity : integer; const aMessage : string);
var var
@ -634,16 +675,27 @@ function CefRegisterSchemeHandlerFactory(const SchemeName : ustring;
var var
TempScheme, TempHostName : TCefString; TempScheme, TempHostName : TCefString;
TempFactory : ICefSchemeHandlerFactory; TempFactory : ICefSchemeHandlerFactory;
begin
Result := False;
try
if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
begin begin
TempScheme := CefString(SchemeName); TempScheme := CefString(SchemeName);
TempHostName := CefString(HostName); TempHostName := CefString(HostName);
TempFactory := TCefSchemeHandlerFactoryOwn.Create(handler); TempFactory := TCefSchemeHandlerFactoryOwn.Create(handler);
Result := cef_register_scheme_handler_factory(@TempScheme, @TempHostName, TempFactory.Wrap) <> 0; Result := cef_register_scheme_handler_factory(@TempScheme, @TempHostName, TempFactory.Wrap) <> 0;
end; end;
finally
TempFactory := nil;
end;
end;
function CefClearSchemeHandlerFactories : boolean; function CefClearSchemeHandlerFactories : boolean;
begin begin
Result := cef_clear_scheme_handler_factories() <> 0; Result := (GlobalCEFApp <> nil) and
GlobalCEFApp.LibLoaded and
(cef_clear_scheme_handler_factories() <> 0);
end; end;
function CefAddCrossOriginWhitelistEntry(const SourceOrigin : ustring; function CefAddCrossOriginWhitelistEntry(const SourceOrigin : ustring;
@ -652,6 +704,8 @@ function CefAddCrossOriginWhitelistEntry(const SourceOrigin : ustring;
AllowTargetSubdomains : Boolean): Boolean; AllowTargetSubdomains : Boolean): Boolean;
var var
TempSourceOrigin, TempTargetProtocol, TempTargetDomain : TCefString; TempSourceOrigin, TempTargetProtocol, TempTargetDomain : TCefString;
begin
if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
begin begin
TempSourceOrigin := CefString(SourceOrigin); TempSourceOrigin := CefString(SourceOrigin);
TempTargetProtocol := CefString(TargetProtocol); TempTargetProtocol := CefString(TargetProtocol);
@ -660,6 +714,9 @@ begin
@TempTargetProtocol, @TempTargetProtocol,
@TempTargetDomain, @TempTargetDomain,
Ord(AllowTargetSubdomains)) <> 0; Ord(AllowTargetSubdomains)) <> 0;
end
else
Result := False;
end; end;
function CefRemoveCrossOriginWhitelistEntry(const SourceOrigin : ustring; function CefRemoveCrossOriginWhitelistEntry(const SourceOrigin : ustring;
@ -668,6 +725,8 @@ function CefRemoveCrossOriginWhitelistEntry(const SourceOrigin : ustrin
AllowTargetSubdomains : Boolean): Boolean; AllowTargetSubdomains : Boolean): Boolean;
var var
TempSourceOrigin, TempTargetProtocol, TempTargetDomain : TCefString; TempSourceOrigin, TempTargetProtocol, TempTargetDomain : TCefString;
begin
if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
begin begin
TempSourceOrigin := CefString(SourceOrigin); TempSourceOrigin := CefString(SourceOrigin);
TempTargetProtocol := CefString(TargetProtocol); TempTargetProtocol := CefString(TargetProtocol);
@ -676,6 +735,9 @@ begin
@TempTargetProtocol, @TempTargetProtocol,
@TempTargetDomain, @TempTargetDomain,
Ord(AllowTargetSubdomains)) <> 0; Ord(AllowTargetSubdomains)) <> 0;
end
else
Result := False;
end; end;
function CefClearCrossOriginWhitelist: Boolean; function CefClearCrossOriginWhitelist: Boolean;
@ -1107,61 +1169,76 @@ end;
function CefParseUrl(const url: ustring; var parts: TUrlParts): Boolean; function CefParseUrl(const url: ustring; var parts: TUrlParts): Boolean;
var var
u: TCefString; TempURL : TCefString;
p: TCefUrlParts; TempParts : TCefUrlParts;
begin begin
FillChar(p, sizeof(p), 0); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
u := CefString(url); begin
Result := cef_parse_url(@u, p) <> 0; FillChar(TempParts, sizeof(TempParts), 0);
TempURL := CefString(url);
Result := cef_parse_url(@TempURL, TempParts) <> 0;
if Result then if Result then
begin begin
//parts.spec := CefString(@p.spec); //parts.spec := CefString(@TempParts.spec);
parts.scheme := CefString(@p.scheme); parts.scheme := CefString(@TempParts.scheme);
parts.username := CefString(@p.username); parts.username := CefString(@TempParts.username);
parts.password := CefString(@p.password); parts.password := CefString(@TempParts.password);
parts.host := CefString(@p.host); parts.host := CefString(@TempParts.host);
parts.port := CefString(@p.port); parts.port := CefString(@TempParts.port);
parts.origin := CefString(@p.origin); parts.origin := CefString(@TempParts.origin);
parts.path := CefString(@p.path); parts.path := CefString(@TempParts.path);
parts.query := CefString(@p.query); parts.query := CefString(@TempParts.query);
end; end;
end
else
Result := False;
end; end;
function CefCreateUrl(var parts: TUrlParts): ustring; function CefCreateUrl(var parts: TUrlParts): ustring;
var var
p: TCefUrlParts; TempURL : TCefString;
u: TCefString; TempParts : TCefUrlParts;
begin begin
FillChar(p, sizeof(p), 0);
p.spec := CefString(parts.spec);
p.scheme := CefString(parts.scheme);
p.username := CefString(parts.username);
p.password := CefString(parts.password);
p.host := CefString(parts.host);
p.port := CefString(parts.port);
p.origin := CefString(parts.origin);
p.path := CefString(parts.path);
p.query := CefString(parts.query);
FillChar(u, SizeOf(u), 0);
if cef_create_url(@p, @u) <> 0 then
Result := CefString(@u) else
Result := ''; Result := '';
if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
begin
FillChar(TempParts, sizeof(TempParts), 0);
TempParts.spec := CefString(parts.spec);
TempParts.scheme := CefString(parts.scheme);
TempParts.username := CefString(parts.username);
TempParts.password := CefString(parts.password);
TempParts.host := CefString(parts.host);
TempParts.port := CefString(parts.port);
TempParts.origin := CefString(parts.origin);
TempParts.path := CefString(parts.path);
TempParts.query := CefString(parts.query);
FillChar(TempURL, SizeOf(TempURL), 0);
if cef_create_url(@TempParts, @TempURL) <> 0 then Result := CefString(@TempURL);
end;
end; end;
function CefFormatUrlForSecurityDisplay(const originUrl: string): string; function CefFormatUrlForSecurityDisplay(const originUrl: string): string;
var var
o: TCefString; TempOrigin : TCefString;
begin begin
o := CefString(originUrl); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := CefStringFreeAndGet(cef_format_url_for_security_display(@o)); begin
TempOrigin := CefString(originUrl);
Result := CefStringFreeAndGet(cef_format_url_for_security_display(@TempOrigin));
end
else
Result := '';
end; end;
function CefGetMimeType(const extension: ustring): ustring; function CefGetMimeType(const extension: ustring): ustring;
var var
s: TCefString; TempExt : TCefString;
begin begin
s := CefString(extension); TempExt := CefString(extension);
Result := CefStringFreeAndGet(cef_get_mime_type(@s)); Result := CefStringFreeAndGet(cef_get_mime_type(@TempExt));
end; end;
procedure CefGetExtensionsForMimeType(const mimeType: ustring; var extensions: TStringList); procedure CefGetExtensionsForMimeType(const mimeType: ustring; var extensions: TStringList);
@ -1169,7 +1246,7 @@ var
TempSL : ICefStringList; TempSL : ICefStringList;
TempMimeType : TCefString; TempMimeType : TCefString;
begin begin
if (extensions <> nil) then if (extensions <> nil) and (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
begin begin
TempSL := TCefStringListOwn.Create; TempSL := TCefStringListOwn.Create;
TempMimeType := CefString(mimeType); TempMimeType := CefString(mimeType);
@ -1180,40 +1257,62 @@ end;
function CefBase64Encode(const data: Pointer; dataSize: NativeUInt): ustring; function CefBase64Encode(const data: Pointer; dataSize: NativeUInt): ustring;
begin begin
Result:= CefStringFreeAndGet(cef_base64encode(data, dataSize)); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := CefStringFreeAndGet(cef_base64encode(data, dataSize))
else
Result := '';
end; end;
function CefBase64Decode(const data: ustring): ICefBinaryValue; function CefBase64Decode(const data: ustring): ICefBinaryValue;
var var
s: TCefString; TempData : TCefString;
begin begin
s := CefString(data); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := TCefBinaryValueRef.UnWrap(cef_base64decode(@s)); begin
TempData := CefString(data);
Result := TCefBinaryValueRef.UnWrap(cef_base64decode(@TempData));
end
else
Result := nil;
end; end;
function CefUriEncode(const text: ustring; usePlus: Boolean): ustring; function CefUriEncode(const text: ustring; usePlus: Boolean): ustring;
var var
s: TCefString; TempText : TCefString;
begin begin
s := CefString(text); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := CefStringFreeAndGet(cef_uriencode(@s, Ord(usePlus))); begin
TempText := CefString(text);
Result := CefStringFreeAndGet(cef_uriencode(@TempText, Ord(usePlus)));
end
else
Result := '';
end; end;
function CefUriDecode(const text: ustring; convertToUtf8: Boolean; function CefUriDecode(const text: ustring; convertToUtf8: Boolean; unescapeRule: TCefUriUnescapeRule): ustring;
unescapeRule: TCefUriUnescapeRule): ustring;
var var
s: TCefString; TempText : TCefString;
begin begin
s := CefString(text); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := CefStringFreeAndGet(cef_uridecode(@s, Ord(convertToUtf8), unescapeRule)); begin
TempText := CefString(text);
Result := CefStringFreeAndGet(cef_uridecode(@TempText, Ord(convertToUtf8), unescapeRule));
end
else
Result := '';
end; end;
function CefParseJson(const jsonString: ustring; options: TCefJsonParserOptions): ICefValue; function CefParseJson(const jsonString: ustring; options: TCefJsonParserOptions): ICefValue;
var var
s: TCefString; TempJSON : TCefString;
begin begin
s := CefString(jsonString); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := TCefValueRef.UnWrap(cef_parse_json(@s, options)); begin
TempJSON := CefString(jsonString);
Result := TCefValueRef.UnWrap(cef_parse_json(@TempJSON, options));
end
else
Result := nil;
end; end;
function CefParseJsonAndReturnError(const jsonString : ustring; function CefParseJsonAndReturnError(const jsonString : ustring;
@ -1221,90 +1320,148 @@ function CefParseJsonAndReturnError(const jsonString : ustring;
out errorCodeOut : TCefJsonParserError; out errorCodeOut : TCefJsonParserError;
out errorMsgOut : ustring): ICefValue; out errorMsgOut : ustring): ICefValue;
var var
s, e: TCefString; TempJSON, TempError : TCefString;
begin begin
s := CefString(jsonString); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
FillChar(e, SizeOf(e), 0); begin
Result := TCefValueRef.UnWrap(cef_parse_jsonand_return_error(@s, options, @errorCodeOut, @e)); FillChar(TempError, SizeOf(TempError), 0);
errorMsgOut := CefString(@e); TempJSON := CefString(jsonString);
Result := TCefValueRef.UnWrap(cef_parse_jsonand_return_error(@TempJSON, options, @errorCodeOut, @TempError));
errorMsgOut := CefString(@TempError);
end
else
begin
errorCodeOut := JSON_NO_ERROR;
Result := nil;
errorMsgOut := '';
end;
end; end;
function CefWriteJson(const node: ICefValue; options: TCefJsonWriterOptions): ustring; function CefWriteJson(const node: ICefValue; options: TCefJsonWriterOptions): ustring;
begin begin
Result := CefStringFreeAndGet(cef_write_json(CefGetData(node), options)); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := CefStringFreeAndGet(cef_write_json(CefGetData(node), options))
else
Result := '';
end; end;
function CefCreateDirectory(const fullPath: ustring): Boolean; function CefCreateDirectory(const fullPath: ustring): Boolean;
var var
path: TCefString; TempPath : TCefString;
begin begin
path := CefString(fullPath); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := cef_create_directory(@path) <> 0; begin
TempPath := CefString(fullPath);
Result := cef_create_directory(@TempPath) <> 0;
end
else
Result := False;
end; end;
function CefGetTempDirectory(out tempDir: ustring): Boolean; function CefGetTempDirectory(out tempDir: ustring): Boolean;
var var
path: TCefString; TempPath : TCefString;
begin begin
FillChar(path, SizeOf(path), 0); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := cef_get_temp_directory(@path) <> 0; begin
tempDir := CefString(@path); FillChar(TempPath, SizeOf(TempPath), 0);
Result := cef_get_temp_directory(@TempPath) <> 0;
tempDir := CefString(@TempPath);
end
else
begin
Result := False;
tempDir := '';
end;
end; end;
function CefCreateNewTempDirectory(const prefix: ustring; out newTempPath: ustring): Boolean; function CefCreateNewTempDirectory(const prefix: ustring; out newTempPath: ustring): Boolean;
var var
path, pref: TCefString; TempPath, TempPref : TCefString;
begin begin
FillChar(path, SizeOf(path), 0); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
pref := CefString(prefix); begin
Result := cef_create_new_temp_directory(@pref, @path) <> 0; FillChar(TempPath, SizeOf(TempPath), 0);
newTempPath := CefString(@path); TempPref := CefString(prefix);
Result := cef_create_new_temp_directory(@TempPref, @TempPath) <> 0;
newTempPath := CefString(@TempPath);
end
else
begin
Result := False;
newTempPath := '';
end;
end; end;
function CefCreateTempDirectoryInDirectory(const baseDir, prefix: ustring; function CefCreateTempDirectoryInDirectory(const baseDir, prefix: ustring; out newDir: ustring): Boolean;
out newDir: ustring): Boolean;
var var
base, path, pref: TCefString; TempBase, TempPath, TempPref: TCefString;
begin begin
FillChar(path, SizeOf(path), 0); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
pref := CefString(prefix); begin
base := CefString(baseDir); FillChar(TempPath, SizeOf(TempPath), 0);
Result := cef_create_temp_directory_in_directory(@base, @pref, @path) <> 0; TempPref := CefString(prefix);
newDir := CefString(@path); TempBase := CefString(baseDir);
Result := cef_create_temp_directory_in_directory(@TempBase, @TempPref, @TempPath) <> 0;
newDir := CefString(@TempPath);
end
else
begin
Result := False;
newDir := '';
end;
end; end;
function CefDirectoryExists(const path: ustring): Boolean; function CefDirectoryExists(const path: ustring): Boolean;
var var
str: TCefString; TempPath : TCefString;
begin begin
str := CefString(path); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := cef_directory_exists(@str) <> 0; begin
TempPath := CefString(path);
Result := cef_directory_exists(@TempPath) <> 0;
end
else
Result := False;
end; end;
function CefDeleteFile(const path: ustring; recursive: Boolean): Boolean; function CefDeleteFile(const path: ustring; recursive: Boolean): Boolean;
var var
str: TCefString; TempPath : TCefString;
begin begin
str := CefString(path); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
Result := cef_delete_file(@str, Ord(recursive)) <> 0; begin
TempPath := CefString(path);
Result := cef_delete_file(@TempPath, Ord(recursive)) <> 0;
end
else
Result := False;
end; end;
function CefZipDirectory(const srcDir, destFile: ustring; includeHiddenFiles: Boolean): Boolean; function CefZipDirectory(const srcDir, destFile: ustring; includeHiddenFiles: Boolean): Boolean;
var var
src, dst: TCefString; TempSrc, TempDst : TCefString;
begin begin
src := CefString(srcDir); if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
dst := CefString(destFile); begin
Result := cef_zip_directory(@src, @dst, Ord(includeHiddenFiles)) <> 0; TempSrc := CefString(srcDir);
TempDst := CefString(destFile);
Result := cef_zip_directory(@TempSrc, @TempDst, Ord(includeHiddenFiles)) <> 0;
end
else
Result := False;
end; end;
procedure CefLoadCRLSetsFile(const path : ustring); procedure CefLoadCRLSetsFile(const path : ustring);
var var
TempPath : TCefString; TempPath : TCefString;
begin
if (GlobalCEFApp <> nil) and GlobalCEFApp.LibLoaded then
begin begin
TempPath := CefString(path); TempPath := CefString(path);
cef_load_crlsets_file(@TempPath); cef_load_crlsets_file(@TempPath);
end; end;
end;
function CefIsKeyDown(aWparam : WPARAM) : boolean; function CefIsKeyDown(aWparam : WPARAM) : boolean;
begin begin