mirror of
https://github.com/salvadordf/CEF4Delphi.git
synced 2024-11-24 08:02:15 +02:00
3059 lines
161 KiB
ObjectPascal
3059 lines
161 KiB
ObjectPascal
// ************************************************************************
|
|
// ***************************** CEF4Delphi *******************************
|
|
// ************************************************************************
|
|
//
|
|
// CEF4Delphi is based on DCEF3 which uses CEF to embed a chromium-based
|
|
// browser in Delphi applications.
|
|
//
|
|
// The original license of DCEF3 still applies to CEF4Delphi.
|
|
//
|
|
// For more information about CEF4Delphi visit :
|
|
// https://www.briskbard.com/index.php?lang=en&pageid=cef
|
|
//
|
|
// Copyright © 2023 Salvador Diaz Fau. All rights reserved.
|
|
//
|
|
// ************************************************************************
|
|
// ************ vvvv Original license and comments below vvvv *************
|
|
// ************************************************************************
|
|
(*
|
|
* Delphi Chromium Embedded 3
|
|
*
|
|
* Usage allowed under the restrictions of the Lesser GNU General Public License
|
|
* or alternatively the restrictions of the Mozilla Public License 1.1
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
|
|
* the specific language governing rights and limitations under the License.
|
|
*
|
|
* Unit owner : Henri Gourvest <hgourvest@gmail.com>
|
|
* Web site : http://www.progdigy.com
|
|
* Repository : http://code.google.com/p/delphichromiumembedded/
|
|
* Group : http://groups.google.com/group/delphichromiumembedded
|
|
*
|
|
* Embarcadero Technologies, Inc is not permitted to use or redistribute
|
|
* this source code without explicit permission.
|
|
*
|
|
*)
|
|
|
|
unit uCEFInterfaces;
|
|
|
|
{$IFDEF FPC}
|
|
{$MODE OBJFPC}{$H+}
|
|
{$ENDIF}
|
|
|
|
{$I cef.inc}
|
|
|
|
{$IFNDEF TARGET_64BITS}{$ALIGN ON}{$ENDIF}
|
|
{$MINENUMSIZE 4}
|
|
|
|
interface
|
|
|
|
uses
|
|
{$IFDEF DELPHI16_UP}
|
|
{$IFDEF MSWINDOWS}WinApi.Windows,{$ENDIF} System.Classes,
|
|
{$ELSE}
|
|
{$IFDEF MSWINDOWS}Windows,{$ENDIF} Classes,
|
|
{$ENDIF}
|
|
uCEFTypes, uCEFSchemeRegistrar;
|
|
|
|
type
|
|
ICefBrowser = interface;
|
|
ICefFrame = interface;
|
|
ICefFrameHandler = interface;
|
|
ICefRequest = interface;
|
|
ICefv8Value = interface;
|
|
ICefV8Exception = interface;
|
|
ICefV8StackTrace = interface;
|
|
ICefDomVisitor = interface;
|
|
ICefDomDocument = interface;
|
|
ICefDomNode = interface;
|
|
ICefv8Context = interface;
|
|
ICefListValue = interface;
|
|
ICefBinaryValue = interface;
|
|
ICefDictionaryValue = interface;
|
|
ICefClient = interface;
|
|
ICefUrlrequestClient = interface;
|
|
ICefBrowserHost = interface;
|
|
ICefTask = interface;
|
|
ICefTaskRunner = interface;
|
|
ICefFileDialogCallback = interface;
|
|
ICefPrintHandler = interface;
|
|
ICefPrintDialogCallback = interface;
|
|
ICefPrintJobCallback = interface;
|
|
ICefRequestContext = interface;
|
|
ICefAccessibilityHandler = interface;
|
|
ICefDragData = interface;
|
|
ICefNavigationEntry = interface;
|
|
ICefSslInfo = interface;
|
|
ICefSSLStatus = interface;
|
|
ICefImage = interface;
|
|
IChromiumEvents = interface;
|
|
ICefThread = interface;
|
|
ICefWaitableEvent = interface;
|
|
ICefX509CertPrincipal = interface;
|
|
ICefX509Certificate = interface;
|
|
ICefSelectClientCertificateCallback = interface;
|
|
ICefCommandLine = interface;
|
|
ICefRequestHandler = interface;
|
|
ICefResourceRequestHandler = interface;
|
|
ICefCookieAccessFilter = interface;
|
|
ICefResourceBundleHandler = interface;
|
|
ICefBrowserProcessHandler = interface;
|
|
ICefRenderProcessHandler = interface;
|
|
ICefProcessMessage = interface;
|
|
ICefLifeSpanHandler = interface;
|
|
ICefCommandHandler = interface;
|
|
ICefGetExtensionResourceCallback = interface;
|
|
ICefExtensionHandler = interface;
|
|
ICefExtension = interface;
|
|
ICefStreamReader = interface;
|
|
ICefLoadHandler = interface;
|
|
ICefServer = interface;
|
|
ICefServerHandler = interface;
|
|
ICefContextMenuParams = interface;
|
|
ICefMenuModel = interface;
|
|
ICefRunContextMenuCallback = interface;
|
|
ICefRunQuickMenuCallback = interface;
|
|
ICefDownloadItem = interface;
|
|
ICefBeforeDownloadCallback = interface;
|
|
ICefJsDialogCallback = interface;
|
|
ICefDownloadItemCallback = interface;
|
|
ICefResourceSkipCallback = interface;
|
|
ICefResourceReadCallback = interface;
|
|
ICefResourceHandler = interface;
|
|
ICefResponse = interface;
|
|
ICefResponseFilter = interface;
|
|
ICefAuthCallback = interface;
|
|
ICefCallback = interface;
|
|
ICefDragHandler = interface;
|
|
ICefFindHandler = interface;
|
|
ICefCookieManager = interface;
|
|
ICefDisplay = interface;
|
|
ICefLayout = interface;
|
|
ICefBoxLayout = interface;
|
|
ICefFillLayout = interface;
|
|
ICefView = interface;
|
|
ICefBrowserView = interface;
|
|
ICefButton = interface;
|
|
ICefPanel = interface;
|
|
ICefScrollView = interface;
|
|
ICefTextfield = interface;
|
|
ICefViewDelegate = interface;
|
|
ICefWindow = interface;
|
|
ICefLabelButton = interface;
|
|
ICefMenuButton = interface;
|
|
ICefUrlRequest = interface;
|
|
ICefPostDataElement = interface;
|
|
ICefRegistration = interface;
|
|
ICefMediaRouter = interface;
|
|
ICefMediaObserver = interface;
|
|
ICefMediaRoute = interface;
|
|
ICefMediaRouteCreateCallback = interface;
|
|
ICefMediaSink = interface;
|
|
ICefMediaSinkDeviceInfoCallback = interface;
|
|
ICefMediaSource = interface;
|
|
ICefAudioHandler = interface;
|
|
ICefDevToolsMessageObserver = interface;
|
|
ICefValue = interface;
|
|
ICefPrintSettings = interface;
|
|
ICefMediaAccessCallback = interface;
|
|
ICefMediaAccessHandler = interface;
|
|
ICefPermissionPromptCallback = interface;
|
|
ICefPermissionHandler = interface;
|
|
ICefSharedMemoryRegion = interface;
|
|
ICefSharedProcessMessageBuilder = interface;
|
|
|
|
TCefv8ValueArray = array of ICefv8Value;
|
|
TCefX509CertificateArray = array of ICefX509Certificate;
|
|
TCefBinaryValueArray = array of ICefBinaryValue;
|
|
TCefFrameIdentifierArray = array of int64;
|
|
TCefPostDataElementArray = array of ICefPostDataElement;
|
|
TCefMediaRouteArray = array of ICefMediaRoute;
|
|
TCefMediaSinkArray = array of ICefMediaSink;
|
|
TCefDisplayArray = array of ICefDisplay;
|
|
|
|
TCefMediaSinkInfo = record
|
|
ID : ustring;
|
|
Name : ustring;
|
|
Description : ustring;
|
|
IconType : TCefMediaSinkIconType;
|
|
SinkType : TCefMediaType;
|
|
SinkIntf : ICefMediaSink;
|
|
end;
|
|
TCefMediaSinkInfoArray = array of TCefMediaSinkInfo;
|
|
|
|
TCefMediaRouteInfo = record
|
|
ID : ustring;
|
|
SourceID : ustring;
|
|
SinkID : ustring;
|
|
RouteIntf : ICefMediaRoute;
|
|
end;
|
|
TCefMediaRouteInfoArray = array of TCefMediaRouteInfo;
|
|
|
|
TCefMediaSourceInfo = record
|
|
ID : ustring;
|
|
Valid : boolean;
|
|
SourceType : TCefMediaType;
|
|
SourceIntf : ICefMediaSource;
|
|
end;
|
|
TCefMediaSourceInfoArray = array of TCefMediaSourceInfo;
|
|
|
|
|
|
// *******************************************
|
|
// **** Callback procedures and functions ****
|
|
// *******************************************
|
|
|
|
TCefEndTracingCallbackProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(const tracingFile: ustring);
|
|
TCefFastTaskProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure();
|
|
TCefv8ArrayBufferReleaseCallbackProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(buffer : Pointer);
|
|
TCefWebPluginIsUnstableProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(const path: ustring; unstable: Boolean);
|
|
TCefV8AccessorGetterProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} function(const name: ustring; const object_: ICefv8Value; var value: ICefv8Value; var exception: ustring): Boolean;
|
|
TCefV8AccessorSetterProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} function(const name: ustring; const object_, value: ICefv8Value; var exception: ustring): Boolean;
|
|
TCefV8InterceptorGetterByNameProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} function(const name: ustring; const object_: ICefv8Value; var value: ICefv8Value; var exception: ustring): Boolean;
|
|
TCefV8InterceptorSetterByNameProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} function(const name: ustring; const object_, value: ICefv8Value; var exception: ustring): Boolean;
|
|
TCefV8InterceptorGetterByIndexProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} function(index: integer; const object_: ICefv8Value; var value: ICefv8Value; var exception: ustring): Boolean;
|
|
TCefV8InterceptorSetterByIndexProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} function(index: integer; const object_, value: ICefv8Value; var exception: ustring): Boolean;
|
|
TOnPdfPrintFinishedProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(const path: ustring; ok: Boolean);
|
|
TCefDomVisitorProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(const document: ICefDomDocument);
|
|
TCefDomVisitorProc2 = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(const browser : ICefBrowser; const frame: ICefFrame; const document: ICefDomDocument);
|
|
TCefDomVisitorProc3 = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(const browser : ICefBrowser; const frame: ICefFrame; const document: ICefDomDocument; const aValue : ustring);
|
|
TCefStringVisitorProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(const str: ustring);
|
|
TCefRunFileDialogCallbackProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(const filePaths: TStrings);
|
|
TCefCompletionCallbackProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure();
|
|
TCefSetCookieCallbackProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(success: Boolean);
|
|
TCefDeleteCookiesCallbackProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(numDeleted: Integer);
|
|
TCefNavigationEntryVisitorProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} function(const entry: ICefNavigationEntry; current: Boolean; index, total: Integer): Boolean;
|
|
TOnDownloadImageFinishedProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(const imageUrl: ustring; httpStatusCode: Integer; const image: ICefImage);
|
|
TCefCookieVisitorProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} function(const name, value, domain, path: ustring; secure, httponly, hasExpires: Boolean; const creation, lastAccess, expires: TDateTime; count, total: Integer; same_site : TCefCookieSameSite; priority : TCefCookiePriority; out deleteCookie: Boolean): Boolean;
|
|
TCefMediaRouteCreateCallbackProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(result: TCefMediaRouterCreateResult; const error: ustring; const route: ICefMediaRoute);
|
|
TCefMediaSinkDeviceInfoCallbackProc = {$IFDEF DELPHI12_UP}reference to{$ENDIF} procedure(const ip_address: ustring; port: integer; const model_name: ustring);
|
|
|
|
|
|
|
|
// *******************************************
|
|
// ************ Custom interfaces ************
|
|
// *******************************************
|
|
|
|
ICefStringList = interface
|
|
['{DB24F301-2F64-48D6-A72E-33697748147E}']
|
|
function GetHandle: TCefStringList;
|
|
function GetSize: NativeUInt;
|
|
function GetValue(Index: NativeUInt): ustring;
|
|
procedure Append(const Value: ustring);
|
|
procedure Clear;
|
|
function Copy : TCefStringList;
|
|
procedure CopyToStrings(const aStrings : TStrings);
|
|
procedure AddStrings(const aStrings : TStrings);
|
|
|
|
property Handle : TCefStringList read GetHandle;
|
|
property Size : NativeUInt read GetSize;
|
|
property Value[index: NativeUInt] : ustring read GetValue;
|
|
end;
|
|
|
|
ICefStringMap = interface
|
|
['{A33EBC01-B23A-4918-86A4-E24A243B342F}']
|
|
function GetHandle: TCefStringMap;
|
|
function GetSize: NativeUInt;
|
|
function Find(const Key: ustring): ustring;
|
|
function GetKey(Index: NativeUInt): ustring;
|
|
function GetValue(Index: NativeUInt): ustring;
|
|
function Append(const Key, Value: ustring) : boolean;
|
|
procedure Clear;
|
|
|
|
property Handle : TCefStringMap read GetHandle;
|
|
property Size : NativeUInt read GetSize;
|
|
property Key[index: NativeUInt] : ustring read GetKey;
|
|
property Value[index: NativeUInt] : ustring read GetValue;
|
|
end;
|
|
|
|
ICefStringMultimap = interface
|
|
['{583ED0C2-A9D6-4034-A7C9-20EC7E47F0C7}']
|
|
function GetHandle: TCefStringMultimap;
|
|
function GetSize: NativeUInt;
|
|
function FindCount(const Key: ustring): NativeUInt;
|
|
function GetEnumerate(const Key: ustring; ValueIndex: NativeUInt): ustring;
|
|
function GetKey(Index: NativeUInt): ustring;
|
|
function GetValue(Index: NativeUInt): ustring;
|
|
function Append(const Key, Value: ustring) : boolean;
|
|
procedure Clear;
|
|
|
|
property Handle : TCefStringMultimap read GetHandle;
|
|
property Size : NativeUInt read GetSize;
|
|
property Key[index: NativeUInt] : ustring read GetKey;
|
|
property Value[index: NativeUInt] : ustring read GetValue;
|
|
property Enumerate[const aKey: ustring; aValueIndex: NativeUInt] : ustring read GetEnumerate;
|
|
end;
|
|
|
|
IChromiumEvents = interface
|
|
['{0C139DB1-0349-4D7F-8155-76FEA6A0126D}']
|
|
procedure GetSettings(var settings: TCefBrowserSettings);
|
|
|
|
// ICefClient
|
|
function doOnProcessMessageReceived(const browser: ICefBrowser; const frame: ICefFrame; sourceProcess: TCefProcessId; const message: ICefProcessMessage): Boolean;
|
|
|
|
// ICefLoadHandler
|
|
procedure doOnLoadingStateChange(const browser: ICefBrowser; isLoading, canGoBack, canGoForward: Boolean);
|
|
procedure doOnLoadStart(const browser: ICefBrowser; const frame: ICefFrame; transitionType: TCefTransitionType);
|
|
procedure doOnLoadEnd(const browser: ICefBrowser; const frame: ICefFrame; httpStatusCode: Integer);
|
|
procedure doOnLoadError(const browser: ICefBrowser; const frame: ICefFrame; errorCode: TCefErrorCode; const errorText, failedUrl: ustring);
|
|
|
|
// ICefFocusHandler
|
|
procedure doOnTakeFocus(const browser: ICefBrowser; next: Boolean);
|
|
function doOnSetFocus(const browser: ICefBrowser; source: TCefFocusSource): Boolean;
|
|
procedure doOnGotFocus(const browser: ICefBrowser);
|
|
|
|
// ICefContextMenuHandler
|
|
procedure doOnBeforeContextMenu(const browser: ICefBrowser; const frame: ICefFrame; const params: ICefContextMenuParams; const model: ICefMenuModel);
|
|
function doRunContextMenu(const browser: ICefBrowser; const frame: ICefFrame; const params: ICefContextMenuParams; const model: ICefMenuModel; const callback: ICefRunContextMenuCallback): Boolean;
|
|
function doOnContextMenuCommand(const browser: ICefBrowser; const frame: ICefFrame; const params: ICefContextMenuParams; commandId: Integer; eventFlags: TCefEventFlags): Boolean;
|
|
procedure doOnContextMenuDismissed(const browser: ICefBrowser; const frame: ICefFrame);
|
|
function doRunQuickMenu(const browser: ICefBrowser; const frame: ICefFrame; location: PCefPoint; size: PCefSize; edit_state_flags: TCefQuickMenuEditStateFlags; const callback: ICefRunQuickMenuCallback): boolean;
|
|
function doOnQuickMenuCommand(const browser: ICefBrowser; const frame: ICefFrame; command_id: integer; event_flags: TCefEventFlags): boolean;
|
|
procedure doOnQuickMenuDismissed(const browser: ICefBrowser; const frame: ICefFrame);
|
|
|
|
// ICefKeyboardHandler
|
|
function doOnPreKeyEvent(const browser: ICefBrowser; const event: PCefKeyEvent; osEvent: TCefEventHandle; out isKeyboardShortcut: Boolean): Boolean;
|
|
function doOnKeyEvent(const browser: ICefBrowser; const event: PCefKeyEvent; osEvent: TCefEventHandle): Boolean;
|
|
|
|
// ICefDisplayHandler
|
|
procedure doOnAddressChange(const browser: ICefBrowser; const frame: ICefFrame; const url: ustring);
|
|
procedure doOnTitleChange(const browser: ICefBrowser; const title: ustring);
|
|
procedure doOnFaviconUrlChange(const browser: ICefBrowser; const iconUrls: TStrings);
|
|
procedure doOnFullScreenModeChange(const browser: ICefBrowser; fullscreen: Boolean);
|
|
function doOnTooltip(const browser: ICefBrowser; var text: ustring): Boolean;
|
|
procedure doOnStatusMessage(const browser: ICefBrowser; const value: ustring);
|
|
function doOnConsoleMessage(const browser: ICefBrowser; level: TCefLogSeverity; const message, source: ustring; line: Integer): Boolean;
|
|
function doOnAutoResize(const browser: ICefBrowser; const new_size: PCefSize): Boolean;
|
|
procedure doOnLoadingProgressChange(const browser: ICefBrowser; const progress: double);
|
|
procedure doOnCursorChange(const browser: ICefBrowser; cursor_: TCefCursorHandle; cursorType: TCefCursorType; const customCursorInfo: PCefCursorInfo; var aResult : boolean);
|
|
procedure doOnMediaAccessChange(const browser: ICefBrowser; has_video_access, has_audio_access: boolean);
|
|
|
|
// ICefDownloadHandler
|
|
function doOnCanDownload(const browser: ICefBrowser; const url, request_method: ustring): boolean;
|
|
procedure doOnBeforeDownload(const browser: ICefBrowser; const downloadItem: ICefDownloadItem; const suggestedName: ustring; const callback: ICefBeforeDownloadCallback);
|
|
procedure doOnDownloadUpdated(const browser: ICefBrowser; const downloadItem: ICefDownloadItem; const callback: ICefDownloadItemCallback);
|
|
|
|
// ICefJsDialogHandler
|
|
function doOnJsdialog(const browser: ICefBrowser; const originUrl: ustring; dialogType: TCefJsDialogType; const messageText, defaultPromptText: ustring; const callback: ICefJsDialogCallback; out suppressMessage: Boolean): Boolean;
|
|
function doOnBeforeUnloadDialog(const browser: ICefBrowser; const messageText: ustring; isReload: Boolean; const callback: ICefJsDialogCallback): Boolean;
|
|
procedure doOnResetDialogState(const browser: ICefBrowser);
|
|
procedure doOnDialogClosed(const browser: ICefBrowser);
|
|
|
|
// ICefLifeSpanHandler
|
|
function doOnBeforePopup(const browser: ICefBrowser; const frame: ICefFrame; const targetUrl, targetFrameName: ustring; targetDisposition: TCefWindowOpenDisposition; userGesture: Boolean; const popupFeatures: TCefPopupFeatures; var windowInfo: TCefWindowInfo; var client: ICefClient; var settings: TCefBrowserSettings; var extra_info: ICefDictionaryValue; var noJavascriptAccess: Boolean): Boolean;
|
|
procedure doOnAfterCreated(const browser: ICefBrowser);
|
|
procedure doOnBeforeClose(const browser: ICefBrowser);
|
|
function doOnClose(const browser: ICefBrowser): Boolean;
|
|
|
|
// ICefRequestHandler
|
|
function doOnBeforeBrowse(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; user_gesture, isRedirect: Boolean): Boolean;
|
|
function doOnOpenUrlFromTab(const browser: ICefBrowser; const frame: ICefFrame; const targetUrl: ustring; targetDisposition: TCefWindowOpenDisposition; userGesture: Boolean): Boolean;
|
|
procedure doGetResourceRequestHandler_ReqHdlr(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; is_navigation, is_download: boolean; const request_initiator: ustring; var disable_default_handling: boolean; var aResourceRequestHandler : ICefResourceRequestHandler);
|
|
function doOnGetAuthCredentials(const browser: ICefBrowser; const originUrl: ustring; isProxy: Boolean; const host: ustring; port: Integer; const realm, scheme: ustring; const callback: ICefAuthCallback): Boolean;
|
|
function doOnCertificateError(const browser: ICefBrowser; certError: TCefErrorcode; const requestUrl: ustring; const sslInfo: ICefSslInfo; const callback: ICefCallback): Boolean;
|
|
function doOnSelectClientCertificate(const browser: ICefBrowser; isProxy: boolean; const host: ustring; port: integer; certificatesCount: NativeUInt; const certificates: TCefX509CertificateArray; const callback: ICefSelectClientCertificateCallback): boolean;
|
|
procedure doOnRenderViewReady(const browser: ICefBrowser);
|
|
procedure doOnRenderProcessTerminated(const browser: ICefBrowser; status: TCefTerminationStatus);
|
|
procedure doOnDocumentAvailableInMainFrame(const browser: ICefBrowser);
|
|
|
|
// ICefResourceRequestHandler
|
|
function doOnBeforeResourceLoad(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const callback: ICefCallback): TCefReturnValue;
|
|
procedure doOnGetResourceHandler(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; var aResourceHandler: ICefResourceHandler);
|
|
procedure doOnResourceRedirect(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; var newUrl: ustring);
|
|
function doOnResourceResponse(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse): Boolean;
|
|
procedure doOnGetResourceResponseFilter(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; var aResponseFilter: ICefResponseFilter);
|
|
procedure doOnResourceLoadComplete(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; status: TCefUrlRequestStatus; receivedContentLength: Int64);
|
|
procedure doOnProtocolExecution(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; var allowOsExecution: Boolean);
|
|
|
|
// ICefCookieAccessFilter
|
|
function doCanSendCookie(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const cookie: PCefCookie): boolean;
|
|
function doCanSaveCookie(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; const cookie: PCefCookie): boolean;
|
|
|
|
// ICefDialogHandler
|
|
function doOnFileDialog(const browser: ICefBrowser; mode: TCefFileDialogMode; const title, defaultFilePath: ustring; const acceptFilters: TStrings; const callback: ICefFileDialogCallback): Boolean;
|
|
|
|
// ICefRenderHandler
|
|
procedure doOnGetAccessibilityHandler(var aAccessibilityHandler : ICefAccessibilityHandler);
|
|
function doOnGetRootScreenRect(const browser: ICefBrowser; var rect: TCefRect): Boolean;
|
|
procedure doOnGetViewRect(const browser: ICefBrowser; var rect: TCefRect);
|
|
function doOnGetScreenPoint(const browser: ICefBrowser; viewX, viewY: Integer; var screenX, screenY: Integer): Boolean;
|
|
function doOnGetScreenInfo(const browser: ICefBrowser; var screenInfo: TCefScreenInfo): Boolean;
|
|
procedure doOnPopupShow(const browser: ICefBrowser; show: Boolean);
|
|
procedure doOnPopupSize(const browser: ICefBrowser; const rect: PCefRect);
|
|
procedure doOnPaint(const browser: ICefBrowser; type_: TCefPaintElementType; dirtyRectsCount: NativeUInt; const dirtyRects: PCefRectArray; const buffer: Pointer; width, height: Integer);
|
|
procedure doOnAcceleratedPaint(const browser: ICefBrowser; type_: TCefPaintElementType; dirtyRectsCount: NativeUInt; const dirtyRects: PCefRectArray; shared_handle: Pointer);
|
|
procedure doGetTouchHandleSize(const browser: ICefBrowser; orientation: TCefHorizontalAlignment; var size: TCefSize);
|
|
procedure doOnTouchHandleStateChanged(const browser: ICefBrowser; const state: TCefTouchHandleState);
|
|
function doOnStartDragging(const browser: ICefBrowser; const dragData: ICefDragData; allowedOps: TCefDragOperations; x, y: Integer): Boolean;
|
|
procedure doOnUpdateDragCursor(const browser: ICefBrowser; operation: TCefDragOperation);
|
|
procedure doOnScrollOffsetChanged(const browser: ICefBrowser; x, y: Double);
|
|
procedure doOnIMECompositionRangeChanged(const browser: ICefBrowser; const selected_range: PCefRange; character_boundsCount: NativeUInt; const character_bounds: PCefRect);
|
|
procedure doOnTextSelectionChanged(const browser: ICefBrowser; const selected_text: ustring; const selected_range: PCefRange);
|
|
procedure doOnVirtualKeyboardRequested(const browser: ICefBrowser; input_mode: TCefTextInpuMode);
|
|
|
|
// ICefDragHandler
|
|
function doOnDragEnter(const browser: ICefBrowser; const dragData: ICefDragData; mask: TCefDragOperations): Boolean;
|
|
procedure doOnDraggableRegionsChanged(const browser: ICefBrowser; const frame: ICefFrame; regionsCount: NativeUInt; const regions: PCefDraggableRegionArray);
|
|
|
|
// ICefFindHandler
|
|
procedure doOnFindResult(const browser: ICefBrowser; identifier, count: Integer; const selectionRect: PCefRect; activeMatchOrdinal: Integer; finalUpdate: Boolean);
|
|
|
|
// ICefRequestContextHandler
|
|
procedure doOnRequestContextInitialized(const request_context: ICefRequestContext);
|
|
procedure doGetResourceRequestHandler_ReqCtxHdlr(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; is_navigation, is_download: boolean; const request_initiator: ustring; var disable_default_handling: boolean; var aResourceRequestHandler : ICefResourceRequestHandler);
|
|
|
|
// ICefMediaObserver
|
|
procedure doOnSinks(const sinks: TCefMediaSinkArray);
|
|
procedure doOnRoutes(const routes: TCefMediaRouteArray);
|
|
procedure doOnRouteStateChanged(const route: ICefMediaRoute; state: TCefMediaRouteConnectionState);
|
|
procedure doOnRouteMessageReceived(const route: ICefMediaRoute; const message_: ustring);
|
|
|
|
// ICefAudioHandler
|
|
procedure doOnGetAudioParameters(const browser: ICefBrowser; var params: TCefAudioParameters; var aResult: boolean);
|
|
procedure doOnAudioStreamStarted(const browser: ICefBrowser; const params: TCefAudioParameters; channels: integer);
|
|
procedure doOnAudioStreamPacket(const browser: ICefBrowser; const data : PPSingle; frames: integer; pts: int64);
|
|
procedure doOnAudioStreamStopped(const browser: ICefBrowser);
|
|
procedure doOnAudioStreamError(const browser: ICefBrowser; const message_: ustring);
|
|
|
|
// ICefDevToolsMessageObserver
|
|
procedure doOnDevToolsMessage(const browser: ICefBrowser; const message_: Pointer; message_size: NativeUInt; var aHandled: boolean);
|
|
procedure doOnDevToolsMethodResult(const browser: ICefBrowser; message_id: integer; success: boolean; const result: Pointer; result_size: NativeUInt);
|
|
procedure doOnDevToolsEvent(const browser: ICefBrowser; const method: ustring; const params: Pointer; params_size: NativeUInt);
|
|
procedure doOnDevToolsAgentAttached(const browser: ICefBrowser);
|
|
procedure doOnDevToolsAgentDetached(const browser: ICefBrowser);
|
|
|
|
// ICefExtensionHandler
|
|
procedure doOnExtensionLoadFailed(result: TCefErrorcode);
|
|
procedure doOnExtensionLoaded(const extension: ICefExtension);
|
|
procedure doOnExtensionUnloaded(const extension: ICefExtension);
|
|
function doOnExtensionBeforeBackgroundBrowser(const extension: ICefExtension; const url: ustring; var client: ICefClient; var settings: TCefBrowserSettings) : boolean;
|
|
function doOnExtensionBeforeBrowser(const extension: ICefExtension; const browser, active_browser: ICefBrowser; index: Integer; const url: ustring; active: boolean; var windowInfo: TCefWindowInfo; var client: ICefClient; var settings: TCefBrowserSettings) : boolean;
|
|
procedure doOnExtensionGetActiveBrowser(const extension: ICefExtension; const browser: ICefBrowser; include_incognito: boolean; var aRsltBrowser: ICefBrowser);
|
|
function doOnExtensionCanAccessBrowser(const extension: ICefExtension; const browser: ICefBrowser; include_incognito: boolean; const target_browser: ICefBrowser): boolean;
|
|
function doOnExtensionGetExtensionResource(const extension: ICefExtension; const browser: ICefBrowser; const file_: ustring; const callback: ICefGetExtensionResourceCallback): boolean;
|
|
|
|
// ICefPrintHandler
|
|
procedure doOnPrintStart(const browser: ICefBrowser);
|
|
procedure doOnPrintSettings(const browser: ICefBrowser; const settings: ICefPrintSettings; getDefaults: boolean);
|
|
procedure doOnPrintDialog(const browser: ICefBrowser; hasSelection: boolean; const callback: ICefPrintDialogCallback; var aResult : boolean);
|
|
procedure doOnPrintJob(const browser: ICefBrowser; const documentName, PDFFilePath: ustring; const callback: ICefPrintJobCallback; var aResult : boolean);
|
|
procedure doOnPrintReset(const browser: ICefBrowser);
|
|
procedure doOnGetPDFPaperSize(const browser: ICefBrowser; deviceUnitsPerInch: Integer; var aResult : TCefSize);
|
|
|
|
// ICefFrameHandler
|
|
procedure doOnFrameCreated(const browser: ICefBrowser; const frame: ICefFrame);
|
|
procedure doOnFrameAttached(const browser: ICefBrowser; const frame: ICefFrame; reattached: boolean);
|
|
procedure doOnFrameDetached(const browser: ICefBrowser; const frame: ICefFrame);
|
|
procedure doOnMainFrameChanged(const browser: ICefBrowser; const old_frame, new_frame: ICefFrame);
|
|
|
|
// ICefCommandHandler
|
|
function doOnChromeCommand(const browser: ICefBrowser; command_id: integer; disposition: TCefWindowOpenDisposition): boolean;
|
|
|
|
// ICefPermissionHandler
|
|
function doOnRequestMediaAccessPermission(const browser: ICefBrowser; const frame: ICefFrame; const requesting_origin: ustring; requested_permissions: cardinal; const callback: ICefMediaAccessCallback): boolean;
|
|
function doOnShowPermissionPrompt(const browser: ICefBrowser; prompt_id: uint64; const requesting_origin: ustring; requested_permissions: cardinal; const callback: ICefPermissionPromptCallback): boolean;
|
|
procedure doOnDismissPermissionPrompt(const browser: ICefBrowser; prompt_id: uint64; result: TCefPermissionRequestResult);
|
|
|
|
// Custom
|
|
procedure doCookiesDeleted(numDeleted : integer);
|
|
procedure doPdfPrintFinished(aResultOK : boolean);
|
|
procedure doTextResultAvailable(const aText : ustring);
|
|
procedure doUpdatePreferences(const aBrowser: ICefBrowser);
|
|
procedure doUpdateOwnPreferences;
|
|
function doSavePreferences : boolean;
|
|
procedure doResolvedHostAvailable(result: TCefErrorCode; const resolvedIps: TStrings);
|
|
function doNavigationVisitorResultAvailable(const entry: ICefNavigationEntry; current: Boolean; index, total: Integer) : boolean;
|
|
procedure doDownloadImageFinished(const imageUrl: ustring; httpStatusCode: Integer; const image: ICefImage);
|
|
procedure doOnCookiesStoreFlushed;
|
|
procedure doCertificateExceptionsCleared;
|
|
procedure doHttpAuthCredentialsCleared;
|
|
procedure doAllConnectionsClosed;
|
|
procedure doOnExecuteTaskOnCefThread(aTaskID : cardinal);
|
|
procedure doOnCookiesVisited(const name_, value, domain, path: ustring; secure, httponly, hasExpires: Boolean; const creation, lastAccess, expires: TDateTime; count, total, aID : Integer; same_site : TCefCookieSameSite; priority : TCefCookiePriority; var aDeleteCookie, aResult : Boolean);
|
|
procedure doOnCookieVisitorDestroyed(aID : integer);
|
|
procedure doOnCookieSet(aSuccess : boolean; aID : integer);
|
|
procedure doUpdateZoomStep(aInc : boolean);
|
|
procedure doUpdateZoomPct(aInc : boolean);
|
|
procedure doSetZoomLevel(const aValue : double);
|
|
procedure doSetZoomPct(const aValue : double);
|
|
procedure doSetZoomStep(aValue : byte);
|
|
procedure doReadZoom;
|
|
procedure doMediaRouteCreateFinished(result: TCefMediaRouterCreateResult; const error: ustring; const route: ICefMediaRoute);
|
|
procedure doOnMediaSinkDeviceInfo(const ip_address: ustring; port: integer; const model_name: ustring);
|
|
procedure doBrowserNavigation(aTask : TCefBrowserNavigation);
|
|
procedure doSetAudioMuted(aValue : boolean);
|
|
procedure doToggleAudioMuted;
|
|
function MustCreateAudioHandler : boolean;
|
|
function MustCreateCommandHandler : boolean;
|
|
function MustCreateLoadHandler : boolean;
|
|
function MustCreateFocusHandler : boolean;
|
|
function MustCreateContextMenuHandler : boolean;
|
|
function MustCreateDialogHandler : boolean;
|
|
function MustCreateKeyboardHandler : boolean;
|
|
function MustCreateDisplayHandler : boolean;
|
|
function MustCreateDownloadHandler : boolean;
|
|
function MustCreateJsDialogHandler : boolean;
|
|
function MustCreateLifeSpanHandler : boolean;
|
|
function MustCreateRenderHandler : boolean;
|
|
function MustCreateRequestHandler : boolean;
|
|
function MustCreateDragHandler : boolean;
|
|
function MustCreateFindHandler : boolean;
|
|
function MustCreateResourceRequestHandler : boolean;
|
|
function MustCreateCookieAccessFilter : boolean;
|
|
function MustCreateMediaObserver : boolean;
|
|
function MustCreatePrintHandler : boolean;
|
|
function MustCreateFrameHandler : boolean;
|
|
function MustCreatePermissionHandler : boolean;
|
|
end;
|
|
|
|
IServerEvents = interface
|
|
['{06A1B3C6-0967-4F6C-A751-8AA3A29E2FF5}']
|
|
procedure doOnServerCreated(const server: ICefServer);
|
|
procedure doOnServerDestroyed(const server: ICefServer);
|
|
procedure doOnClientConnected(const server: ICefServer; connection_id: Integer);
|
|
procedure doOnClientDisconnected(const server: ICefServer; connection_id: Integer);
|
|
procedure doOnHttpRequest(const server: ICefServer; connection_id: Integer; const client_address: ustring; const request: ICefRequest);
|
|
procedure doOnWebSocketRequest(const server: ICefServer; connection_id: Integer; const client_address: ustring; const request: ICefRequest; const callback: ICefCallback);
|
|
procedure doOnWebSocketConnected(const server: ICefServer; connection_id: Integer);
|
|
procedure doOnWebSocketMessage(const server: ICefServer; connection_id: Integer; const data: Pointer; data_size: NativeUInt);
|
|
end;
|
|
|
|
ICEFUrlRequestClientEvents = interface
|
|
['{1AA800A7-56A1-43CA-A224-49368F18BDD8}']
|
|
// ICefUrlrequestClient
|
|
procedure doOnRequestComplete(const request: ICefUrlRequest);
|
|
procedure doOnUploadProgress(const request: ICefUrlRequest; current, total: Int64);
|
|
procedure doOnDownloadProgress(const request: ICefUrlRequest; current, total: Int64);
|
|
procedure doOnDownloadData(const request: ICefUrlRequest; data: Pointer; dataLength: NativeUInt);
|
|
function doOnGetAuthCredentials(isProxy: Boolean; const host: ustring; port: Integer; const realm, scheme: ustring; const callback: ICefAuthCallback): Boolean;
|
|
|
|
// Custom
|
|
procedure doOnCreateURLRequest;
|
|
end;
|
|
|
|
|
|
|
|
// *******************************************
|
|
// ************** CEF interfaces *************
|
|
// *******************************************
|
|
|
|
// TCefBaseRefCounted
|
|
// /include/capi/cef_base_capi.h (cef_base_ref_counted_t)
|
|
ICefBaseRefCounted = interface
|
|
['{1F9A7B44-DCDC-4477-9180-3ADD44BDEB7B}']
|
|
function Wrap: Pointer;
|
|
function SameAs(aData : Pointer) : boolean; overload;
|
|
function SameAs(const aBaseRefCounted : ICefBaseRefCounted) : boolean; overload;
|
|
function HasOneRef : boolean;
|
|
function HasAtLeastOneRef : boolean;
|
|
procedure DestroyOtherRefs;
|
|
end;
|
|
|
|
// TCefRunFileDialogCallback
|
|
// /include/capi/cef_browser_capi.h (cef_run_file_dialog_callback_t)
|
|
ICefRunFileDialogCallback = interface(ICefBaseRefCounted)
|
|
['{59FCECC6-E897-45BA-873B-F09586C4BE47}']
|
|
procedure OnFileDialogDismissed(const filePaths: TStrings);
|
|
end;
|
|
|
|
// TCefNavigationEntryVisitor
|
|
// /include/capi/cef_browser_capi.h (cef_navigation_entry_visitor_t)
|
|
ICefNavigationEntryVisitor = interface(ICefBaseRefCounted)
|
|
['{CC4D6BC9-0168-4C2C-98BA-45E9AA9CD619}']
|
|
function Visit(const entry: ICefNavigationEntry; current: Boolean; index, total: Integer): Boolean;
|
|
end;
|
|
|
|
// TCefPdfPrintCallback
|
|
// /include/capi/cef_browser_capi.h (cef_pdf_print_callback_t)
|
|
ICefPdfPrintCallback = interface(ICefBaseRefCounted)
|
|
['{F1CC58E9-2C30-4932-91AE-467C8D8EFB8E}']
|
|
procedure OnPdfPrintFinished(const path: ustring; ok: Boolean);
|
|
end;
|
|
|
|
// TCefDownloadImageCallback
|
|
// /include/capi/cef_browser_capi.h (cef_download_image_callback_t)
|
|
ICefDownloadImageCallback = interface(ICefBaseRefCounted)
|
|
['{0C6E9032-27DF-4584-95C6-DC3C7CB63727}']
|
|
procedure OnDownloadImageFinished(const imageUrl: ustring; httpStatusCode: Integer; const image: ICefImage);
|
|
end;
|
|
|
|
// TCefBrowserHost
|
|
// /include/capi/cef_browser_capi.h (cef_browser_host_t)
|
|
ICefBrowserHost = interface(ICefBaseRefCounted)
|
|
['{53AE02FF-EF5D-48C3-A43E-069DA9535424}']
|
|
function GetBrowser: ICefBrowser;
|
|
procedure CloseBrowser(forceClose: Boolean);
|
|
function TryCloseBrowser: Boolean;
|
|
procedure SetFocus(focus: Boolean);
|
|
function GetWindowHandle: TCefWindowHandle;
|
|
function GetOpenerWindowHandle: TCefWindowHandle;
|
|
function HasView: Boolean;
|
|
function GetRequestContext: ICefRequestContext;
|
|
function GetZoomLevel: Double;
|
|
procedure SetZoomLevel(const zoomLevel: Double);
|
|
procedure RunFileDialog(mode: TCefFileDialogMode; const title, defaultFilePath: ustring; const acceptFilters: TStrings; const callback: ICefRunFileDialogCallback);
|
|
procedure RunFileDialogProc(mode: TCefFileDialogMode; const title, defaultFilePath: ustring; const acceptFilters: TStrings; const callback: TCefRunFileDialogCallbackProc);
|
|
procedure StartDownload(const url: ustring);
|
|
procedure DownloadImage(const imageUrl: ustring; isFavicon: Boolean; maxImageSize: cardinal; bypassCache: Boolean; const callback: ICefDownloadImageCallback);
|
|
procedure Print;
|
|
procedure PrintToPdf(const path: ustring; settings: PCefPdfPrintSettings; const callback: ICefPdfPrintCallback);
|
|
procedure PrintToPdfProc(const path: ustring; settings: PCefPdfPrintSettings; const callback: TOnPdfPrintFinishedProc);
|
|
procedure Find(const searchText: ustring; forward_, matchCase, findNext: Boolean);
|
|
procedure StopFinding(clearSelection: Boolean);
|
|
procedure ShowDevTools(const windowInfo: PCefWindowInfo; const client: ICefClient; const settings: PCefBrowserSettings; inspectElementAt: PCefPoint);
|
|
procedure CloseDevTools;
|
|
function HasDevTools: Boolean;
|
|
function SendDevToolsMessage(const message_: ustring): boolean;
|
|
function ExecuteDevToolsMethod(message_id: integer; const method: ustring; const params: ICefDictionaryValue): Integer;
|
|
function AddDevToolsMessageObserver(const observer: ICefDevToolsMessageObserver): ICefRegistration;
|
|
procedure GetNavigationEntries(const visitor: ICefNavigationEntryVisitor; currentOnly: Boolean);
|
|
procedure GetNavigationEntriesProc(const proc: TCefNavigationEntryVisitorProc; currentOnly: Boolean);
|
|
procedure ReplaceMisspelling(const word: ustring);
|
|
procedure AddWordToDictionary(const word: ustring);
|
|
function IsWindowRenderingDisabled: Boolean;
|
|
procedure WasResized;
|
|
procedure WasHidden(hidden: Boolean);
|
|
procedure NotifyScreenInfoChanged;
|
|
procedure Invalidate(kind: TCefPaintElementType);
|
|
procedure SendExternalBeginFrame;
|
|
procedure SendKeyEvent(const event: PCefKeyEvent);
|
|
procedure SendMouseClickEvent(const event: PCefMouseEvent; type_: TCefMouseButtonType; mouseUp: Boolean; clickCount: Integer);
|
|
procedure SendMouseMoveEvent(const event: PCefMouseEvent; mouseLeave: Boolean);
|
|
procedure SendMouseWheelEvent(const event: PCefMouseEvent; deltaX, deltaY: Integer);
|
|
procedure SendTouchEvent(const event: PCefTouchEvent);
|
|
procedure SendCaptureLostEvent;
|
|
procedure NotifyMoveOrResizeStarted;
|
|
function GetWindowlessFrameRate : Integer;
|
|
procedure SetWindowlessFrameRate(frameRate: Integer);
|
|
procedure IMESetComposition(const text: ustring; const underlines : TCefCompositionUnderlineDynArray; const replacement_range, selection_range : PCefRange);
|
|
procedure IMECommitText(const text: ustring; const replacement_range : PCefRange; relative_cursor_pos : integer);
|
|
procedure IMEFinishComposingText(keep_selection : boolean);
|
|
procedure IMECancelComposition;
|
|
procedure DragTargetDragEnter(const dragData: ICefDragData; const event: PCefMouseEvent; allowedOps: TCefDragOperations);
|
|
procedure DragTargetDragOver(const event: PCefMouseEvent; allowedOps: TCefDragOperations);
|
|
procedure DragTargetDragLeave;
|
|
procedure DragTargetDrop(const event: PCefMouseEvent);
|
|
procedure DragSourceEndedAt(x, y: Integer; op: TCefDragOperation);
|
|
procedure DragSourceSystemDragEnded;
|
|
function GetVisibleNavigationEntry : ICefNavigationEntry;
|
|
procedure SetAccessibilityState(accessibilityState: TCefState);
|
|
procedure SetAutoResizeEnabled(enabled: boolean; const min_size, max_size: PCefSize);
|
|
function GetExtension : ICefExtension;
|
|
function IsBackgroundHost : boolean;
|
|
procedure SetAudioMuted(mute: boolean);
|
|
function IsAudioMuted : boolean;
|
|
|
|
property Browser : ICefBrowser read GetBrowser;
|
|
property WindowHandle : TCefWindowHandle read GetWindowHandle;
|
|
property OpenerWindowHandle : TCefWindowHandle read GetOpenerWindowHandle;
|
|
property ZoomLevel : Double read GetZoomLevel write SetZoomLevel;
|
|
property RequestContext : ICefRequestContext read GetRequestContext;
|
|
property VisibleNavigationEntry : ICefNavigationEntry read GetVisibleNavigationEntry;
|
|
end;
|
|
|
|
// TCefProcessMessage
|
|
// /include/capi/cef_process_message_capi.h (cef_process_message_t)
|
|
ICefProcessMessage = interface(ICefBaseRefCounted)
|
|
['{E0B1001A-8777-425A-869B-29D40B8B93B1}']
|
|
function IsValid: Boolean;
|
|
function IsReadOnly: Boolean;
|
|
function Copy: ICefProcessMessage;
|
|
function GetName: ustring;
|
|
function GetArgumentList: ICefListValue;
|
|
function GetSharedMemoryRegion: ICefSharedMemoryRegion;
|
|
|
|
property Name : ustring read GetName;
|
|
property ArgumentList : ICefListValue read GetArgumentList;
|
|
property SharedMemoryRegion : ICefSharedMemoryRegion read GetSharedMemoryRegion;
|
|
end;
|
|
|
|
// TCefBrowser
|
|
// /include/capi/cef_browser_capi.h (cef_browser_t)
|
|
ICefBrowser = interface(ICefBaseRefCounted)
|
|
['{BA003C2E-CF15-458F-9D4A-FE3CEFCF3EEF}']
|
|
function IsValid: boolean;
|
|
function GetHost: ICefBrowserHost;
|
|
function CanGoBack: Boolean;
|
|
procedure GoBack;
|
|
function CanGoForward: Boolean;
|
|
procedure GoForward;
|
|
function IsLoading: Boolean;
|
|
procedure Reload;
|
|
procedure ReloadIgnoreCache;
|
|
procedure StopLoad;
|
|
function GetIdentifier: Integer;
|
|
function IsSame(const that: ICefBrowser): Boolean;
|
|
function IsPopup: Boolean;
|
|
function HasDocument: Boolean;
|
|
function GetMainFrame: ICefFrame;
|
|
function GetFocusedFrame: ICefFrame;
|
|
function GetFrameByident(const identifier: Int64): ICefFrame;
|
|
function GetFrame(const name: ustring): ICefFrame;
|
|
function GetFrameCount: NativeUInt;
|
|
function GetFrameIdentifiers(var aFrameCount : NativeUInt; var aFrameIdentifierArray : TCefFrameIdentifierArray) : boolean;
|
|
function GetFrameNames(var aFrameNames : TStrings) : boolean;
|
|
|
|
property MainFrame : ICefFrame read GetMainFrame;
|
|
property FocusedFrame : ICefFrame read GetFocusedFrame;
|
|
property FrameCount : NativeUInt read GetFrameCount;
|
|
property Host : ICefBrowserHost read GetHost;
|
|
property Identifier : Integer read GetIdentifier;
|
|
end;
|
|
|
|
// TCefPostDataElement
|
|
// /include/capi/cef_request_capi.h (cef_post_data_element_t)
|
|
ICefPostDataElement = interface(ICefBaseRefCounted)
|
|
['{3353D1B8-0300-4ADC-8D74-4FF31C77D13C}']
|
|
function IsReadOnly: Boolean;
|
|
procedure SetToEmpty;
|
|
procedure SetToFile(const fileName: ustring);
|
|
procedure SetToBytes(size: NativeUInt; const bytes: Pointer);
|
|
function GetType: TCefPostDataElementType;
|
|
function GetFile: ustring;
|
|
function GetBytesCount: NativeUInt;
|
|
function GetBytes(size: NativeUInt; bytes: Pointer): NativeUInt;
|
|
end;
|
|
|
|
// TCefPostData
|
|
// /include/capi/cef_request_capi.h (cef_post_data_t)
|
|
ICefPostData = interface(ICefBaseRefCounted)
|
|
['{1E677630-9339-4732-BB99-D6FE4DE4AEC0}']
|
|
function IsReadOnly: Boolean;
|
|
function HasExcludedElements: Boolean;
|
|
function GetElementCount: NativeUInt;
|
|
procedure GetElements(elementsCount: NativeUInt; var elements: TCefPostDataElementArray);
|
|
function RemoveElement(const element: ICefPostDataElement): Boolean;
|
|
function AddElement(const element: ICefPostDataElement): Boolean;
|
|
procedure RemoveElements;
|
|
end;
|
|
|
|
// TCefRequest
|
|
// /include/capi/cef_request_capi.h (cef_request_t)
|
|
ICefRequest = interface(ICefBaseRefCounted)
|
|
['{FB4718D3-7D13-4979-9F4C-D7F6C0EC592A}']
|
|
function IsReadOnly: Boolean;
|
|
function GetUrl: ustring;
|
|
function GetMethod: ustring;
|
|
function GetPostData: ICefPostData;
|
|
procedure GetHeaderMap(const HeaderMap: ICefStringMultimap);
|
|
procedure SetUrl(const value: ustring);
|
|
procedure SetMethod(const value: ustring);
|
|
procedure SetReferrer(const referrerUrl: ustring; policy: TCefReferrerPolicy);
|
|
function GetReferrerUrl: ustring;
|
|
function GetReferrerPolicy: TCefReferrerPolicy;
|
|
procedure SetPostData(const value: ICefPostData);
|
|
procedure SetHeaderMap(const HeaderMap: ICefStringMultimap);
|
|
function GetHeaderByName(const name: ustring): ustring;
|
|
procedure SetHeaderByName(const name, value: ustring; overwrite: boolean);
|
|
function GetFlags: TCefUrlRequestFlags;
|
|
procedure SetFlags(flags: TCefUrlRequestFlags);
|
|
function GetFirstPartyForCookies: ustring;
|
|
procedure SetFirstPartyForCookies(const url: ustring);
|
|
procedure Assign(const url, method: ustring; const postData: ICefPostData; const headerMap: ICefStringMultimap);
|
|
function GetResourceType: TCefResourceType;
|
|
function GetTransitionType: TCefTransitionType;
|
|
function GetIdentifier: UInt64;
|
|
|
|
property Url : ustring read GetUrl write SetUrl;
|
|
property Method : ustring read GetMethod write SetMethod;
|
|
property ReferrerUrl : ustring read GetReferrerUrl;
|
|
property ReferrerPolicy : TCefReferrerPolicy read GetReferrerPolicy;
|
|
property PostData : ICefPostData read GetPostData write SetPostData;
|
|
property Flags : TCefUrlRequestFlags read GetFlags write SetFlags;
|
|
property FirstPartyForCookies : ustring read GetFirstPartyForCookies write SetFirstPartyForCookies;
|
|
property ResourceType : TCefResourceType read GetResourceType;
|
|
property TransitionType : TCefTransitionType read GetTransitionType;
|
|
property Identifier : UInt64 read GetIdentifier;
|
|
end;
|
|
|
|
// TCefStringVisitor
|
|
// /include/capi/cef_string_visitor_capi.h (cef_string_visitor_t)
|
|
ICefStringVisitor = interface(ICefBaseRefCounted)
|
|
['{63ED4D6C-2FC8-4537-964B-B84C008F6158}']
|
|
procedure Visit(const str: ustring);
|
|
end;
|
|
|
|
// TCefFrame
|
|
// /include/capi/cef_frame_capi.h (cef_frame_t)
|
|
ICefFrame = interface(ICefBaseRefCounted)
|
|
['{8FD3D3A6-EA3A-4A72-8501-0276BD5C3D1D}']
|
|
function IsValid: Boolean;
|
|
procedure Undo;
|
|
procedure Redo;
|
|
procedure Cut;
|
|
procedure Copy;
|
|
procedure Paste;
|
|
procedure Del;
|
|
procedure SelectAll;
|
|
procedure ViewSource;
|
|
procedure GetSource(const visitor: ICefStringVisitor);
|
|
procedure GetSourceProc(const proc: TCefStringVisitorProc);
|
|
procedure GetText(const visitor: ICefStringVisitor);
|
|
procedure GetTextProc(const proc: TCefStringVisitorProc);
|
|
procedure LoadRequest(const request: ICefRequest);
|
|
procedure LoadUrl(const url: ustring);
|
|
procedure ExecuteJavaScript(const code, scriptUrl: ustring; startLine: Integer);
|
|
function IsMain: Boolean;
|
|
function IsFocused: Boolean;
|
|
function GetName: ustring;
|
|
function GetIdentifier: Int64;
|
|
function GetParent: ICefFrame;
|
|
function GetUrl: ustring;
|
|
function GetBrowser: ICefBrowser;
|
|
function GetV8Context: ICefv8Context;
|
|
procedure VisitDom(const visitor: ICefDomVisitor);
|
|
procedure VisitDomProc(const proc: TCefDomVisitorProc);
|
|
function CreateUrlRequest(const request: ICefRequest; const client: ICefUrlrequestClient): ICefUrlRequest;
|
|
procedure SendProcessMessage(targetProcess: TCefProcessId; const message_: ICefProcessMessage);
|
|
|
|
property Name : ustring read GetName;
|
|
property Url : ustring read GetUrl;
|
|
property Browser : ICefBrowser read GetBrowser;
|
|
property Parent : ICefFrame read GetParent;
|
|
property Identifier : int64 read GetIdentifier;
|
|
end;
|
|
|
|
// TCefFrameHandler
|
|
// /include/capi/cef_frame_handler_capi.h (cef_frame_handler_t)
|
|
ICefFrameHandler = interface(ICefBaseRefCounted)
|
|
['{B437128C-F7CB-4F75-83CF-A257B98C0B6E}']
|
|
procedure OnFrameCreated(const browser: ICefBrowser; const frame: ICefFrame);
|
|
procedure OnFrameAttached(const browser: ICefBrowser; const frame: ICefFrame; reattached: boolean);
|
|
procedure OnFrameDetached(const browser: ICefBrowser; const frame: ICefFrame);
|
|
procedure OnMainFrameChanged(const browser: ICefBrowser; const old_frame, new_frame: ICefFrame);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefStreamReader
|
|
// /include/capi/cef_stream_capi.h (cef_stream_reader_t)
|
|
ICefCustomStreamReader = interface(ICefBaseRefCounted)
|
|
['{BBCFF23A-6FE7-4C28-B13E-6D2ACA5C83B7}']
|
|
function Read(ptr: Pointer; size, n: NativeUInt): NativeUInt;
|
|
function Seek(offset: Int64; whence: Integer): Integer;
|
|
function Tell: Int64;
|
|
function Eof: Boolean;
|
|
function MayBlock: Boolean;
|
|
end;
|
|
|
|
// TCefStreamReader
|
|
// /include/capi/cef_stream_capi.h (cef_stream_reader_t)
|
|
ICefStreamReader = interface(ICefBaseRefCounted)
|
|
['{DD5361CB-E558-49C5-A4BD-D1CE84ADB277}']
|
|
function Read(ptr: Pointer; size, n: NativeUInt): NativeUInt;
|
|
function Seek(offset: Int64; whence: Integer): Integer;
|
|
function Tell: Int64;
|
|
function Eof: Boolean;
|
|
function MayBlock: Boolean;
|
|
end;
|
|
|
|
// TCefWriteHandler
|
|
// /include/capi/cef_stream_capi.h (cef_write_handler_t)
|
|
ICefWriteHandler = interface(ICefBaseRefCounted)
|
|
['{F2431888-4EAB-421E-9EC3-320BE695AF30}']
|
|
function Write(const ptr: Pointer; size, n: NativeUInt): NativeUInt;
|
|
function Seek(offset: Int64; whence: Integer): Integer;
|
|
function Tell: Int64;
|
|
function Flush: Integer;
|
|
function MayBlock: Boolean;
|
|
end;
|
|
|
|
// TCefStreamWriter
|
|
// /include/capi/cef_stream_capi.h (cef_stream_writer_t)
|
|
ICefStreamWriter = interface(ICefBaseRefCounted)
|
|
['{4AA6C477-7D8A-4D5A-A704-67F900A827E7}']
|
|
function Write(const ptr: Pointer; size, n: NativeUInt): NativeUInt;
|
|
function Seek(offset: Int64; whence: Integer): Integer;
|
|
function Tell: Int64;
|
|
function Flush: Integer;
|
|
function MayBlock: Boolean;
|
|
end;
|
|
|
|
// TCefResponse
|
|
// /include/capi/cef_response_capi.h (cef_response_t)
|
|
ICefResponse = interface(ICefBaseRefCounted)
|
|
['{E9C896E4-59A8-4B96-AB5E-6EA3A498B7F1}']
|
|
function IsReadOnly: Boolean;
|
|
function GetError: TCefErrorCode;
|
|
procedure SetError(error: TCefErrorCode);
|
|
function GetStatus: Integer;
|
|
procedure SetStatus(status: Integer);
|
|
function GetStatusText: ustring;
|
|
procedure SetStatusText(const StatusText: ustring);
|
|
function GetMimeType: ustring;
|
|
procedure SetMimeType(const mimetype: ustring);
|
|
function GetCharset: ustring;
|
|
procedure SetCharset(const charset: ustring);
|
|
function GetHeaderByName(const name: ustring): ustring;
|
|
procedure SetHeaderByName(const name, value: ustring; overwrite: boolean);
|
|
procedure GetHeaderMap(const headerMap: ICefStringMultimap);
|
|
procedure SetHeaderMap(const headerMap: ICefStringMultimap);
|
|
function GetURL: ustring;
|
|
procedure SetURL(const url: ustring);
|
|
|
|
property Status : Integer read GetStatus write SetStatus;
|
|
property StatusText : ustring read GetStatusText write SetStatusText;
|
|
property MimeType : ustring read GetMimeType write SetMimeType;
|
|
property Charset : ustring read GetCharset write SetCharset;
|
|
property Error : TCefErrorCode read GetError write SetError;
|
|
property URL : ustring read GetURL write SetURL;
|
|
end;
|
|
|
|
// TCefDownloadItem
|
|
// /include/capi/cef_download_item_capi.h (cef_download_item_t)
|
|
ICefDownloadItem = interface(ICefBaseRefCounted)
|
|
['{B34BD320-A82E-4185-8E84-B98E5EEC803F}']
|
|
function IsValid: Boolean;
|
|
function IsInProgress: Boolean;
|
|
function IsComplete: Boolean;
|
|
function IsCanceled: Boolean;
|
|
function GetCurrentSpeed: Int64;
|
|
function GetPercentComplete: Integer;
|
|
function GetTotalBytes: Int64;
|
|
function GetReceivedBytes: Int64;
|
|
function GetStartTime: TDateTime;
|
|
function GetEndTime: TDateTime;
|
|
function GetFullPath: ustring;
|
|
function GetId: Cardinal;
|
|
function GetUrl: ustring;
|
|
function GetOriginalUrl: ustring;
|
|
function GetSuggestedFileName: ustring;
|
|
function GetContentDisposition: ustring;
|
|
function GetMimeType: ustring;
|
|
|
|
property CurrentSpeed : Int64 read GetCurrentSpeed;
|
|
property PercentComplete : Integer read GetPercentComplete;
|
|
property TotalBytes : Int64 read GetTotalBytes;
|
|
property ReceivedBytes : Int64 read GetReceivedBytes;
|
|
property StartTime : TDateTime read GetStartTime;
|
|
property EndTime : TDateTime read GetEndTime;
|
|
property FullPath : ustring read GetFullPath;
|
|
property Id : Cardinal read GetId;
|
|
property Url : ustring read GetUrl;
|
|
property OriginalUrl : ustring read GetOriginalUrl;
|
|
property SuggestedFileName : ustring read GetSuggestedFileName;
|
|
property ContentDisposition : ustring read GetContentDisposition;
|
|
property MimeType : ustring read GetMimeType;
|
|
end;
|
|
|
|
// TCefBeforeDownloadCallback
|
|
// /include/capi/cef_download_handler_capi.h (cef_before_download_callback_t)
|
|
ICefBeforeDownloadCallback = interface(ICefBaseRefCounted)
|
|
['{5A81AF75-CBA2-444D-AD8E-522160F36433}']
|
|
procedure Cont(const downloadPath: ustring; showDialog: Boolean);
|
|
end;
|
|
|
|
// TCefDownloadItemCallback
|
|
// /include/capi/cef_download_handler_capi.h (cef_download_item_callback_t)
|
|
ICefDownloadItemCallback = interface(ICefBaseRefCounted)
|
|
['{498F103F-BE64-4D5F-86B7-B37EC69E1735}']
|
|
procedure Cancel;
|
|
procedure Pause;
|
|
procedure Resume;
|
|
end;
|
|
|
|
// TCefDownloadHandler
|
|
// /include/capi/cef_download_handler_capi.h (cef_download_handler_t)
|
|
ICefDownloadHandler = interface(ICefBaseRefCounted)
|
|
['{3137F90A-5DC5-43C1-858D-A269F28EF4F1}']
|
|
function CanDownload(const browser: ICefBrowser; const url, request_method: ustring): boolean;
|
|
procedure OnBeforeDownload(const browser: ICefBrowser; const downloadItem: ICefDownloadItem; const suggestedName: ustring; const callback: ICefBeforeDownloadCallback);
|
|
procedure OnDownloadUpdated(const browser: ICefBrowser; const downloadItem: ICefDownloadItem; const callback: ICefDownloadItemCallback);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefV8Exception
|
|
// /include/capi/cef_v8_capi.h (cef_v8exception_t)
|
|
ICefV8Exception = interface(ICefBaseRefCounted)
|
|
['{7E422CF0-05AC-4A60-A029-F45105DCE6A4}']
|
|
function GetMessage: ustring;
|
|
function GetSourceLine: ustring;
|
|
function GetScriptResourceName: ustring;
|
|
function GetLineNumber: Integer;
|
|
function GetStartPosition: Integer;
|
|
function GetEndPosition: Integer;
|
|
function GetStartColumn: Integer;
|
|
function GetEndColumn: Integer;
|
|
|
|
property Message : ustring read GetMessage;
|
|
property SourceLine : ustring read GetSourceLine;
|
|
property ScriptResourceName : ustring read GetScriptResourceName;
|
|
property LineNumber : Integer read GetLineNumber;
|
|
property StartPosition : Integer read GetStartPosition;
|
|
property EndPosition : Integer read GetEndPosition;
|
|
property StartColumn : Integer read GetStartColumn;
|
|
property EndColumn : Integer read GetEndColumn;
|
|
end;
|
|
|
|
// TCefv8ArrayBufferReleaseCallback
|
|
// /include/capi/cef_v8_capi.h (cef_v8array_buffer_release_callback_t)
|
|
ICefv8ArrayBufferReleaseCallback = interface(ICefBaseRefCounted)
|
|
['{4EAAB422-D046-43DF-B1F0-5503116A5816}']
|
|
procedure ReleaseBuffer(buffer : Pointer);
|
|
end;
|
|
|
|
// TCefV8Context
|
|
// /include/capi/cef_v8_capi.h (cef_v8context_t)
|
|
ICefv8Context = interface(ICefBaseRefCounted)
|
|
['{2295A11A-8773-41F2-AD42-308C215062D9}']
|
|
function GetTaskRunner: ICefTaskRunner;
|
|
function IsValid: Boolean;
|
|
function GetBrowser: ICefBrowser;
|
|
function GetFrame: ICefFrame;
|
|
function GetGlobal: ICefv8Value;
|
|
function Enter: Boolean;
|
|
function Exit: Boolean;
|
|
function IsSame(const that: ICefv8Context): Boolean;
|
|
function Eval(const code: ustring; const script_url: ustring; start_line: integer; var retval: ICefv8Value; var exception: ICefV8Exception): Boolean;
|
|
|
|
property Browser : ICefBrowser read GetBrowser;
|
|
property Frame : ICefFrame read GetFrame;
|
|
property Global : ICefv8Value read GetGlobal;
|
|
end;
|
|
|
|
// TCefv8Handler
|
|
// /include/capi/cef_v8_capi.h (cef_v8handler_t)
|
|
ICefv8Handler = interface(ICefBaseRefCounted)
|
|
['{F94CDC60-FDCB-422D-96D5-D2A775BD5D73}']
|
|
function Execute(const name: ustring; const object_: ICefv8Value; const arguments: TCefv8ValueArray; var retval: ICefv8Value; var exception: ustring): Boolean;
|
|
end;
|
|
|
|
// TCefV8Interceptor
|
|
// /include/capi/cef_v8_capi.h (cef_v8interceptor_t)
|
|
ICefV8Interceptor = interface(ICefBaseRefCounted)
|
|
['{B3B8FD7C-A916-4B25-93A2-2892AC324F21}']
|
|
function GetByName(const name: ustring; const object_: ICefv8Value; var retval: ICefv8Value; var exception: ustring): boolean;
|
|
function GetByIndex(index: integer; const object_: ICefv8Value; var retval: ICefv8Value; var exception: ustring): boolean;
|
|
function SetByName(const name: ustring; const object_, value: ICefv8Value; var exception: ustring): boolean;
|
|
function SetByIndex(index: integer; const object_, value: ICefv8Value; var exception: ustring): boolean;
|
|
end;
|
|
|
|
// TCefV8Accessor
|
|
// /include/capi/cef_v8_capi.h (cef_v8accessor_t)
|
|
ICefV8Accessor = interface(ICefBaseRefCounted)
|
|
['{DCA6D4A2-726A-4E24-AA64-5E8C731D868A}']
|
|
function Get(const name: ustring; const object_: ICefv8Value; var retval: ICefv8Value; var exception: ustring): Boolean;
|
|
function Set_(const name: ustring; const object_, value: ICefv8Value; var exception: ustring): Boolean;
|
|
end;
|
|
|
|
// TCefTask
|
|
// /include/capi/cef_task_capi.h (cef_task_t)
|
|
ICefTask = interface(ICefBaseRefCounted)
|
|
['{0D965470-4A86-47CE-BD39-A8770021AD7E}']
|
|
procedure Execute;
|
|
end;
|
|
|
|
// TCefTaskRunner
|
|
// /include/capi/cef_task_capi.h (cef_task_runner_t)
|
|
ICefTaskRunner = interface(ICefBaseRefCounted)
|
|
['{6A500FA3-77B7-4418-8EA8-6337EED1337B}']
|
|
function IsSame(const that: ICefTaskRunner): Boolean;
|
|
function BelongsToCurrentThread: Boolean;
|
|
function BelongsToThread(threadId: TCefThreadId): Boolean;
|
|
function PostTask(const task: ICefTask): Boolean;
|
|
function PostDelayedTask(const task: ICefTask; delayMs: Int64): Boolean;
|
|
end;
|
|
|
|
// TCefThread
|
|
// /include/capi/cef_thread_capi.h (cef_thread_t)
|
|
ICefThread = interface(ICefBaseRefCounted)
|
|
['{26B30EA5-F44A-4C40-97DF-67FD9E73A4FF}']
|
|
function GetTaskRunner : ICefTaskRunner;
|
|
function GetPlatformThreadID : TCefPlatformThreadId;
|
|
procedure Stop;
|
|
function IsRunning : boolean;
|
|
end;
|
|
|
|
// TCefWaitableEvent
|
|
// /include/capi/cef_waitable_event_capi.h (cef_waitable_event_t)
|
|
ICefWaitableEvent = interface(ICefBaseRefCounted)
|
|
['{965C90C9-3DAE-457F-AA64-E04FF508094A}']
|
|
procedure Reset;
|
|
procedure Signal;
|
|
function IsSignaled : boolean;
|
|
procedure Wait;
|
|
function TimedWait(max_ms: int64): boolean;
|
|
end;
|
|
|
|
// TCefv8Value
|
|
// /include/capi/cef_v8_capi.h (cef_v8value_t)
|
|
ICefv8Value = interface(ICefBaseRefCounted)
|
|
['{52319B8D-75A8-422C-BD4B-16FA08CC7F42}']
|
|
function IsValid: Boolean;
|
|
function IsUndefined: Boolean;
|
|
function IsNull: Boolean;
|
|
function IsBool: Boolean;
|
|
function IsInt: Boolean;
|
|
function IsUInt: Boolean;
|
|
function IsDouble: Boolean;
|
|
function IsDate: Boolean;
|
|
function IsString: Boolean;
|
|
function IsObject: Boolean;
|
|
function IsArray: Boolean;
|
|
function IsArrayBuffer: Boolean;
|
|
function IsFunction: Boolean;
|
|
function IsPromise: Boolean;
|
|
function IsSame(const that: ICefv8Value): Boolean;
|
|
function GetBoolValue: Boolean;
|
|
function GetIntValue: Integer;
|
|
function GetUIntValue: Cardinal;
|
|
function GetDoubleValue: Double;
|
|
function GetDateValue: TDateTime;
|
|
function GetStringValue: ustring;
|
|
function IsUserCreated: Boolean;
|
|
function HasException: Boolean;
|
|
function GetException: ICefV8Exception;
|
|
function ClearException: Boolean;
|
|
function WillRethrowExceptions: Boolean;
|
|
function SetRethrowExceptions(rethrow: Boolean): Boolean;
|
|
function HasValueByKey(const key: ustring): Boolean;
|
|
function HasValueByIndex(index: Integer): Boolean;
|
|
function DeleteValueByKey(const key: ustring): Boolean;
|
|
function DeleteValueByIndex(index: Integer): Boolean;
|
|
function GetValueByKey(const key: ustring): ICefv8Value;
|
|
function GetValueByIndex(index: Integer): ICefv8Value;
|
|
function SetValueByKey(const key: ustring; const value: ICefv8Value; attribute: TCefV8PropertyAttributes): Boolean;
|
|
function SetValueByIndex(index: Integer; const value: ICefv8Value): Boolean;
|
|
function SetValueByAccessor(const key: ustring; settings: TCefV8AccessControls; attribute: TCefV8PropertyAttributes): Boolean;
|
|
function GetKeys(const keys: TStrings): Integer;
|
|
function SetUserData(const data: ICefv8Value): Boolean;
|
|
function GetUserData: ICefv8Value;
|
|
function GetExternallyAllocatedMemory: Integer;
|
|
function AdjustExternallyAllocatedMemory(changeInBytes: Integer): Integer;
|
|
function GetArrayLength: Integer;
|
|
function GetArrayBufferReleaseCallback : ICefv8ArrayBufferReleaseCallback;
|
|
function NeuterArrayBuffer : boolean;
|
|
function GetFunctionName: ustring;
|
|
function GetFunctionHandler: ICefv8Handler;
|
|
function ExecuteFunction(const obj: ICefv8Value; const arguments: TCefv8ValueArray): ICefv8Value;
|
|
function ExecuteFunctionWithContext(const context: ICefv8Context; const obj: ICefv8Value; const arguments: TCefv8ValueArray): ICefv8Value;
|
|
function ResolvePromise(const arg: ICefv8Value): boolean;
|
|
function RejectPromise(const errorMsg: ustring): boolean;
|
|
end;
|
|
|
|
// TCefV8StackFrame
|
|
// /include/capi/cef_v8_capi.h (cef_v8stack_frame_t)
|
|
ICefV8StackFrame = interface(ICefBaseRefCounted)
|
|
['{BA1FFBF4-E9F2-4842-A827-DC220F324286}']
|
|
function IsValid: Boolean;
|
|
function GetScriptName: ustring;
|
|
function GetScriptNameOrSourceUrl: ustring;
|
|
function GetFunctionName: ustring;
|
|
function GetLineNumber: Integer;
|
|
function GetColumn: Integer;
|
|
function IsEval: Boolean;
|
|
function IsConstructor: Boolean;
|
|
|
|
property ScriptName : ustring read GetScriptName;
|
|
property ScriptNameOrSourceUrl : ustring read GetScriptNameOrSourceUrl;
|
|
property FunctionName : ustring read GetFunctionName;
|
|
property LineNumber : Integer read GetLineNumber;
|
|
property Column : Integer read GetColumn;
|
|
end;
|
|
|
|
// TCefV8StackTrace
|
|
// /include/capi/cef_v8_capi.h (cef_v8stack_trace_t)
|
|
ICefV8StackTrace = interface(ICefBaseRefCounted)
|
|
['{32111C84-B7F7-4E3A-92B9-7CA1D0ADB613}']
|
|
function IsValid: Boolean;
|
|
function GetFrameCount: Integer;
|
|
function GetFrame(index: Integer): ICefV8StackFrame;
|
|
|
|
property FrameCount : Integer read GetFrameCount;
|
|
property Frame[index: Integer] : ICefV8StackFrame read GetFrame;
|
|
end;
|
|
|
|
// TCefXmlReader
|
|
// /include/capi/cef_xml_reader_capi.h (cef_xml_reader_t)
|
|
ICefXmlReader = interface(ICefBaseRefCounted)
|
|
['{0DE686C3-A8D7-45D2-82FD-92F7F4E62A90}']
|
|
function MoveToNextNode: Boolean;
|
|
function Close: Boolean;
|
|
function HasError: Boolean;
|
|
function GetError: ustring;
|
|
function GetType: TCefXmlNodeType;
|
|
function GetDepth: Integer;
|
|
function GetLocalName: ustring;
|
|
function GetPrefix: ustring;
|
|
function GetQualifiedName: ustring;
|
|
function GetNamespaceUri: ustring;
|
|
function GetBaseUri: ustring;
|
|
function GetXmlLang: ustring;
|
|
function IsEmptyElement: Boolean;
|
|
function HasValue: Boolean;
|
|
function GetValue: ustring;
|
|
function HasAttributes: Boolean;
|
|
function GetAttributeCount: NativeUInt;
|
|
function GetAttributeByIndex(index: Integer): ustring;
|
|
function GetAttributeByQName(const qualifiedName: ustring): ustring;
|
|
function GetAttributeByLName(const localName, namespaceURI: ustring): ustring;
|
|
function GetInnerXml: ustring;
|
|
function GetOuterXml: ustring;
|
|
function GetLineNumber: Integer;
|
|
function MoveToAttributeByIndex(index: Integer): Boolean;
|
|
function MoveToAttributeByQName(const qualifiedName: ustring): Boolean;
|
|
function MoveToAttributeByLName(const localName, namespaceURI: ustring): Boolean;
|
|
function MoveToFirstAttribute: Boolean;
|
|
function MoveToNextAttribute: Boolean;
|
|
function MoveToCarryingElement: Boolean;
|
|
end;
|
|
|
|
// TCefZipReader
|
|
// /include/capi/cef_zip_reader_capi.h (cef_zip_reader_t)
|
|
ICefZipReader = interface(ICefBaseRefCounted)
|
|
['{3B6C591F-9877-42B3-8892-AA7B27DA34A8}']
|
|
function MoveToFirstFile: Boolean;
|
|
function MoveToNextFile: Boolean;
|
|
function MoveToFile(const fileName: ustring; caseSensitive: Boolean): Boolean;
|
|
function Close: Boolean;
|
|
function GetFileName: ustring;
|
|
function GetFileSize: Int64;
|
|
function GetFileLastModified: TCefBaseTime;
|
|
function OpenFile(const password: ustring): Boolean;
|
|
function CloseFile: Boolean;
|
|
function ReadFile(buffer: Pointer; bufferSize: NativeUInt): Integer;
|
|
function Tell: Int64;
|
|
function Eof: Boolean;
|
|
end;
|
|
|
|
// TCefDomNode
|
|
// /include/capi/cef_dom_capi.h (cef_domnode_t)
|
|
ICefDomNode = interface(ICefBaseRefCounted)
|
|
['{96C03C9E-9C98-491A-8DAD-1947332232D6}']
|
|
function GetType: TCefDomNodeType;
|
|
function IsText: Boolean;
|
|
function IsElement: Boolean;
|
|
function IsEditable: Boolean;
|
|
function IsFormControlElement: Boolean;
|
|
function GetFormControlElementType: ustring;
|
|
function IsSame(const that: ICefDomNode): Boolean;
|
|
function GetName: ustring;
|
|
function GetValue: ustring;
|
|
function SetValue(const value: ustring): Boolean;
|
|
function GetAsMarkup: ustring;
|
|
function GetDocument: ICefDomDocument;
|
|
function GetParent: ICefDomNode;
|
|
function GetPreviousSibling: ICefDomNode;
|
|
function GetNextSibling: ICefDomNode;
|
|
function HasChildren: Boolean;
|
|
function GetFirstChild: ICefDomNode;
|
|
function GetLastChild: ICefDomNode;
|
|
function GetElementTagName: ustring;
|
|
function HasElementAttributes: Boolean;
|
|
function HasElementAttribute(const attrName: ustring): Boolean;
|
|
function GetElementAttribute(const attrName: ustring): ustring;
|
|
procedure GetElementAttributes(const attrMap: ICefStringMap); overload;
|
|
procedure GetElementAttributes(var attrList: TStrings); overload;
|
|
function SetElementAttribute(const attrName, value: ustring): Boolean;
|
|
function GetElementInnerText: ustring;
|
|
function GetElementBounds: TCefRect;
|
|
|
|
property NodeType : TCefDomNodeType read GetType;
|
|
property Name : ustring read GetName;
|
|
property AsMarkup : ustring read GetAsMarkup;
|
|
property Document : ICefDomDocument read GetDocument;
|
|
property Parent : ICefDomNode read GetParent;
|
|
property PreviousSibling : ICefDomNode read GetPreviousSibling;
|
|
property NextSibling : ICefDomNode read GetNextSibling;
|
|
property FirstChild : ICefDomNode read GetFirstChild;
|
|
property LastChild : ICefDomNode read GetLastChild;
|
|
property ElementTagName : ustring read GetElementTagName;
|
|
property ElementInnerText : ustring read GetElementInnerText;
|
|
property ElementBounds : TCefRect read GetElementBounds;
|
|
end;
|
|
|
|
// TCefDomDocument
|
|
// /include/capi/cef_dom_capi.h (cef_domdocument_t)
|
|
ICefDomDocument = interface(ICefBaseRefCounted)
|
|
['{08E74052-45AF-4F69-A578-98A5C3959426}']
|
|
function GetType: TCefDomDocumentType;
|
|
function GetDocument: ICefDomNode;
|
|
function GetBody: ICefDomNode;
|
|
function GetHead: ICefDomNode;
|
|
function GetTitle: ustring;
|
|
function GetElementById(const id: ustring): ICefDomNode;
|
|
function GetFocusedNode: ICefDomNode;
|
|
function HasSelection: Boolean;
|
|
function GetSelectionStartOffset: Integer;
|
|
function GetSelectionEndOffset: Integer;
|
|
function GetSelectionAsMarkup: ustring;
|
|
function GetSelectionAsText: ustring;
|
|
function GetBaseUrl: ustring;
|
|
function GetCompleteUrl(const partialURL: ustring): ustring;
|
|
|
|
property DocType : TCefDomDocumentType read GetType;
|
|
property Document : ICefDomNode read GetDocument;
|
|
property Body : ICefDomNode read GetBody;
|
|
property Head : ICefDomNode read GetHead;
|
|
property Title : ustring read GetTitle;
|
|
property FocusedNode : ICefDomNode read GetFocusedNode;
|
|
property SelectionStartOffset : Integer read GetSelectionStartOffset;
|
|
property SelectionEndOffset : Integer read GetSelectionEndOffset;
|
|
property SelectionAsMarkup : ustring read GetSelectionAsMarkup;
|
|
property SelectionAsText : ustring read GetSelectionAsText;
|
|
property BaseUrl : ustring read GetBaseUrl;
|
|
end;
|
|
|
|
// TCefDomVisitor
|
|
// /include/capi/cef_dom_capi.h (cef_domvisitor_t)
|
|
ICefDomVisitor = interface(ICefBaseRefCounted)
|
|
['{30398428-3196-4531-B968-2DDBED36F6B0}']
|
|
procedure visit(const document: ICefDomDocument);
|
|
end;
|
|
|
|
// TCefCookieVisitor
|
|
// /include/capi/cef_cookie_capi.h (cef_cookie_visitor_t)
|
|
ICefCookieVisitor = interface(ICefBaseRefCounted)
|
|
['{8378CF1B-84AB-4FDB-9B86-34DDABCCC402}']
|
|
function visit(const name, value, domain, path: ustring; secure, httponly, hasExpires: Boolean; const creation, lastAccess, expires: TDateTime; count, total: Integer; same_site : TCefCookieSameSite; priority : TCefCookiePriority; out deleteCookie: Boolean): Boolean;
|
|
end;
|
|
|
|
// TCefCommandLine
|
|
// /include/capi/cef_command_line_capi.h (cef_command_line_t)
|
|
ICefCommandLine = interface(ICefBaseRefCounted)
|
|
['{6B43D21B-0F2C-4B94-B4E6-4AF0D7669D8E}']
|
|
function IsValid: Boolean;
|
|
function IsReadOnly: Boolean;
|
|
function Copy: ICefCommandLine;
|
|
procedure InitFromArgv(argc: Integer; const argv: PPAnsiChar);
|
|
procedure InitFromString(const commandLine: ustring);
|
|
procedure Reset;
|
|
function GetCommandLineString: ustring;
|
|
procedure GetArgv(var args: TStrings);
|
|
function GetProgram: ustring;
|
|
procedure SetProgram(const prog: ustring);
|
|
function HasSwitches: Boolean;
|
|
function HasSwitch(const name: ustring): Boolean;
|
|
function GetSwitchValue(const name: ustring): ustring;
|
|
function GetSwitches(var switches: TStrings): boolean; overload;
|
|
function GetSwitches(var SwitchKeys, SwitchValues: TStringList): boolean; overload;
|
|
procedure AppendSwitch(const name: ustring);
|
|
procedure AppendSwitchWithValue(const name, value: ustring);
|
|
function HasArguments: Boolean;
|
|
procedure GetArguments(var arguments: TStrings);
|
|
procedure AppendArgument(const argument: ustring);
|
|
procedure PrependWrapper(const wrapper: ustring);
|
|
|
|
property CommandLineString : ustring read GetCommandLineString;
|
|
end;
|
|
|
|
// TCefRegistration
|
|
// /include/capi/cef_registration_capi.h (cef_registration_t)
|
|
ICefRegistration = interface(ICefBaseRefCounted)
|
|
['{9226018F-7A56-4F2E-AF01-43268E33EE6B}']
|
|
end;
|
|
|
|
// TCefDevToolsMessageObserver
|
|
// /include/capi/cef_devtools_message_observer_capi.h (cef_dev_tools_message_observer_t)
|
|
ICefDevToolsMessageObserver = interface(ICefBaseRefCounted)
|
|
['{76E5BB2B-7F69-4BC9-94C7-B55C61CE630F}']
|
|
procedure OnDevToolsMessage(const browser: ICefBrowser; const message_: Pointer; message_size: NativeUInt; var aHandled: boolean);
|
|
procedure OnDevToolsMethodResult(const browser: ICefBrowser; message_id: integer; success: boolean; const result: Pointer; result_size: NativeUInt);
|
|
procedure OnDevToolsEvent(const browser: ICefBrowser; const method: ustring; const params: Pointer; params_size: NativeUInt);
|
|
procedure OnDevToolsAgentAttached(const browser: ICefBrowser);
|
|
procedure OnDevToolsAgentDetached(const browser: ICefBrowser);
|
|
end;
|
|
|
|
// TCefMediaRouter
|
|
// /include/capi/cef_media_router_capi.h (cef_media_router_t)
|
|
ICefMediaRouter = interface(ICefBaseRefCounted)
|
|
['{F18C3880-CB8D-48F9-9D74-DCFF4B9E88DF}']
|
|
function AddObserver(const observer: ICefMediaObserver): ICefRegistration;
|
|
function GetSource(const urn: ustring): ICefMediaSource;
|
|
procedure NotifyCurrentSinks;
|
|
procedure CreateRoute(const source: ICefMediaSource; const sink: ICefMediaSink; const callback: ICefMediaRouteCreateCallback);
|
|
procedure NotifyCurrentRoutes;
|
|
end;
|
|
|
|
// TCefMediaObserver
|
|
// /include/capi/cef_media_router_capi.h (cef_media_observer_t)
|
|
ICefMediaObserver = interface(ICefBaseRefCounted)
|
|
['{0B27C8D1-63E3-4F69-939F-DCAD518654A3}']
|
|
procedure OnSinks(const sinks: TCefMediaSinkArray);
|
|
procedure OnRoutes(const routes: TCefMediaRouteArray);
|
|
procedure OnRouteStateChanged(const route: ICefMediaRoute; state: TCefMediaRouteConnectionState);
|
|
procedure OnRouteMessageReceived(const route: ICefMediaRoute; const message_: ustring);
|
|
end;
|
|
|
|
ICefMediaObserverEvents = interface
|
|
['{267D5287-08DB-49D6-AF6E-B27C66C6E5D4}']
|
|
procedure doOnSinks(const sinks: TCefMediaSinkArray);
|
|
procedure doOnRoutes(const routes: TCefMediaRouteArray);
|
|
procedure doOnRouteStateChanged(const route: ICefMediaRoute; state: TCefMediaRouteConnectionState);
|
|
procedure doOnRouteMessageReceived(const route: ICefMediaRoute; const message_: ustring);
|
|
end;
|
|
|
|
// TCefMediaRoute
|
|
// /include/capi/cef_media_router_capi.h (cef_media_observer_t)
|
|
ICefMediaRoute = interface(ICefBaseRefCounted)
|
|
['{D8959122-DD19-4933-B4D9-DF829062A0D3}']
|
|
function GetId: ustring;
|
|
function GetSource: ICefMediaSource;
|
|
function GetSink: ICefMediaSink;
|
|
procedure SendRouteMessage(const message_: ustring);
|
|
procedure Terminate;
|
|
|
|
property ID : ustring read GetId;
|
|
property Source : ICefMediaSource read GetSource;
|
|
property Sink : ICefMediaSink read GetSink;
|
|
end;
|
|
|
|
// TCefMediaRouteCreateCallback
|
|
// /include/capi/cef_media_router_capi.h (cef_media_route_create_callback_t)
|
|
ICefMediaRouteCreateCallback = interface(ICefBaseRefCounted)
|
|
['{8848CBFE-36AC-4AC8-BC10-386B69FB27BE}']
|
|
procedure OnMediaRouteCreateFinished(result: TCefMediaRouterCreateResult; const error: ustring; const route: ICefMediaRoute);
|
|
end;
|
|
|
|
//
|
|
ICefMediaSinkDeviceInfoCallback = interface(ICefBaseRefCounted)
|
|
['{633898DD-4169-45D0-ADDD-6E68B3686E0D}']
|
|
procedure OnMediaSinkDeviceInfo(const ip_address: ustring; port: integer; const model_name: ustring);
|
|
end;
|
|
|
|
// TCefMediaSink
|
|
// /include/capi/cef_media_router_capi.h (cef_media_sink_t)
|
|
ICefMediaSink = interface(ICefBaseRefCounted)
|
|
['{EDA1A4B2-2A4C-42DD-A7DF-901BF93D908D}']
|
|
function GetId: ustring;
|
|
function GetName: ustring;
|
|
function GetDescription: ustring;
|
|
function GetIconType: TCefMediaSinkIconType;
|
|
procedure GetDeviceInfo(const callback: ICefMediaSinkDeviceInfoCallback);
|
|
function IsCastSink: boolean;
|
|
function IsDialSink: boolean;
|
|
function IsCompatibleWith(const source: ICefMediaSource): boolean;
|
|
|
|
property ID : ustring read GetId;
|
|
property Name : ustring read GetName;
|
|
property Description : ustring read GetDescription;
|
|
property IconType : TCefMediaSinkIconType read GetIconType;
|
|
end;
|
|
|
|
// TCefMediaSource
|
|
// /include/capi/cef_media_router_capi.h (cef_media_source_t)
|
|
ICefMediaSource = interface(ICefBaseRefCounted)
|
|
['{734ED6E4-6498-43ED-AAA4-6B993EDC30BE}']
|
|
function GetId : ustring;
|
|
function IsCastSource : boolean;
|
|
function IsDialSource : boolean;
|
|
|
|
property ID : ustring read GetId;
|
|
end;
|
|
|
|
|
|
// TCefResourceBundleHandler
|
|
// /include/capi/cef_resource_bundle_handler_capi.h (cef_resource_bundle_handler_t)
|
|
ICefResourceBundleHandler = interface(ICefBaseRefCounted)
|
|
['{09C264FD-7E03-41E3-87B3-4234E82B5EA2}']
|
|
function GetLocalizedString(stringId: Integer; var stringVal: ustring): Boolean;
|
|
function GetDataResource(resourceId: Integer; var data: Pointer; var dataSize: NativeUInt): Boolean;
|
|
function GetDataResourceForScale(resourceId: Integer; scaleFactor: TCefScaleFactor; var data: Pointer; var dataSize: NativeUInt): Boolean;
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefBrowserProcessHandler
|
|
// /include/capi/cef_browser_process_handler_capi.h (cef_browser_process_handler_t)
|
|
ICefBrowserProcessHandler = interface(ICefBaseRefCounted)
|
|
['{27291B7A-C0AE-4EE0-9115-15C810E22F6C}']
|
|
procedure OnRegisterCustomPreferences(type_: TCefPreferencesType; registrar: PCefPreferenceRegistrar);
|
|
procedure OnContextInitialized;
|
|
procedure OnBeforeChildProcessLaunch(const commandLine: ICefCommandLine);
|
|
procedure OnScheduleMessagePumpWork(const delayMs: Int64);
|
|
procedure GetDefaultClient(var aClient : ICefClient);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefRenderProcessHandler
|
|
// /include/capi/cef_render_process_handler_capi.h (cef_render_process_handler_t)
|
|
ICefRenderProcessHandler = interface(ICefBaseRefCounted)
|
|
['{FADEE3BC-BF66-430A-BA5D-1EE3782ECC58}']
|
|
procedure OnWebKitInitialized;
|
|
procedure OnBrowserCreated(const browser: ICefBrowser; const extra_info: ICefDictionaryValue);
|
|
procedure OnBrowserDestroyed(const browser: ICefBrowser);
|
|
function GetLoadHandler : ICefLoadHandler;
|
|
procedure OnContextCreated(const browser: ICefBrowser; const frame: ICefFrame; const context: ICefv8Context);
|
|
procedure OnContextReleased(const browser: ICefBrowser; const frame: ICefFrame; const context: ICefv8Context);
|
|
procedure OnUncaughtException(const browser: ICefBrowser; const frame: ICefFrame; const context: ICefv8Context; const V8Exception: ICefV8Exception; const stackTrace: ICefV8StackTrace);
|
|
procedure OnFocusedNodeChanged(const browser: ICefBrowser; const frame: ICefFrame; const node: ICefDomNode);
|
|
function OnProcessMessageReceived(const browser: ICefBrowser; const frame: ICefFrame; sourceProcess: TCefProcessId; const aMessage: ICefProcessMessage): Boolean;
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefApp
|
|
// /include/capi/cef_app_capi.h (cef_app_t)
|
|
ICefApp = interface(ICefBaseRefCounted)
|
|
['{970CA670-9070-4642-B188-7D8A22DAEED4}']
|
|
procedure OnBeforeCommandLineProcessing(const processType: ustring; const commandLine: ICefCommandLine);
|
|
procedure OnRegisterCustomSchemes(const registrar: TCefSchemeRegistrarRef);
|
|
procedure GetResourceBundleHandler(var aHandler : ICefResourceBundleHandler);
|
|
procedure GetBrowserProcessHandler(var aHandler : ICefBrowserProcessHandler);
|
|
procedure GetRenderProcessHandler(var aHandler : ICefRenderProcessHandler);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefCompletionCallback
|
|
// /include/capi/cef_callback_capi.h (cef_completion_callback_t)
|
|
ICefCompletionCallback = interface(ICefBaseRefCounted)
|
|
['{A8ECCFBB-FEE0-446F-AB32-AD69A7478D57}']
|
|
procedure OnComplete;
|
|
end;
|
|
|
|
// TCefSetCookieCallback
|
|
// /include/capi/cef_cookie_capi.h (cef_set_cookie_callback_t)
|
|
ICefSetCookieCallback = interface(ICefBaseRefCounted)
|
|
['{16E14B6F-CB0A-4F9D-A008-239E0BC7B892}']
|
|
procedure OnComplete(success: Boolean);
|
|
end;
|
|
|
|
// TCefDeleteCookiesCallback
|
|
// /include/capi/cef_cookie_capi.h (cef_delete_cookies_callback_t)
|
|
ICefDeleteCookiesCallback = interface(ICefBaseRefCounted)
|
|
['{758B79A1-B9E8-4F0D-94A0-DCE5AFADE33D}']
|
|
procedure OnComplete(numDeleted: Integer);
|
|
end;
|
|
|
|
// TCefCookieManager
|
|
// /include/capi/cef_cookie_capi.h (cef_cookie_manager_t)
|
|
ICefCookieManager = Interface(ICefBaseRefCounted)
|
|
['{CC1749E6-9AD3-4283-8430-AF6CBF3E8785}']
|
|
function VisitAllCookies(const visitor: ICefCookieVisitor): Boolean;
|
|
function VisitAllCookiesProc(const visitor: TCefCookieVisitorProc): Boolean;
|
|
function VisitUrlCookies(const url: ustring; includeHttpOnly: Boolean; const visitor: ICefCookieVisitor): Boolean;
|
|
function VisitUrlCookiesProc(const url: ustring; includeHttpOnly: Boolean; const visitor: TCefCookieVisitorProc): Boolean;
|
|
function SetCookie(const url, name, value, domain, path: ustring; secure, httponly, hasExpires: Boolean; const creation, lastAccess, expires: TDateTime; same_site : TCefCookieSameSite; priority : TCefCookiePriority; const callback: ICefSetCookieCallback): Boolean;
|
|
function SetCookieProc(const url: ustring; const name, value, domain, path: ustring; secure, httponly, hasExpires: Boolean; const creation, lastAccess, expires: TDateTime; same_site : TCefCookieSameSite; priority : TCefCookiePriority; const callback: TCefSetCookieCallbackProc): Boolean;
|
|
function DeleteCookies(const url, cookieName: ustring; const callback: ICefDeleteCookiesCallback): Boolean;
|
|
function DeleteCookiesProc(const url, cookieName: ustring; const callback: TCefDeleteCookiesCallbackProc): Boolean;
|
|
function FlushStore(const callback: ICefCompletionCallback): Boolean;
|
|
function FlushStoreProc(const proc: TCefCompletionCallbackProc): Boolean;
|
|
end;
|
|
|
|
// TCefCallback
|
|
// /include/capi/cef_callback_capi.h (cef_callback_t)
|
|
ICefCallback = interface(ICefBaseRefCounted)
|
|
['{1B8C449F-E2D6-4B78-9BBA-6F47E8BCDF37}']
|
|
procedure Cont;
|
|
procedure Cancel;
|
|
end;
|
|
|
|
// TCefResourceSkipCallback
|
|
// /include/capi/cef_resource_handler_capi.h (cef_resource_skip_callback_t)
|
|
ICefResourceSkipCallback = interface(ICefBaseRefCounted)
|
|
['{5ADDE93E-5858-41FD-81E8-ED8BF710D92A}']
|
|
procedure Cont(bytes_skipped: int64);
|
|
end;
|
|
|
|
// TCefResourceReadCallback
|
|
// /include/capi/cef_resource_handler_capi.h (cef_resource_read_callback_t)
|
|
ICefResourceReadCallback = interface(ICefBaseRefCounted)
|
|
['{7669335F-7A4B-4657-86CA-C02B12369602}']
|
|
procedure Cont(bytes_read: int64);
|
|
end;
|
|
|
|
// TCefResourceHandler
|
|
// /include/capi/cef_resource_handler_capi.h (cef_resource_handler_t)
|
|
ICefResourceHandler = interface(ICefBaseRefCounted)
|
|
['{BD3EA208-AAAD-488C-BFF2-76993022F2B5}']
|
|
function open(const request: ICefRequest; var handle_request: boolean; const callback: ICefCallback): boolean;
|
|
function ProcessRequest(const request: ICefRequest; const callback: ICefCallback): boolean; // deprecated
|
|
procedure GetResponseHeaders(const response: ICefResponse; out responseLength: Int64; out redirectUrl: ustring);
|
|
function skip(bytes_to_skip: int64; var bytes_skipped: Int64; const callback: ICefResourceSkipCallback): boolean;
|
|
function read(const data_out: Pointer; bytes_to_read: Integer; var bytes_read: Integer; const callback: ICefResourceReadCallback): boolean;
|
|
function ReadResponse(const dataOut: Pointer; bytesToRead: Integer; var bytesRead: Integer; const callback: ICefCallback): boolean; // deprecated
|
|
procedure Cancel;
|
|
end;
|
|
|
|
// TCefSchemeHandlerFactory
|
|
// /include/capi/cef_scheme_capi.h (cef_scheme_handler_factory_t)
|
|
ICefSchemeHandlerFactory = interface(ICefBaseRefCounted)
|
|
['{4D9B7960-B73B-4EBD-9ABE-6C1C43C245EB}']
|
|
function New(const browser: ICefBrowser; const frame: ICefFrame; const schemeName: ustring; const request: ICefRequest): ICefResourceHandler;
|
|
end;
|
|
|
|
// TCefAuthCallback
|
|
// /include/capi/cef_auth_callback_capi.h (cef_auth_callback_t)
|
|
ICefAuthCallback = interface(ICefBaseRefCounted)
|
|
['{500C2023-BF4D-4FF7-9C04-165E5C389131}']
|
|
procedure Cont(const username, password: ustring);
|
|
procedure Cancel;
|
|
end;
|
|
|
|
// TCefJsDialogCallback
|
|
// /include/capi/cef_jsdialog_handler_capi.h (cef_jsdialog_callback_t)
|
|
ICefJsDialogCallback = interface(ICefBaseRefCounted)
|
|
['{187B2156-9947-4108-87AB-32E559E1B026}']
|
|
procedure Cont(success: Boolean; const userInput: ustring);
|
|
end;
|
|
|
|
// TCefContextMenuParams
|
|
// /include/capi/cef_context_menu_handler_capi.h (cef_context_menu_params_t)
|
|
ICefContextMenuParams = interface(ICefBaseRefCounted)
|
|
['{E31BFA9E-D4E2-49B7-A05D-20018C8794EB}']
|
|
function GetXCoord: Integer;
|
|
function GetYCoord: Integer;
|
|
function GetTypeFlags: TCefContextMenuTypeFlags;
|
|
function GetLinkUrl: ustring;
|
|
function GetUnfilteredLinkUrl: ustring;
|
|
function GetSourceUrl: ustring;
|
|
function HasImageContents: Boolean;
|
|
function GetTitleText: ustring;
|
|
function GetPageUrl: ustring;
|
|
function GetFrameUrl: ustring;
|
|
function GetFrameCharset: ustring;
|
|
function GetMediaType: TCefContextMenuMediaType;
|
|
function GetMediaStateFlags: TCefContextMenuMediaStateFlags;
|
|
function GetSelectionText: ustring;
|
|
function GetMisspelledWord: ustring;
|
|
function GetDictionarySuggestions(const suggestions: TStringList): Boolean;
|
|
function IsEditable: Boolean;
|
|
function IsSpellCheckEnabled: Boolean;
|
|
function GetEditStateFlags: TCefContextMenuEditStateFlags;
|
|
function IsCustomMenu: Boolean;
|
|
|
|
property XCoord : Integer read GetXCoord;
|
|
property YCoord : Integer read GetYCoord;
|
|
property TypeFlags : TCefContextMenuTypeFlags read GetTypeFlags;
|
|
property LinkUrl : ustring read GetLinkUrl;
|
|
property UnfilteredLinkUrl : ustring read GetUnfilteredLinkUrl;
|
|
property SourceUrl : ustring read GetSourceUrl;
|
|
property TitleText : ustring read GetTitleText;
|
|
property PageUrl : ustring read GetPageUrl;
|
|
property FrameUrl : ustring read GetFrameUrl;
|
|
property FrameCharset : ustring read GetFrameCharset;
|
|
property MediaType : TCefContextMenuMediaType read GetMediaType;
|
|
property MediaStateFlags : TCefContextMenuMediaStateFlags read GetMediaStateFlags;
|
|
property SelectionText : ustring read GetSelectionText;
|
|
property EditStateFlags : TCefContextMenuEditStateFlags read GetEditStateFlags;
|
|
end;
|
|
|
|
// TCefMenuModel
|
|
// /include/capi/cef_menu_model_capi.h (cef_menu_model_t)
|
|
ICefMenuModel = interface(ICefBaseRefCounted)
|
|
['{40AF19D3-8B4E-44B8-8F89-DEB5907FC495}']
|
|
function IsSubMenu: Boolean;
|
|
function Clear: Boolean;
|
|
function GetCount: NativeUInt;
|
|
function AddSeparator: Boolean;
|
|
function AddItem(commandId: Integer; const text: ustring): Boolean;
|
|
function AddCheckItem(commandId: Integer; const text: ustring): Boolean;
|
|
function AddRadioItem(commandId: Integer; const text: ustring; groupId: Integer): Boolean;
|
|
function AddSubMenu(commandId: Integer; const text: ustring): ICefMenuModel;
|
|
function InsertSeparatorAt(index: NativeUInt): Boolean;
|
|
function InsertItemAt(index: NativeUInt; commandId: Integer; const text: ustring): Boolean;
|
|
function InsertCheckItemAt(index: NativeUInt; commandId: Integer; const text: ustring): Boolean;
|
|
function InsertRadioItemAt(index: NativeUInt; commandId: Integer; const text: ustring; groupId: Integer): Boolean;
|
|
function InsertSubMenuAt(index: NativeUInt; commandId: Integer; const text: ustring): ICefMenuModel;
|
|
function Remove(commandId: Integer): Boolean;
|
|
function RemoveAt(index: NativeUInt): Boolean;
|
|
function GetIndexOf(commandId: Integer): Integer;
|
|
function GetCommandIdAt(index: NativeUInt): Integer;
|
|
function SetCommandIdAt(index: NativeUInt; commandId: Integer): Boolean;
|
|
function GetLabel(commandId: Integer): ustring;
|
|
function GetLabelAt(index: NativeUInt): ustring;
|
|
function SetLabel(commandId: Integer; const text: ustring): Boolean;
|
|
function SetLabelAt(index: NativeUInt; const text: ustring): Boolean;
|
|
function GetType(commandId: Integer): TCefMenuItemType;
|
|
function GetTypeAt(index: NativeUInt): TCefMenuItemType;
|
|
function GetGroupId(commandId: Integer): Integer;
|
|
function GetGroupIdAt(index: NativeUInt): Integer;
|
|
function SetGroupId(commandId, groupId: Integer): Boolean;
|
|
function SetGroupIdAt(index: NativeUInt; groupId: Integer): Boolean;
|
|
function GetSubMenu(commandId: Integer): ICefMenuModel;
|
|
function GetSubMenuAt(index: NativeUInt): ICefMenuModel;
|
|
function IsVisible(commandId: Integer): Boolean;
|
|
function isVisibleAt(index: NativeUInt): Boolean;
|
|
function SetVisible(commandId: Integer; visible: Boolean): Boolean;
|
|
function SetVisibleAt(index: NativeUInt; visible: Boolean): Boolean;
|
|
function IsEnabled(commandId: Integer): Boolean;
|
|
function IsEnabledAt(index: NativeUInt): Boolean;
|
|
function SetEnabled(commandId: Integer; enabled: Boolean): Boolean;
|
|
function SetEnabledAt(index: NativeUInt; enabled: Boolean): Boolean;
|
|
function IsChecked(commandId: Integer): Boolean;
|
|
function IsCheckedAt(index: NativeUInt): Boolean;
|
|
function setChecked(commandId: Integer; checked: Boolean): Boolean;
|
|
function setCheckedAt(index: NativeUInt; checked: Boolean): Boolean;
|
|
function HasAccelerator(commandId: Integer): Boolean;
|
|
function HasAcceleratorAt(index: NativeUInt): Boolean;
|
|
function SetAccelerator(commandId, keyCode: Integer; shiftPressed, ctrlPressed, altPressed: Boolean): Boolean;
|
|
function SetAcceleratorAt(index: NativeUInt; keyCode: Integer; shiftPressed, ctrlPressed, altPressed: Boolean): Boolean;
|
|
function RemoveAccelerator(commandId: Integer): Boolean;
|
|
function RemoveAcceleratorAt(index: NativeUInt): Boolean;
|
|
function GetAccelerator(commandId: Integer; out keyCode: Integer; out shiftPressed, ctrlPressed, altPressed: Boolean): Boolean;
|
|
function GetAcceleratorAt(index: NativeUInt; out keyCode: Integer; out shiftPressed, ctrlPressed, altPressed: Boolean): Boolean;
|
|
function SetColor(commandId: Integer; colorType: TCefMenuColorType; color: TCefColor): Boolean;
|
|
function SetColorAt(index: Integer; colorType: TCefMenuColorType; color: TCefColor): Boolean;
|
|
function GetColor(commandId: Integer; colorType: TCefMenuColorType; out color: TCefColor): Boolean;
|
|
function GetColorAt(index: Integer; colorType: TCefMenuColorType; out color: TCefColor): Boolean;
|
|
function SetFontList(commandId: Integer; const fontList: ustring): Boolean;
|
|
function SetFontListAt(index: Integer; const fontList: ustring): Boolean;
|
|
end;
|
|
|
|
// TCefValue
|
|
// /include/capi/cef_values_capi.h (cef_value_t)
|
|
ICefValue = interface(ICefBaseRefCounted)
|
|
['{66F9F439-B12B-4EC3-A945-91AE4EF4D4BA}']
|
|
function IsValid: Boolean;
|
|
function IsOwned: Boolean;
|
|
function IsReadOnly: Boolean;
|
|
function IsSame(const that: ICefValue): Boolean;
|
|
function IsEqual(const that: ICefValue): Boolean;
|
|
function Copy: ICefValue;
|
|
function GetType: TCefValueType;
|
|
function GetBool: Boolean;
|
|
function GetInt: Integer;
|
|
function GetDouble: Double;
|
|
function GetString: ustring;
|
|
function GetBinary: ICefBinaryValue;
|
|
function GetDictionary: ICefDictionaryValue;
|
|
function GetList: ICefListValue;
|
|
function SetNull: Boolean;
|
|
function SetBool(value: boolean): Boolean;
|
|
function SetInt(value: Integer): Boolean;
|
|
function SetDouble(value: Double): Boolean;
|
|
function SetString(const value: ustring): Boolean;
|
|
function SetBinary(const value: ICefBinaryValue): Boolean;
|
|
function SetDictionary(const value: ICefDictionaryValue): Boolean;
|
|
function SetList(const value: ICefListValue): Boolean;
|
|
end;
|
|
|
|
// TCefBinaryValue
|
|
// /include/capi/cef_values_capi.h (cef_binary_value_t)
|
|
ICefBinaryValue = interface(ICefBaseRefCounted)
|
|
['{974AA40A-9C5C-4726-81F0-9F0D46D7C5B3}']
|
|
function IsValid: Boolean;
|
|
function IsOwned: Boolean;
|
|
function IsSame(const that: ICefBinaryValue): Boolean;
|
|
function IsEqual(const that: ICefBinaryValue): Boolean;
|
|
function Copy: ICefBinaryValue;
|
|
function GetSize: NativeUInt;
|
|
function GetData(buffer: Pointer; bufferSize, dataOffset: NativeUInt): NativeUInt;
|
|
|
|
property Size : NativeUInt read GetSize;
|
|
end;
|
|
|
|
// TCefDictionaryValue
|
|
// /include/capi/cef_values_capi.h (cef_dictionary_value_t)
|
|
ICefDictionaryValue = interface(ICefBaseRefCounted)
|
|
['{B9638559-54DC-498C-8185-233EEF12BC69}']
|
|
function IsValid: Boolean;
|
|
function isOwned: Boolean;
|
|
function IsReadOnly: Boolean;
|
|
function IsSame(const that: ICefDictionaryValue): Boolean;
|
|
function IsEqual(const that: ICefDictionaryValue): Boolean;
|
|
function Copy(excludeEmptyChildren: Boolean): ICefDictionaryValue;
|
|
function GetSize: NativeUInt;
|
|
function Clear: Boolean;
|
|
function HasKey(const key: ustring): Boolean;
|
|
function GetKeys(const keys: TStrings): Boolean;
|
|
function Remove(const key: ustring): Boolean;
|
|
function GetType(const key: ustring): TCefValueType;
|
|
function GetValue(const key: ustring): ICefValue;
|
|
function GetBool(const key: ustring): Boolean;
|
|
function GetInt(const key: ustring): Integer;
|
|
function GetDouble(const key: ustring): Double;
|
|
function GetString(const key: ustring): ustring;
|
|
function GetBinary(const key: ustring): ICefBinaryValue;
|
|
function GetDictionary(const key: ustring): ICefDictionaryValue;
|
|
function GetList(const key: ustring): ICefListValue;
|
|
function SetValue(const key: ustring; const value: ICefValue): Boolean;
|
|
function SetNull(const key: ustring): Boolean;
|
|
function SetBool(const key: ustring; value: Boolean): Boolean;
|
|
function SetInt(const key: ustring; value: Integer): Boolean;
|
|
function SetDouble(const key: ustring; value: Double): Boolean;
|
|
function SetString(const key, value: ustring): Boolean;
|
|
function SetBinary(const key: ustring; const value: ICefBinaryValue): Boolean;
|
|
function SetDictionary(const key: ustring; const value: ICefDictionaryValue): Boolean;
|
|
function SetList(const key: ustring; const value: ICefListValue): Boolean;
|
|
end;
|
|
|
|
// TCefListValue
|
|
// /include/capi/cef_values_capi.h (cef_list_value_t)
|
|
ICefListValue = interface(ICefBaseRefCounted)
|
|
['{09174B9D-0CC6-4360-BBB0-3CC0117F70F6}']
|
|
function IsValid: Boolean;
|
|
function IsOwned: Boolean;
|
|
function IsReadOnly: Boolean;
|
|
function IsSame(const that: ICefListValue): Boolean;
|
|
function IsEqual(const that: ICefListValue): Boolean;
|
|
function Copy: ICefListValue;
|
|
function SetSize(size: NativeUInt): Boolean;
|
|
function GetSize: NativeUInt;
|
|
function Clear: Boolean;
|
|
function Remove(index: NativeUInt): Boolean;
|
|
function GetType(index: NativeUInt): TCefValueType;
|
|
function GetValue(index: NativeUInt): ICefValue;
|
|
function GetBool(index: NativeUInt): Boolean;
|
|
function GetInt(index: NativeUInt): Integer;
|
|
function GetDouble(index: NativeUInt): Double;
|
|
function GetString(index: NativeUInt): ustring;
|
|
function GetBinary(index: NativeUInt): ICefBinaryValue;
|
|
function GetDictionary(index: NativeUInt): ICefDictionaryValue;
|
|
function GetList(index: NativeUInt): ICefListValue;
|
|
function SetValue(index: NativeUInt; const value: ICefValue): Boolean;
|
|
function SetNull(index: NativeUInt): Boolean;
|
|
function SetBool(index: NativeUInt; value: Boolean): Boolean;
|
|
function SetInt(index: NativeUInt; value: Integer): Boolean;
|
|
function SetDouble(index: NativeUInt; value: Double): Boolean;
|
|
function SetString(index: NativeUInt; const value: ustring): Boolean;
|
|
function SetBinary(index: NativeUInt; const value: ICefBinaryValue): Boolean;
|
|
function SetDictionary(index: NativeUInt; const value: ICefDictionaryValue): Boolean;
|
|
function SetList(index: NativeUInt; const value: ICefListValue): Boolean;
|
|
end;
|
|
|
|
// TCefLifeSpanHandler
|
|
// /include/capi/cef_life_span_handler_capi.h (cef_life_span_handler_t)
|
|
ICefLifeSpanHandler = interface(ICefBaseRefCounted)
|
|
['{0A3EB782-A319-4C35-9B46-09B2834D7169}']
|
|
function OnBeforePopup(const browser: ICefBrowser; const frame: ICefFrame; const targetUrl, targetFrameName: ustring; targetDisposition: TCefWindowOpenDisposition; userGesture: Boolean; const popupFeatures: TCefPopupFeatures; var windowInfo: TCefWindowInfo; var client: ICefClient; var settings: TCefBrowserSettings; var extra_info: ICefDictionaryValue; var noJavascriptAccess: Boolean): Boolean;
|
|
procedure OnAfterCreated(const browser: ICefBrowser);
|
|
function DoClose(const browser: ICefBrowser): Boolean;
|
|
procedure OnBeforeClose(const browser: ICefBrowser);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefCommandHandler
|
|
// /include/capi/cef_command_handler_capi.h (cef_command_handler_t)
|
|
ICefCommandHandler = interface(ICefBaseRefCounted)
|
|
['{7C931B93-53DC-4607-AABB-2CB4AEF7FB96}']
|
|
function OnChromeCommand(const browser: ICefBrowser; command_id: integer; disposition: TCefWindowOpenDisposition): boolean;
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefGetExtensionResourceCallback
|
|
// /include/capi/cef_extension_handler_capi.h (cef_get_extension_resource_callback_t)
|
|
ICefGetExtensionResourceCallback = interface(ICefBaseRefCounted)
|
|
['{579C8602-8252-40D0-9E0A-501F32C36C42}']
|
|
procedure cont(const stream: ICefStreamReader);
|
|
procedure cancel;
|
|
end;
|
|
|
|
// TCefExtensionHandler
|
|
// /include/capi/cef_extension_handler_capi.h (cef_extension_handler_t)
|
|
ICefExtensionHandler = interface(ICefBaseRefCounted)
|
|
['{3234008F-D809-459D-963D-23BA50219648}']
|
|
procedure OnExtensionLoadFailed(result: TCefErrorcode);
|
|
procedure OnExtensionLoaded(const extension: ICefExtension);
|
|
procedure OnExtensionUnloaded(const extension: ICefExtension);
|
|
function OnBeforeBackgroundBrowser(const extension: ICefExtension; const url: ustring; var client: ICefClient; var settings: TCefBrowserSettings) : boolean;
|
|
function OnBeforeBrowser(const extension: ICefExtension; const browser, active_browser: ICefBrowser; index: Integer; const url: ustring; active: boolean; var windowInfo: TCefWindowInfo; var client: ICefClient; var settings: TCefBrowserSettings) : boolean;
|
|
procedure GetActiveBrowser(const extension: ICefExtension; const browser: ICefBrowser; include_incognito: boolean; var aRsltBrowser: ICefBrowser);
|
|
function CanAccessBrowser(const extension: ICefExtension; const browser: ICefBrowser; include_incognito: boolean; const target_browser: ICefBrowser): boolean;
|
|
function GetExtensionResource(const extension: ICefExtension; const browser: ICefBrowser; const file_: ustring; const callback: ICefGetExtensionResourceCallback): boolean;
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefExtension
|
|
// /include/capi/cef_extension_capi.h (cef_extension_t)
|
|
ICefExtension = interface(ICefBaseRefCounted)
|
|
['{D30D1C64-A26F-49C0-AEB7-C55EC68951CA}']
|
|
function GetIdentifier : ustring;
|
|
function GetPath : ustring;
|
|
function GetManifest : ICefDictionaryValue;
|
|
function IsSame(const that : ICefExtension) : boolean;
|
|
function GetHandler : ICefExtensionHandler;
|
|
function GetLoaderContext : ICefRequestContext;
|
|
function IsLoaded : boolean;
|
|
procedure unload;
|
|
function GetBrowserActionPopup : ustring;
|
|
function GetBrowserActionIcon : ustring;
|
|
function GetPageActionPopup : ustring;
|
|
function GetPageActionIcon : ustring;
|
|
function GetOptionsPage : ustring;
|
|
function GetOptionsUIPage : ustring;
|
|
function GetBackgroundPage : ustring;
|
|
function GetURL : ustring;
|
|
|
|
property Identifier : ustring read GetIdentifier;
|
|
property Path : ustring read GetPath;
|
|
property Manifest : ICefDictionaryValue read GetManifest;
|
|
property Handler : ICefExtensionHandler read GetHandler;
|
|
property LoaderContext : ICefRequestContext read GetLoaderContext;
|
|
property BrowserActionPopup : ustring read GetBrowserActionPopup;
|
|
property BrowserActionIcon : ustring read GetBrowserActionIcon;
|
|
property PageActionPopup : ustring read GetPageActionPopup;
|
|
property PageActionIcon : ustring read GetPageActionIcon;
|
|
property OptionsPage : ustring read GetOptionsPage;
|
|
property OptionsUIPage : ustring read GetOptionsUIPage;
|
|
property BackgroundPage : ustring read GetBackgroundPage;
|
|
property URL : ustring read GetURL;
|
|
end;
|
|
|
|
// TCefLoadHandler
|
|
// /include/capi/cef_load_handler_capi.h (cef_load_handler_t)
|
|
ICefLoadHandler = interface(ICefBaseRefCounted)
|
|
['{2C63FB82-345D-4A5B-9858-5AE7A85C9F49}']
|
|
procedure OnLoadingStateChange(const browser: ICefBrowser; isLoading, canGoBack, canGoForward: Boolean);
|
|
procedure OnLoadStart(const browser: ICefBrowser; const frame: ICefFrame; transitionType: TCefTransitionType);
|
|
procedure OnLoadEnd(const browser: ICefBrowser; const frame: ICefFrame; httpStatusCode: Integer);
|
|
procedure OnLoadError(const browser: ICefBrowser; const frame: ICefFrame; errorCode: Integer; const errorText, failedUrl: ustring);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefResponseFilter
|
|
// /include/capi/cef_response_filter_capi.h (cef_response_filter_t)
|
|
ICefResponseFilter = interface(ICefBaseRefCounted)
|
|
['{5013BC3C-F1AE-407A-A571-A4C6B1D6831E}']
|
|
function InitFilter: Boolean;
|
|
function Filter(data_in: Pointer; data_in_size: NativeUInt; var data_in_read: NativeUInt; data_out: Pointer; data_out_size : NativeUInt; var data_out_written: NativeUInt): TCefResponseFilterStatus;
|
|
end;
|
|
|
|
// TCefRequestHandler
|
|
// /include/capi/cef_request_handler_capi.h (cef_request_handler_t)
|
|
ICefRequestHandler = interface(ICefBaseRefCounted)
|
|
['{050877A9-D1F8-4EB3-B58E-50DC3E3D39FD}']
|
|
function OnBeforeBrowse(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; user_gesture, isRedirect: Boolean): Boolean;
|
|
function OnOpenUrlFromTab(const browser: ICefBrowser; const frame: ICefFrame; const targetUrl: ustring; targetDisposition: TCefWindowOpenDisposition; userGesture: Boolean): Boolean;
|
|
procedure GetResourceRequestHandler(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; is_navigation, is_download: boolean; const request_initiator: ustring; var disable_default_handling: boolean; var aResourceRequestHandler : ICefResourceRequestHandler);
|
|
function GetAuthCredentials(const browser: ICefBrowser; const originUrl: ustring; isProxy: Boolean; const host: ustring; port: Integer; const realm, scheme: ustring; const callback: ICefAuthCallback): Boolean;
|
|
function OnCertificateError(const browser: ICefBrowser; certError: TCefErrorcode; const requestUrl: ustring; const sslInfo: ICefSslInfo; const callback: ICefCallback): Boolean;
|
|
function OnSelectClientCertificate(const browser: ICefBrowser; isProxy: boolean; const host: ustring; port: integer; certificatesCount: NativeUInt; const certificates: TCefX509CertificateArray; const callback: ICefSelectClientCertificateCallback): boolean;
|
|
procedure OnRenderViewReady(const browser: ICefBrowser);
|
|
procedure OnRenderProcessTerminated(const browser: ICefBrowser; status: TCefTerminationStatus);
|
|
procedure OnDocumentAvailableInMainFrame(const browser: ICefBrowser);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefResourceRequestHandler
|
|
// /include/capi/cef_resource_request_handler_capi.h (cef_resource_request_handler_t)
|
|
ICefResourceRequestHandler = interface(ICefBaseRefCounted)
|
|
['{CFA42A38-EA91-4A95-95CE-178BCD412411}']
|
|
procedure GetCookieAccessFilter(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; var aFilter: ICefCookieAccessFilter);
|
|
function OnBeforeResourceLoad(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const callback: ICefCallback): TCefReturnValue;
|
|
procedure GetResourceHandler(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; var aResourceHandler : ICefResourceHandler);
|
|
procedure OnResourceRedirect(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; var newUrl: ustring);
|
|
function OnResourceResponse(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse): Boolean;
|
|
procedure GetResourceResponseFilter(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; var aResourceFilter: ICefResponseFilter);
|
|
procedure OnResourceLoadComplete(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; status: TCefUrlRequestStatus; receivedContentLength: Int64);
|
|
procedure OnProtocolExecution(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; var allowOsExecution: Boolean);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefCookieAccessFilter
|
|
// /include/capi/cef_resource_request_handler_capi.h (cef_cookie_access_filter_t)
|
|
ICefCookieAccessFilter = interface(ICefBaseRefCounted)
|
|
['{65ECD862-F55F-46E4-8AC3-2AE90DCC86F5}']
|
|
function CanSendCookie(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const cookie: PCefCookie): boolean;
|
|
function CanSaveCookie(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; const cookie: PCefCookie): boolean;
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
|
|
// TCefDisplayHandler
|
|
// /include/capi/cef_display_handler_capi.h (cef_display_handler_t)
|
|
ICefDisplayHandler = interface(ICefBaseRefCounted)
|
|
['{1EC7C76D-6969-41D1-B26D-079BCFF054C4}']
|
|
procedure OnAddressChange(const browser: ICefBrowser; const frame: ICefFrame; const url: ustring);
|
|
procedure OnTitleChange(const browser: ICefBrowser; const title: ustring);
|
|
procedure OnFaviconUrlChange(const browser: ICefBrowser; const icon_urls: TStrings);
|
|
procedure OnFullScreenModeChange(const browser: ICefBrowser; fullscreen: Boolean);
|
|
function OnTooltip(const browser: ICefBrowser; var text: ustring): Boolean;
|
|
procedure OnStatusMessage(const browser: ICefBrowser; const value: ustring);
|
|
function OnConsoleMessage(const browser: ICefBrowser; level: TCefLogSeverity; const message_, source: ustring; line: Integer): Boolean;
|
|
function OnAutoResize(const browser: ICefBrowser; const new_size: PCefSize): Boolean;
|
|
procedure OnLoadingProgressChange(const browser: ICefBrowser; const progress: double);
|
|
procedure OnCursorChange(const browser: ICefBrowser; cursor_: TCefCursorHandle; CursorType: TCefCursorType; const customCursorInfo: PCefCursorInfo; var aResult : boolean);
|
|
procedure OnMediaAccessChange(const browser: ICefBrowser; has_video_access, has_audio_access: boolean);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefFocusHandler
|
|
// /include/capi/cef_focus_handler_capi.h (cef_focus_handler_t)
|
|
ICefFocusHandler = interface(ICefBaseRefCounted)
|
|
['{BB7FA3FA-7B1A-4ADC-8E50-12A24018DD90}']
|
|
procedure OnTakeFocus(const browser: ICefBrowser; next: Boolean);
|
|
function OnSetFocus(const browser: ICefBrowser; source: TCefFocusSource): Boolean;
|
|
procedure OnGotFocus(const browser: ICefBrowser);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefKeyboardHandler
|
|
// /include/capi/cef_keyboard_handler_capi.h (cef_keyboard_handler_t)
|
|
ICefKeyboardHandler = interface(ICefBaseRefCounted)
|
|
['{0512F4EC-ED88-44C9-90D3-5C6D03D3B146}']
|
|
function OnPreKeyEvent(const browser: ICefBrowser; const event: PCefKeyEvent; osEvent: TCefEventHandle; out isKeyboardShortcut: Boolean): Boolean;
|
|
function OnKeyEvent(const browser: ICefBrowser; const event: PCefKeyEvent; osEvent: TCefEventHandle): Boolean;
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefJsDialogHandler
|
|
// /include/capi/cef_jsdialog_handler_capi.h (cef_jsdialog_handler_t)
|
|
ICefJsDialogHandler = interface(ICefBaseRefCounted)
|
|
['{64E18F86-DAC5-4ED1-8589-44DE45B9DB56}']
|
|
function OnJsdialog(const browser: ICefBrowser; const originUrl: ustring; dialogType: TCefJsDialogType; const messageText, defaultPromptText: ustring; const callback: ICefJsDialogCallback; out suppressMessage: Boolean): Boolean;
|
|
function OnBeforeUnloadDialog(const browser: ICefBrowser; const messageText: ustring; isReload: Boolean; const callback: ICefJsDialogCallback): Boolean;
|
|
procedure OnResetDialogState(const browser: ICefBrowser);
|
|
procedure OnDialogClosed(const browser: ICefBrowser);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefAudioHandler
|
|
// /include/capi/cef_audio_handler_capi.h (cef_audio_handler_t)
|
|
ICefAudioHandler = interface(ICefBaseRefCounted)
|
|
['{8963271A-0B94-4279-82C8-FB2EA7B3CDEC}']
|
|
procedure OnGetAudioParameters(const browser: ICefBrowser; var params: TCefAudioParameters; var aResult: boolean);
|
|
procedure OnAudioStreamStarted(const browser: ICefBrowser; const params: TCefAudioParameters; channels: integer);
|
|
procedure OnAudioStreamPacket(const browser: ICefBrowser; const data : PPSingle; frames: integer; pts: int64);
|
|
procedure OnAudioStreamStopped(const browser: ICefBrowser);
|
|
procedure OnAudioStreamError(const browser: ICefBrowser; const message_: ustring);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefRunContextMenuCallback
|
|
// /include/capi/cef_context_menu_handler_capi.h (cef_run_context_menu_callback_t)
|
|
ICefRunContextMenuCallback = interface(ICefBaseRefCounted)
|
|
['{44C3C6E3-B64D-4F6E-A318-4A0F3A72EB00}']
|
|
procedure Cont(commandId: Integer; eventFlags: TCefEventFlags);
|
|
procedure Cancel;
|
|
end;
|
|
|
|
// TCefRunContextMenuCallback
|
|
// /include/capi/cef_context_menu_handler_capi.h (cef_run_quick_menu_callback_t)
|
|
ICefRunQuickMenuCallback = interface(ICefBaseRefCounted)
|
|
['{11AD68BF-0055-4106-8F6B-B576F90D812F}']
|
|
procedure Cont(command_id: Integer; event_flags: TCefEventFlags);
|
|
procedure Cancel;
|
|
end;
|
|
|
|
// TCefContextMenuHandler
|
|
// /include/capi/cef_context_menu_handler_capi.h (cef_context_menu_handler_t)
|
|
ICefContextMenuHandler = interface(ICefBaseRefCounted)
|
|
['{C2951895-4087-49D5-BA18-4D9BA4F5EDD7}']
|
|
procedure OnBeforeContextMenu(const browser: ICefBrowser; const frame: ICefFrame; const params: ICefContextMenuParams; const model: ICefMenuModel);
|
|
function RunContextMenu(const browser: ICefBrowser; const frame: ICefFrame; const params: ICefContextMenuParams; const model: ICefMenuModel; const callback: ICefRunContextMenuCallback): Boolean;
|
|
function OnContextMenuCommand(const browser: ICefBrowser; const frame: ICefFrame; const params: ICefContextMenuParams; commandId: Integer; eventFlags: TCefEventFlags): Boolean;
|
|
procedure OnContextMenuDismissed(const browser: ICefBrowser; const frame: ICefFrame);
|
|
function RunQuickMenu(const browser: ICefBrowser; const frame: ICefFrame; location: PCefPoint; size: PCefSize; edit_state_flags: TCefQuickMenuEditStateFlags; const callback: ICefRunQuickMenuCallback): boolean;
|
|
function OnQuickMenuCommand(const browser: ICefBrowser; const frame: ICefFrame; command_id: integer; event_flags: TCefEventFlags): boolean;
|
|
procedure OnQuickMenuDismissed(const browser: ICefBrowser; const frame: ICefFrame);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefAccessibilityHandler
|
|
// /include/capi/cef_accessibility_handler_capi.h (cef_accessibility_handler_t)
|
|
ICefAccessibilityHandler = interface(ICefBaseRefCounted)
|
|
['{1878C3C7-7692-44AB-BFE0-6C387106816B}']
|
|
procedure OnAccessibilityTreeChange(const value: ICefValue);
|
|
procedure OnAccessibilityLocationChange(const value: ICefValue);
|
|
end;
|
|
|
|
// TCefDialogHandler
|
|
// /include/capi/cef_dialog_handler_capi.h (cef_dialog_handler_t)
|
|
ICefDialogHandler = interface(ICefBaseRefCounted)
|
|
['{7763F4B2-8BE1-4E80-AC43-8B825850DC67}']
|
|
function OnFileDialog(const browser: ICefBrowser; mode: TCefFileDialogMode; const title, defaultFilePath: ustring; const acceptFilters: TStrings; const callback: ICefFileDialogCallback): Boolean;
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefRenderHandler
|
|
// /include/capi/cef_render_handler_capi.h (cef_render_handler_t)
|
|
ICefRenderHandler = interface(ICefBaseRefCounted)
|
|
['{1FC1C22B-085A-4741-9366-5249B88EC410}']
|
|
procedure GetAccessibilityHandler(var aAccessibilityHandler : ICefAccessibilityHandler);
|
|
function GetRootScreenRect(const browser: ICefBrowser; var rect: TCefRect): Boolean;
|
|
procedure GetViewRect(const browser: ICefBrowser; var rect: TCefRect);
|
|
function GetScreenPoint(const browser: ICefBrowser; viewX, viewY: Integer; var screenX, screenY: Integer): Boolean;
|
|
function GetScreenInfo(const browser: ICefBrowser; var screenInfo: TCefScreenInfo): Boolean;
|
|
procedure OnPopupShow(const browser: ICefBrowser; show: Boolean);
|
|
procedure OnPopupSize(const browser: ICefBrowser; const rect: PCefRect);
|
|
procedure OnPaint(const browser: ICefBrowser; kind: TCefPaintElementType; dirtyRectsCount: NativeUInt; const dirtyRects: PCefRectArray; const buffer: Pointer; width, height: Integer);
|
|
procedure OnAcceleratedPaint(const browser: ICefBrowser; kind: TCefPaintElementType; dirtyRectsCount: NativeUInt; const dirtyRects: PCefRectArray; shared_handle: Pointer);
|
|
procedure GetTouchHandleSize(const browser: ICefBrowser; orientation: TCefHorizontalAlignment; var size: TCefSize);
|
|
procedure OnTouchHandleStateChanged(const browser: ICefBrowser; const state: TCefTouchHandleState);
|
|
function OnStartDragging(const browser: ICefBrowser; const dragData: ICefDragData; allowedOps: TCefDragOperations; x, y: Integer): Boolean;
|
|
procedure OnUpdateDragCursor(const browser: ICefBrowser; operation: TCefDragOperation);
|
|
procedure OnScrollOffsetChanged(const browser: ICefBrowser; x, y: Double);
|
|
procedure OnIMECompositionRangeChanged(const browser: ICefBrowser; const selected_range: PCefRange; character_boundsCount: NativeUInt; const character_bounds: PCefRect);
|
|
procedure OnTextSelectionChanged(const browser: ICefBrowser; const selected_text: ustring; const selected_range: PCefRange);
|
|
procedure OnVirtualKeyboardRequested(const browser: ICefBrowser; input_mode: TCefTextInpuMode);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefClient
|
|
// /include/capi/cef_client_capi.h (cef_client_t)
|
|
ICefClient = interface(ICefBaseRefCounted)
|
|
['{1D502075-2FF0-4E13-A112-9E541CD811F4}']
|
|
procedure GetAudioHandler(var aHandler : ICefAudioHandler);
|
|
procedure GetCommandHandler(var aHandler : ICefCommandHandler);
|
|
procedure GetContextMenuHandler(var aHandler : ICefContextMenuHandler);
|
|
procedure GetDialogHandler(var aHandler : ICefDialogHandler);
|
|
procedure GetDisplayHandler(var aHandler : ICefDisplayHandler);
|
|
procedure GetDownloadHandler(var aHandler : ICefDownloadHandler);
|
|
procedure GetDragHandler(var aHandler : ICefDragHandler);
|
|
procedure GetFindHandler(var aHandler : ICefFindHandler);
|
|
procedure GetFocusHandler(var aHandler : ICefFocusHandler);
|
|
procedure GetFrameHandler(var aHandler : ICefFrameHandler);
|
|
procedure GetPermissionHandler(var aHandler: ICefPermissionHandler);
|
|
procedure GetJsdialogHandler(var aHandler : ICefJsdialogHandler);
|
|
procedure GetKeyboardHandler(var aHandler : ICefKeyboardHandler);
|
|
procedure GetLifeSpanHandler(var aHandler : ICefLifeSpanHandler);
|
|
procedure GetLoadHandler(var aHandler : ICefLoadHandler);
|
|
procedure GetPrintHandler(var aHandler : ICefPrintHandler);
|
|
procedure GetRenderHandler(var aHandler : ICefRenderHandler);
|
|
procedure GetRequestHandler(var aHandler : ICefRequestHandler);
|
|
function OnProcessMessageReceived(const browser: ICefBrowser; const frame: ICefFrame; sourceProcess: TCefProcessId; const message_ : ICefProcessMessage): Boolean;
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefUrlRequest
|
|
// /include/capi/cef_urlrequest_capi.h (cef_urlrequest_t)
|
|
ICefUrlRequest = interface(ICefBaseRefCounted)
|
|
['{59226AC1-A0FA-4D59-9DF4-A65C42391A67}']
|
|
function GetRequest: ICefRequest;
|
|
function GetRequestStatus: TCefUrlRequestStatus;
|
|
function GetRequestError: Integer;
|
|
function GetResponse: ICefResponse;
|
|
function GetResponseWasCached: boolean;
|
|
procedure Cancel;
|
|
|
|
property Request : ICefRequest read GetRequest;
|
|
property RequestStatus : TCefUrlRequestStatus read GetRequestStatus;
|
|
property RequestError : Integer read GetRequestError;
|
|
property Response : ICefResponse read GetResponse;
|
|
property ResponseWasCached : boolean read GetResponseWasCached;
|
|
end;
|
|
|
|
// TCefUrlrequestClient
|
|
// /include/capi/cef_urlrequest_capi.h (cef_urlrequest_client_t)
|
|
ICefUrlrequestClient = interface(ICefBaseRefCounted)
|
|
['{114155BD-C248-4651-9A4F-26F3F9A4F737}']
|
|
procedure OnRequestComplete(const request: ICefUrlRequest);
|
|
procedure OnUploadProgress(const request: ICefUrlRequest; current, total: Int64);
|
|
procedure OnDownloadProgress(const request: ICefUrlRequest; current, total: Int64);
|
|
procedure OnDownloadData(const request: ICefUrlRequest; data: Pointer; dataLength: NativeUInt);
|
|
function OnGetAuthCredentials(isProxy: Boolean; const host: ustring; port: Integer; const realm, scheme: ustring; const callback: ICefAuthCallback): Boolean;
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefEndTracingCallback
|
|
// /include/capi/cef_trace_capi.h (cef_end_tracing_callback_t)
|
|
ICefEndTracingCallback = interface(ICefBaseRefCounted)
|
|
['{79020EBE-9D1D-49A6-9714-8778FE8929F2}']
|
|
procedure OnEndTracingComplete(const tracingFile: ustring);
|
|
end;
|
|
|
|
// TCefFileDialogCallback
|
|
// /include/capi/cef_dialog_handler_capi.h (cef_file_dialog_callback_t)
|
|
ICefFileDialogCallback = interface(ICefBaseRefCounted)
|
|
['{1AF659AB-4522-4E39-9C52-184000D8E3C7}']
|
|
procedure Cont(const filePaths: TStrings);
|
|
procedure Cancel;
|
|
end;
|
|
|
|
// TCefDragData
|
|
// /include/capi/cef_drag_data_capi.h (cef_drag_data_t)
|
|
ICefDragData = interface(ICefBaseRefCounted)
|
|
['{FBB6A487-F633-4055-AB3E-6619EDE75683}']
|
|
function Clone: ICefDragData;
|
|
function IsReadOnly: Boolean;
|
|
function IsLink: Boolean;
|
|
function IsFragment: Boolean;
|
|
function IsFile: Boolean;
|
|
function GetLinkUrl: ustring;
|
|
function GetLinkTitle: ustring;
|
|
function GetLinkMetadata: ustring;
|
|
function GetFragmentText: ustring;
|
|
function GetFragmentHtml: ustring;
|
|
function GetFragmentBaseUrl: ustring;
|
|
function GetFileName: ustring;
|
|
function GetFileContents(const writer: ICefStreamWriter): NativeUInt;
|
|
function GetFileNames(var names: TStrings): Integer;
|
|
procedure SetLinkUrl(const url: ustring);
|
|
procedure SetLinkTitle(const title: ustring);
|
|
procedure SetLinkMetadata(const data: ustring);
|
|
procedure SetFragmentText(const text: ustring);
|
|
procedure SetFragmentHtml(const html: ustring);
|
|
procedure SetFragmentBaseUrl(const baseUrl: ustring);
|
|
procedure ResetFileContents;
|
|
procedure AddFile(const path, displayName: ustring);
|
|
procedure ClearFilenames;
|
|
function GetImage : ICefImage;
|
|
function GetImageHotspot : TCefPoint;
|
|
function HasImage : boolean;
|
|
end;
|
|
|
|
// TCefDragHandler
|
|
// /include/capi/cef_drag_handler_capi.h (cef_drag_handler_t)
|
|
ICefDragHandler = interface(ICefBaseRefCounted)
|
|
['{59A89579-5B18-489F-A25C-5CC25FF831FC}']
|
|
function OnDragEnter(const browser: ICefBrowser; const dragData: ICefDragData; mask: TCefDragOperations): Boolean;
|
|
procedure OnDraggableRegionsChanged(const browser: ICefBrowser; const frame: ICefFrame; regionsCount: NativeUInt; const regions: PCefDraggableRegionArray);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefFindHandler
|
|
// /include/capi/cef_find_handler_capi.h (cef_find_handler_t)
|
|
ICefFindHandler = interface(ICefBaseRefCounted)
|
|
['{F20DF234-BD43-42B3-A80B-D354A9E5B787}']
|
|
procedure OnFindResult(const browser: ICefBrowser; identifier, count: Integer; const selectionRect: PCefRect; activeMatchOrdinal: Integer; finalUpdate: Boolean);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefRequestContextHandler
|
|
// /include/capi/cef_request_context_handler_capi.h (cef_request_context_handler_t)
|
|
ICefRequestContextHandler = interface(ICefBaseRefCounted)
|
|
['{76EB1FA7-78DF-4FD5-ABB3-1CDD3E73A140}']
|
|
procedure OnRequestContextInitialized(const request_context: ICefRequestContext);
|
|
procedure GetResourceRequestHandler(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; is_navigation, is_download: boolean; const request_initiator: ustring; var disable_default_handling: boolean; var aResourceRequestHandler : ICefResourceRequestHandler);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefResolveCallback
|
|
// /include/capi/cef_request_context_capi.h (cef_resolve_callback_t)
|
|
ICefResolveCallback = interface(ICefBaseRefCounted)
|
|
['{0C0EA252-7968-4163-A1BE-A1453576DD06}']
|
|
procedure OnResolveCompleted(result: TCefErrorCode; const resolvedIps: TStrings);
|
|
end;
|
|
|
|
// TCefPreferenceManager
|
|
// /include/capi/cef_preference_capi.h (cef_preference_manager_t)
|
|
// /include/capi/cef_preference_manager_capi.h (cef_preference_manager_t)
|
|
ICefPreferenceManager = interface(ICefBaseRefCounted)
|
|
['{E8231D35-D028-4E64-BFDB-7E4596027DEC}']
|
|
function HasPreference(const name: ustring): Boolean;
|
|
function GetPreference(const name: ustring): ICefValue;
|
|
function GetAllPreferences(includeDefaults: Boolean): ICefDictionaryValue;
|
|
function CanSetPreference(const name: ustring): Boolean;
|
|
function SetPreference(const name: ustring; const value: ICefValue; out error: ustring): Boolean;
|
|
end;
|
|
|
|
// TCefRequestContext
|
|
// /include/capi/cef_request_context_capi.h (cef_request_context_t)
|
|
ICefRequestContext = interface(ICefPreferenceManager)
|
|
['{5830847A-2971-4BD5-ABE6-21451F8923F7}']
|
|
function IsSame(const other: ICefRequestContext): Boolean;
|
|
function IsSharingWith(const other: ICefRequestContext): Boolean;
|
|
function IsGlobal: Boolean;
|
|
function GetHandler: ICefRequestContextHandler;
|
|
function GetCachePath: ustring;
|
|
function GetCookieManager(const callback: ICefCompletionCallback): ICefCookieManager;
|
|
function GetCookieManagerProc(const callback: TCefCompletionCallbackProc): ICefCookieManager;
|
|
function RegisterSchemeHandlerFactory(const schemeName, domainName: ustring; const factory: ICefSchemeHandlerFactory): Boolean;
|
|
function ClearSchemeHandlerFactories: Boolean;
|
|
procedure ClearCertificateExceptions(const callback: ICefCompletionCallback);
|
|
procedure ClearHttpAuthCredentials(const callback: ICefCompletionCallback);
|
|
procedure CloseAllConnections(const callback: ICefCompletionCallback);
|
|
procedure ResolveHost(const origin: ustring; const callback: ICefResolveCallback);
|
|
procedure LoadExtension(const root_directory: ustring; const manifest: ICefDictionaryValue; const handler: ICefExtensionHandler);
|
|
function DidLoadExtension(const extension_id: ustring): boolean;
|
|
function HasExtension(const extension_id: ustring): boolean;
|
|
function GetExtensions(const extension_ids: TStringList): boolean;
|
|
function GetExtension(const extension_id: ustring): ICefExtension;
|
|
function GetMediaRouter(const callback: ICefCompletionCallback): ICefMediaRouter;
|
|
|
|
property CachePath : ustring read GetCachePath;
|
|
property IsGlobalContext : boolean read IsGlobal;
|
|
end;
|
|
|
|
// TCefPrintSettings
|
|
// /include/capi/cef_print_settings_capi.h (cef_print_settings_t)
|
|
ICefPrintSettings = Interface(ICefBaseRefCounted)
|
|
['{ACBD2395-E9C1-49E5-B7F3-344DAA4A0F12}']
|
|
function IsValid: Boolean;
|
|
function IsReadOnly: Boolean;
|
|
procedure SetOrientation(landscape: Boolean);
|
|
function IsLandscape: Boolean;
|
|
procedure SetPrinterPrintableArea(const physicalSizeDeviceUnits: PCefSize; const printableAreaDeviceUnits: PCefRect; landscapeNeedsFlip: Boolean);
|
|
procedure SetDeviceName(const name: ustring);
|
|
function GetDeviceName: ustring;
|
|
procedure SetDpi(dpi: Integer);
|
|
function GetDpi: Integer;
|
|
procedure SetPageRanges(const ranges: TCefRangeArray);
|
|
function GetPageRangesCount: NativeUInt;
|
|
procedure GetPageRanges(out ranges: TCefRangeArray);
|
|
procedure SetSelectionOnly(selectionOnly: Boolean);
|
|
function IsSelectionOnly: Boolean;
|
|
procedure SetCollate(collate: Boolean);
|
|
function WillCollate: Boolean;
|
|
procedure SetColorModel(model: TCefColorModel);
|
|
function GetColorModel: TCefColorModel;
|
|
procedure SetCopies(copies: Integer);
|
|
function GetCopies: Integer;
|
|
procedure SetDuplexMode(mode: TCefDuplexMode);
|
|
function GetDuplexMode: TCefDuplexMode;
|
|
|
|
property Landscape : Boolean read IsLandscape write SetOrientation;
|
|
property DeviceName : ustring read GetDeviceName write SetDeviceName;
|
|
property Dpi : Integer read GetDpi write SetDpi;
|
|
property SelectionOnly : Boolean read IsSelectionOnly write SetSelectionOnly;
|
|
property Collate : Boolean read WillCollate write SetCollate;
|
|
property ColorModel : TCefColorModel read GetColorModel write SetColorModel;
|
|
property Copies : Integer read GetCopies write SetCopies;
|
|
property DuplexMode : TCefDuplexMode read GetDuplexMode write SetDuplexMode;
|
|
end;
|
|
|
|
// TCefPrintDialogCallback
|
|
// /include/capi/cef_print_handler_capi.h (cef_print_dialog_callback_t)
|
|
ICefPrintDialogCallback = interface(ICefBaseRefCounted)
|
|
['{1D7FB71E-0019-4A80-95ED-91DDD019253B}']
|
|
procedure cont(const settings: ICefPrintSettings);
|
|
procedure cancel;
|
|
end;
|
|
|
|
// TCefPrintJobCallback
|
|
// /include/capi/cef_print_handler_capi.h (cef_print_job_callback_t)
|
|
ICefPrintJobCallback = interface(ICefBaseRefCounted)
|
|
['{5554852A-052C-464B-A868-B618C7E7E2FD}']
|
|
procedure cont;
|
|
end;
|
|
|
|
// TCefPrintHandler
|
|
// /include/capi/cef_print_handler_capi.h (cef_print_handler_t)
|
|
ICefPrintHandler = interface(ICefBaseRefCounted)
|
|
['{2831D5C9-6E2B-4A30-A65A-0F4435371EFC}']
|
|
procedure OnPrintStart(const browser: ICefBrowser);
|
|
procedure OnPrintSettings(const browser: ICefBrowser; const settings: ICefPrintSettings; getDefaults: boolean);
|
|
procedure OnPrintDialog(const browser: ICefBrowser; hasSelection: boolean; const callback: ICefPrintDialogCallback; var aResult: boolean);
|
|
procedure OnPrintJob(const browser: ICefBrowser; const documentName, PDFFilePath: ustring; const callback: ICefPrintJobCallback; var aResult: boolean);
|
|
procedure OnPrintReset(const browser: ICefBrowser);
|
|
procedure GetPDFPaperSize(const browser: ICefBrowser; deviceUnitsPerInch: integer; var aResult: TCefSize);
|
|
|
|
procedure RemoveReferences; // custom procedure to clear all references
|
|
end;
|
|
|
|
// TCefNavigationEntry
|
|
// /include/capi/cef_navigation_entry_capi.h (cef_navigation_entry_t)
|
|
ICefNavigationEntry = interface(ICefBaseRefCounted)
|
|
['{D17B4B37-AA45-42D9-B4E4-AAB6FE2AB297}']
|
|
function IsValid: Boolean;
|
|
function GetUrl: ustring;
|
|
function GetDisplayUrl: ustring;
|
|
function GetOriginalUrl: ustring;
|
|
function GetTitle: ustring;
|
|
function GetTransitionType: TCefTransitionType;
|
|
function HasPostData: Boolean;
|
|
function GetCompletionTime: TDateTime;
|
|
function GetHttpStatusCode: Integer;
|
|
function GetSSLStatus: ICefSSLStatus;
|
|
|
|
property Url : ustring read GetUrl;
|
|
property DisplayUrl : ustring read GetDisplayUrl;
|
|
property OriginalUrl : ustring read GetOriginalUrl;
|
|
property Title : ustring read GetTitle;
|
|
property TransitionType : TCefTransitionType read GetTransitionType;
|
|
property CompletionTime : TDateTime read GetCompletionTime;
|
|
property HttpStatusCode : Integer read GetHttpStatusCode;
|
|
property SSLStatus : ICefSSLStatus read GetSSLStatus;
|
|
end;
|
|
|
|
// TCefX509CertPrincipal
|
|
// /include/capi/cef_x509_certificate_capi.h (cef_x509cert_principal_t)
|
|
ICefX509CertPrincipal = interface(ICefBaseRefCounted)
|
|
['{CD3621ED-7D68-4A1F-95B5-190C7001B65F}']
|
|
function GetDisplayName: ustring;
|
|
function GetCommonName: ustring;
|
|
function GetLocalityName: ustring;
|
|
function GetStateOrProvinceName: ustring;
|
|
function GetCountryName: ustring;
|
|
procedure GetStreetAddresses(const addresses: TStrings);
|
|
procedure GetOrganizationNames(const names: TStrings);
|
|
procedure GetOrganizationUnitNames(const names: TStrings);
|
|
procedure GetDomainComponents(const components: TStrings);
|
|
end;
|
|
|
|
// TCefX509Certificate
|
|
// /include/capi/cef_x509_certificate_capi.h (cef_x509certificate_t)
|
|
ICefX509Certificate = interface(ICefBaseRefCounted)
|
|
['{C897979D-F068-4428-82DF-4221612FF7E0}']
|
|
function GetSubject: ICefX509CertPrincipal;
|
|
function GetIssuer: ICefX509CertPrincipal;
|
|
function GetSerialNumber: ICefBinaryValue;
|
|
function GetValidStart: TCefBaseTime;
|
|
function GetValidExpiry: TCefBaseTime;
|
|
function GetValidStartAsDateTime: TDateTime;
|
|
function GetValidExpiryAsDateTime: TDateTime;
|
|
function GetDerEncoded: ICefBinaryValue;
|
|
function GetPemEncoded: ICefBinaryValue;
|
|
function GetIssuerChainSize: NativeUInt;
|
|
procedure GetDEREncodedIssuerChain(chainCount: NativeUInt; var chain : TCefBinaryValueArray);
|
|
procedure GetPEMEncodedIssuerChain(chainCount: NativeUInt; var chain : TCefBinaryValueArray);
|
|
end;
|
|
|
|
// TCefSslInfo
|
|
// /include/capi/cef_ssl_info_capi.h (cef_sslinfo_t)
|
|
ICefSslInfo = interface(ICefBaseRefCounted)
|
|
['{67EC86BD-DE7D-453D-908F-AD15626C514F}']
|
|
function GetCertStatus: TCefCertStatus;
|
|
function GetX509Certificate: ICefX509Certificate;
|
|
end;
|
|
|
|
// TCefSSLStatus
|
|
// /include/capi/cef_ssl_status_capi.h (cef_sslstatus_t)
|
|
ICefSSLStatus = interface(ICefBaseRefCounted)
|
|
['{E3F004F2-03D5-46A2-91D0-510C50F3B225}']
|
|
function IsSecureConnection: boolean;
|
|
function GetCertStatus: TCefCertStatus;
|
|
function GetSSLVersion: TCefSSLVersion;
|
|
function GetContentStatus: TCefSSLContentStatus;
|
|
function GetX509Certificate: ICefX509Certificate;
|
|
end;
|
|
|
|
// TCefSelectClientCertificateCallback
|
|
// /include/capi/cef_request_handler_capi.h (cef_select_client_certificate_callback_t)
|
|
ICefSelectClientCertificateCallback = interface(ICefBaseRefCounted)
|
|
['{003E3D09-ADE8-4C6E-A174-079D3D616608}']
|
|
procedure Select(const cert: ICefX509Certificate);
|
|
end;
|
|
|
|
// TCefResourceBundle
|
|
// /include/capi/cef_resource_bundle_capi.h (cef_resource_bundle_t)
|
|
ICefResourceBundle = interface(ICefBaseRefCounted)
|
|
['{3213CF97-C854-452B-B615-39192F8D07DC}']
|
|
function GetLocalizedString(stringId: Integer): ustring;
|
|
function GetDataResource(resourceId: Integer): ICefBinaryValue;
|
|
function GetDataResourceForScale(resourceId: Integer; scaleFactor: TCefScaleFactor): ICefBinaryValue;
|
|
end;
|
|
|
|
// TCefImage
|
|
// /include/capi/cef_image_capi.h (cef_image_t)
|
|
ICefImage = interface(ICefBaseRefCounted)
|
|
['{E2C2F424-26A2-4498-BB45-DA23219831BE}']
|
|
function IsEmpty: Boolean;
|
|
function IsSame(const that: ICefImage): Boolean;
|
|
function AddBitmap(scaleFactor: Single; pixelWidth, pixelHeight: Integer; colorType: TCefColorType; alphaType: TCefAlphaType; const pixelData: Pointer; pixelDataSize: NativeUInt): Boolean;
|
|
function AddPng(scaleFactor: Single; const pngData: Pointer; pngDataSize: NativeUInt): Boolean;
|
|
function AddJpeg(scaleFactor: Single; const jpegData: Pointer; jpegDataSize: NativeUInt): Boolean;
|
|
function GetWidth: NativeUInt;
|
|
function GetHeight: NativeUInt;
|
|
function HasRepresentation(scaleFactor: Single): Boolean;
|
|
function RemoveRepresentation(scaleFactor: Single): Boolean;
|
|
function GetRepresentationInfo(scaleFactor: Single; var actualScaleFactor: Single; var pixelWidth, pixelHeight: Integer): Boolean;
|
|
function GetAsBitmap(scaleFactor: Single; colorType: TCefColorType; alphaType: TCefAlphaType; var pixelWidth, pixelHeight: Integer): ICefBinaryValue;
|
|
function GetAsPng(scaleFactor: Single; withTransparency: Boolean; var pixelWidth, pixelHeight: Integer): ICefBinaryValue;
|
|
function GetAsJpeg(scaleFactor: Single; quality: Integer; var pixelWidth, pixelHeight: Integer): ICefBinaryValue;
|
|
|
|
property Width : NativeUInt read GetWidth;
|
|
property Height : NativeUInt read GetHeight;
|
|
end;
|
|
|
|
// TCefMenuModelDelegate
|
|
// /include/capi/cef_menu_model_delegate_capi.h (cef_menu_model_delegate_t)
|
|
ICefMenuModelDelegate = interface(ICefBaseRefCounted)
|
|
['{1430D202-2795-433E-9A35-C79A0996F316}']
|
|
procedure ExecuteCommand(const menuModel: ICefMenuModel; commandId: Integer; eventFlags: TCefEventFlags);
|
|
procedure MouseOutsideMenu(const menuModel: ICefMenuModel; const screenPoint: PCefPoint);
|
|
procedure UnhandledOpenSubmenu(const menuModel: ICefMenuModel; isRTL: boolean);
|
|
procedure UnhandledCloseSubmenu(const menuModel: ICefMenuModel; isRTL: boolean);
|
|
procedure MenuWillShow(const menuModel: ICefMenuModel);
|
|
procedure MenuClosed(const menuModel: ICefMenuModel);
|
|
function FormatLabel(const menuModel: ICefMenuModel; var label_ : ustring) : boolean;
|
|
end;
|
|
|
|
// TCefServer
|
|
// /include/capi/cef_server_capi.h (cef_server_t)
|
|
ICefServer = interface(ICefBaseRefCounted)
|
|
['{41D41764-A74B-4552-B166-C77E70549047}']
|
|
function GetTaskRunner : ICefTaskRunner;
|
|
procedure Shutdown;
|
|
function IsRunning : boolean;
|
|
function GetAddress : ustring;
|
|
function HasConnection : boolean;
|
|
function IsValidConnection(connection_id: Integer) : boolean;
|
|
procedure SendHttp200response(connection_id: Integer; const content_type: ustring; const data: Pointer; data_size: NativeUInt);
|
|
procedure SendHttp404response(connection_id: Integer);
|
|
procedure SendHttp500response(connection_id: Integer; const error_message: ustring);
|
|
procedure SendHttpResponse(connection_id, response_code: Integer; const content_type: ustring; content_length: int64; const extra_headers: ICefStringMultimap);
|
|
procedure SendRawData(connection_id: Integer; const data: Pointer; data_size: NativeUInt);
|
|
procedure CloseConnection(connection_id: Integer);
|
|
procedure SendWebSocketMessage(connection_id: Integer; const data: Pointer; data_size: NativeUInt);
|
|
end;
|
|
|
|
// TCefServerHandler
|
|
// /include/capi/cef_server_capi.h (cef_server_handler_t)
|
|
ICefServerHandler = interface(ICefBaseRefCounted)
|
|
['{AFB64A63-44C9-44CD-959B-D8E20F549879}']
|
|
procedure OnServerCreated(const server: ICefServer);
|
|
procedure OnServerDestroyed(const server: ICefServer);
|
|
procedure OnClientConnected(const server: ICefServer; connection_id: Integer);
|
|
procedure OnClientDisconnected(const server: ICefServer; connection_id: Integer);
|
|
procedure OnHttpRequest(const server: ICefServer; connection_id: Integer; const client_address: ustring; const request: ICefRequest);
|
|
procedure OnWebSocketRequest(const server: ICefServer; connection_id: Integer; const client_address: ustring; const request: ICefRequest; const callback: ICefCallback);
|
|
procedure OnWebSocketConnected(const server: ICefServer; connection_id: Integer);
|
|
procedure OnWebSocketMessage(const server: ICefServer; connection_id: Integer; const data: Pointer; data_size: NativeUInt);
|
|
end;
|
|
|
|
// TCefMediaAccessCallback
|
|
// This interface is declared twice with almost identical parameters. "allowed_permissions" is defined as int and uint32.
|
|
// /include/capi/cef_media_access_handler_capi.h (cef_media_access_callback_t)
|
|
// /include/capi/cef_permission_handler_capi.h (cef_media_access_callback_t)
|
|
ICefMediaAccessCallback = interface(ICefBaseRefCounted)
|
|
['{66F6F5F4-8489-408B-B9ED-6B705C2E2010}']
|
|
procedure cont(allowed_permissions: TCefMediaAccessPermissionTypes);
|
|
procedure cancel;
|
|
end;
|
|
|
|
// TCefMediaAccessHandler
|
|
// /include/capi/cef_media_access_handler_capi.h (cef_media_access_handler_t)
|
|
ICefMediaAccessHandler = interface(ICefBaseRefCounted)
|
|
['{8ED04C4A-05F2-46FD-89C4-E6114000D219}']
|
|
function OnRequestMediaAccessPermission(const browser: ICefBrowser; const frame: ICefFrame; const requesting_url: ustring; requested_permissions: TCefMediaAccessPermissionTypes; const callback: ICefMediaAccessCallback): boolean;
|
|
|
|
procedure RemoveReferences;
|
|
end;
|
|
|
|
// TCefPermissionPromptCallback
|
|
// /include/capi/cef_permission_handler_capi.h (cef_permission_prompt_callback_t)
|
|
ICefPermissionPromptCallback = interface(ICefBaseRefCounted)
|
|
['{F8827C7D-7B14-499E-B38A-5F9FEB1FD6A6}']
|
|
procedure cont(result: TCefPermissionRequestResult);
|
|
end;
|
|
|
|
// TCefPermissionHandler
|
|
// /include/capi/cef_permission_handler_capi.h (cef_permission_handler_t)
|
|
ICefPermissionHandler = interface(ICefBaseRefCounted)
|
|
['{DC079268-FB08-44DA-B216-35C5C339B341}']
|
|
function OnRequestMediaAccessPermission(const browser: ICefBrowser; const frame: ICefFrame; const requesting_origin: ustring; requested_permissions: cardinal; const callback: ICefMediaAccessCallback): boolean;
|
|
function OnShowPermissionPrompt(const browser: ICefBrowser; prompt_id: uint64; const requesting_origin: ustring; requested_permissions: cardinal; const callback: ICefPermissionPromptCallback): boolean;
|
|
procedure OnDismissPermissionPrompt(const browser: ICefBrowser; prompt_id: uint64; result: TCefPermissionRequestResult);
|
|
|
|
procedure RemoveReferences;
|
|
end;
|
|
|
|
// TCefSharedMemoryRegion
|
|
// /include/capi/cef_shared_memory_region_capi.h (cef_shared_memory_region_t)
|
|
ICefSharedMemoryRegion = interface(ICefBaseRefCounted)
|
|
['{2828D0E1-44D0-4C6F-8C63-5CA6036DDA82}']
|
|
function IsValid: boolean;
|
|
function Size: NativeUInt;
|
|
function Memory: pointer;
|
|
end;
|
|
|
|
// TCefSharedProcessMessageBuilder
|
|
// /include/capi/cef_shared_process_message_builder_capi.h (cef_shared_process_message_builder_t)
|
|
ICefSharedProcessMessageBuilder = interface(ICefBaseRefCounted)
|
|
['{B2AF627F-33FA-44F1-B943-FC4F120C84F8}']
|
|
function IsValid: boolean;
|
|
function Size: NativeUInt;
|
|
function Memory: pointer;
|
|
function Build: ICefProcessMessage;
|
|
end;
|
|
|
|
|
|
|
|
// *********************************
|
|
// ************* Views *************
|
|
// *********************************
|
|
|
|
// TCefDisplay
|
|
// /include/capi/views/cef_display_capi.h (cef_display_t)
|
|
ICefDisplay = interface(ICefBaseRefCounted)
|
|
['{EC2D3606-DB4C-4894-8D38-B8F99E091965}']
|
|
function GetID : int64;
|
|
function GetDeviceScaleFactor : Single;
|
|
procedure ConvertPointToPixels(var point: TCefPoint);
|
|
procedure ConvertPointFromPixels(var point: TCefPoint);
|
|
function GetBounds : TCefRect;
|
|
function GetWorkArea : TCefRect;
|
|
function GetRotation : Integer;
|
|
|
|
property ID : int64 read GetID;
|
|
property DeviceScaleFactor : Single read GetDeviceScaleFactor;
|
|
property Bounds : TCefRect read GetBounds;
|
|
property WorkArea : TCefRect read GetWorkArea;
|
|
property Rotation : Integer read GetRotation;
|
|
end;
|
|
|
|
// TCefLayout
|
|
// /include/capi/views/cef_layout_capi.h (cef_layout_t)
|
|
ICefLayout = interface(ICefBaseRefCounted)
|
|
['{0EC7AE4B-1672-4D0B-B617-0BDA72F3C7F4}']
|
|
function AsBoxLayout : ICefBoxLayout;
|
|
function AsFillLayout : ICefFillLayout;
|
|
function IsValid : boolean;
|
|
|
|
property Valid : boolean read IsValid;
|
|
end;
|
|
|
|
// TCefBoxLayout
|
|
// /include/capi/views/cef_box_layout_capi.h (cef_box_layout_t)
|
|
ICefBoxLayout = interface(ICefLayout)
|
|
['{E59FCCAE-A371-4C21-98D3-93D3217016AE}']
|
|
procedure SetFlexForView(const view: ICefView; flex: Integer);
|
|
procedure ClearFlexForView(const view: ICefView);
|
|
end;
|
|
|
|
// TCefFillLayout
|
|
// /include/capi/views/cef_fill_layout_capi.h (cef_fill_layout_t)
|
|
ICefFillLayout = interface(ICefLayout)
|
|
['{3DB214F2-7F27-4306-82C9-8166160422B1}']
|
|
end;
|
|
|
|
// TCefOverlayController
|
|
// /include/capi/views/cef_overlay_controller_capi.h (cef_overlay_controller_t)
|
|
ICefOverlayController = interface(ICefBaseRefCounted)
|
|
['{13E1F3D2-32FF-4D30-A30E-D67B6A4846AB}']
|
|
function IsValid: boolean;
|
|
function IsSame(const that: ICefOverlayController): boolean;
|
|
function GetContentsView: ICefView;
|
|
function GetWindow: ICefWindow;
|
|
function GetDockingMode: TCefDockingMode;
|
|
procedure DestroyOverlay;
|
|
procedure SetBounds(const bounds: TCefRect);
|
|
function GetBounds: TCefRect;
|
|
function GetBoundsInScreen: TCefRect;
|
|
procedure SetSize(const size: TCefSize);
|
|
function GetSize: TCefSize;
|
|
procedure SetPosition(const position: TCefPoint);
|
|
function GetPosition: TCefPoint;
|
|
procedure SetInsets(const insets: TCefInsets);
|
|
function GetInsets: TCefInsets;
|
|
procedure SizeToPreferredSize;
|
|
procedure SetVisible(visible: boolean);
|
|
function IsVisible: boolean;
|
|
function IsDrawn: boolean;
|
|
property ContentsView : ICefView read GetContentsView;
|
|
property Window : ICefWindow read GetWindow;
|
|
property DockingMode : TCefDockingMode read GetDockingMode;
|
|
property Bounds : TCefRect read GetBounds write SetBounds;
|
|
property BoundsInScreen : TCefRect read GetBoundsInScreen;
|
|
property Size : TCefSize read GetSize write SetSize;
|
|
property Position : TCefPoint read GetPosition write SetPosition;
|
|
property Insets : TCefInsets read GetInsets write SetInsets;
|
|
property Visible : boolean read IsVisible write SetVisible;
|
|
property Drawn : boolean read IsDrawn;
|
|
end;
|
|
|
|
// TCefView
|
|
// /include/capi/views/cef_view_capi.h (cef_view_t)
|
|
ICefView = interface(ICefBaseRefCounted)
|
|
['{E9AF950A-F4E8-420C-BD1F-F26F4FDFA48D}']
|
|
function AsBrowserView : ICefBrowserView;
|
|
function AsButton : ICefButton;
|
|
function AsPanel : ICefPanel;
|
|
function AsScrollView : ICefScrollView;
|
|
function AsTextfield : ICefTextfield;
|
|
function GetTypeString : ustring;
|
|
function ToStringEx(include_children: boolean): ustring;
|
|
function IsValid : boolean;
|
|
function IsAttached : boolean;
|
|
function IsSame(const that: ICefView): boolean;
|
|
function GetDelegate : ICefViewDelegate;
|
|
function GetWindow : ICefWindow;
|
|
function GetID : Integer;
|
|
procedure SetID(id_: Integer);
|
|
function GetGroupID : Integer;
|
|
procedure SetGroupID(group_id: Integer);
|
|
function GetParentView : ICefView;
|
|
function GetViewForID(id_: Integer): ICefView;
|
|
procedure SetBounds(const bounds_: TCefRect);
|
|
function GetBounds : TCefRect;
|
|
function GetBoundsInScreen : TCefRect;
|
|
procedure SetSize(const size_: TCefSize);
|
|
function GetSize : TCefSize;
|
|
procedure SetPosition(const position_: TCefPoint);
|
|
function GetPosition : TCefPoint;
|
|
procedure SetInsets(const insets: TCefInsets);
|
|
function GetInsets: TCefInsets;
|
|
function GetPreferredSize : TCefSize;
|
|
procedure SizeToPreferredSize;
|
|
function GetMinimumSize : TCefSize;
|
|
function GetMaximumSize : TCefSize;
|
|
function GetHeightForWidth(width: Integer): Integer;
|
|
procedure InvalidateLayout;
|
|
procedure SetVisible(visible_: boolean);
|
|
function IsVisible : boolean;
|
|
function IsDrawn : boolean;
|
|
procedure SetEnabled(enabled_: boolean);
|
|
function IsEnabled : boolean;
|
|
procedure SetFocusable(focusable_: boolean);
|
|
function IsFocusable : boolean;
|
|
function IsAccessibilityFocusable : boolean;
|
|
procedure RequestFocus;
|
|
procedure SetBackgroundColor(color: TCefColor);
|
|
function GetBackgroundColor : TCefColor;
|
|
function ConvertPointToScreen(var point: TCefPoint): boolean;
|
|
function ConvertPointFromScreen(var point: TCefPoint): boolean;
|
|
function ConvertPointToWindow(var point: TCefPoint): boolean;
|
|
function ConvertPointFromWindow(var point: TCefPoint): boolean;
|
|
function ConvertPointToView(const view : ICefView; var point: TCefPoint): boolean;
|
|
function ConvertPointFromView(const view : ICefView; var point: TCefPoint): boolean;
|
|
|
|
property Valid : boolean read IsValid;
|
|
property Attached : boolean read IsAttached;
|
|
property Delegate : ICefViewDelegate read GetDelegate;
|
|
property Window : ICefWindow read GetWindow;
|
|
property ParentView : ICefView read GetParentView;
|
|
property BoundsInScreen : TCefRect read GetBoundsInScreen;
|
|
property PreferredSize : TCefSize read GetPreferredSize;
|
|
property MinimumSize : TCefSize read GetMinimumSize;
|
|
property MaximumSize : TCefSize read GetMaximumSize;
|
|
property Visible : boolean read IsVisible write SetVisible;
|
|
property Drawn : boolean read IsDrawn;
|
|
property Enabled : boolean read IsEnabled write SetEnabled;
|
|
property Focusable : boolean read IsFocusable write SetFocusable;
|
|
property AccessibilityFocusable : boolean read IsAccessibilityFocusable;
|
|
property BackgroundColor : TCefColor read GetBackgroundColor write SetBackgroundColor;
|
|
property ID : integer read GetID write SetID;
|
|
property GroupID : integer read GetGroupID write SetGroupID;
|
|
property Bounds : TCefRect read GetBounds write SetBounds;
|
|
property Size : TCefSize read GetSize write SetSize;
|
|
property Position : TCefPoint read GetPosition write SetPosition;
|
|
property Insets : TCefInsets read GetInsets write SetInsets;
|
|
property TypeString : ustring read GetTypeString;
|
|
end;
|
|
|
|
// TCefViewDelegate
|
|
// /include/capi/views/cef_view_delegate_capi.h (cef_view_delegate_t)
|
|
ICefViewDelegate = interface(ICefBaseRefCounted)
|
|
['{5F900206-B969-4E51-B56C-0FF38D749C72}']
|
|
procedure OnGetPreferredSize(const view: ICefView; var aResult : TCefSize);
|
|
procedure OnGetMinimumSize(const view: ICefView; var aResult : TCefSize);
|
|
procedure OnGetMaximumSize(const view: ICefView; var aResult : TCefSize);
|
|
procedure OnGetHeightForWidth(const view: ICefView; width: Integer; var aResult: Integer);
|
|
procedure OnParentViewChanged(const view: ICefView; added: boolean; const parent: ICefView);
|
|
procedure OnChildViewChanged(const view: ICefView; added: boolean; const child: ICefView);
|
|
procedure OnWindowChanged(const view: ICefView; added: boolean);
|
|
procedure OnLayoutChanged(const view: ICefView; new_bounds: TCefRect);
|
|
procedure OnFocus(const view: ICefView);
|
|
procedure OnBlur(const view: ICefView);
|
|
end;
|
|
|
|
ICefViewDelegateEvents = interface
|
|
['{74DDDB37-8F08-4672-BDB6-55CA2CD374ED}']
|
|
// ICefViewDelegate
|
|
procedure doOnGetPreferredSize(const view: ICefView; var aResult : TCefSize);
|
|
procedure doOnGetMinimumSize(const view: ICefView; var aResult : TCefSize);
|
|
procedure doOnGetMaximumSize(const view: ICefView; var aResult : TCefSize);
|
|
procedure doOnGetHeightForWidth(const view: ICefView; width: Integer; var aResult: Integer);
|
|
procedure doOnParentViewChanged(const view: ICefView; added: boolean; const parent: ICefView);
|
|
procedure doOnChildViewChanged(const view: ICefView; added: boolean; const child: ICefView);
|
|
procedure doOnWindowChanged(const view: ICefView; added: boolean);
|
|
procedure doOnLayoutChanged(const view: ICefView; new_bounds: TCefRect);
|
|
procedure doOnFocus(const view: ICefView);
|
|
procedure doOnBlur(const view: ICefView);
|
|
|
|
// Custom
|
|
procedure doCreateCustomView;
|
|
end;
|
|
|
|
// TCefTextfield
|
|
// /include/capi/views/cef_textfield_capi.h (cef_textfield_t)
|
|
ICefTextfield = interface(ICefView)
|
|
['{B5E30155-DEA5-4CBF-BC9D-578CBCA586D9}']
|
|
procedure SetPasswordInput(password_input: boolean);
|
|
function IsPasswordInput : boolean;
|
|
procedure SetReadOnly(read_only: boolean);
|
|
function IsReadOnly : boolean;
|
|
function GetText : ustring;
|
|
procedure SetText(const text_: ustring);
|
|
procedure AppendText(const text_: ustring);
|
|
procedure InsertOrReplaceText(const text_: ustring);
|
|
function HasSelection : boolean;
|
|
function GetSelectedText : ustring;
|
|
procedure SelectAll(reversed: boolean);
|
|
procedure ClearSelection;
|
|
function GetSelectedRange : TCefRange;
|
|
procedure SelectRange(const range: TCefRange);
|
|
function GetCursorPosition : NativeUInt;
|
|
procedure SetTextColor(color: TCefColor);
|
|
function GetTextColor : TCefColor;
|
|
procedure SetSelectionTextColor(color: TCefColor);
|
|
function GetSelectionTextColor : TCefColor;
|
|
procedure SetSelectionBackgroundColor(color: TCefColor);
|
|
function GetSelectionBackgroundColor : TCefColor;
|
|
procedure SetFontList(const font_list: ustring);
|
|
procedure ApplyTextColor(color: TCefColor; const range: TCefRange);
|
|
procedure ApplyTextStyle(style: TCefTextStyle; add: boolean; const range: TCefRange);
|
|
function IsCommandEnabled(command_id: TCefTextFieldCommands): boolean;
|
|
procedure ExecuteCommand(command_id: TCefTextFieldCommands);
|
|
procedure ClearEditHistory;
|
|
procedure SetPlaceholderText(const text_: ustring);
|
|
function GetPlaceholderText : ustring;
|
|
procedure SetPlaceholderTextColor(color: TCefColor);
|
|
procedure SetAccessibleName(const name: ustring);
|
|
|
|
property PasswordInput : boolean read IsPasswordInput write SetPasswordInput;
|
|
property ReadOnly : boolean read IsReadOnly write SetReadOnly;
|
|
property Text : ustring read GetText write SetText;
|
|
property SelectedText : ustring read GetSelectedText;
|
|
property TextColor : TCefColor read GetTextColor write SetTextColor;
|
|
property SelectionTextColor : TCefColor read GetSelectionTextColor write SetSelectionTextColor;
|
|
property SelectionBackgroundColor : TCefColor read GetSelectionBackgroundColor write SetSelectionBackgroundColor;
|
|
property PlaceholderText : ustring read GetPlaceholderText write SetPlaceholderText;
|
|
end;
|
|
|
|
// TCefTextfieldDelegate
|
|
// /include/capi/views/cef_textfield_delegate_capi.h (cef_textfield_delegate_t)
|
|
ICefTextfieldDelegate = interface(ICefViewDelegate)
|
|
['{72612994-92BB-4DE9-BB38-6F49FB45F94B}']
|
|
procedure OnKeyEvent(const textfield: ICefTextfield; const event: TCefKeyEvent; var aResult : boolean);
|
|
procedure OnAfterUserAction(const textfield: ICefTextfield);
|
|
end;
|
|
|
|
ICefTextfieldDelegateEvents = interface(ICefViewDelegateEvents)
|
|
['{682480E0-C786-4E65-B950-4FF2B13B97B9}']
|
|
procedure doOnKeyEvent(const textfield: ICefTextfield; const event: TCefKeyEvent; var aResult : boolean);
|
|
procedure doOnAfterUserAction(const textfield: ICefTextfield);
|
|
end;
|
|
|
|
// TCefScrollView
|
|
// /include/capi/views/cef_scroll_view_capi.h (cef_scroll_view_t)
|
|
ICefScrollView = interface(ICefView)
|
|
['{55DF2883-0574-4F10-B6F5-DE4730964B5B}']
|
|
procedure SetContentView(const view: ICefView);
|
|
function GetContentView : ICefView;
|
|
function GetVisibleContentRect : TCefRect;
|
|
function HasHorizontalScrollbar : boolean;
|
|
function GetHorizontalScrollbarHeight : Integer;
|
|
function HasVerticalScrollbar : boolean;
|
|
function GetVerticalScrollbarWidth : Integer;
|
|
|
|
property ContentView : ICefView read GetContentView write SetContentView;
|
|
property VisibleContentRect : TCefRect read GetVisibleContentRect;
|
|
property HorizontalScrollbarHeight : Integer read GetHorizontalScrollbarHeight;
|
|
property VerticalScrollbarWidth : Integer read GetVerticalScrollbarWidth;
|
|
end;
|
|
|
|
// TCefPanel
|
|
// /include/capi/views/cef_panel_capi.h (cef_panel_t)
|
|
ICefPanel = interface(ICefView)
|
|
['{6F2F680A-3637-4438-81B8-79AD6C02252D}']
|
|
function GetAsWindow : ICefWindow;
|
|
function SetToFillLayout : ICefFillLayout;
|
|
function SetToBoxLayout(const settings: TCefBoxLayoutSettings): ICefBoxLayout;
|
|
function GetLayout : ICefLayout;
|
|
procedure Layout;
|
|
procedure AddChildView(const view: ICefView);
|
|
procedure AddChildViewAt(const view: ICefView; index: Integer);
|
|
procedure ReorderChildView(const view: ICefView; index: Integer);
|
|
procedure RemoveChildView(const view: ICefView);
|
|
procedure RemoveAllChildViews;
|
|
function GetChildViewCount : NativeUInt;
|
|
function GetChildViewAt(index: Integer): ICefView;
|
|
|
|
property AsWindow : ICefWindow read GetAsWindow;
|
|
end;
|
|
|
|
// TCefPanelDelegate
|
|
// /include/capi/views/cef_panel_delegate_capi.h (cef_panel_delegate_t)
|
|
ICefPanelDelegate = interface(ICefViewDelegate)
|
|
['{305D453F-FEBA-48ED-AE33-5D978823EA96}']
|
|
end;
|
|
|
|
ICefPanelDelegateEvents = interface(ICefViewDelegateEvents)
|
|
['{F1F2963F-82C3-48F0-9B9C-7C213BACB96B}']
|
|
end;
|
|
|
|
// TCefBrowserView
|
|
// /include/capi/views/cef_browser_view_capi.h (cef_browser_view_t)
|
|
ICefBrowserView = interface(ICefView)
|
|
['{A617EE5D-B933-4E14-9FC0-7E88E9B6C051}']
|
|
function GetBrowser : ICefBrowser;
|
|
function GetChromeToolbar : ICefView;
|
|
procedure SetPreferAccelerators(prefer_accelerators: boolean);
|
|
end;
|
|
|
|
// TCefBrowserViewDelegate
|
|
// /include/capi/views/cef_browser_view_delegate_capi.h (cef_browser_view_delegate_t)
|
|
ICefBrowserViewDelegate = interface(ICefViewDelegate)
|
|
['{578A0DD4-2E7D-4061-B4DB-7C3CDC7A90C0}']
|
|
procedure OnBrowserCreated(const browser_view: ICefBrowserView; const browser: ICefBrowser);
|
|
procedure OnBrowserDestroyed(const browser_view: ICefBrowserView; const browser: ICefBrowser);
|
|
procedure OnGetDelegateForPopupBrowserView(const browser_view: ICefBrowserView; const settings: TCefBrowserSettings; const client: ICefClient; is_devtools: boolean; var aResult : ICefBrowserViewDelegate);
|
|
procedure OnPopupBrowserViewCreated(const browser_view, popup_browser_view: ICefBrowserView; is_devtools: boolean; var aResult : boolean);
|
|
function GetChromeToolbarType: TCefChromeToolbarType;
|
|
|
|
property ChromeToolbarType: TCefChromeToolbarType read GetChromeToolbarType;
|
|
end;
|
|
|
|
ICefBrowserViewDelegateEvents = interface(ICefViewDelegateEvents)
|
|
['{AB94B875-63C6-4FEF-BB30-0816402ABA1C}']
|
|
procedure doOnBrowserCreated(const browser_view: ICefBrowserView; const browser: ICefBrowser);
|
|
procedure doOnBrowserDestroyed(const browser_view: ICefBrowserView; const browser: ICefBrowser);
|
|
procedure doOnGetDelegateForPopupBrowserView(const browser_view: ICefBrowserView; const settings: TCefBrowserSettings; const client: ICefClient; is_devtools: boolean; var aResult : ICefBrowserViewDelegate);
|
|
procedure doOnPopupBrowserViewCreated(const browser_view, popup_browser_view: ICefBrowserView; is_devtools: boolean; var aResult : boolean);
|
|
procedure doOnGetChromeToolbarType(var aChromeToolbarType: TCefChromeToolbarType);
|
|
end;
|
|
|
|
// TCefButton
|
|
// /include/capi/views/cef_button_capi.h (cef_button_t)
|
|
ICefButton = interface(ICefView)
|
|
['{D3D2E8A0-9F9C-4BD8-B495-655976534281}']
|
|
function AsLabelButton : ICefLabelButton;
|
|
procedure SetState(state_: TCefButtonState);
|
|
function GetState : TCefButtonState;
|
|
procedure SetInkDropEnabled(enabled_: boolean);
|
|
procedure SetTooltipText(const tooltip_text: ustring);
|
|
procedure SetAccessibleName(const name: ustring);
|
|
|
|
property State : TCefButtonState read GetState write SetState;
|
|
end;
|
|
|
|
// TCefButtonDelegate
|
|
// /include/capi/views/cef_button_delegate_capi.h (cef_button_delegate_t)
|
|
ICefButtonDelegate = interface(ICefViewDelegate)
|
|
['{EA1EB5A4-DFB0-4A13-A23B-54FAF9401B39}']
|
|
procedure OnButtonPressed(const button: ICefButton);
|
|
procedure OnButtonStateChanged(const button: ICefButton);
|
|
end;
|
|
|
|
ICefButtonDelegateEvents = interface(ICefViewDelegateEvents)
|
|
['{E8DF70BE-5DEB-42CF-AF86-B0FF1040498E}']
|
|
procedure doOnButtonPressed(const button: ICefButton);
|
|
procedure doOnButtonStateChanged(const button: ICefButton);
|
|
end;
|
|
|
|
// TCefLabelButton
|
|
// /include/capi/views/cef_label_button_capi.h (cef_label_button_t)
|
|
ICefLabelButton = interface(ICefButton)
|
|
['{A99FD4F3-7EE6-4796-8BF6-EC367D51EED8}']
|
|
function AsMenuButton : ICefMenuButton;
|
|
procedure SetText(const text_: ustring);
|
|
function GetText : ustring;
|
|
procedure SetImage(button_state: TCefButtonState; const image: ICefImage);
|
|
function GetImage(button_state: TCefButtonState): ICefImage;
|
|
procedure SetTextColor(for_state: TCefButtonState; color: TCefColor);
|
|
procedure SetEnabledTextColors(color: TCefColor);
|
|
procedure SetFontList(const font_list: ustring);
|
|
procedure SetHorizontalAlignment(alignment: TCefHorizontalAlignment);
|
|
procedure SetMinimumSize(const size_: TCefSize);
|
|
procedure SetMaximumSize(const size_: TCefSize);
|
|
|
|
property Text : ustring read GetText write SetText;
|
|
end;
|
|
|
|
// TCefMenuButton
|
|
// /include/capi/views/cef_menu_button_capi.h (cef_menu_button_t)
|
|
ICefMenuButton = interface(ICefLabelButton)
|
|
['{62BFE81A-7810-400B-83C6-76D1DF133710}']
|
|
procedure ShowMenu(const menu_model: ICefMenuModel; const screen_point: TCefPoint; anchor_position: TCefMenuAnchorPosition);
|
|
procedure TriggerMenu;
|
|
end;
|
|
|
|
// TCefMenuButtonPressedLock
|
|
// /include/capi/views/cef_menu_button_delegate_capi.h (cef_menu_button_pressed_lock_t)
|
|
ICefMenuButtonPressedLock = interface(ICefBaseRefCounted)
|
|
['{71498C53-0B1D-4A05-98A0-3E589F2A1683}']
|
|
end;
|
|
|
|
// TCefMenuButtonDelegate
|
|
// /include/capi/views/cef_menu_button_delegate_capi.h (cef_menu_button_delegate_t)
|
|
ICefMenuButtonDelegate = interface(ICefButtonDelegate)
|
|
['{D0E89A75-463A-4766-8701-BD8D24B11E9F}']
|
|
procedure OnMenuButtonPressed(const menu_button: ICefMenuButton; const screen_point: TCefPoint; const button_pressed_lock: ICefMenuButtonPressedLock);
|
|
end;
|
|
|
|
ICefMenuButtonDelegateEvents = interface(ICefButtonDelegateEvents)
|
|
['{DA36DD60-7609-4576-BB8E-6A55FD48C680}']
|
|
procedure doOnMenuButtonPressed(const menu_button: ICefMenuButton; const screen_point: TCefPoint; const button_pressed_lock: ICefMenuButtonPressedLock);
|
|
end;
|
|
|
|
// TCefWindow
|
|
// /include/capi/views/cef_window_capi.h (cef_window_t)
|
|
ICefWindow = interface(ICefPanel)
|
|
['{C450C974-BF0A-4968-A6BE-153CEAD10DA6}']
|
|
procedure Show;
|
|
procedure Hide;
|
|
procedure CenterWindow(const size_: TCefSize);
|
|
procedure Close;
|
|
function IsClosed : boolean;
|
|
procedure Activate;
|
|
procedure Deactivate;
|
|
function IsActive : boolean;
|
|
procedure BringToTop;
|
|
procedure SetAlwaysOnTop(on_top: boolean);
|
|
function IsAlwaysOnTop : boolean;
|
|
procedure Maximize;
|
|
procedure Minimize;
|
|
procedure Restore;
|
|
procedure SetFullscreen(fullscreen: boolean);
|
|
function IsMaximized : boolean;
|
|
function IsMinimized : boolean;
|
|
function IsFullscreen : boolean;
|
|
procedure SetTitle(const title_: ustring);
|
|
function GetTitle : ustring;
|
|
procedure SetWindowIcon(const image: ICefImage);
|
|
function GetWindowIcon : ICefImage;
|
|
procedure SetWindowAppIcon(const image: ICefImage);
|
|
function GetWindowAppIcon : ICefImage;
|
|
function AddOverlayView(const view: ICefView; docking_mode: TCefDockingMode): ICefOverlayController;
|
|
procedure ShowMenu(const menu_model: ICefMenuModel; const screen_point: TCefPoint; anchor_position : TCefMenuAnchorPosition);
|
|
procedure CancelMenu;
|
|
function GetDisplay : ICefDisplay;
|
|
function GetClientAreaBoundsInScreen : TCefRect;
|
|
procedure SetDraggableRegions(regionsCount: NativeUInt; const regions: PCefDraggableRegionArray);
|
|
function GetWindowHandle : TCefWindowHandle;
|
|
procedure SendKeyPress(key_code: Integer; event_flags: cardinal);
|
|
procedure SendMouseMove(screen_x, screen_y: Integer);
|
|
procedure SendMouseEvents(button: TCefMouseButtonType; mouse_down, mouse_up: boolean);
|
|
procedure SetAccelerator(command_id, key_code : Integer; shift_pressed, ctrl_pressed, alt_pressed: boolean);
|
|
procedure RemoveAccelerator(command_id: Integer);
|
|
procedure RemoveAllAccelerators;
|
|
|
|
property Title : ustring read GetTitle write SetTitle;
|
|
property WindowIcon : ICefImage read GetWindowIcon write SetWindowIcon;
|
|
property WindowAppIcon : ICefImage read GetWindowAppIcon write SetWindowAppIcon;
|
|
property Display : ICefDisplay read GetDisplay;
|
|
property ClientAreaBoundsInScreen : TCefRect read GetClientAreaBoundsInScreen;
|
|
property WindowHandle : TCefWindowHandle read GetWindowHandle;
|
|
end;
|
|
|
|
// TCefWindowDelegate
|
|
// /include/capi/views/cef_window_delegate_capi.h (cef_window_delegate_t)
|
|
ICefWindowDelegate = interface(ICefPanelDelegate)
|
|
['{52D4EE2C-303B-42B6-A35F-30D03834A23F}']
|
|
procedure OnWindowCreated(const window_: ICefWindow);
|
|
procedure OnWindowClosing(const window_: ICefWindow);
|
|
procedure OnWindowDestroyed(const window_: ICefWindow);
|
|
procedure OnWindowActivationChanged(const window_: ICefWindow; active: boolean);
|
|
procedure OnWindowBoundsChanged(const window_: ICefWindow; const new_bounds: TCefRect);
|
|
procedure OnGetParentWindow(const window_: ICefWindow; var is_menu, can_activate_menu: boolean; var aResult : ICefWindow);
|
|
procedure OnGetInitialBounds(const window_: ICefWindow; var aResult : TCefRect);
|
|
procedure OnGetInitialShowState(const window_: ICefWindow; var aResult : TCefShowState);
|
|
procedure OnIsFrameless(const window_: ICefWindow; var aResult : boolean);
|
|
procedure OnCanResize(const window_: ICefWindow; var aResult : boolean);
|
|
procedure OnCanMaximize(const window_: ICefWindow; var aResult : boolean);
|
|
procedure OnCanMinimize(const window_: ICefWindow; var aResult : boolean);
|
|
procedure OnCanClose(const window_: ICefWindow; var aResult : boolean);
|
|
procedure OnAccelerator(const window_: ICefWindow; command_id: Integer; var aResult : boolean);
|
|
procedure OnKeyEvent(const window_: ICefWindow; const event: TCefKeyEvent; var aResult : boolean);
|
|
end;
|
|
|
|
ICefWindowDelegateEvents = interface(ICefPanelDelegateEvents)
|
|
['{05C19A41-E75D-459E-AD4D-C8A0CA4A49D3}']
|
|
procedure doOnWindowCreated(const window_: ICefWindow);
|
|
procedure doOnWindowClosing(const window_: ICefWindow);
|
|
procedure doOnWindowDestroyed(const window_: ICefWindow);
|
|
procedure doOnWindowActivationChanged(const window_: ICefWindow; active: boolean);
|
|
procedure doOnWindowBoundsChanged(const window_: ICefWindow; const new_bounds: TCefRect);
|
|
procedure doOnGetParentWindow(const window_: ICefWindow; var is_menu, can_activate_menu: boolean; var aResult : ICefWindow);
|
|
procedure doOnGetInitialBounds(const window_: ICefWindow; var aResult : TCefRect);
|
|
procedure doOnGetInitialShowState(const window_: ICefWindow; var aResult : TCefShowState);
|
|
procedure doOnIsFrameless(const window_: ICefWindow; var aResult : boolean);
|
|
procedure doOnCanResize(const window_: ICefWindow; var aResult : boolean);
|
|
procedure doOnCanMaximize(const window_: ICefWindow; var aResult : boolean);
|
|
procedure doOnCanMinimize(const window_: ICefWindow; var aResult : boolean);
|
|
procedure doOnCanClose(const window_: ICefWindow; var aResult : boolean);
|
|
procedure doOnAccelerator(const window_: ICefWindow; command_id: Integer; var aResult : boolean);
|
|
procedure doOnKeyEvent(const window_: ICefWindow; const event: TCefKeyEvent; var aResult : boolean);
|
|
end;
|
|
|
|
implementation
|
|
|
|
end.
|