unit uCEFChromiumCore; {$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, WinApi.Messages, WinApi.ActiveX, WinApi.CommCtrl,{$ENDIF} System.Classes, System.SyncObjs, System.Types, {$ELSE} {$IFDEF MSWINDOWS}Windows, ActiveX, CommCtrl,{$ENDIF} Classes, {$IFDEF FPC} LCLProc, LCLType, LCLIntf, LResources, LMessages, InterfaceBase, {$IFDEF LINUX}xlib,{$ENDIF} {$ELSE} Messages, {$ENDIF} SyncObjs, {$ENDIF} uCEFTypes, uCEFInterfaces, uCEFLibFunctions, uCEFMiscFunctions, uCEFClient, uCEFConstants, uCEFTask, uCEFDomVisitor, uCEFChromiumEvents, {$IFDEF MSWINDOWS}uCEFDragAndDropMgr,{$ENDIF} {$IFDEF LINUX}uCEFLinuxTypes, uCEFLinuxFunctions,{$ENDIF} uCEFChromiumOptions, uCEFChromiumFontOptions, uCEFPDFPrintOptions, uCEFBrowserViewComponent, uCEFWindowInfoWrapper; type TBrowserInfoList = class; ///

/// Parent class of TChromium and TFMXChromium that puts together all browser procedures, functions, properties and events in one place. /// It has all you need to create, modify and destroy a web browser. ///

TChromiumCore = class(TComponent, IChromiumEvents) protected {$IFDEF MSWINDOWS} FCompHandle : HWND; {$ENDIF} FHandler : ICefClient; FBrowsersCS : TCriticalSection; FBrowsers : TBrowserInfoList; FBrowserId : integer; FMultiBrowserMode : boolean; FReqContextHandler : ICefRequestContextHandler; FResourceRequestHandler : ICefResourceRequestHandler; FMediaObserver : ICefMediaObserver; FMediaObserverReg : ICefRegistration; FDevToolsMsgObserver : ICefDevToolsMessageObserver; FDevToolsMsgObserverReg : ICefRegistration; FExtensionHandler : ICefExtensionHandler; FDefaultUrl : ustring; FOptions : TChromiumOptions; FFontOptions : TChromiumFontOptions; FPDFPrintOptions : TPDFPrintOptions; FDefaultEncoding : ustring; FProxyType : integer; FProxyScheme : TCefProxyScheme; FProxyServer : ustring; FProxyPort : integer; FProxyUsername : ustring; FProxyPassword : ustring; FProxyScriptURL : ustring; FProxyByPassList : ustring; FMaxConnectionsPerProxy : integer; FUpdatePreferences : boolean; FCustomHeaderName : ustring; FCustomHeaderValue : ustring; FAddCustomHeader : boolean; FDoNotTrack : boolean; FSendReferrer : boolean; FHyperlinkAuditing : boolean; FAllowOutdatedPlugins : boolean; FAlwaysAuthorizePlugins : boolean; FAlwaysOpenPDFExternally : boolean; FSpellChecking : boolean; FSpellCheckerDicts : ustring; FZoomStep : byte; FZoomStepCS : TCriticalSection; FPrefsFileName : string; FIsOSR : boolean; FSafeSearch : boolean; FOffline : boolean; FYouTubeRestrict : integer; FPrintingEnabled : boolean; FWindowInfo : TCEFWindowInfoWrapper; FBrowserSettings : TCefBrowserSettings; FDevWindowInfo : TCEFWindowInfoWrapper; FDevBrowserSettings : TCefBrowserSettings; FDragOperations : TCefDragOperations; {$IFDEF MSWINDOWS} FDragDropManager : TCEFDragAndDropMgr; FDropTargetWnd : HWND; {$ENDIF} FDragAndDropInitialized : boolean; FWebRTCIPHandlingPolicy : TCefWebRTCHandlingPolicy; FWebRTCMultipleRoutes : TCefState; FWebRTCNonProxiedUDP : TCefState; FAcceptLanguageList : ustring; FAcceptCookies : TCefCookiePref; FBlock3rdPartyCookies : boolean; FQuicAllowed : boolean; FJavascriptEnabled : boolean; FLoadImagesAutomatically : boolean; FBatterySaverModeState : TCefBatterySaverModeState; FHighEfficiencyModeState : TCefHighEfficiencyModeState; FCanFocus : boolean; FEnableFocusDelayMs : cardinal; FComponentID : integer; FDownloadBubble : TCefState; {$IFDEF LINUX} FXDisplay : PXDisplay; {$ENDIF} {$IFDEF MSWINDOWS} FOldBrowserCompWndPrc : TFNWndProc; FOldWidgetCompWndPrc : TFNWndProc; FOldRenderCompWndPrc : TFNWndProc; FBrowserCompStub : Pointer; FWidgetCompStub : Pointer; FRenderCompStub : Pointer; FBrowserCompHWND : THandle; FWidgetCompHWND : THandle; FRenderCompHWND : THandle; {$ENDIF} // ICefClient FOnProcessMessageReceived : TOnProcessMessageReceived; // ICefLoadHandler FOnLoadStart : TOnLoadStart; FOnLoadEnd : TOnLoadEnd; FOnLoadError : TOnLoadError; FOnLoadingStateChange : TOnLoadingStateChange; // ICefFocusHandler FOnTakeFocus : TOnTakeFocus; FOnSetFocus : TOnSetFocus; FOnGotFocus : TOnGotFocus; // ICefContextMenuHandler FOnBeforeContextMenu : TOnBeforeContextMenu; FOnRunContextMenu : TOnRunContextMenu; FOnContextMenuCommand : TOnContextMenuCommand; FOnContextMenuDismissed : TOnContextMenuDismissed; FOnRunQuickMenu : TOnRunQuickMenuEvent; FOnQuickMenuCommand : TOnQuickMenuCommandEvent; FOnQuickMenuDismissed : TOnQuickMenuDismissedEvent; // ICefKeyboardHandler FOnPreKeyEvent : TOnPreKeyEvent; FOnKeyEvent : TOnKeyEvent; // ICefDisplayHandler FOnAddressChange : TOnAddressChange; FOnTitleChange : TOnTitleChange; FOnFavIconUrlChange : TOnFavIconUrlChange; FOnFullScreenModeChange : TOnFullScreenModeChange; FOnTooltip : TOnTooltip; FOnStatusMessage : TOnStatusMessage; FOnConsoleMessage : TOnConsoleMessage; FOnAutoResize : TOnAutoResize; FOnLoadingProgressChange : TOnLoadingProgressChange; FOnCursorChange : TOnCursorChange; FOnMediaAccessChange : TOnMediaAccessChange; // ICefDownloadHandler FOnCanDownload : TOnCanDownloadEvent; FOnBeforeDownload : TOnBeforeDownload; FOnDownloadUpdated : TOnDownloadUpdated; // ICefJsDialogHandler FOnJsdialog : TOnJsdialog; FOnBeforeUnloadDialog : TOnBeforeUnloadDialog; FOnResetDialogState : TOnResetDialogState; FOnDialogClosed : TOnDialogClosed; // ICefLifeSpanHandler FOnBeforePopup : TOnBeforePopup; FOnBeforeDevToolsPopup : TOnBeforeDevToolsPopup; FOnAfterCreated : TOnAfterCreated; FOnBeforeClose : TOnBeforeClose; FOnClose : TOnClose; // ICefRequestHandler FOnBeforeBrowse : TOnBeforeBrowse; FOnOpenUrlFromTab : TOnOpenUrlFromTab; FOnGetAuthCredentials : TOnGetAuthCredentials; FOnCertificateError : TOnCertificateError; FOnSelectClientCertificate : TOnSelectClientCertificate; FOnRenderViewReady : TOnRenderViewReady; FOnRenderProcessUnresponsive : TOnRenderProcessUnresponsive; FOnRenderProcessResponsive : TOnRenderProcessResponsive; FOnRenderProcessTerminated : TOnRenderProcessTerminated; FOnGetResourceRequestHandler_ReqHdlr : TOnGetResourceRequestHandler; FOnDocumentAvailableInMainFrame : TOnDocumentAvailableInMainFrame; // ICefResourceRequestHandler FOnBeforeResourceLoad : TOnBeforeResourceLoad; FOnGetResourceHandler : TOnGetResourceHandler; FOnResourceRedirect : TOnResourceRedirect; FOnResourceResponse : TOnResourceResponse; FOnGetResourceResponseFilter : TOnGetResourceResponseFilter; FOnResourceLoadComplete : TOnResourceLoadComplete; FOnProtocolExecution : TOnProtocolExecution; // ICefCookieAccessFilter FOnCanSendCookie : TOnCanSendCookie; FOnCanSaveCookie : TOnCanSaveCookie; // ICefDialogHandler FOnFileDialog : TOnFileDialog; // ICefRenderHandler FOnGetAccessibilityHandler : TOnGetAccessibilityHandler; FOnGetRootScreenRect : TOnGetRootScreenRect; FOnGetViewRect : TOnGetViewRect; FOnGetScreenPoint : TOnGetScreenPoint; FOnGetScreenInfo : TOnGetScreenInfo; FOnPopupShow : TOnPopupShow; FOnPopupSize : TOnPopupSize; FOnPaint : TOnPaint; FOnAcceleratedPaint : TOnAcceleratedPaint; FOnGetTouchHandleSize : TOnGetTouchHandleSize; FOnTouchHandleStateChanged : TOnTouchHandleStateChanged; FOnStartDragging : TOnStartDragging; FOnUpdateDragCursor : TOnUpdateDragCursor; FOnScrollOffsetChanged : TOnScrollOffsetChanged; FOnIMECompositionRangeChanged : TOnIMECompositionRangeChanged; FOnTextSelectionChanged : TOnTextSelectionChanged; FOnVirtualKeyboardRequested : TOnVirtualKeyboardRequested; // ICefDragHandler FOnDragEnter : TOnDragEnter; FOnDraggableRegionsChanged : TOnDraggableRegionsChanged; // ICefFindHandler FOnFindResult : TOnFindResult; // ICefRequestContextHandler FOnRequestContextInitialized : TOnRequestContextInitialized; FOnGetResourceRequestHandler_ReqCtxHdlr : TOnGetResourceRequestHandler; // ICefMediaObserver FOnSinks : TOnSinksEvent; FOnRoutes : TOnRoutesEvent; FOnRouteStateChanged : TOnRouteStateChangedEvent; FOnRouteMessageReceived : TOnRouteMessageReceivedEvent; // ICefAudioHandler FOnGetAudioParameters : TOnGetAudioParametersEvent; FOnAudioStreamStarted : TOnAudioStreamStartedEvent; FOnAudioStreamPacket : TOnAudioStreamPacketEvent; FOnAudioStreamStopped : TOnAudioStreamStoppedEvent; FOnAudioStreamError : TOnAudioStreamErrorEvent; // ICefDevToolsMessageObserver FOnDevToolsMessage : TOnDevToolsMessageEvent; FOnDevToolsRawMessage : TOnDevToolsRawMessageEvent; FOnDevToolsMethodResult : TOnDevToolsMethodResultEvent; FOnDevToolsMethodRawResult : TOnDevToolsMethodRawResultEvent; FOnDevToolsEvent : TOnDevToolsEventEvent; FOnDevToolsRawEvent : TOnDevToolsEventRawEvent; FOnDevToolsAgentAttached : TOnDevToolsAgentAttachedEvent; FOnDevToolsAgentDetached : TOnDevToolsAgentDetachedEvent; // ICefExtensionHandler FOnExtensionLoadFailed : TOnExtensionLoadFailedEvent; FOnExtensionLoaded : TOnExtensionLoadedEvent; FOnExtensionUnloaded : TOnExtensionUnloadedEvent; FOnExtensionBeforeBackgroundBrowser : TOnBeforeBackgroundBrowserEvent; FOnExtensionBeforeBrowser : TOnBeforeBrowserEvent; FOnExtensionGetActiveBrowser : TOnGetActiveBrowserEvent; FOnExtensionCanAccessBrowser : TOnCanAccessBrowserEvent; FOnExtensionGetExtensionResource : TOnGetExtensionResourceEvent; // ICefPrintHandler FOnPrintStart : TOnPrintStartEvent; FOnPrintSettings : TOnPrintSettingsEvent; FOnPrintDialog : TOnPrintDialogEvent; FOnPrintJob : TOnPrintJobEvent; FOnPrintReset : TOnPrintResetEvent; FOnGetPDFPaperSize : TOnGetPDFPaperSizeEvent; // ICefFrameHandler FOnFrameCreated : TOnFrameCreated; FOnFrameAttached : TOnFrameAttached; FOnFrameDetached : TOnFrameDetached; FOnMainFrameChanged : TOnMainFrameChanged; // ICefCommandHandler FOnChromeCommand : TOnChromeCommandEvent; FOnIsChromeAppMenuItemVisible : TOnIsChromeAppMenuItemVisibleEvent; FOnIsChromeAppMenuItemEnabled : TOnIsChromeAppMenuItemEnabledEvent; FOnIsChromePageActionIconVisible : TOnIsChromePageActionIconVisibleEvent; FOnIsChromeToolbarButtonVisible : TOnIsChromeToolbarButtonVisibleEvent; // ICefPermissionHandler FOnRequestMediaAccessPermission : TOnRequestMediaAccessPermissionEvent; FOnShowPermissionPrompt : TOnShowPermissionPromptEvent; FOnDismissPermissionPrompt : TOnDismissPermissionPromptEvent; // Custom FOnTextResultAvailable : TOnTextResultAvailableEvent; FOnPdfPrintFinished : TOnPdfPrintFinishedEvent; FOnPrefsAvailable : TOnPrefsAvailableEvent; FOnPrefsUpdated : TNotifyEvent; FOnCookiesDeleted : TOnCookiesDeletedEvent; FOnResolvedHostAvailable : TOnResolvedIPsAvailableEvent; FOnNavigationVisitorResultAvailable : TOnNavigationVisitorResultAvailableEvent; FOnDownloadImageFinished : TOnDownloadImageFinishedEvent; FOnCookiesFlushed : TNotifyEvent; FOnCertificateExceptionsCleared : TNotifyEvent; FOnHttpAuthCredentialsCleared : TNotifyEvent; FOnAllConnectionsClosed : TNotifyEvent; FOnExecuteTaskOnCefThread : TOnExecuteTaskOnCefThread; FOnCookiesVisited : TOnCookiesVisited; FOnCookieVisitorDestroyed : TOnCookieVisitorDestroyed; FOnCookieSet : TOnCookieSet; FOnZoomPctAvailable : TOnZoomPctAvailable; FOnMediaRouteCreateFinished : TOnMediaRouteCreateFinishedEvent; FOnMediaSinkDeviceInfo : TOnMediaSinkDeviceInfoEvent; FOnCanFocus : TNotifyEvent; {$IFDEF MSWINDOWS} FOnBrowserCompMsg : TOnCompMsgEvent; FOnWidgetCompMsg : TOnCompMsgEvent; FOnRenderCompMsg : TOnCompMsgEvent; {$ENDIF} function GetIsLoading : boolean; function GetMultithreadApp : boolean; function GetHasDocument : boolean; function GetHasView : boolean; function GetHasDevTools : boolean; function GetHasClientHandler : boolean; function GetHasBrowser : boolean; function GetCanGoBack : boolean; function GetCanGoForward : boolean; function GetDocumentURL : ustring; function GetZoomLevel : double; function GetZoomPct : double; function GetZoomStep : byte; function GetDefaultZoomLevel : double; function GetCanIncZoom: boolean; function GetCanDecZoom: boolean; function GetCanResetZoom: boolean; function GetIsPopUp : boolean; function GetWindowHandle : TCefWindowHandle; function GetOpenerWindowHandle : TCefWindowHandle; function GetWindowlessFrameRate : integer; function GetFrameIsFocused : boolean; function GetInitialized : boolean; function GetVisibleNavigationEntry : ICefNavigationEntry; function GetRuntimeStyle : TCefRuntimeStyle; function GetHasValidMainFrame : boolean; function GetFrameCount : NativeUInt; function GetRequestContextCache : ustring; function GetRequestContextIsGlobal : boolean; function GetChromeColorSchemeMode: TCefColorVariant; function GetChromeColorSchemeColor: TCefColor; function GetChromeColorSchemeVariant: TCefColorVariant; function GetAudioMuted : boolean; function GetFullscreen : boolean; function GetIsRenderProcessUnresponsive : boolean; function GetParentFormHandle : TCefWindowHandle; virtual; function GetRequestContext : ICefRequestContext; function GetMediaRouter : ICefMediaRouter; function GetBrowser : ICefBrowser; function GetBrowserId : integer; function GetBrowserById(aID : integer) : ICefBrowser; function GetBrowserCount : integer; function GetBrowserIdByIndex(aIndex : integer) : integer; function GetComponentID : integer; function GetCefWindowInfo : TCefWindowInfo; {$IFDEF MSWINDOWS} function GetWindowInfoExStyle : DWORD; {$ENDIF} {$IFDEF LINUX} function GetXDisplay : PXDisplay; {$ENDIF} procedure SetDoNotTrack(aValue : boolean); procedure SetSendReferrer(aValue : boolean); procedure SetHyperlinkAuditing(aValue : boolean); procedure SetAllowOutdatedPlugins(aValue : boolean); procedure SetAlwaysAuthorizePlugins(aValue : boolean); procedure SetAlwaysOpenPDFExternally(aValue : boolean); procedure SetSpellChecking(aValue : boolean); procedure SetSpellCheckerDicts(const aValue : ustring); procedure SetWebRTCIPHandlingPolicy(aValue : TCefWebRTCHandlingPolicy); procedure SetWebRTCMultipleRoutes(aValue : TCefState); procedure SetWebRTCNonProxiedUDP(aValue : TCefState); procedure SetProxyType(aValue : integer); procedure SetProxyScheme(aValue : TCefProxyScheme); procedure SetProxyServer(const aValue : ustring); procedure SetProxyPort(aValue : integer); procedure SetProxyUsername(const aValue : ustring); procedure SetProxyPassword(const aValue : ustring); procedure SetProxyScriptURL(const aValue : ustring); procedure SetProxyByPassList(const aValue : ustring); procedure SetMaxConnectionsPerProxy(const aValue : integer); procedure SetCustomHeaderName(const aValue : ustring); procedure SetCustomHeaderValue(const aValue : ustring); procedure SetZoomLevel(const aValue : double); procedure SetZoomPct(const aValue : double); procedure SetZoomStep(aValue : byte); procedure SetWindowlessFrameRate(aValue : integer); procedure SetAudioMuted(aValue : boolean); procedure SetSafeSearch(aValue : boolean); procedure SetOffline(aValue : boolean); procedure SetYouTubeRestrict(aValue : integer); procedure SetPrintingEnabled(aValue : boolean); procedure SetAcceptLanguageList(const aValue : ustring); procedure SetAcceptCookies(const aValue : TCefCookiePref); procedure SetBlock3rdPartyCookies(const aValue : boolean); procedure SetMultiBrowserMode(aValue : boolean); procedure SetQuicAllowed(aValue : boolean); procedure SetJavascriptEnabled(aValue : boolean); procedure SetLoadImagesAutomatically(aValue : boolean); procedure SetBatterySaverModeState(aValue : TCefBatterySaverModeState); procedure SetHighEfficiencyModeState(aValue : TCefHighEfficiencyModeState); procedure SetDefaultUrl(const aValue : ustring); procedure SetRuntimeStyle(aValue : TCefRuntimeStyle); {$IFDEF MSWINDOWS} procedure SetWindowInfoExStyle(aValue : DWORD); {$ENDIF} function CreateBrowserHost(aWindowInfo : PCefWindowInfo; const aURL : ustring; const aSettings : PCefBrowserSettings; const aExtraInfo : ICefDictionaryValue; const aContext : ICefRequestContext): boolean; function CreateBrowserHostSync(aWindowInfo : PCefWindowInfo; const aURL : ustring; const aSettings : PCefBrowserSettings; const aExtraInfo : ICefDictionaryValue; const aContext : ICefRequestContext): Boolean; procedure DestroyAllBrowsers; procedure DestroyClientHandler; procedure DestroyReqContextHandler; procedure DestroyResourceRequestHandler; procedure DestroyMediaObserver; procedure DestroyDevToolsMsgObserver; procedure DestroyExtensionHandler; procedure DestroyAllHandlersAndObservers; procedure CreateResourceRequestHandler; virtual; procedure CreateMediaObserver; virtual; procedure CreateDevToolsMsgObserver; virtual; procedure CreateExtensionHandler; virtual; procedure CreateRequestContextHandler; virtual; procedure CreateOptionsClasses; virtual; procedure CreateSyncObjects; virtual; procedure CreateBrowserInfoList; virtual; {$IFDEF MSWINDOWS} procedure CreateWindowWithWndProc; virtual; {$ENDIF} procedure InitializeEvents; procedure InitializeSettings(var aSettings : TCefBrowserSettings); function UpdateProxyPrefs(const aBrowser: ICefBrowser) : boolean; function UpdatePreference(const aBrowser: ICefBrowser; const aName : ustring; aValue : boolean) : boolean; overload; function UpdatePreference(const aBrowser: ICefBrowser; const aName : ustring; aValue : integer) : boolean; overload; function UpdatePreference(const aBrowser: ICefBrowser; const aName : ustring; const aValue : double) : boolean; overload; function UpdatePreference(const aBrowser: ICefBrowser; const aName, aValue : ustring) : boolean; overload; function UpdatePreference(const aBrowser: ICefBrowser; const aName : ustring; const aValue : TStringList) : boolean; overload; function UpdateStringListPref(const aBrowser: ICefBrowser; const aName, aValue : ustring) : boolean; function ExecuteUpdateZoomStepTask(aInc : boolean) : boolean; function ExecuteUpdateZoomPctTask(aInc : boolean) : boolean; function ExecuteReadZoomTask : boolean; function ExecuteSetZoomPctTask(const aValue : double) : boolean; function ExecuteSetZoomLevelTask(const aValue : double) : boolean; function ExecuteSetZoomStepTask(aValue : byte) : boolean; function ExecuteBrowserNavigationTask(aTask : TCefBrowserNavigation) : boolean; procedure UpdateHostZoomLevel(const aValue : double); procedure UpdateHostZoomPct(const aValue : double); procedure DelayedDragging; procedure InitializeWindowInfo(aParentHandle : TCefWindowHandle; aParentRect : TRect; const aWindowName : ustring); virtual; procedure DefaultInitializeDevToolsWindowInfo(aDevToolsWnd: TCefWindowHandle; const aClientRect: TRect; const aWindowName: ustring); function AddBrowser(const aBrowser : ICefBrowser) : boolean; function RemoveBrowser(const aBrowser : ICefBrowser) : boolean; procedure SetBrowserIsClosing(aID : integer); {$IFDEF MSWINDOWS} procedure PrefsAvailableMsg(aResultOK : boolean); function SendCompMessage(aMsg : cardinal; aWParam : WPARAM = 0; aLParam : LPARAM = 0) : boolean; procedure ToMouseEvent(grfKeyState : Longint; pt : TPoint; var aMouseEvent : TCefMouseEvent); procedure WndProc(var aMessage: TMessage); procedure CreateStub(const aMethod : TWndMethod; var aStub : Pointer); procedure FreeAndNilStub(var aStub : pointer); function InstallCompWndProc(aWnd: THandle; aStub: Pointer): TFNWndProc; procedure RestoreCompWndProc(var aOldWnd: THandle; aNewWnd: THandle; var aProc: TFNWndProc); procedure CallOldCompWndProc(aProc: TFNWndProc; aWnd: THandle; var aMessage: TMessage); procedure BrowserCompWndProc(var aMessage: TMessage); procedure WidgetCompWndProc(var aMessage: TMessage); procedure RenderCompWndProc(var aMessage: TMessage); procedure RestoreOldCompWndProc; function CopyDCToBitmapStream(aSrcDC : HDC; const aSrcRect : TRect; const aStream : TStream) : boolean; {$ENDIF} procedure DragDropManager_OnDragEnter(Sender: TObject; const aDragData : ICefDragData; grfKeyState: Longint; pt: TPoint; var dwEffect: Longint); procedure DragDropManager_OnDragOver(Sender: TObject; grfKeyState: Longint; pt: TPoint; var dwEffect: Longint); procedure DragDropManager_OnDragLeave(Sender: TObject); procedure DragDropManager_OnDrop(Sender: TObject; grfKeyState: Longint; pt: TPoint; var dwEffect: Longint); // ICefClient function doOnProcessMessageReceived(const browser: ICefBrowser; const frame: ICefFrame; sourceProcess: TCefProcessId; const aMessage: ICefProcessMessage): Boolean; virtual; // ICefLoadHandler procedure doOnLoadStart(const browser: ICefBrowser; const frame: ICefFrame; transitionType: TCefTransitionType); virtual; procedure doOnLoadEnd(const browser: ICefBrowser; const frame: ICefFrame; httpStatusCode: Integer); virtual; procedure doOnLoadError(const browser: ICefBrowser; const frame: ICefFrame; errorCode: TCefErrorCode; const errorText, failedUrl: ustring); virtual; procedure doOnLoadingStateChange(const browser: ICefBrowser; isLoading, canGoBack, canGoForward: Boolean); virtual; // ICefFocusHandler procedure doOnTakeFocus(const browser: ICefBrowser; next: Boolean); virtual; function doOnSetFocus(const browser: ICefBrowser; source: TCefFocusSource): Boolean; virtual; procedure doOnGotFocus(const browser: ICefBrowser); virtual; // ICefContextMenuHandler procedure doOnBeforeContextMenu(const browser: ICefBrowser; const frame: ICefFrame; const params: ICefContextMenuParams; const model: ICefMenuModel); virtual; function doRunContextMenu(const browser: ICefBrowser; const frame: ICefFrame; const params: ICefContextMenuParams; const model: ICefMenuModel; const callback: ICefRunContextMenuCallback): Boolean; virtual; function doOnContextMenuCommand(const browser: ICefBrowser; const frame: ICefFrame; const params: ICefContextMenuParams; commandId: Integer; eventFlags: TCefEventFlags): Boolean; virtual; procedure doOnContextMenuDismissed(const browser: ICefBrowser; const frame: ICefFrame); virtual; function doRunQuickMenu(const browser: ICefBrowser; const frame: ICefFrame; location: PCefPoint; size: PCefSize; edit_state_flags: TCefQuickMenuEditStateFlags; const callback: ICefRunQuickMenuCallback): boolean; virtual; function doOnQuickMenuCommand(const browser: ICefBrowser; const frame: ICefFrame; command_id: integer; event_flags: TCefEventFlags): boolean; virtual; procedure doOnQuickMenuDismissed(const browser: ICefBrowser; const frame: ICefFrame); virtual; // ICefKeyboardHandler function doOnPreKeyEvent(const browser: ICefBrowser; const event: PCefKeyEvent; osEvent: TCefEventHandle; out isKeyboardShortcut: Boolean): Boolean; virtual; function doOnKeyEvent(const browser: ICefBrowser; const event: PCefKeyEvent; osEvent: TCefEventHandle): Boolean; virtual; // ICefDisplayHandler procedure doOnAddressChange(const browser: ICefBrowser; const frame: ICefFrame; const url: ustring); virtual; procedure doOnTitleChange(const browser: ICefBrowser; const title: ustring); virtual; procedure doOnFaviconUrlChange(const browser: ICefBrowser; const iconUrls: TStrings); virtual; procedure doOnFullScreenModeChange(const browser: ICefBrowser; fullscreen: Boolean); virtual; function doOnTooltip(const browser: ICefBrowser; var text: ustring): Boolean; virtual; procedure doOnStatusMessage(const browser: ICefBrowser; const value: ustring); virtual; function doOnConsoleMessage(const browser: ICefBrowser; level: TCefLogSeverity; const aMessage, source: ustring; line: Integer): Boolean; virtual; function doOnAutoResize(const browser: ICefBrowser; const new_size: PCefSize): Boolean; virtual; procedure doOnLoadingProgressChange(const browser: ICefBrowser; const progress: double); virtual; procedure doOnCursorChange(const browser: ICefBrowser; cursor_: TCefCursorHandle; cursorType: TCefCursorType; const customCursorInfo: PCefCursorInfo; var aResult : boolean); virtual; procedure doOnMediaAccessChange(const browser: ICefBrowser; has_video_access, has_audio_access: boolean); virtual; // ICefDownloadHandler function doOnCanDownload(const browser: ICefBrowser; const url, request_method: ustring): boolean; function doOnBeforeDownload(const browser: ICefBrowser; const downloadItem: ICefDownloadItem; const suggestedName: ustring; const callback: ICefBeforeDownloadCallback): boolean; virtual; procedure doOnDownloadUpdated(const browser: ICefBrowser; const downloadItem: ICefDownloadItem; const callback: ICefDownloadItemCallback); virtual; // ICefJsDialogHandler function doOnJsdialog(const browser: ICefBrowser; const originUrl: ustring; dialogType: TCefJsDialogType; const messageText, defaultPromptText: ustring; const callback: ICefJsDialogCallback; out suppressMessage: Boolean): Boolean; virtual; function doOnBeforeUnloadDialog(const browser: ICefBrowser; const messageText: ustring; isReload: Boolean; const callback: ICefJsDialogCallback): Boolean; virtual; procedure doOnResetDialogState(const browser: ICefBrowser); virtual; procedure doOnDialogClosed(const browser: ICefBrowser); virtual; // 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; virtual; procedure doOnBeforeDevToolsPopup(const browser: ICefBrowser; var windowInfo: TCefWindowInfo; var client: ICefClient; var settings: TCefBrowserSettings; var extra_info: ICefDictionaryValue; var use_default_window: boolean); virtual; procedure doOnAfterCreated(const browser: ICefBrowser); virtual; procedure doOnBeforeClose(const browser: ICefBrowser); virtual; function doOnClose(const browser: ICefBrowser): Boolean; virtual; // ICefRequestHandler function doOnBeforeBrowse(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; user_gesture, isRedirect: Boolean): Boolean; virtual; function doOnOpenUrlFromTab(const browser: ICefBrowser; const frame: ICefFrame; const targetUrl: ustring; targetDisposition: TCefWindowOpenDisposition; userGesture: Boolean): Boolean; virtual; 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); virtual; function doOnGetAuthCredentials(const browser: ICefBrowser; const originUrl: ustring; isProxy: Boolean; const host: ustring; port: Integer; const realm, scheme: ustring; const callback: ICefAuthCallback): Boolean; virtual; function doOnCertificateError(const browser: ICefBrowser; certError: TCefErrorcode; const requestUrl: ustring; const sslInfo: ICefSslInfo; const callback: ICefCallback): Boolean; virtual; function doOnSelectClientCertificate(const browser: ICefBrowser; isProxy: boolean; const host: ustring; port: integer; certificatesCount: NativeUInt; const certificates: TCefX509CertificateArray; const callback: ICefSelectClientCertificateCallback): boolean; virtual; procedure doOnRenderViewReady(const browser: ICefBrowser); virtual; function doOnRenderProcessUnresponsive(const browser: ICefBrowser; const callback: ICefUnresponsiveProcessCallback): boolean; virtual; procedure doOnRenderProcessResponsive(const browser: ICefBrowser); virtual; procedure doOnRenderProcessTerminated(const browser: ICefBrowser; status: TCefTerminationStatus; error_code: integer; const error_string: ustring); virtual; procedure doOnDocumentAvailableInMainFrame(const browser: ICefBrowser); virtual; // ICefResourceRequestHandler function doOnBeforeResourceLoad(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const callback: ICefCallback): TCefReturnValue; virtual; procedure doOnGetResourceHandler(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; var aResourceHandler : ICefResourceHandler); virtual; procedure doOnResourceRedirect(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; var newUrl: ustring); virtual; function doOnResourceResponse(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse): Boolean; virtual; procedure doOnGetResourceResponseFilter(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; var aResponseFilter: ICefResponseFilter); virtual; procedure doOnResourceLoadComplete(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; status: TCefUrlRequestStatus; receivedContentLength: Int64); virtual; procedure doOnProtocolExecution(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; var allowOsExecution: Boolean); virtual; // ICefCookieAccessFilter function doCanSendCookie(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const cookie: PCefCookie): boolean; virtual; function doCanSaveCookie(const browser: ICefBrowser; const frame: ICefFrame; const request: ICefRequest; const response: ICefResponse; const cookie: PCefCookie): boolean; virtual; // ICefDialogHandler function doOnFileDialog(const browser: ICefBrowser; mode: TCefFileDialogMode; const title, defaultFilePath: ustring; const acceptFilters, accept_extensions, accept_descriptions: TStrings; const callback: ICefFileDialogCallback): Boolean; virtual; // ICefRenderHandler procedure doOnGetAccessibilityHandler(var aAccessibilityHandler : ICefAccessibilityHandler); virtual; function doOnGetRootScreenRect(const browser: ICefBrowser; var rect: TCefRect): Boolean; virtual; procedure doOnGetViewRect(const browser: ICefBrowser; var rect: TCefRect); virtual; function doOnGetScreenPoint(const browser: ICefBrowser; viewX, viewY: Integer; var screenX, screenY: Integer): Boolean; virtual; function doOnGetScreenInfo(const browser: ICefBrowser; var screenInfo: TCefScreenInfo): Boolean; virtual; procedure doOnPopupShow(const browser: ICefBrowser; show: Boolean); virtual; procedure doOnPopupSize(const browser: ICefBrowser; const rect: PCefRect); virtual; procedure doOnPaint(const browser: ICefBrowser; type_: TCefPaintElementType; dirtyRectsCount: NativeUInt; const dirtyRects: PCefRectArray; const buffer: Pointer; width, height: Integer); virtual; procedure doOnAcceleratedPaint(const browser: ICefBrowser; type_: TCefPaintElementType; dirtyRectsCount: NativeUInt; const dirtyRects: PCefRectArray; const info: PCefAcceleratedPaintInfo); virtual; procedure doGetTouchHandleSize(const browser: ICefBrowser; orientation: TCefHorizontalAlignment; var size: TCefSize); virtual; procedure doOnTouchHandleStateChanged(const browser: ICefBrowser; const state: TCefTouchHandleState); virtual; function doOnStartDragging(const browser: ICefBrowser; const dragData: ICefDragData; allowedOps: TCefDragOperations; x, y: Integer): Boolean; virtual; procedure doOnUpdateDragCursor(const browser: ICefBrowser; operation: TCefDragOperation); virtual; procedure doOnScrollOffsetChanged(const browser: ICefBrowser; x, y: Double); virtual; procedure doOnIMECompositionRangeChanged(const browser: ICefBrowser; const selected_range: PCefRange; character_boundsCount: NativeUInt; const character_bounds: PCefRect); virtual; procedure doOnTextSelectionChanged(const browser: ICefBrowser; const selected_text: ustring; const selected_range: PCefRange); virtual; procedure doOnVirtualKeyboardRequested(const browser: ICefBrowser; input_mode: TCefTextInpuMode); virtual; // ICefDragHandler function doOnDragEnter(const browser: ICefBrowser; const dragData: ICefDragData; mask: TCefDragOperations): Boolean; virtual; procedure doOnDraggableRegionsChanged(const browser: ICefBrowser; const frame: ICefFrame; regionsCount: NativeUInt; const regions: PCefDraggableRegionArray); virtual; // ICefFindHandler procedure doOnFindResult(const browser: ICefBrowser; identifier, count: Integer; const selectionRect: PCefRect; activeMatchOrdinal: Integer; finalUpdate: Boolean); virtual; // ICefRequestContextHandler procedure doOnRequestContextInitialized(const request_context: ICefRequestContext); virtual; 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); virtual; // ICefMediaObserver procedure doOnSinks(const sinks: TCefMediaSinkArray); virtual; procedure doOnRoutes(const routes: TCefMediaRouteArray); virtual; procedure doOnRouteStateChanged(const route: ICefMediaRoute; state: TCefMediaRouteConnectionState); virtual; procedure doOnRouteMessageReceived(const route: ICefMediaRoute; const message_: ustring); virtual; // ICefAudioHandler procedure doOnGetAudioParameters(const browser: ICefBrowser; var params: TCefAudioParameters; var aResult: boolean); virtual; procedure doOnAudioStreamStarted(const browser: ICefBrowser; const params: TCefAudioParameters; channels: integer); virtual; procedure doOnAudioStreamPacket(const browser: ICefBrowser; const data : PPSingle; frames: integer; pts: int64); virtual; procedure doOnAudioStreamStopped(const browser: ICefBrowser); virtual; procedure doOnAudioStreamError(const browser: ICefBrowser; const message_: ustring); virtual; // ICefDevToolsMessageObserver procedure doOnDevToolsMessage(const browser: ICefBrowser; const message_: Pointer; message_size: NativeUInt; var aHandled: boolean); virtual; procedure doOnDevToolsMethodResult(const browser: ICefBrowser; message_id: integer; success: boolean; const result: Pointer; result_size: NativeUInt); virtual; procedure doOnDevToolsEvent(const browser: ICefBrowser; const method: ustring; const params: Pointer; params_size: NativeUInt); virtual; procedure doOnDevToolsAgentAttached(const browser: ICefBrowser); virtual; procedure doOnDevToolsAgentDetached(const browser: ICefBrowser); virtual; // 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; function doOnIsChromeAppMenuItemVisible(const browser: ICefBrowser; command_id: integer): boolean; function doOnIsChromeAppMenuItemEnabled(const browser: ICefBrowser; command_id: integer): boolean; function doOnIsChromePageActionIconVisible(icon_type: TCefChromePageActionIconType): boolean; function doOnIsChromeToolbarButtonVisible(button_type: TCefChromeToolbarButtonType): 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 GetSettings(var aSettings : TCefBrowserSettings); procedure doCookiesDeleted(numDeleted : integer); virtual; procedure doPdfPrintFinished(aResultOK : boolean); virtual; procedure doTextResultAvailable(const aText : ustring); virtual; procedure doUpdatePreferences(const aBrowser: ICefBrowser); virtual; procedure doUpdateOwnPreferences; virtual; function doSavePreferences : boolean; virtual; procedure doResolvedHostAvailable(result: TCefErrorCode; const resolvedIps: TStrings); virtual; function doNavigationVisitorResultAvailable(const entry: ICefNavigationEntry; current: Boolean; index, total: Integer) : boolean; virtual; procedure doDownloadImageFinished(const imageUrl: ustring; httpStatusCode: Integer; const image: ICefImage); virtual; procedure doOnCookiesStoreFlushed; virtual; procedure doCertificateExceptionsCleared; virtual; procedure doHttpAuthCredentialsCleared; virtual; procedure doAllConnectionsClosed; virtual; procedure doOnExecuteTaskOnCefThread(aTaskID : cardinal); virtual; 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); virtual; procedure doOnCookieVisitorDestroyed(aID : integer); virtual; procedure doOnCookieSet(aSuccess : boolean; aID : integer); virtual; procedure doUpdateZoomStep(aInc : boolean); virtual; procedure doUpdateZoomPct(aInc : boolean); virtual; procedure doReadZoom; virtual; procedure doSetZoomLevel(const aValue : double); virtual; procedure doSetZoomPct(const aValue : double); virtual; procedure doSetZoomStep(aValue : byte); virtual; procedure doMediaRouteCreateFinished(result: TCefMediaRouterCreateResult; const error: ustring; const route: ICefMediaRoute); virtual; procedure doOnMediaSinkDeviceInfo(const ip_address: ustring; port: integer; const model_name: ustring); virtual; procedure doBrowserNavigation(aTask : TCefBrowserNavigation); virtual; procedure doSetAudioMuted(aValue : boolean); virtual; procedure doToggleAudioMuted; virtual; procedure doEnableFocus; virtual; function MustCreateAudioHandler : boolean; virtual; function MustCreateCommandHandler : boolean; virtual; function MustCreateDevToolsMessageObserver : boolean; virtual; function MustCreateLoadHandler : boolean; virtual; function MustCreateFocusHandler : boolean; virtual; function MustCreateContextMenuHandler : boolean; virtual; function MustCreateDialogHandler : boolean; virtual; function MustCreateKeyboardHandler : boolean; virtual; function MustCreateDisplayHandler : boolean; virtual; function MustCreateDownloadHandler : boolean; virtual; function MustCreateJsDialogHandler : boolean; virtual; function MustCreateLifeSpanHandler : boolean; virtual; function MustCreateRenderHandler : boolean; virtual; function MustCreateRequestHandler : boolean; virtual; function MustCreateDragHandler : boolean; virtual; function MustCreateFindHandler : boolean; virtual; function MustCreateResourceRequestHandler : boolean; virtual; function MustCreateCookieAccessFilter : boolean; virtual; function MustCreateMediaObserver : boolean; virtual; function MustCreateExtensionHandler : boolean; virtual; function MustCreatePrintHandler : boolean; virtual; function MustCreateFrameHandler : boolean; virtual; function MustCreatePermissionHandler : boolean; virtual; property ParentFormHandle : TCefWindowHandle read GetParentFormHandle; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure AfterConstruction; override; procedure BeforeDestruction; override; ///

/// Used to create the client handler which will also create most of the browser handlers needed for the browser. ///

function CreateClientHandler(aIsOSR : boolean = True) : boolean; overload; ///

/// Used to create the client handler when a browser requests a new browser in a popup window or tab in the TChromiumCore.OnBeforePopup event. ///

function CreateClientHandler(var aClient : ICefClient; aIsOSR : boolean = True) : boolean; overload; ///

/// Request that the browser close. The JavaScript 'onbeforeunload' event will /// be fired. If |aForceClose| is false (0) the event handler, if any, will be /// allowed to prompt the user and the user can optionally cancel the close. /// If |aForceClose| is true (1) the prompt will not be displayed and the /// close will proceed. Results in a call to /// ICefLifeSpanHandler.DoClose() if the event handler allows the close /// or if |aForceClose| is true (1). See ICefLifeSpanHandler.DoClose() /// documentation for additional usage information. ///

procedure CloseBrowser(aForceClose : boolean); ///

/// Calls CloseBrowser for all the browsers handled by this TChromiumCore instance. ///

procedure CloseAllBrowsers; ///

/// Helper for closing a browser. Call this function from the top-level window /// close handler (if any). Internally this calls CloseBrowser(false (0)) if /// the close has not yet been initiated. This function returns false (0) /// while the close is pending and true (1) after the close has completed. See /// CloseBrowser() and ICefLifeSpanHandler.DoClose() documentation for /// additional usage information. This function must be called on the browser /// process UI thread. ///

function TryCloseBrowser : boolean; ///

/// Select the browser with the aID identifier when TChromiumCore uses the /// multi-browser mode. ///

function SelectBrowser(aID : integer) : boolean; ///

/// Returns the index in the browsers array of the browser with the aID /// identifier when TChromiumCore uses the multi-browser mode. ///

function IndexOfBrowserID(aID : integer) : integer; ///

/// Creates a new request context in the aContext parameter that shares /// storage with the request context of the current browser and uses an /// optional handler. ///

function ShareRequestContext(var aContext : ICefRequestContext; const aHandler : ICefRequestContextHandler = nil) : boolean; {$IFDEF MSWINDOWS} ///

/// Used with browsers in OSR mode to initialize drag and drop in Windows. ///

procedure InitializeDragAndDrop(const aDropTargetWnd : HWND); ///

/// Used with browsers in OSR mode to shutdown drag and drop in Windows. ///

procedure ShutdownDragAndDrop; ///

/// Used to reparent the browser to a different TCEFWindowParent. ///

function SetNewBrowserParent(aNewParentHwnd : HWND) : boolean; {$ENDIF MSWINDOWS} ///

/// Used to create the browser after the global request context has been /// initialized. You need to set all properties and events before calling /// this function because it will only create the internal handlers needed /// for those events and the property values will be used in the browser /// initialization. /// The browser will be fully initialized when the TChromiumCore.OnAfterCreated /// event is triggered. ///

function CreateBrowser(aParentHandle : TCefWindowHandle; aParentRect : TRect; const aWindowName : ustring = ''; const aContext : ICefRequestContext = nil; const aExtraInfo : ICefDictionaryValue = nil; aForceAsPopup : boolean = False) : boolean; overload; virtual; ///

function CreateBrowser(const aURL : ustring; const aBrowserViewComp : TCEFBrowserViewComponent; const aContext : ICefRequestContext = nil; const aExtraInfo : ICefDictionaryValue = nil) : boolean; overload; virtual; ///

/// Used to navigate to a URL in the specified frame or the main frame. ///

procedure LoadURL(const aURL : ustring; const aFrameName : ustring = ''; const aFrameIdentifier : ustring = ''); overload; ///

/// Used to navigate to a URL in the specified frame or the main frame. ///

procedure LoadURL(const aURL : ustring; const aFrame : ICefFrame); overload; ///

/// Used to load a DATA URI with the HTML string contents in the specified frame or the main frame. ///

procedure LoadString(const aHTML : ustring; const aFrameName : ustring = ''; const aFrameIdentifier : ustring = ''); overload; ///

/// Used to load a DATA URI with the HTML string contents in the specified frame or the main frame. ///

procedure LoadString(const aHTML : ustring; const aFrame : ICefFrame); overload; ///

/// Used to load a DATA URI with the stream contents in the specified frame or the main frame. /// The DATA URI will be configured with the mime type and charset specified in the parameters. ///

procedure LoadResource(const aStream : TCustomMemoryStream; const aMimeType, aCharset : string; const aFrameName : ustring = ''; const aFrameIdentifier : ustring = ''); overload; ///

/// Used to load a DATA URI with the stream contents in the specified frame or the main frame. /// The DATA URI will be configured with the mime type and charset specified in the parameters. ///

procedure LoadResource(const aStream : TCustomMemoryStream; const aMimeType, aCharset : string; const aFrame : ICefFrame); overload; ///

/// Load the request represented by the aRequest object. ///

/// /// WARNING: This function will fail with bad IPC message reason /// INVALID_INITIATOR_ORIGIN (213) unless you first navigate to the request /// origin using some other mechanism (LoadURL, link click, etc). /// procedure LoadRequest(const aRequest: ICefRequest); ///

/// Navigate backwards. ///

procedure GoBack; ///

/// Navigate forwards. ///

procedure GoForward; ///

/// Reload the current page. ///

procedure Reload; ///

/// Reload the current page ignoring any cached data. ///

procedure ReloadIgnoreCache; ///

/// Stop loading the page. ///

procedure StopLoad; ///

/// Starts downloading a file in the specified URL. ///

procedure StartDownload(const aURL : ustring); ///

/// Starts downloading an image in the specified URL. /// Use the TChromiumCore.OnDownloadImageFinished event to receive the image. ///

procedure DownloadImage(const imageUrl: ustring; isFavicon: Boolean; maxImageSize: cardinal; bypassCache: Boolean); ///

/// Calls ICefBrowserHost.SendMouseWheelEvent to simulate a simple mouse wheel event. /// Use TChromiumCore.SendMouseWheelEvent if you need to specify the mouse coordinates or the event flags. ///

procedure SimulateMouseWheel(aDeltaX, aDeltaY : integer); ///

/// Dispatches a key event to the page using the "Input.dispatchKeyEvent" /// DevTools method. The browser has to be focused before simulating any /// key event. ///

/// Type of the key event. /// Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8. /// Windows virtual key code. /// Native virtual key code. /// Time at which the event occurred. /// Whether the event was from the left or right side of the keyboard. 1=Left, 2=Right. /// Whether the event was generated from auto repeat. /// Whether the event was generated from the keypad. /// Whether the event was a system key event. /// Text as generated by processing a virtual key code with a keyboard layout. Not needed for for keyUp and rawKeyDown events. /// Text that would have been generated by the keyboard if no modifiers were pressed (except for shift). Useful for shortcut (accelerator) key handling. /// Unique key identifier (e.g., 'U+0041'). /// Unique DOM defined string value for each physical key (e.g., 'KeyA'). /// Unique DOM defined string value describing the meaning of the key in the context of active modifiers, keyboard layout, etc (e.g., 'AltGr'). /// /// See the "Input.dispatchKeyEvent" DevTools method. /// procedure SimulateKeyEvent(type_: TSimulatedCefKeyEventType; modifiers, windowsVirtualKeyCode, nativeVirtualKeyCode: integer; timestamp: integer = 0; location: integer = 0; autoRepeat: boolean = False; isKeypad: boolean = False; isSystemKey: boolean = False; const text: ustring = ''; const unmodifiedtext: ustring = ''; const keyIdentifier: ustring = ''; const code: ustring = ''; const key: ustring = ''); ///

/// Clears all certificate exceptions that were added as part of handling /// OnCertificateError. If you call this it is recommended that you also call /// CloseAllConnections() or you risk not being prompted again for server /// certificates if you reconnect quickly. /// If aClearImmediately is false then OnCertificateExceptionsCleared is /// triggered when the exceptions are cleared. ///

function ClearCertificateExceptions(aClearImmediately : boolean = True) : boolean; ///

/// Clears all HTTP authentication credentials that were added as part of /// handling GetAuthCredentials. If |callback| is non-NULL it will be executed /// on the UI thread after completion. /// If aClearImmediately is false then OnHttpAuthCredentialsCleared is triggered /// when the credeintials are cleared. ///

function ClearHttpAuthCredentials(aClearImmediately : boolean = True) : boolean; ///

/// Clears all active and idle connections that Chromium currently has. This /// is only recommended if you have released all other CEF objects but don't /// yet want to call cef_shutdown(). ///

function CloseAllConnections(aCloseImmediately : boolean = True) : boolean; ///

/// Retrieve all the HTML content from the specified frame or the main frame. /// Leave aFrameName empty to get the HTML source from the main frame. /// It uses a CefStringVisitor to get the HTML content asynchronously and the /// result will be received in the TChromiumCore.OnTextResultAvailable event. ///

procedure RetrieveHTML(const aFrameName : ustring = ''; const aFrameIdentifier : ustring = ''); overload; ///

/// Retrieve all the HTML content from the specified frame or the main frame. /// Set aFrame to nil to get the HTML source from the main frame. /// It uses a CefStringVisitor to get the HTML content asynchronously and the /// result will be received in the TChromiumCore.OnTextResultAvailable event. ///

procedure RetrieveHTML(const aFrame : ICefFrame); overload; ///

/// Retrieve all the text content from the specified frame or the main frame. /// Leave aFrameName empty to get the text from the main frame. /// It uses a CefStringVisitor to get the text asynchronously and the /// result will be received in the TChromiumCore.OnTextResultAvailable event. ///

procedure RetrieveText(const aFrameName : ustring = ''; const aFrameIdentifier : ustring = ''); overload; ///

/// Retrieve all the text content from the specified frame or the main frame. /// Set aFrame to nil to get the text from the main frame. /// It uses a CefStringVisitor to get the text asynchronously and the /// result will be received in the TChromiumCore.OnTextResultAvailable event. ///

procedure RetrieveText(const aFrame : ICefFrame); overload; ///

/// Retrieve a snapshot of current navigation entries asynchronously. The /// TChromiumCore.OnNavigationVisitorResultAvailable event will be triggered /// for each navigation entry. ///

procedure GetNavigationEntries(currentOnly: Boolean); ///

/// Returns the names of all existing frames. ///

function GetFrameNames(var aFrameNames : TStrings) : boolean; ///

/// Returns the identifiers of all existing frames. ///

function GetFrameIdentifiers(var aFrameIdentifiers : TStrings) : boolean; ///

/// Execute a string of JavaScript code in the specified frame or the main frame. ///

/// JavaScript code. /// The URL where the script in question can be found, if any. The renderer may request this URL to show the developer the source of the error. /// Name of the frame where the JavaScript code will be executed. This name is generated automatically by Chromium. See ICefBrowser.GetFrameNames. /// Identifier of the frame where the JavaScript code will be executed. /// The base line number to use for error reporting. procedure ExecuteJavaScript(const aCode, aScriptURL : ustring; const aFrameName : ustring = ''; const aFrameIdentifier : ustring = ''; aStartLine : integer = 0); overload; ///

/// Execute a string of JavaScript code in the specified frame or the main frame. ///

/// JavaScript code. /// The URL where the script in question can be found, if any. The renderer may request this URL to show the developer the source of the error. /// Frame where the JavaScript code will be executed. /// The base line number to use for error reporting. procedure ExecuteJavaScript(const aCode, aScriptURL : ustring; const aFrame : ICefFrame; aStartLine : integer = 0); overload; ///

/// Used to update the browser preferences using the TChromiumCore property values asynchronously. ///

procedure UpdatePreferences; ///

/// Save the browser preferences as a text file. ///

procedure SavePreferences(const aFileName : string); ///

/// Calls CefRequestContext.ResolveHost to resolve the domain in the URL parameter /// to a list of IP addresses. /// The result will be received in the TChromiumCore.OnResolvedHostAvailable event. ///

procedure ResolveHost(const aURL : ustring); ///

/// Used to check if the browser parameter is the same as the selected browser in TChromiumCore. ///

function IsSameBrowser(const aBrowser : ICefBrowser) : boolean; ///

/// Calling ExecuteTaskOnCefThread function will trigger the TChromiumCore.OnExecuteTaskOnCefThread event. ///

/// Indicates the CEF thread on which TChromiumCore.OnExecuteTaskOnCefThread will be executed. /// Custom ID used to identify the task that triggered the TChromiumCore.OnExecuteTaskOnCefThread event. /// Optional delay in milliseconds to trigger the TChromiumCore.OnExecuteTaskOnCefThread event. function ExecuteTaskOnCefThread(aCefThreadId : TCefThreadId; aTaskID : cardinal; aDelayMs : Int64 = 0) : boolean; ///

/// This procedure calls the Emulation.setUserAgentOverride DevTools method to override the user agent string. ///

procedure SetUserAgentOverride(const aUserAgent : ustring; const aAcceptLanguage : ustring = ''; const aPlatform : ustring = ''); ///

/// This procedure calls the Storage.clearDataForOrigin DevTools method to clear the storage data for a given origin. ///

procedure ClearDataForOrigin(const aOrigin : ustring; aStorageTypes : TCefClearDataStorageTypes = cdstAll); ///

/// This procedure calls the Network.clearBrowserCache DevTools method to clear the cache data. ///

procedure ClearCache; ///

/// Enable or disable the browser's audio. ///

procedure ToggleAudioMuted; ///

/// Used to delete cookies immediately or asynchronously. If aDeleteImmediately is false TChromiumCore.DeleteCookies triggers /// the TChromiumCore.OnCookiesDeleted event when the cookies are deleted. ///

function DeleteCookies(const url : ustring = ''; const cookieName : ustring = ''; aDeleteImmediately : boolean = False) : boolean; ///

/// TChromiumCore.VisitAllCookies triggers the TChromiumCore.OnCookiesVisited event for each cookie /// aID is an optional parameter to identify which VisitAllCookies call has triggered the /// OnCookiesVisited event. /// TChromiumCore.OnCookiesVisited may not be triggered if the cookie store is empty but the /// TChromium.OnCookieVisitorDestroyed event will always be triggered to signal when the browser /// when the visit is over. ///

function VisitAllCookies(aID : integer = 0) : boolean; ///

/// TChromiumCore.VisitURLCookies triggers the TChromiumCore.OnCookiesVisited event for each cookie /// aID is an optional parameter to identify which VisitURLCookies call has triggered the /// OnCookiesVisited event. /// TChromiumCore.OnCookiesVisited may not be triggered if the cookie store is empty but the /// TChromium.OnCookieVisitorDestroyed event will always be triggered to signal when the browser /// when the visit is over. ///

function VisitURLCookies(const url : ustring; includeHttpOnly : boolean = False; aID : integer = 0) : boolean; ///

/// TChromiumCore.SetCookie triggers the TChromiumCore.OnCookieSet event when the cookie has been set /// aID is an optional parameter to identify which SetCookie call has triggered the /// OnCookieSet event. ///

function SetCookie(const url, name_, value, domain, path: ustring; secure, httponly, hasExpires: Boolean; const creation, lastAccess, expires: TDateTime; same_site : TCefCookieSameSite; priority : TCefCookiePriority; aSetImmediately : boolean = True; aID : integer = 0): Boolean; ///

/// Flush the backing store (if any) to disk. ///

/// If aFlushImmediately is false the cookies will be flushed on the CEF UI thread and the OnCookiesFlushed event will be triggered. /// Returns false (0) if cookies cannot be accessed. function FlushCookieStore(aFlushImmediately : boolean = True) : boolean; ///

/// Open developer tools (DevTools) in its own browser. If inspectElementAt has a valid point /// with coordinates different than low(integer) then the element at the specified location /// will be inspected. If the DevTools browser is already open then it will be focused. ///

procedure ShowDevTools(const inspectElementAt: TPoint; aWindowInfo: PCefWindowInfo); ///

/// close the developer tools. ///

procedure CloseDevTools; overload; ///

/// close the developer tools. ///

procedure CloseDevTools(const aDevToolsWnd : TCefWindowHandle); overload; ///

/// Send a function call message over the DevTools protocol. |message_| must be /// a UTF8-encoded JSON dictionary that contains "id" (int), "function" /// (string) and "params" (dictionary, optional) values. See the DevTools /// protocol documentation at https://chromedevtools.github.io/devtools- /// protocol/ for details of supported functions and the expected "params" /// dictionary contents. |message_| will be copied if necessary. This function /// will return true (1) if called on the UI thread and the message was /// successfully submitted for validation, otherwise false (0). Validation /// will be applied asynchronously and any messages that fail due to /// formatting errors or missing parameters may be discarded without /// notification. Prefer ExecuteDevToolsMethod if a more structured approach /// to message formatting is desired. /// Every valid function call will result in an asynchronous function result /// or error message that references the sent message "id". Event messages are /// received while notifications are enabled (for example, between function /// calls for "Page.enable" and "Page.disable"). All received messages will be /// delivered to the observer(s) registered with AddDevToolsMessageObserver. /// See ICefDevToolsMessageObserver.OnDevToolsMessage documentation for /// details of received message contents. /// Usage of the SendDevToolsMessage, ExecuteDevToolsMethod and /// AddDevToolsMessageObserver functions does not require an active DevTools /// front-end or remote-debugging session. Other active DevTools sessions will /// continue to function independently. However, any modification of global /// browser state by one session may not be reflected in the UI of other /// sessions. /// Communication with the DevTools front-end (when displayed) can be logged /// for development purposes by passing the `--devtools-protocol-log- /// file=` command-line flag. ///

function SendDevToolsMessage(const message_: ustring): boolean; ///

/// Execute a function call over the DevTools protocol. This is a more /// structured version of SendDevToolsMessage. |message_id| is an incremental /// number that uniquely identifies the message (pass 0 to have the next /// number assigned automatically based on previous values). |function| is the /// function name. |params| are the function parameters, which may be NULL. /// See the DevTools protocol documentation (linked above) for details of /// supported functions and the expected |params| dictionary contents. This /// function will return the assigned message ID if called on the UI thread /// and the message was successfully submitted for validation, otherwise 0. /// See the SendDevToolsMessage documentation for additional usage /// information. ///

function ExecuteDevToolsMethod(message_id: integer; const method: ustring; const params: ICefDictionaryValue): Integer; ///

/// Add an observer for DevTools protocol messages (function results and /// events). The observer will remain registered until the returned /// Registration object is destroyed. See the SendDevToolsMessage /// documentation for additional usage information. ///

function AddDevToolsMessageObserver(const observer: ICefDevToolsMessageObserver): ICefRegistration; ///

procedure Find(const aSearchText : ustring; aForward, aMatchCase, aFindNext : Boolean); ///

/// Cancel all searches that are currently going on. ///

procedure StopFinding(aClearSelection : Boolean); ///

/// Print the current browser contents. ///

procedure Print; ///

/// Print the current browser contents to the PDF file specified by |path| and /// execute |callback| on completion. The caller is responsible for deleting /// |path| when done. For PDF printing to work on Linux you must implement the /// ICefPrintHandler.GetPdfPaperSize function. /// The TChromiumCore.OnPdfPrintFinished event will be triggered when the PDF /// file is created. ///

procedure PrintToPDF(const aFilePath : ustring); ///

/// Execute copy on the focused frame. ///

procedure ClipboardCopy; ///

/// Execute paste on the focused frame. ///

procedure ClipboardPaste; ///

/// Execute cut on the focused frame. ///

procedure ClipboardCut; ///

/// Execute undo on the focused frame. ///

procedure ClipboardUndo; ///

/// Execute redo on the focused frame. ///

procedure ClipboardRedo; ///

/// Execute delete on the focused frame. ///

procedure ClipboardDel; ///

/// Execute select all on the focused frame. ///

procedure SelectAll; ///

/// Increase the zoom value. This procedure triggers the TChromium.OnZoomPctAvailable event with the new zoom value. ///

procedure IncZoomStep; ///

/// Decrease the zoom value. This procedure triggers the TChromium.OnZoomPctAvailable event with the new zoom value. ///

procedure DecZoomStep; ///

/// Increase the zoom value. This procedure triggers the TChromium.OnZoomPctAvailable event with the new zoom value. ///

procedure IncZoomPct; ///

/// Decrease the zoom value. This procedure triggers the TChromium.OnZoomPctAvailable event with the new zoom value. ///

procedure DecZoomPct; ///

/// Reset the zoom value. This procedure triggers the TChromium.OnZoomPctAvailable event with the new zoom value. ///

procedure ResetZoomStep; ///

/// Reset the zoom value. This procedure triggers the TChromium.OnZoomPctAvailable event with the new zoom value. ///

procedure ResetZoomLevel; ///

/// Reset the zoom value. This procedure triggers the TChromium.OnZoomPctAvailable event with the new zoom value. ///

procedure ResetZoomPct; ///

/// Read the zoom value. This procedure triggers the TChromium.OnZoomPctAvailable event with the zoom value. ///

procedure ReadZoom; ///

/// Execute a zoom IN command in this browser. If called on the CEF UI thread the /// change will be applied immediately. Otherwise, the change will be applied /// asynchronously on the CEF UI thread. ///

procedure IncZoomCommand; ///

/// Execute a zoom OUT command in this browser. If called on the CEF UI thread the /// change will be applied immediately. Otherwise, the change will be applied /// asynchronously on the CEF UI thread. ///

procedure DecZoomCommand; ///

/// Execute a zoom RESET command in this browser. If called on the CEF UI thread the /// change will be applied immediately. Otherwise, the change will be applied /// asynchronously on the CEF UI thread. ///

procedure ResetZoomCommand; ///

/// Notify the browser that the widget has been resized. The browser will /// first call ICefRenderHandler.GetViewRect to get the new size and then /// call ICefRenderHandler.OnPaint asynchronously with the updated /// regions. This function is only used when window rendering is disabled. ///

procedure WasResized; ///

/// Notify the browser that it has been hidden or shown. Layouting and /// ICefRenderHandler.OnPaint notification will stop when the browser is /// hidden. This function is only used when window rendering is disabled. ///

procedure WasHidden(hidden: Boolean); ///

/// Send a notification to the browser that the screen info has changed. The /// browser will then call ICefRenderHandler.GetScreenInfo to update the /// screen information with the new values. This simulates moving the webview /// window from one display to another, or changing the properties of the /// current display. This function is only used when window rendering is /// disabled. ///

procedure NotifyScreenInfoChanged; ///

/// Notify the browser that the window hosting it is about to be moved or /// resized. This function is only used on Windows and Linux. ///

procedure NotifyMoveOrResizeStarted; ///

/// Invalidate the view. The browser will call ICefRenderHandler.OnPaint /// asynchronously. This function is only used when window rendering is /// disabled. ///

procedure Invalidate(type_: TCefPaintElementType = PET_VIEW); ///

/// Requests the renderer to exit browser fullscreen. In most cases exiting /// window fullscreen should also exit browser fullscreen. With the Alloy /// runtime this function should be called in response to a user action such /// as clicking the green traffic light button on MacOS /// (ICefWindowDelegate.OnWindowFullscreenTransition callback) or pressing /// the "ESC" key (ICefKeyboardHandler.OnPreKeyEvent callback). With the /// Chrome runtime these standard exit actions are handled internally but /// new/additional user actions can use this function. Set |will_cause_resize| /// to true (1) if exiting browser fullscreen will cause a view resize. ///

procedure ExitFullscreen(will_cause_resize: boolean); ///

/// Returns true (1) if a Chrome command is supported and enabled. Values for /// |command_id| can be found in the cef_command_ids.h file. This function can /// only be called on the UI thread. Only used with the Chrome runtime. ///

/// /// See the IDC_* constants in uCEFConstants.pas for all the |command_id| values. /// The command_id values are also available in chrome/app/chrome_command_ids.h /// function CanExecuteChromeCommand(command_id: integer): boolean; ///

/// Execute a Chrome command. Values for |command_id| can be found in the /// cef_command_ids.h file. |disposition| provides information about the /// intended command target. Only used with the Chrome runtime. ///

/// /// See the IDC_* constants in uCEFConstants.pas for all the |command_id| values. /// The command_id values are also available in chrome/app/chrome_command_ids.h /// procedure ExecuteChromeCommand(command_id: integer; disposition: TCefWindowOpenDisposition); ///

/// Issue a BeginFrame request to Chromium. Only valid when /// TCefWindowInfo.external_begin_frame_enabled is set to true (1). ///

procedure SendExternalBeginFrame; ///

/// Send a key event to the browser. ///

procedure SendKeyEvent(const event: PCefKeyEvent); ///

/// Send a mouse click event to the browser. The |x| and |y| coordinates are /// relative to the upper-left corner of the view. ///

procedure SendMouseClickEvent(const event: PCefMouseEvent; type_: TCefMouseButtonType; mouseUp: Boolean; clickCount: Integer); ///

/// Send a mouse move event to the browser. The |x| and |y| coordinates are /// relative to the upper-left corner of the view. ///

procedure SendMouseMoveEvent(const event: PCefMouseEvent; mouseLeave: Boolean); ///

/// Send a mouse wheel event to the browser. The |x| and |y| coordinates are /// relative to the upper-left corner of the view. The |deltaX| and |deltaY| /// values represent the movement delta in the X and Y directions /// respectively. In order to scroll inside select popups with window /// rendering disabled ICefRenderHandler.GetScreenPoint should be /// implemented properly. ///

procedure SendMouseWheelEvent(const event: PCefMouseEvent; deltaX, deltaY: Integer); ///

/// Send a touch event to the browser for a windowless browser. ///

procedure SendTouchEvent(const event: PCefTouchEvent); ///

/// Send a capture lost event to the browser. ///

procedure SendCaptureLostEvent; ///

/// Send a message to the specified |targetProcess|. Ownership of the message /// contents will be transferred and the |ProcMessage| reference will be /// invalidated. Message delivery is not guaranteed in all cases (for example, /// if the browser is closing, navigating, or if the target process crashes). /// Send an ACK message back from the target process if confirmation is /// required. ///

procedure SendProcessMessage(targetProcess: TCefProcessId; const ProcMessage: ICefProcessMessage; const aFrameName : ustring = ''; const aFrameIdentifier : ustring = ''); overload; ///

procedure SendProcessMessage(targetProcess: TCefProcessId; const ProcMessage: ICefProcessMessage; const aFrame : ICefFrame); overload; ///

/// Create a new URL request that will be treated as originating from this /// frame and the associated browser. Use TCustomCefUrlrequestClient.Create instead if /// you do not want the request to have this association, in which case it may /// be handled differently (see documentation on that function). A request /// created with this function may only originate from the browser process, /// and will behave as follows: ///


      ///   - It may be intercepted by the client via CefResourceRequestHandler or
      ///     CefSchemeHandlerFactory.
      ///   - POST data may only contain a single element of type PDE_TYPE_FILE or
      ///     PDE_TYPE_BYTES.
      ///

/// The |request| object will be marked as read-only after calling this /// function. ///

function CreateUrlRequest(const request: ICefRequest; const client: ICefUrlrequestClient; const aFrameName : ustring = ''; const aFrameIdentifier : ustring = ''): ICefUrlRequest; overload; ///


      ///   - It may be intercepted by the client via CefResourceRequestHandler or
      ///     CefSchemeHandlerFactory.
      ///   - POST data may only contain a single element of type PDE_TYPE_FILE or
      ///     PDE_TYPE_BYTES.
      ///

/// The |request| object will be marked as read-only after calling this /// function. ///

function CreateUrlRequest(const request: ICefRequest; const client: ICefUrlrequestClient; const aFrame : ICefFrame): ICefUrlRequest; overload; ///

/// Set whether the browser is focused. ///

procedure SetFocus(focus: Boolean); ///

/// Set accessibility state for all frames. |accessibility_state| may be /// default, enabled or disabled. If |accessibility_state| is STATE_DEFAULT /// then accessibility will be disabled by default and the state may be /// further controlled with the "force-renderer-accessibility" and "disable- /// renderer-accessibility" command-line switches. If |accessibility_state| is /// STATE_ENABLED then accessibility will be enabled. If |accessibility_state| /// is STATE_DISABLED then accessibility will be completely disabled. /// For windowed browsers accessibility will be enabled in Complete mode /// (which corresponds to kAccessibilityModeComplete in Chromium). In this /// mode all platform accessibility objects will be created and managed by /// Chromium's internal implementation. The client needs only to detect the /// screen reader and call this function appropriately. For example, on macOS /// the client can handle the @"AXEnhancedUserStructure" accessibility /// attribute to detect VoiceOver state changes and on Windows the client can /// handle WM_GETOBJECT with OBJID_CLIENT to detect accessibility readers. /// For windowless browsers accessibility will be enabled in TreeOnly mode /// (which corresponds to kAccessibilityModeWebContentsOnly in Chromium). In /// this mode renderer accessibility is enabled, the full tree is computed, /// and events are passed to CefAccessibiltyHandler, but platform /// accessibility objects are not created. The client may implement platform /// accessibility objects using CefAccessibiltyHandler callbacks if desired. ///

procedure SetAccessibilityState(accessibilityState: TCefState); ///

/// Call this function when the user drags the mouse into the web view (before /// calling DragTargetDragOver/DragTargetLeave/DragTargetDrop). |drag_data| /// should not contain file contents as this type of data is not allowed to be /// dragged into the web view. File contents can be removed using /// ICefDragData.ResetFileContents (for example, if |drag_data| comes from /// ICefRenderHandler.StartDragging). This function is only used when /// window rendering is disabled. ///

procedure DragTargetDragEnter(const dragData: ICefDragData; const event: PCefMouseEvent; allowedOps: TCefDragOperations); ///

/// Call this function each time the mouse is moved across the web view during /// a drag operation (after calling DragTargetDragEnter and before calling /// DragTargetDragLeave/DragTargetDrop). This function is only used when /// window rendering is disabled. ///

procedure DragTargetDragOver(const event: PCefMouseEvent; allowedOps: TCefDragOperations); ///

/// Call this function when the user drags the mouse out of the web view /// (after calling DragTargetDragEnter). This function is only used when /// window rendering is disabled. ///

procedure DragTargetDragLeave; ///

/// Call this function when the user completes the drag operation by dropping /// the object onto the web view (after calling DragTargetDragEnter). The /// object being dropped is |drag_data|, given as an argument to the previous /// DragTargetDragEnter call. This function is only used when window rendering /// is disabled. ///

procedure DragTargetDrop(const event: PCefMouseEvent); ///

/// Call this function when the drag operation started by a /// ICefRenderHandler.StartDragging call has ended either in a drop or by /// being cancelled. |x| and |y| are mouse coordinates relative to the upper- /// left corner of the view. If the web view is both the drag source and the /// drag target then all DragTarget* functions should be called before /// DragSource* mthods. This function is only used when window rendering is /// disabled. ///

procedure DragSourceEndedAt(x, y: Integer; op: TCefDragOperation); ///

/// Call this function when the drag operation started by a /// ICefRenderHandler.StartDragging call has completed. This function may /// be called immediately without first calling DragSourceEndedAt to cancel a /// drag operation. If the web view is both the drag source and the drag /// target then all DragTarget* functions should be called before DragSource* /// mthods. This function is only used when window rendering is disabled. ///

procedure DragSourceSystemDragEnded; ///

/// Begins a new composition or updates the existing composition. Blink has a /// special node (a composition node) that allows the input function to change /// text without affecting other DOM nodes. |text| is the optional text that /// will be inserted into the composition node. |underlines| is an optional /// set of ranges that will be underlined in the resulting text. /// |replacement_range| is an optional range of the existing text that will be /// replaced. |selection_range| is an optional range of the resulting text /// that will be selected after insertion or replacement. The /// |replacement_range| value is only used on OS X. /// This function may be called multiple times as the composition changes. /// When the client is done making changes the composition should either be /// canceled or completed. To cancel the composition call /// ImeCancelComposition. To complete the composition call either /// ImeCommitText or ImeFinishComposingText. Completion is usually signaled /// when: ///


      /// 1. The client receives a WM_IME_COMPOSITION message with a GCS_RESULTSTR
      ///    flag (on Windows), or;
      /// 2. The client receives a "commit" signal of GtkIMContext (on Linux), or;
      /// 3. insertText of NSTextInput is called (on Mac).
      ///

/// This function is only used when window rendering is disabled. ///

procedure IMESetComposition(const text: ustring; const underlines : TCefCompositionUnderlineDynArray; const replacement_range, selection_range : PCefRange); ///

/// Completes the existing composition by optionally inserting the specified /// |text| into the composition node. |replacement_range| is an optional range /// of the existing text that will be replaced. |relative_cursor_pos| is where /// the cursor will be positioned relative to the current cursor position. See /// comments on ImeSetComposition for usage. The |replacement_range| and /// |relative_cursor_pos| values are only used on OS X. This function is only /// used when window rendering is disabled. ///

procedure IMECommitText(const text: ustring; const replacement_range : PCefRange; relative_cursor_pos : integer); ///

/// Completes the existing composition by applying the current composition /// node contents. If |keep_selection| is false (0) the current selection, if /// any, will be discarded. See comments on ImeSetComposition for usage. This /// function is only used when window rendering is disabled. ///

procedure IMEFinishComposingText(keep_selection : boolean); ///

/// Cancels the existing composition and discards the composition node /// contents without applying them. See comments on ImeSetComposition for /// usage. This function is only used when window rendering is disabled. ///

procedure IMECancelComposition; ///

/// If a misspelled word is currently selected in an editable node calling /// this function will replace it with the specified |word|. ///

procedure ReplaceMisspelling(const aWord : ustring); ///

/// Add the specified |word| to the spelling dictionary. ///

procedure AddWordToDictionary(const aWord : ustring); {$IFDEF LINUX} ///

/// Used in Linux to resize the browser contents. ///

procedure UpdateBrowserSize(aLeft, aTop, aWidth, aHeight : integer); ///

/// Used in Linux to update the browser visibility. ///

procedure UpdateXWindowVisibility(aVisible : boolean); {$ENDIF} ///

/// Add an observer for MediaRouter events. The observer will remain /// registered until the returned Registration object is destroyed. ///

function AddObserver(const observer: ICefMediaObserver): ICefRegistration; ///

/// Returns a MediaSource object for the specified media source URN. Supported /// URN schemes include "cast:" and "dial:", and will be already known by the /// client application (e.g. "cast:?clientId="). ///

function GetSource(const urn: ustring): ICefMediaSource; ///

/// Trigger an asynchronous call to ICefMediaObserver.OnSinks on all /// registered observers. ///

procedure NotifyCurrentSinks; ///

/// Trigger an asynchronous call to ICefMediaObserver.OnRoutes on all /// registered observers. ///

procedure NotifyCurrentRoutes; ///

/// Create a new route between |source| and |sink|. Source and sink must be /// valid, compatible (as reported by ICefMediaSink.IsCompatibleWith), and /// a route between them must not already exist. |callback| will be executed /// on success or failure. If route creation succeeds it will also trigger an /// asynchronous call to ICefMediaObserver.OnRoutes on all registered /// observers. /// This procedure is asynchronous and the result, ICefMediaRoute and the error /// message will be available in the TChromium.OnMediaRouteCreateFinished event. ///

procedure CreateRoute(const source: ICefMediaSource; const sink: ICefMediaSink); ///

/// Asynchronously retrieves device info. /// This procedure will trigger OnMediaSinkDeviceInfo with the device info. ///

procedure GetDeviceInfo(const aMediaSink: ICefMediaSink); ///

/// Load an extension. /// If extension resources will be read from disk using the default load /// implementation then |root_directory| should be the absolute path to the /// extension resources directory and |manifest| should be NULL. If extension /// resources will be provided by the client (e.g. via cef_request_handler_t /// and/or cef_extension_handler_t) then |root_directory| should be a path /// component unique to the extension (if not absolute this will be internally /// prefixed with the PK_DIR_RESOURCES path) and |manifest| should contain the /// contents that would otherwise be read from the "manifest.json" file on /// disk. /// The loaded extension will be accessible in all contexts sharing the same /// storage (HasExtension returns true (1)). However, only the context on /// which this function was called is considered the loader (DidLoadExtension /// returns true (1)) and only the loader will receive /// TCustomRequestContextHandler callbacks for the extension. /// TCustomExtensionHandler.OnExtensionLoaded will be called on load success /// or TCustomExtensionHandler.OnExtensionLoadFailed will be called on load /// failure. /// If the extension specifies a background script via the "background" /// manifest key then TCustomExtensionHandler.OnBeforeBackgroundBrowser will /// be called to create the background browser. See that function for /// additional information about background scripts. /// For visible extension views the client application should evaluate the /// manifest to determine the correct extension URL to load and then pass that /// URL to the ICefBrowserHost.CreateBrowser* function after the extension /// has loaded. For example, the client can look for the "browser_action" /// manifest key as documented at /// https://developer.chrome.com/extensions/browserAction. Extension URLs take /// the form "chrome-extension:///". /// Browsers that host extensions differ from normal browsers as follows: ///


      ///  - Can access chrome.* JavaScript APIs if allowed by the manifest. Visit
      ///    chrome://extensions-support for the list of extension APIs currently
      ///    supported by CEF.
      ///  - Main frame navigation to non-extension content is blocked.
      ///  - Pinch-zooming is disabled.
      ///  - ICefBrowserHost.GetExtension returns the hosted extension.
      ///  - ICefBrowserHost.IsBackgroundHost returns true for background hosts.
      ///

/// See https://developer.chrome.com/extensions for extension implementation /// and usage documentation. ///

/// /// WARNING: This function is deprecated and will be removed in ~M127. /// function LoadExtension(const root_directory: ustring; const manifest: ICefDictionaryValue = nil; const handler: ICefExtensionHandler = nil; const requestContext : ICefRequestContext = nil) : boolean; deprecated; ///

/// Returns true (1) if this context was used to load the extension identified /// by |extension_id|. Other contexts sharing the same storage will also have /// access to the extension (see HasExtension). This function must be called /// on the browser process UI thread. ///

/// /// WARNING: This function is deprecated and will be removed in ~M127. /// function DidLoadExtension(const extension_id: ustring): boolean; deprecated; ///

/// Returns true (1) if this context has access to the extension identified by /// |extension_id|. This may not be the context that was used to load the /// extension (see DidLoadExtension). This function must be called on the /// browser process UI thread. ///

/// /// WARNING: This function is deprecated and will be removed in ~M127. /// function HasExtension(const extension_id: ustring): boolean; deprecated; ///

/// Retrieve the list of all extensions that this context has access to (see /// HasExtension). |extension_ids| will be populated with the list of /// extension ID values. Returns true (1) on success. This function must be /// called on the browser process UI thread. ///

/// /// WARNING: This function is deprecated and will be removed in ~M127. /// function GetExtensions(const extension_ids: TStringList): boolean; deprecated; ///

/// Returns the extension matching |extension_id| or NULL if no matching /// extension is accessible in this context (see HasExtension). This function /// must be called on the browser process UI thread. ///

/// /// WARNING: This function is deprecated and will be removed in ~M127. /// function GetExtension(const extension_id: ustring): ICefExtension; deprecated; ///

/// Returns the current value for |content_type| that applies for the /// specified URLs. If both URLs are NULL the default value will be returned. /// Returns nullptr if no value is configured. Must be called on the browser /// process UI thread. ///

function GetWebsiteSetting(const requesting_url, top_level_url: ustring; content_type: TCefContentSettingTypes): ICefValue; ///

/// Sets the current value for |content_type| for the specified URLs in the /// default scope. If both URLs are NULL, and the context is not incognito, /// the default value will be set. Pass nullptr for |value| to remove the /// default value for this content type. /// WARNING: Incorrect usage of this function may cause instability or /// security issues in Chromium. Make sure that you first understand the /// potential impact of any changes to |content_type| by reviewing the related /// source code in Chromium. For example, if you plan to modify /// CEF_CONTENT_SETTING_TYPE_POPUPS, first review and understand the usage of /// ContentSettingsType::POPUPS in Chromium: /// https://source.chromium.org/search?q=ContentSettingsType::POPUPS ///

procedure SetWebsiteSetting(const requesting_url, top_level_url: ustring; content_type: TCefContentSettingTypes; const value: ICefValue); ///

/// Returns the current value for |content_type| that applies for the /// specified URLs. If both URLs are NULL the default value will be returned. /// Returns CEF_CONTENT_SETTING_VALUE_DEFAULT if no value is configured. Must /// be called on the browser process UI thread. ///

function GetContentSetting(const requesting_url, top_level_url: ustring; content_type: TCefContentSettingTypes): TCefContentSettingValues; ///

/// Sets the current value for |content_type| for the specified URLs in the /// default scope. If both URLs are NULL, and the context is not incognito, /// the default value will be set. Pass CEF_CONTENT_SETTING_VALUE_DEFAULT for /// |value| to use the default value for this content type. /// WARNING: Incorrect usage of this function may cause instability or /// security issues in Chromium. Make sure that you first understand the /// potential impact of any changes to |content_type| by reviewing the related /// source code in Chromium. For example, if you plan to modify /// CEF_CONTENT_SETTING_TYPE_POPUPS, first review and understand the usage of /// ContentSettingsType::POPUPS in Chromium: /// https://source.chromium.org/search?q=ContentSettingsType::POPUPS ///

procedure SetContentSetting(const requesting_url, top_level_url: ustring; content_type: TCefContentSettingTypes; value: TCefContentSettingValues); ///

procedure SetChromeColorScheme(variant: TCefColorVariant; user_color: TCefColor); ///

/// First URL loaded by the browser after its creation. ///

property DefaultUrl : ustring read FDefaultUrl write SetDefaultUrl; ///

/// Properties used to fill the TCefBrowserSettings record which is used during the browser creation. ///

property Options : TChromiumOptions read FOptions write FOptions; ///

/// Font properties used to fill the TCefBrowserSettings record which is used during the browser creation. ///

property FontOptions : TChromiumFontOptions read FFontOptions write FFontOptions; ///

/// Properties used to fill the TCefPdfPrintSettings record which is used in the TChromiumCore.PrintToPDF call. ///

property PDFPrintOptions : TPDFPrintOptions read FPDFPrintOptions write FPDFPrintOptions; ///

/// Default encoding for Web content. If empty "ISO-8859-1" will be used. Also /// configurable using the "default-encoding" command-line switch. It's used during the browser creation. ///

property DefaultEncoding : ustring read FDefaultEncoding write FDefaultEncoding; ///

/// Globally unique identifier for the seleted browser. ///

property BrowserId : integer read GetBrowserId; ///

/// Returns a ICefBrowser instance of the selected browser. ///

property Browser : ICefBrowser read GetBrowser; ///

/// Returns a ICefBrowser instance of the browser with the specified id. ///

property BrowserById[id : integer] : ICefBrowser read GetBrowserById; ///

/// Returns the number of browsers in the browser array when the multi-browser mode is enabled. ///

property BrowserCount : integer read GetBrowserCount; ///

/// Returns the identifier of the browser in the specified array position when the multi-browser mode is enabled. ///

property BrowserIdByIndex[i : integer] : integer read GetBrowserIdByIndex; ///

/// Returns the ICefClient instance used by the selected browser. ///

property CefClient : ICefClient read FHandler; ///

/// Returns the ICefRequestContextHandler instance used in this browser. ///

property ReqContextHandler : ICefRequestContextHandler read FReqContextHandler; ///

/// Returns the ICefResourceRequestHandler instance used in this browser. ///

property ResourceRequestHandler : ICefResourceRequestHandler read FResourceRequestHandler; ///

/// Returns the TCefWindowInfo record used when the browser was created. ///

property CefWindowInfo : TCefWindowInfo read GetCefWindowInfo; ///

/// Returns the current visible navigation entry for this browser. ///

/// /// This property can only be used on the CEF UI thread. /// property VisibleNavigationEntry : ICefNavigationEntry read GetVisibleNavigationEntry; ///

/// Returns the runtime style for this browser (ALLOY or CHROME). See /// TCefRuntimeStyle documentation for details. ///

/// /// This property can only be read on the CEF UI thread. /// property RuntimeStyle : TCefRuntimeStyle read GetRuntimeStyle write SetRuntimeStyle; ///

/// Returns a ICefRequestContext instance used by the selected browser. ///

property RequestContext : ICefRequestContext read GetRequestContext; ///

/// Returns a ICefMediaRouter instance used by the selected browser. ///

property MediaRouter : ICefMediaRouter read GetMediaRouter; ///

/// Returns a ICefMediaObserver instance used by the selected browser. ///

property MediaObserver : ICefMediaObserver read FMediaObserver; ///

/// Returns the ICefRegistration instance obtained when the default MediaObserver was added. ///

property MediaObserverReg : ICefRegistration read FMediaObserverReg; ///

/// Returns a ICefDevToolsMessageObserver instance used by the selected browser. ///

property DevToolsMsgObserver : ICefDevToolsMessageObserver read FDevToolsMsgObserver; ///

/// Returns the ICefRegistration instance obtained when the default DevToolsMessageObserver was added. ///

property DevToolsMsgObserverReg : ICefRegistration read FDevToolsMsgObserverReg; ///

/// Returns a ICefExtensionHandler instance used by the selected browser. ///

property ExtensionHandler : ICefExtensionHandler read FExtensionHandler; ///

/// Returns the value of GlobalCEFApp.MultiThreadedMessageLoop. ///

property MultithreadApp : boolean read GetMultithreadApp; ///

/// Calls ICefBrowser.IsLoading and returns true if the browser is currently loading. ///

property IsLoading : boolean read GetIsLoading; ///

/// Calls ICefBrowser.HasDocument and returns true if a document has been loaded in the browser. ///

property HasDocument : boolean read GetHasDocument; ///

/// Calls ICefBrowserHost.HasView and returns true if this browser is wrapped in a ICefBrowserView. ///

property HasView : boolean read GetHasView; ///

/// Calls ICefBrowserHost.HasDevTools and returns true if this browser currently has an associated DevTools browser. ///

property HasDevTools : boolean read GetHasDevTools; ///

/// Returns true if ICefClient has a valid value. ///

property HasClientHandler : boolean read GetHasClientHandler; ///

/// Returns true if this component has a valid selected browser. ///

property HasBrowser : boolean read GetHasBrowser; ///

/// Calls ICefBrowser.CanGoBack and returns true if the browser can navigate back. ///

property CanGoBack : boolean read GetCanGoBack; ///

/// Calls ICefBrowser.CanGoForward and returns true if the browser can navigate forward. ///

property CanGoForward : boolean read GetCanGoForward; ///

/// Calls ICefBrowser.IsPopUp and returns true if the window is a popup window. ///

property IsPopUp : boolean read GetIsPopUp; ///

/// Calls ICefBrowserHost.GetWindowHandle and returns the window handle for this browser. ///

property WindowHandle : TCefWindowHandle read GetWindowHandle; ///

/// Calls ICefBrowserHost.GetOpenerWindowHandle and returns the window handle of the browser that opened this browser. ///

property OpenerWindowHandle : TCefWindowHandle read GetOpenerWindowHandle; {$IFDEF MSWINDOWS} ///

/// Handle of one to the child controls created automatically by CEF to show the web contents. ///

property BrowserHandle : THandle read FBrowserCompHWND; ///

/// Handle of one to the child controls created automatically by CEF to show the web contents. ///

property WidgetHandle : THandle read FWidgetCompHWND; ///

/// Handle of one to the child controls created automatically by CEF to show the web contents. ///

property RenderHandle : THandle read FRenderCompHWND; {$ENDIF} ///

/// Returns true if ICefBrowser.FocusedFrame has a valid value. ///

property FrameIsFocused : boolean read GetFrameIsFocused; ///

/// Returns true when the browser is fully initialized and it's not being closed. ///

property Initialized : boolean read GetInitialized; ///

/// Returns the cache value in ICefRequestContext.CachePath. ///

property RequestContextCache : ustring read GetRequestContextCache; ///

/// Calls ICefRequestContext.IsGlobal to check if the request context is the global context or it's independent. ///

property RequestContextIsGlobal : boolean read GetRequestContextIsGlobal; ///

/// Returns the current Chrome color scheme mode (SYSTEM, LIGHT or DARK). Must /// be called on the browser process UI thread. ///

property ChromeColorSchemeMode : TCefColorVariant read GetChromeColorSchemeMode; ///

/// Returns the current Chrome color scheme color, or transparent (0) for the /// default color. Must be called on the browser process UI thread. ///

property ChromeColorSchemeColor : TCefColor read GetChromeColorSchemeColor; ///

/// Returns the current Chrome color scheme variant. Must be called on the /// browser process UI thread. ///

property ChromeColorSchemeVariant : TCefColorVariant read GetChromeColorSchemeVariant; ///

/// Returns the URL of the main frame. ///

property DocumentURL : ustring read GetDocumentURL; ///

/// Returns the current zoom value. This property is based on the CefBrowserHost.ZoomLevel value which can only be read in the CEF UI thread. ///

property ZoomLevel : double read GetZoomLevel write SetZoomLevel; ///

/// Get the default zoom level. This value will be 0.0 by default but can be /// configured with the Chrome runtime. This function can only be called on /// the CEF UI thread. ///

property DefaultZoomLevel : double read GetDefaultZoomLevel; ///

/// Returns true (1) if this browser can execute the zoom IN command. /// This function can only be called on the CEF UI thread. ///

property CanIncZoom : boolean read GetCanIncZoom; ///

/// Returns true (1) if this browser can execute the zoom OUT command. /// This function can only be called on the CEF UI thread. ///

property CanDecZoom : boolean read GetCanDecZoom; ///

/// Returns true (1) if this browser can execute the zoom RESET command. /// This function can only be called on the CEF UI thread. ///

property CanResetZoom : boolean read GetCanResetZoom; ///

/// Returns the current zoom value. This property is based on the CefBrowserHost.ZoomLevel value which can only be read in the CEF UI thread. ///

property ZoomPct : double read GetZoomPct write SetZoomPct; ///

/// Returns the current zoom value. This property is based on the CefBrowserHost.ZoomLevel value which can only be read in the CEF UI thread. ///

property ZoomStep : byte read GetZoomStep write SetZoomStep; ///

/// Returns the maximum rate in frames per second (fps) that OnPaint will be called for a browser in OSR mode. ///

property WindowlessFrameRate : integer read GetWindowlessFrameRate write SetWindowlessFrameRate; ///

/// Custom HTTP header name added to all requests. ///

property CustomHeaderName : ustring read FCustomHeaderName write SetCustomHeaderName; ///

/// Custom HTTP header value added to all requests. ///

property CustomHeaderValue : ustring read FCustomHeaderValue write SetCustomHeaderValue; ///

/// Set to True if you want to send the DNT header. ///

property DoNotTrack : boolean read FDoNotTrack write SetDoNotTrack; ///

/// Set to True if you want to send the referer header. ///

property SendReferrer : boolean read FSendReferrer write SetSendReferrer; ///

/// Enable hyperlink auditing. ///

property HyperlinkAuditing : boolean read FHyperlinkAuditing write SetHyperlinkAuditing; ///

/// Allow using outdated plugins. ///

property AllowOutdatedPlugins : boolean read FAllowOutdatedPlugins write SetAllowOutdatedPlugins; ///

/// Always authorize plugins. ///

property AlwaysAuthorizePlugins : boolean read FAlwaysAuthorizePlugins write SetAlwaysAuthorizePlugins; ///

/// Always open PDF files externally. ///

property AlwaysOpenPDFExternally : boolean read FAlwaysOpenPDFExternally write SetAlwaysOpenPDFExternally; ///

/// Set to True if you want to enable the spell checker. ///

property SpellChecking : boolean read FSpellChecking write SetSpellChecking; ///

/// Comma delimited list of language codes used by the spell checker, for example "es-ES,en-US,fr-FR,de-DE,it-IT". ///

property SpellCheckerDicts : ustring read FSpellCheckerDicts write SetSpellCheckerDicts; ///

/// Returns true if the main frame exists and it's valid. ///

property HasValidMainFrame : boolean read GetHasValidMainFrame; ///

/// Returns the number of frames that currently exist. ///

property FrameCount : NativeUInt read GetFrameCount; ///

/// Returns the TcefDragOperation value used during drag and drop. ///

property DragOperations : TCefDragOperations read FDragOperations write FDragOperations; ///

/// Returns true if the browser's audio is muted. ///

property AudioMuted : boolean read GetAudioMuted write SetAudioMuted; ///

/// Returns true (1) if the renderer is currently in browser fullscreen. This /// differs from window fullscreen in that browser fullscreen is entered using /// the JavaScript Fullscreen API and modifies CSS attributes such as the /// ::backdrop pseudo-element and :fullscreen pseudo-structure. This property /// can only be called on the UI thread. ///

property Fullscreen : boolean read GetFullscreen; ///

/// Returns true (1) if the render process associated with this browser is /// currently unresponsive as indicated by a lack of input event processing /// for at least 15 seconds. To receive associated state change notifications /// and optionally handle an unresponsive render process implement /// ICefRequestHandler.OnRenderProcessUnresponsive. ///

/// /// This property can only be read on the CEF UI thread. /// property IsRenderProcessUnresponsive : boolean read GetIsRenderProcessUnresponsive; ///

/// Forces the Google safesearch in the browser preferences. ///

property SafeSearch : boolean read FSafeSearch write SetSafeSearch; ///

/// Forces the YouTube restrictions in the browser preferences. ///

property YouTubeRestrict : integer read FYouTubeRestrict write SetYouTubeRestrict; ///

/// Enables printing in the browser preferences. ///

property PrintingEnabled : boolean read FPrintingEnabled write SetPrintingEnabled; ///

/// Set the accept language list in the browser preferences. ///

property AcceptLanguageList : ustring read FAcceptLanguageList write SetAcceptLanguageList; ///

/// Sets the cookies policy value in the browser preferences. ///

property AcceptCookies : TCefCookiePref read FAcceptCookies write SetAcceptCookies; ///

/// Blocks third party cookies in the browser preferences. ///

property Block3rdPartyCookies : boolean read FBlock3rdPartyCookies write SetBlock3rdPartyCookies; ///

/// Enables the multi-browser mode that allows TChromiumCore to handle several browsers with one component. These browsers are usually the main browser, popup windows and new tabs. ///

property MultiBrowserMode : boolean read FMultiBrowserMode write SetMultiBrowserMode; {$IFDEF MSWINDOWS} ///

/// Default ExStyle value used to initialize the browser. A value of WS_EX_NOACTIVATE can be used as a workaround for some focus issues in CEF. ///

property DefaultWindowInfoExStyle : DWORD read GetWindowInfoExStyle write SetWindowInfoExStyle; {$ENDIF} ///

/// Uses the Network.emulateNetworkConditions DevTool method to set the browser in offline mode. ///

property Offline : boolean read FOffline write SetOffline; ///

/// Enables the Quic protocol in the browser preferences. ///

property QuicAllowed : boolean read FQuicAllowed write SetQuicAllowed; ///

/// Enables JavaScript in the browser preferences. ///

property JavascriptEnabled : boolean read FJavascriptEnabled write SetJavascriptEnabled; ///

/// Enables automatic image loading in the browser preferences. ///

property LoadImagesAutomatically : boolean read FLoadImagesAutomatically write SetLoadImagesAutomatically; ///

/// Battery saver mode state. ///

property BatterySaverModeState : TCefBatterySaverModeState read FBatterySaverModeState write SetBatterySaverModeState; ///

/// High efficiency mode state. ///

property HighEfficiencyModeState : TCefHighEfficiencyModeState read FHighEfficiencyModeState write SetHighEfficiencyModeState; ///

/// Indicates whether the browser can receive focus. ///

property CanFocus : boolean read FCanFocus; ///

/// Delay in milliseconds to enable browser focus. ///

property EnableFocusDelayMs : cardinal read FEnableFocusDelayMs write FEnableFocusDelayMs; {$IFDEF LINUX} ///

/// Gets the Xdisplay pointer in Linux. ///

property XDisplay : PXDisplay read GetXDisplay; {$ENDIF} ///

/// WebRTC handling policy setting in the browser preferences. ///

property WebRTCIPHandlingPolicy : TCefWebRTCHandlingPolicy read FWebRTCIPHandlingPolicy write SetWebRTCIPHandlingPolicy; ///

/// WebRTC multiple routes setting in the browser preferences. ///

property WebRTCMultipleRoutes : TCefState read FWebRTCMultipleRoutes write SetWebRTCMultipleRoutes; ///

/// WebRTC nonproxied UDP setting in the browser preferences. ///

property WebRTCNonproxiedUDP : TCefState read FWebRTCNonProxiedUDP write SetWebRTCNonProxiedUDP; ///

/// Proxy type: CEF_PROXYTYPE_DIRECT, CEF_PROXYTYPE_AUTODETECT, CEF_PROXYTYPE_SYSTEM, CEF_PROXYTYPE_FIXED_SERVERS or CEF_PROXYTYPE_PAC_SCRIPT. ///

property ProxyType : integer read FProxyType write SetProxyType; ///

/// Proxy scheme ///

property ProxyScheme : TCefProxyScheme read FProxyScheme write SetProxyScheme; ///

/// Proxy server address ///

property ProxyServer : ustring read FProxyServer write SetProxyServer; ///

/// Proxy server port ///

property ProxyPort : integer read FProxyPort write SetProxyPort; ///

/// Proxy username ///

property ProxyUsername : ustring read FProxyUsername write SetProxyUsername; ///

/// Proxy password ///

property ProxyPassword : ustring read FProxyPassword write SetProxyPassword; ///

/// URL of the PAC script file. ///

property ProxyScriptURL : ustring read FProxyScriptURL write SetProxyScriptURL; ///

/// This tells chromium to bypass any specified proxy for the given semi-colon-separated list of hosts. ///

property ProxyByPassList : ustring read FProxyByPassList write SetProxyByPassList; ///

/// Sets the maximum connections per proxy value in the browser preferences (experimental). ///

property MaxConnectionsPerProxy : integer read FMaxConnectionsPerProxy write SetMaxConnectionsPerProxy; ///

/// Enable the file download bubble when using the Chrome runtime. ///

property DownloadBubble : TCefState read FDownloadBubble write FDownloadBubble; published ///

/// Triggered after a TChromiumCore.RetrieveHTML or TChromiumCore.RetrieveText call with the HTML or text results. ///

property OnTextResultAvailable : TOnTextResultAvailableEvent read FOnTextResultAvailable write FOnTextResultAvailable; ///

/// Triggered after a TChromiumCore.PrintToPDF call when the PDF has been created. ///

property OnPdfPrintFinished : TOnPdfPrintFinishedEvent read FOnPdfPrintFinished write FOnPdfPrintFinished; ///

/// Triggered after a TChromiumCore.SavePreferences call when the preferences have been saved. ///

property OnPrefsAvailable : TOnPrefsAvailableEvent read FOnPrefsAvailable write FOnPrefsAvailable; ///

/// Triggered when the browser preferences have been updated. ///

property OnPrefsUpdated : TNotifyEvent read FOnPrefsUpdated write FOnPrefsUpdated; ///

/// Triggered after a TChromiumCore.DeleteCookies call when the cookies have been deleted. ///

property OnCookiesDeleted : TOnCookiesDeletedEvent read FOnCookiesDeleted write FOnCookiesDeleted; ///

/// Triggered after a TChromiumCore.ResolveHost call with the host information. ///

property OnResolvedHostAvailable : TOnResolvedIPsAvailableEvent read FOnResolvedHostAvailable write FOnResolvedHostAvailable; ///

/// Triggered after a TChromiumCore.GetNavigationEntries call with a navigation entry. ///

property OnNavigationVisitorResultAvailable : TOnNavigationVisitorResultAvailableEvent read FOnNavigationVisitorResultAvailable write FOnNavigationVisitorResultAvailable; ///

/// Triggered after a TChromiumCore.DownloadImage call when the download is complete. ///

property OnDownloadImageFinished : TOnDownloadImageFinishedEvent read FOnDownloadImageFinished write FOnDownloadImageFinished; ///

/// Triggered after a TChromiumCore.FlushCookieStore call when the cookies are flushed. ///

property OnCookiesFlushed : TNotifyEvent read FOnCookiesFlushed write FOnCookiesFlushed; ///

/// Triggered after a TChromiumCore.ClearCertificateExceptions call when the exceptions are cleared. ///

property OnCertificateExceptionsCleared : TNotifyEvent read FOnCertificateExceptionsCleared write FOnCertificateExceptionsCleared; ///

/// Triggered after a TChromiumCore.ClearHttpAuthCredentials call when the credentials are cleared. ///

property OnHttpAuthCredentialsCleared : TNotifyEvent read FOnHttpAuthCredentialsCleared write FOnHttpAuthCredentialsCleared; ///

/// Triggered after a TChromiumCore.CloseAllConnections call when the connections are closed. ///

property OnAllConnectionsClosed : TNotifyEvent read FOnAllConnectionsClosed write FOnAllConnectionsClosed; ///

/// Triggered after a TChromiumCore.ExecuteTaskOnCefThread call in the context of the specified CEF thread. ///

property OnExecuteTaskOnCefThread : TOnExecuteTaskOnCefThread read FOnExecuteTaskOnCefThread write FOnExecuteTaskOnCefThread; ///

/// Triggered after a TChromiumCore.VisitAllCookies call with cookie information. ///

property OnCookiesVisited : TOnCookiesVisited read FOnCookiesVisited write FOnCookiesVisited; ///

/// Triggered after a TChromiumCore.VisitAllCookies call when the IcefCookieVisitor has been destroyed. ///

property OnCookieVisitorDestroyed : TOnCookieVisitorDestroyed read FOnCookieVisitorDestroyed write FOnCookieVisitorDestroyed; ///

/// Triggered after a TChromiumCore.SetCookie call when the cookie has been set. ///

property OnCookieSet : TOnCookieSet read FOnCookieSet write FOnCookieSet; ///

/// Triggered after a call to any of the procedures to increase, decrease or reset the zoom with the new zoom value. ///

property OnZoomPctAvailable : TOnZoomPctAvailable read FOnZoomPctAvailable write FOnZoomPctAvailable; ///

/// Triggered after a TChromiumCore.CreateRoute call when the route is created. ///

property OnMediaRouteCreateFinished : TOnMediaRouteCreateFinishedEvent read FOnMediaRouteCreateFinished write FOnMediaRouteCreateFinished; ///

/// Triggered after a TChromiumCore.GetDeviceInfo call with the device info. ///

property OnMediaSinkDeviceInfo : TOnMediaSinkDeviceInfoEvent read FOnMediaSinkDeviceInfo write FOnMediaSinkDeviceInfo; ///

/// Triggered when the browser is capable of being focused. ///

property OnCanFocus : TNotifyEvent read FOnCanFocus write FOnCanFocus; {$IFDEF MSWINDOWS} ///

/// Triggered for all messages sent to the child controls created by CEF to show the web contents. ///

property OnBrowserCompMsg : TOnCompMsgEvent read FOnBrowserCompMsg write FOnBrowserCompMsg; ///

/// Triggered for all messages sent to the child controls created by CEF to show the web contents. ///

property OnWidgetCompMsg : TOnCompMsgEvent read FOnWidgetCompMsg write FOnWidgetCompMsg; ///

/// Triggered for all messages sent to the child controls created by CEF to show the web contents. ///

property OnRenderCompMsg : TOnCompMsgEvent read FOnRenderCompMsg write FOnRenderCompMsg; {$ENDIF} ///

/// Called when a new message is received from a different process. Return /// true (1) if the message was handled or false (0) otherwise. It is safe to /// keep a reference to |message| outside of this callback. ///

/// /// CEF source file: /include/capi/cef_client_capi.h (cef_client_t) /// property OnProcessMessageReceived : TOnProcessMessageReceived read FOnProcessMessageReceived write FOnProcessMessageReceived; ///

/// Called after a navigation has been committed and before the browser begins /// loading contents in the frame. The |frame| value will never be NULL -- /// call the IsMain() function to check if this frame is the main frame. /// |transition_type| provides information about the source of the navigation /// and an accurate value is only available in the browser process. Multiple /// frames may be loading at the same time. Sub-frames may start or continue /// loading after the main frame load has ended. This function will not be /// called for same page navigations (fragments, history state, etc.) or for /// navigations that fail or are canceled before commit. For notification of /// overall browser load status use OnLoadingStateChange instead. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_load_handler_capi.h (cef_load_handler_t) /// property OnLoadStart : TOnLoadStart read FOnLoadStart write FOnLoadStart; ///

/// Called when the browser is done loading a frame. The |frame| value will /// never be NULL -- call the IsMain() function to check if this frame is the /// main frame. Multiple frames may be loading at the same time. Sub-frames /// may start or continue loading after the main frame load has ended. This /// function will not be called for same page navigations (fragments, history /// state, etc.) or for navigations that fail or are canceled before commit. /// For notification of overall browser load status use OnLoadingStateChange /// instead. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_load_handler_capi.h (cef_load_handler_t) /// property OnLoadEnd : TOnLoadEnd read FOnLoadEnd write FOnLoadEnd; ///

/// Called when a navigation fails or is canceled. This function may be called /// by itself if before commit or in combination with OnLoadStart/OnLoadEnd if /// after commit. |errorCode| is the error code number, |errorText| is the /// error text and |failedUrl| is the URL that failed to load. See /// net\base\net_error_list.h for complete descriptions of the error codes. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_load_handler_capi.h (cef_load_handler_t) /// property OnLoadError : TOnLoadError read FOnLoadError write FOnLoadError; ///

/// Called when the loading state has changed. This callback will be executed /// twice -- once when loading is initiated either programmatically or by user /// action, and once when loading is terminated due to completion, /// cancellation of failure. It will be called before any calls to OnLoadStart /// and after all calls to OnLoadError and/or OnLoadEnd. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_load_handler_capi.h (cef_load_handler_t) /// property OnLoadingStateChange : TOnLoadingStateChange read FOnLoadingStateChange write FOnLoadingStateChange; ///

/// Called when the browser component is about to loose focus. For instance, /// if focus was on the last HTML element and the user pressed the TAB key. /// |next| will be true (1) if the browser is giving focus to the next /// component and false (0) if the browser is giving focus to the previous /// component. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_focus_handler_capi.h (cef_focus_handler_t) /// property OnTakeFocus : TOnTakeFocus read FOnTakeFocus write FOnTakeFocus; ///

/// Called when the browser component is requesting focus. |source| indicates /// where the focus request is originating from. Return false (0) to allow the /// focus to be set or true (1) to cancel setting the focus. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_focus_handler_capi.h (cef_focus_handler_t) /// property OnSetFocus : TOnSetFocus read FOnSetFocus write FOnSetFocus; ///

/// Called when the browser component has received focus. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_focus_handler_capi.h (cef_focus_handler_t) /// property OnGotFocus : TOnGotFocus read FOnGotFocus write FOnGotFocus; ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_context_menu_handler_capi.h (cef_context_menu_handler_t) /// property OnBeforeContextMenu : TOnBeforeContextMenu read FOnBeforeContextMenu write FOnBeforeContextMenu; ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_context_menu_handler_capi.h (cef_context_menu_handler_t) /// property OnRunContextMenu : TOnRunContextMenu read FOnRunContextMenu write FOnRunContextMenu; ///

/// Called to execute a command selected from the context menu. Return true /// (1) if the command was handled or false (0) for the default /// implementation. See cef_menu_id_t for the command ids that have default /// implementations. All user-defined command ids should be between /// MENU_ID_USER_FIRST and MENU_ID_USER_LAST. |params| will have the same /// values as what was passed to on_before_context_menu(). Do not keep a /// reference to |params| outside of this callback. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_context_menu_handler_capi.h (cef_context_menu_handler_t) /// property OnContextMenuCommand : TOnContextMenuCommand read FOnContextMenuCommand write FOnContextMenuCommand; ///

/// Called when the context menu is dismissed irregardless of whether the menu /// was canceled or a command was selected. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_context_menu_handler_capi.h (cef_context_menu_handler_t) /// property OnContextMenuDismissed : TOnContextMenuDismissed read FOnContextMenuDismissed write FOnContextMenuDismissed; ///

/// Called to allow custom display of the quick menu for a windowless browser. /// |location| is the top left corner of the selected region. |size| is the /// size of the selected region. |edit_state_flags| is a combination of flags /// that represent the state of the quick menu. Return true (1) if the menu /// will be handled and execute |callback| either synchronously or /// asynchronously with the selected command ID. Return false (0) to cancel /// the menu. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_context_menu_handler_capi.h (cef_context_menu_handler_t) /// property OnRunQuickMenu : TOnRunQuickMenuEvent read FOnRunQuickMenu write FOnRunQuickMenu; ///

/// Called to execute a command selected from the quick menu for a windowless /// browser. Return true (1) if the command was handled or false (0) for the /// default implementation. See cef_menu_id_t for command IDs that have /// default implementations. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_context_menu_handler_capi.h (cef_context_menu_handler_t) /// property OnQuickMenuCommand : TOnQuickMenuCommandEvent read FOnQuickMenuCommand write FOnQuickMenuCommand; ///

/// Called when the quick menu for a windowless browser is dismissed /// irregardless of whether the menu was canceled or a command was selected. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_context_menu_handler_capi.h (cef_context_menu_handler_t) /// property OnQuickMenuDismissed : TOnQuickMenuDismissedEvent read FOnQuickMenuDismissed write FOnQuickMenuDismissed; ///

/// Called before a keyboard event is sent to the renderer. |event| contains /// information about the keyboard event. |os_event| is the operating system /// event message, if any. Return true (1) if the event was handled or false /// (0) otherwise. If the event will be handled in on_key_event() as a /// keyboard shortcut set |is_keyboard_shortcut| to true (1) and return false /// (0). ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_keyboard_handler_capi.h (cef_keyboard_handler_t) /// property OnPreKeyEvent : TOnPreKeyEvent read FOnPreKeyEvent write FOnPreKeyEvent; ///

/// Called after the renderer and JavaScript in the page has had a chance to /// handle the event. |event| contains information about the keyboard event. /// |os_event| is the operating system event message, if any. Return true (1) /// if the keyboard event was handled or false (0) otherwise. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_keyboard_handler_capi.h (cef_keyboard_handler_t) /// property OnKeyEvent : TOnKeyEvent read FOnKeyEvent write FOnKeyEvent; ///

/// Called when a frame's address has changed. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnAddressChange : TOnAddressChange read FOnAddressChange write FOnAddressChange; ///

/// Called when the page title changes. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnTitleChange : TOnTitleChange read FOnTitleChange write FOnTitleChange; ///

/// Called when the page icon changes. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnFavIconUrlChange : TOnFavIconUrlChange read FOnFavIconUrlChange write FOnFavIconUrlChange; ///

/// Called when web content in the page has toggled fullscreen mode. If /// |fullscreen| is true (1) the content will automatically be sized to fill /// the browser content area. If |fullscreen| is false (0) the content will /// automatically return to its original size and position. With the Alloy /// runtime the client is responsible for triggering the fullscreen transition /// (for example, by calling ICefWindow.SetFullscreen when using Views). /// With the Chrome runtime the fullscreen transition will be triggered /// automatically. The ICefWindowDelegate.OnWindowFullscreenTransition /// function will be called during the fullscreen transition for notification /// purposes. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnFullScreenModeChange : TOnFullScreenModeChange read FOnFullScreenModeChange write FOnFullScreenModeChange; ///

/// Called when the browser is about to display a tooltip. |text| contains the /// text that will be displayed in the tooltip. To handle the display of the /// tooltip yourself return true (1). Otherwise, you can optionally modify /// |text| and then return false (0) to allow the browser to display the /// tooltip. When window rendering is disabled the application is responsible /// for drawing tooltips and the return value is ignored. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnTooltip : TOnTooltip read FOnTooltip write FOnTooltip; ///

/// Called when the browser receives a status message. |value| contains the /// text that will be displayed in the status message. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnStatusMessage : TOnStatusMessage read FOnStatusMessage write FOnStatusMessage; ///

/// Called to display a console message. Return true (1) to stop the message /// from being output to the console. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnConsoleMessage : TOnConsoleMessage read FOnConsoleMessage write FOnConsoleMessage; ///

/// Called when auto-resize is enabled via /// cef_browser_host_t::SetAutoResizeEnabled and the contents have auto- /// resized. |new_size| will be the desired size in view coordinates. Return /// true (1) if the resize was handled or false (0) for default handling. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnAutoResize : TOnAutoResize read FOnAutoResize write FOnAutoResize; ///

/// Called when the overall page loading progress has changed. |progress| /// ranges from 0.0 to 1.0. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnLoadingProgressChange : TOnLoadingProgressChange read FOnLoadingProgressChange write FOnLoadingProgressChange; ///

/// Called when the browser's cursor has changed. If |type| is CT_CUSTOM then /// |custom_cursor_info| will be populated with the custom cursor information. /// Return true (1) if the cursor change was handled or false (0) for default /// handling. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnCursorChange : TOnCursorChange read FOnCursorChange write FOnCursorChange; ///

/// Called when the browser's access to an audio and/or video source has /// changed. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_display_handler_capi.h (cef_display_handler_t) /// property OnMediaAccessChange : TOnMediaAccessChange read FOnMediaAccessChange write FOnMediaAccessChange; ///

/// Called before a download begins in response to a user-initiated action /// (e.g. alt + link click or link click that returns a `Content-Disposition: /// attachment` response from the server). |url| is the target download URL /// and |request_function| is the target function (GET, POST, etc). Return /// true (1) to proceed with the download or false (0) to cancel the download. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_download_handler_capi.h (cef_download_handler_t) /// property OnCanDownload : TOnCanDownloadEvent read FOnCanDownload write FOnCanDownload; ///

/// Called before a download begins. |suggested_name| is the suggested name /// for the download file. Set aResult to true (1) and execute |callback| either /// asynchronously or in this function to continue or cancel the download. /// Set aResult to false (0) to proceed with default handling (cancel with Alloy /// style, download shelf with Chrome style). Do not keep a reference to /// |download_item| outside of this function. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_download_handler_capi.h (cef_download_handler_t) /// property OnBeforeDownload : TOnBeforeDownload read FOnBeforeDownload write FOnBeforeDownload; ///

/// Called when a download's status or progress information has been updated. /// This may be called multiple times before and after OnBeforeDownload. /// Execute |callback| either asynchronously or in this function to cancel the /// download if desired. Do not keep a reference to |download_item| outside of /// this function. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_download_handler_capi.h (cef_download_handler_t) /// property OnDownloadUpdated : TOnDownloadUpdated read FOnDownloadUpdated write FOnDownloadUpdated; ///

/// Called to run a JavaScript dialog. If |origin_url| is non-NULL it can be /// passed to the CefFormatUrlForSecurityDisplay function to retrieve a secure /// and user-friendly display string. The |default_prompt_text| value will be /// specified for prompt dialogs only. Set |suppress_message| to true (1) and /// return false (0) to suppress the message (suppressing messages is /// preferable to immediately executing the callback as this is used to detect /// presumably malicious behavior like spamming alert messages in /// onbeforeunload). Set |suppress_message| to false (0) and return false (0) /// to use the default implementation (the default implementation will show /// one modal dialog at a time and suppress any additional dialog requests /// until the displayed dialog is dismissed). Return true (1) if the /// application will use a custom dialog or if the callback has been executed /// immediately. Custom dialogs may be either modal or modeless. If a custom /// dialog is used the application must execute |callback| once the custom /// dialog is dismissed. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_jsdialog_handler_capi.h (cef_jsdialog_handler_t) /// property OnJsdialog : TOnJsdialog read FOnJsdialog write FOnJsdialog; ///

/// Called to run a dialog asking the user if they want to leave a page. /// Return false (0) to use the default dialog implementation. Return true (1) /// if the application will use a custom dialog or if the callback has been /// executed immediately. Custom dialogs may be either modal or modeless. If a /// custom dialog is used the application must execute |callback| once the /// custom dialog is dismissed. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_jsdialog_handler_capi.h (cef_jsdialog_handler_t) /// property OnBeforeUnloadDialog : TOnBeforeUnloadDialog read FOnBeforeUnloadDialog write FOnBeforeUnloadDialog; ///

/// Called to cancel any pending dialogs and reset any saved dialog state. /// Will be called due to events like page navigation irregardless of whether /// any dialogs are currently pending. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_jsdialog_handler_capi.h (cef_jsdialog_handler_t) /// property OnResetDialogState : TOnResetDialogState read FOnResetDialogState write FOnResetDialogState; ///

/// Called when the dialog is closed. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_jsdialog_handler_capi.h (cef_jsdialog_handler_t) /// property OnDialogClosed : TOnDialogClosed read FOnDialogClosed write FOnDialogClosed; ///

/// Called on the CEF UI thread before a new popup browser is created. The /// |browser| and |frame| values represent the source of the popup request. /// The |target_url| and |target_frame_name| values indicate where the popup /// browser should navigate and may be NULL if not specified with the request. /// The |target_disposition| value indicates where the user intended to open /// the popup (e.g. current tab, new tab, etc). The |user_gesture| value will /// be true (1) if the popup was opened via explicit user gesture (e.g. /// clicking a link) or false (0) if the popup opened automatically (e.g. via /// the DomContentLoaded event). The |popupFeatures| structure contains /// additional information about the requested popup window. To allow creation /// of the popup browser optionally modify |windowInfo|, |client|, |settings| /// and |no_javascript_access| and return false (0). To cancel creation of the /// popup browser return true (1). The |client| and |settings| values will /// default to the source browser's values. If the |no_javascript_access| /// value is set to false (0) the new browser will not be scriptable and may /// not be hosted in the same renderer process as the source browser. Any /// modifications to |windowInfo| will be ignored if the parent browser is /// wrapped in a ICefBrowserView. Popup browser creation will be canceled /// if the parent browser is destroyed before the popup browser creation /// completes (indicated by a call to OnAfterCreated for the popup browser). /// The |extra_info| parameter provides an opportunity to specify extra /// information specific to the created popup browser that will be passed to /// ICefRenderProcessHandler.OnBrowserCreated in the render process. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_life_span_handler_capi.h (cef_life_span_handler_t) /// property OnBeforePopup : TOnBeforePopup read FOnBeforePopup write FOnBeforePopup; ///

/// Called on the CEF UI thread before a new DevTools popup browser is created. /// The |browser| value represents the source of the popup request. Optionally /// modify |windowInfo|, |client|, |settings| and |extra_info| values. The /// |client|, |settings| and |extra_info| values will default to the source /// browser's values. Any modifications to |windowInfo| will be ignored if the /// parent browser is Views-hosted (wrapped in a ICefBrowserView). /// The |extra_info| parameter provides an opportunity to specify extra /// information specific to the created popup browser that will be passed to /// ICefRenderProcessHandler.OnBrowserCreated() in the render process. /// The existing |extra_info| object, if any, will be read-only but may be /// replaced with a new object. /// Views-hosted source browsers will create Views-hosted DevTools popups /// unless |use_default_window| is set to to true (1). DevTools popups can be /// blocked by returning true (1) from ICefCommandHandler.OnChromeCommand /// for IDC_DEV_TOOLS. Only used with the Chrome runtime. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_life_span_handler_capi.h (cef_life_span_handler_t) /// property OnBeforeDevToolsPopup : TOnBeforeDevToolsPopup read FOnBeforeDevToolsPopup write FOnBeforeDevToolsPopup; ///

/// Called after a new browser is created. It is now safe to begin performing /// actions with |browser|. ICefFrameHandler callbacks related to initial /// main frame creation will arrive before this callback. See /// ICefFrameHandler documentation for additional usage information. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_life_span_handler_capi.h (cef_life_span_handler_t) /// property OnAfterCreated : TOnAfterCreated read FOnAfterCreated write FOnAfterCreated; ///

/// Called just before a browser is destroyed. Release all references to the /// browser object and do not attempt to execute any functions on the browser /// object (other than IsValid, GetIdentifier or IsSame) after this callback /// returns. ICefFrameHandler callbacks related to final main frame /// destruction will arrive after this callback and ICefBrowser.IsValid /// will return false (0) at that time. Any in-progress network requests /// associated with |browser| will be aborted when the browser is destroyed, /// and ICefResourceRequestHandler callbacks related to those requests may /// still arrive on the IO thread after this callback. See ICefFrameHandler /// and OnClose() documentation for additional usage information. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_life_span_handler_capi.h (cef_life_span_handler_t) /// property OnBeforeClose : TOnBeforeClose read FOnBeforeClose write FOnBeforeClose; ///

/// Called when a browser has recieved a request to close. This may result /// directly from a call to ICefBrowserHost.*CloseBrowser or indirectly /// if the browser is parented to a top-level window created by CEF and the /// user attempts to close that window (by clicking the 'X', for example). The /// OnClose function will be called after the JavaScript 'onunload' event /// has been fired. /// /// An application should handle top-level owner window close notifications by /// calling ICefBrowserHost.TryCloseBrowser or /// ICefBrowserHost.CloseBrowser(false) instead of allowing the window /// to close immediately (see the examples below). This gives CEF an /// opportunity to process the 'onbeforeunload' event and optionally cancel /// the close before OnClose is called. /// /// When windowed rendering is enabled CEF will internally create a window or /// view to host the browser. In that case returning false (0) from OnClose() /// will send the standard close notification to the browser's top-level owner /// window (e.g. WM_CLOSE on Windows, performClose: on OS X, "delete_event" on /// Linux or ICefWindowDelegate.CanClose callback from Views). If the /// browser's host window/view has already been destroyed (via view hierarchy /// tear-down, for example) then OnClose() will not be called for that /// browser since is no longer possible to cancel the close. /// /// When windowed rendering is disabled returning false (0) from OnClose() /// will cause the browser object to be destroyed immediately. /// /// If the browser's top-level owner window requires a non-standard close /// notification then send that notification from OnClose() and return true. /// /// The ICefLifeSpanHandler.OnBeforeClose function will be called /// after OnClose() (if OnClose() is called) and immediately before the /// browser object is destroyed. The application should only exit after /// OnBeforeClose() has been called for all existing browsers. /// /// The below examples describe what should happen during window close when /// the browser is parented to an application-provided top-level window. /// /// Example 1: Using ICefBrowserHost.TryCloseBrowser(). This is /// recommended for clients using standard close handling and windows created /// on the browser process UI thread. ///


      /// 1.  User clicks the window close button which sends a close notification
      ///     to the application's top-level window.
      /// 2.  Application's top-level window receives the close notification and
      ///     calls TryCloseBrowser() (which internally calls CloseBrowser(false)).
      ///     TryCloseBrowser() returns false so the client cancels the window
      ///     close.
      /// 3.  JavaScript 'onbeforeunload' handler executes and shows the close
      ///     confirmation dialog (which can be overridden via
      ///     ICefJSDialogHandler.OnBeforeUnloadDialog()).
      /// 4.  User approves the close.
      /// 5.  JavaScript 'onunload' handler executes.
      /// 6.  CEF sends a close notification to the application's top-level window
      ///     (because OnClose() returned false by default).
      /// 7.  Application's top-level window receives the close notification and
      ///     calls TryCloseBrowser(). TryCloseBrowser() returns true so the client
      ///     allows the window close.
      /// 8.  Application's top-level window is destroyed.
      /// 9.  Application's OnBeforeClose() handler is called and the browser object is destroyed.
      /// 10. Application exits by calling cef_quit_message_loop() if no other browsers exist.
      ///

/// Example 2: Using ICefBrowserHost::CloseBrowser(false) and /// implementing the OnClose() callback. This is recommended for clients /// using non-standard close handling or windows that were not created on the /// browser process UI thread. ///


      /// 1.  User clicks the window close button which sends a close notification
      ///     to the application's top-level window.
      /// 2.  Application's top-level window receives the close notification and:
      ///     A. Calls ICefBrowserHost.CloseBrowser(false).
      ///     B. Cancels the window close.
      /// 3.  JavaScript 'onbeforeunload' handler executes and shows the close
      ///     confirmation dialog (which can be overridden via
      ///     ICefJSDialogHandler.OnBeforeUnloadDialog()).
      /// 4.  User approves the close.
      /// 5.  JavaScript 'onunload' handler executes.
      /// 6.  Application's OnClose() handler is called. Application will:
      ///     A. Set a flag to indicate that the next close attempt will be allowed.
      ///     B. Return false.
      /// 7.  CEF sends an close notification to the application's top-level window.
      /// 8.  Application's top-level window receives the close notification and
      ///     allows the window to close based on the flag from #6B.
      /// 9.  Application's top-level window is destroyed.
      /// 10. Application's OnBeforeClose() handler is called and the browser object is destroyed.
      /// 11. Application exits by calling cef_quit_message_loop() if no other browsers exist.
      ///

///

/// Called on the UI thread before browser navigation. Return true (1) to /// cancel the navigation or false (0) to allow the navigation to proceed. The /// |request| object cannot be modified in this callback. /// ICefLoadHandler.OnLoadingStateChange will be called twice in all /// cases. If the navigation is allowed ICefLoadHandler.OnLoadStart and /// ICefLoadHandler.OnLoadEnd will be called. If the navigation is /// canceled ICefLoadHandler.OnLoadError will be called with an /// |errorCode| value of ERR_ABORTED. The |user_gesture| value will be true /// (1) if the browser navigated via explicit user gesture (e.g. clicking a /// link) or false (0) if it navigated automatically (e.g. via the /// DomContentLoaded event). ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnBeforeBrowse : TOnBeforeBrowse read FOnBeforeBrowse write FOnBeforeBrowse; ///

/// Called on the UI thread before OnBeforeBrowse in certain limited cases /// where navigating a new or different browser might be desirable. This /// includes user-initiated navigation that might open in a special way (e.g. /// links clicked via middle-click or ctrl + left-click) and certain types of /// cross-origin navigation initiated from the renderer process (e.g. /// navigating the top-level frame to/from a file URL). The |browser| and /// |frame| values represent the source of the navigation. The /// |target_disposition| value indicates where the user intended to navigate /// the browser based on standard Chromium behaviors (e.g. current tab, new /// tab, etc). The |user_gesture| value will be true (1) if the browser /// navigated via explicit user gesture (e.g. clicking a link) or false (0) if /// it navigated automatically (e.g. via the DomContentLoaded event). Return /// true (1) to cancel the navigation or false (0) to allow the navigation to /// proceed in the source browser's top-level frame. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnOpenUrlFromTab : TOnOpenUrlFromTab read FOnOpenUrlFromTab write FOnOpenUrlFromTab; ///

/// Called on the IO thread when the browser needs credentials from the user. /// |origin_url| is the origin making this authentication request. |isProxy| /// indicates whether the host is a proxy server. |host| contains the hostname /// and |port| contains the port number. |realm| is the realm of the challenge /// and may be NULL. |scheme| is the authentication scheme used, such as /// "basic" or "digest", and will be NULL if the source of the request is an /// FTP server. Return true (1) to continue the request and call /// ICefAuthCallback.cont() either in this function or at a later time /// when the authentication information is available. Return false (0) to /// cancel the request immediately. ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnGetAuthCredentials : TOnGetAuthCredentials read FOnGetAuthCredentials write FOnGetAuthCredentials; ///

/// Called on the UI thread to handle requests for URLs with an invalid SSL /// certificate. Return true (1) and call ICefCallback functions either in /// this function or at a later time to continue or cancel the request. Return /// false (0) to cancel the request immediately. If /// TCefSettings.ignore_certificate_errors is set all invalid certificates /// will be accepted without calling this function. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnCertificateError : TOnCertificateError read FOnCertificateError write FOnCertificateError; ///

/// Called on the UI thread when a client certificate is being requested for /// authentication. Return false (0) to use the default behavior and /// automatically select the first certificate available. Return true (1) and /// call ICefSelectClientCertificateCallback.Select either in this /// function or at a later time to select a certificate. Do not call Select or /// call it with NULL to continue without using any certificate. |isProxy| /// indicates whether the host is an HTTPS proxy or the origin server. |host| /// and |port| contains the hostname and port of the SSL server. /// |certificates| is the list of certificates to choose from; this list has /// already been pruned by Chromium so that it only contains certificates from /// issuers that the server trusts. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnSelectClientCertificate : TOnSelectClientCertificate read FOnSelectClientCertificate write FOnSelectClientCertificate; ///

/// Called on the browser process UI thread when the render view associated /// with |browser| is ready to receive/handle IPC messages in the render /// process. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnRenderViewReady : TOnRenderViewReady read FOnRenderViewReady write FOnRenderViewReady; ///

/// Called on the browser process UI thread when the render process is /// unresponsive as indicated by a lack of input event processing for at least /// 15 seconds. Return false (0) for the default behavior which is an /// indefinite wait with the Alloy runtime or display of the "Page /// unresponsive" dialog with the Chrome runtime. Return true (1) and don't /// execute the callback for an indefinite wait without display of the Chrome /// runtime dialog. Return true (1) and call /// ICefUnresponsiveProcessCallback.Wait either in this function or at a /// later time to reset the wait timer, potentially triggering another call to /// this function if the process remains unresponsive. Return true (1) and /// call ICefUnresponsiveProcessCallback.Terminate either in this /// function or at a later time to terminate the unresponsive process, /// resulting in a call to OnRenderProcessTerminated. /// OnRenderProcessResponsive will be called if the process becomes responsive /// after this function is called. This functionality depends on the hang /// monitor which can be disabled by passing the `--disable-hang-monitor` /// command-line flag or setting GlobalCEFApp.DisableHangMonitor to True. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnRenderProcessUnresponsive : TOnRenderProcessUnresponsive read FOnRenderProcessUnresponsive write FOnRenderProcessUnresponsive; ///

/// Called on the browser process UI thread when the render process becomes /// responsive after previously being unresponsive. See documentation on /// OnRenderProcessUnresponsive. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnRenderProcessResponsive : TOnRenderProcessResponsive read FOnRenderProcessResponsive write FOnRenderProcessResponsive; ///

/// Called on the browser process UI thread when the render process terminates /// unexpectedly. |status| indicates how the process terminated. |error_code| /// and |error_string| represent the error that would be displayed in Chrome's /// "Aw, Snap!" view. Possible |error_code| values include TCefResultCode /// non-normal exit values and platform-specific crash values (for example, a /// Posix signal or Windows hardware exception). ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnRenderProcessTerminated : TOnRenderProcessTerminated read FOnRenderProcessTerminated write FOnRenderProcessTerminated; ///

/// Called on the browser process IO thread before a resource request is /// initiated. The |browser| and |frame| values represent the source of the /// request. |request| represents the request contents and cannot be modified /// in this callback. |is_navigation| will be true (1) if the resource request /// is a navigation. |is_download| will be true (1) if the resource request is /// a download. |request_initiator| is the origin (scheme + domain) of the /// page that initiated the request. Set |disable_default_handling| to true /// (1) to disable default handling of the request, in which case it will need /// to be handled via ICefResourceRequestHandler.GetResourceHandler or it /// will be canceled. To allow the resource load to proceed with default /// handling return NULL. To specify a handler for the resource return a /// ICefResourceRequestHandler object. If this callback returns NULL the /// same function will be called on the associated /// ICefRequestContextHandler, if any. ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnGetResourceRequestHandler_ReqHdlr : TOnGetResourceRequestHandler read FOnGetResourceRequestHandler_ReqHdlr write FOnGetResourceRequestHandler_ReqHdlr; ///

/// Called on the browser process UI thread when the window.document object of /// the main frame has been created. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_request_handler_capi.h (cef_request_handler_t) /// property OnDocumentAvailableInMainFrame : TOnDocumentAvailableInMainFrame read FOnDocumentAvailableInMainFrame write FOnDocumentAvailableInMainFrame; ///

/// Called on the IO thread before a resource request is loaded. The |browser| /// and |frame| values represent the source of the request, and may be NULL /// for requests originating from service workers or ICefUrlRequest. To /// redirect or change the resource load optionally modify |request|. /// Modification of the request URL will be treated as a redirect. Return /// RV_CONTINUE to continue the request immediately. Return RV_CONTINUE_ASYNC /// and call ICefCallback functions at a later time to continue or cancel /// the request asynchronously. Return RV_CANCEL to cancel the request /// immediately. ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_resource_request_handler_capi.h (cef_resource_request_handler_t) /// property OnBeforeResourceLoad : TOnBeforeResourceLoad read FOnBeforeResourceLoad write FOnBeforeResourceLoad; ///

/// Called on the IO thread before a resource is loaded. The |browser| and /// |frame| values represent the source of the request, and may be NULL for /// requests originating from service workers or ICefUrlRequest. To allow /// the resource to load using the default network loader return NULL. To /// specify a handler for the resource return a ICefResourceHandler object. /// The |request| object cannot not be modified in this callback. ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_resource_request_handler_capi.h (cef_resource_request_handler_t) /// property OnGetResourceHandler : TOnGetResourceHandler read FOnGetResourceHandler write FOnGetResourceHandler; ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_resource_request_handler_capi.h (cef_resource_request_handler_t) /// property OnResourceRedirect : TOnResourceRedirect read FOnResourceRedirect write FOnResourceRedirect; ///

/// Called on the IO thread when a resource response is received. The /// |browser| and |frame| values represent the source of the request, and may /// be NULL for requests originating from service workers or ICefUrlRequest. /// To allow the resource load to proceed without modification return false /// (0). To redirect or retry the resource load optionally modify |request| /// and return true (1). Modification of the request URL will be treated as a /// redirect. Requests handled using the default network loader cannot be /// redirected in this callback. The |response| object cannot be modified in /// this callback. /// WARNING: Redirecting using this function is deprecated. Use /// OnBeforeResourceLoad or GetResourceHandler to perform redirects. ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_resource_request_handler_capi.h (cef_resource_request_handler_t) /// property OnResourceResponse : TOnResourceResponse read FOnResourceResponse write FOnResourceResponse; ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_resource_request_handler_capi.h (cef_resource_request_handler_t) /// property OnGetResourceResponseFilter : TOnGetResourceResponseFilter read FOnGetResourceResponseFilter write FOnGetResourceResponseFilter; ///

/// Called on the IO thread when a resource load has completed. The |browser| /// and |frame| values represent the source of the request, and may be NULL /// for requests originating from service workers or ICefUrlRequest. /// |request| and |response| represent the request and response respectively /// and cannot be modified in this callback. |status| indicates the load /// completion status. |received_content_length| is the number of response /// bytes actually read. This function will be called for all requests, /// including requests that are aborted due to CEF shutdown or destruction of /// the associated browser. In cases where the associated browser is destroyed /// this callback may arrive after the ICefLifeSpanHandler.OnBeforeClose /// callback for that browser. The ICefFrame.IsValid function can be used /// to test for this situation, and care should be taken not to call |browser| /// or |frame| functions that modify state (like LoadURL, SendProcessMessage, /// etc.) if the frame is invalid. ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_resource_request_handler_capi.h (cef_resource_request_handler_t) /// property OnResourceLoadComplete : TOnResourceLoadComplete read FOnResourceLoadComplete write FOnResourceLoadComplete; ///

/// Called on the IO thread to handle requests for URLs with an unknown /// protocol component. The |browser| and |frame| values represent the source /// of the request, and may be NULL for requests originating from service /// workers or ICefUrlRequest. |request| cannot be modified in this /// callback. Set |allow_os_execution| to true (1) to attempt execution via /// the registered OS protocol handler, if any. SECURITY WARNING: YOU SHOULD /// USE THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR OTHER URL /// ANALYSIS BEFORE ALLOWING OS EXECUTION. ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_resource_request_handler_capi.h (cef_resource_request_handler_t) /// property OnProtocolExecution : TOnProtocolExecution read FOnProtocolExecution write FOnProtocolExecution; ///

/// Called on the IO thread before a resource request is sent. The |browser| /// and |frame| values represent the source of the request, and may be NULL /// for requests originating from service workers or ICefUrlRequest. /// |request| cannot be modified in this callback. Return true (1) if the /// specified cookie can be sent with the request or false (0) otherwise. ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_resource_request_handler_capi.h (cef_cookie_access_filter_t) /// property OnCanSendCookie : TOnCanSendCookie read FOnCanSendCookie write FOnCanSendCookie; ///

/// Called on the IO thread after a resource response is received. The /// |browser| and |frame| values represent the source of the request, and may /// be NULL for requests originating from service workers or ICefUrlRequest. /// |request| cannot be modified in this callback. Return true (1) if the /// specified cookie returned with the response can be saved or false (0) /// otherwise. ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_resource_request_handler_capi.h (cef_cookie_access_filter_t) /// property OnCanSaveCookie : TOnCanSaveCookie read FOnCanSaveCookie write FOnCanSaveCookie; ///

/// Called to run a file chooser dialog. |mode| represents the type of dialog /// to display. |title| to the title to be used for the dialog and may be NULL /// to show the default title ("Open" or "Save" depending on the mode). /// |default_file_path| is the path with optional directory and/or file name /// component that should be initially selected in the dialog. /// |accept_filters| are used to restrict the selectable file types and may be /// any combination of valid lower-cased MIME types (e.g. "text/*" or /// "image/*") and individual file extensions (e.g. ".txt" or ".png"). /// |accept_extensions| provides the semicolon-delimited expansion of MIME /// types to file extensions (if known, or NULL string otherwise). /// |accept_descriptions| provides the descriptions for MIME types (if known, /// or NULL string otherwise). For example, the "image/*" mime type might have /// extensions ".png;.jpg;.bmp;..." and description "Image Files". /// |accept_filters|, |accept_extensions| and |accept_descriptions| will all /// be the same size. To display a custom dialog return true (1) and execute /// |callback| either inline or at a later time. To display the default dialog /// return false (0). If this function returns false (0) it may be called an /// additional time for the same dialog (both before and after MIME type /// expansion). ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_dialog_handler_capi.h (cef_dialog_handler_t) /// property OnFileDialog : TOnFileDialog read FOnFileDialog write FOnFileDialog; ///

/// Return the handler for accessibility notifications. If no handler is /// provided the default implementation will be used. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnGetAccessibilityHandler : TOnGetAccessibilityHandler read FOnGetAccessibilityHandler write FOnGetAccessibilityHandler; ///

/// Called to retrieve the root window rectangle in screen DIP coordinates. /// Return true (1) if the rectangle was provided. If this function returns /// false (0) the rectangle from OnGetViewRect will be used. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnGetRootScreenRect : TOnGetRootScreenRect read FOnGetRootScreenRect write FOnGetRootScreenRect; ///

/// Called to retrieve the view rectangle in screen DIP coordinates. This /// function must always provide a non-NULL rectangle. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnGetViewRect : TOnGetViewRect read FOnGetViewRect write FOnGetViewRect; ///

/// Called to retrieve the translation from view DIP coordinates to screen /// coordinates. Windows/Linux should provide screen device (pixel) /// coordinates and MacOS should provide screen DIP coordinates. Return true /// (1) if the requested coordinates were provided. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnGetScreenPoint : TOnGetScreenPoint read FOnGetScreenPoint write FOnGetScreenPoint; ///

/// Called to allow the client to fill in the TCefScreenInfo object with /// appropriate values. Return true (1) if the |screen_info| structure has /// been modified. /// If the screen info rectangle is left NULL the rectangle from OnGetViewRect /// will be used. If the rectangle is still NULL or invalid popups may not be /// drawn correctly. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnGetScreenInfo : TOnGetScreenInfo read FOnGetScreenInfo write FOnGetScreenInfo; ///

/// Called when the browser wants to show or hide the popup widget. The popup /// should be shown if |show| is true (1) and hidden if |show| is false (0). ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnPopupShow : TOnPopupShow read FOnPopupShow write FOnPopupShow; ///

/// Called when the browser wants to move or resize the popup widget. |rect| /// contains the new location and size in view coordinates. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnPopupSize : TOnPopupSize read FOnPopupSize write FOnPopupSize; ///

/// Called when an element should be painted. Pixel values passed to this /// function are scaled relative to view coordinates based on the value of /// TCefScreenInfo.device_scale_factor returned from OnGetScreenInfo. |type| /// indicates whether the element is the view or the popup widget. |buffer| /// contains the pixel data for the whole image. |dirtyRects| contains the set /// of rectangles in pixel coordinates that need to be repainted. |buffer| /// will be |width|*|height|*4 bytes in size and represents a BGRA image with /// an upper-left origin. This function is only called when /// TCefWindowInfo.shared_texture_enabled is set to false (0). ///

/// Called when an element has been rendered to the shared texture handle. /// |type| indicates whether the element is the view or the popup widget. /// |dirtyRects| contains the set of rectangles in pixel coordinates that need /// to be repainted. |info| contains the shared handle; on Windows it is a /// HANDLE to a texture that can be opened with D3D11 OpenSharedResource, on /// macOS it is an IOSurface pointer that can be opened with Metal or OpenGL, /// and on Linux it contains several planes, each with an fd to the underlying /// system native buffer. /// The underlying implementation uses a pool to deliver frames. As a result, /// the handle may differ every frame depending on how many frames are in- /// progress. The handle's resource cannot be cached and cannot be accessed /// outside of this callback. It should be reopened each time this callback is /// executed and the contents should be copied to a texture owned by the /// client application. The contents of |info| will be released back to the /// pool after this callback returns. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnAcceleratedPaint : TOnAcceleratedPaint read FOnAcceleratedPaint write FOnAcceleratedPaint; ///

/// Called to retrieve the size of the touch handle for the specified /// |orientation|. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnGetTouchHandleSize : TOnGetTouchHandleSize read FOnGetTouchHandleSize write FOnGetTouchHandleSize; ///

/// Called when touch handle state is updated. The client is responsible for /// rendering the touch handles. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnTouchHandleStateChanged : TOnTouchHandleStateChanged read FOnTouchHandleStateChanged write FOnTouchHandleStateChanged; ///

/// Called when the user starts dragging content in the web view. Contextual /// information about the dragged content is supplied by |drag_data|. (|x|, /// |y|) is the drag start location in screen coordinates. OS APIs that run a /// system message loop may be used within the StartDragging call. /// Return false (0) to abort the drag operation. Don't call any of /// ICefBrowserHost.DragSource*Ended* functions after returning false (0). /// Return true (1) to handle the drag operation. Call /// ICefBrowserHost.DragSourceEndedAt and DragSourceSystemDragEnded either /// synchronously or asynchronously to inform the web view that the drag /// operation has ended. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnStartDragging : TOnStartDragging read FOnStartDragging write FOnStartDragging; ///

/// Called when the web view wants to update the mouse cursor during a drag & /// drop operation. |operation| describes the allowed operation (none, move, /// copy, link). ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnUpdateDragCursor : TOnUpdateDragCursor read FOnUpdateDragCursor write FOnUpdateDragCursor; ///

/// Called when the scroll offset has changed. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnScrollOffsetChanged : TOnScrollOffsetChanged read FOnScrollOffsetChanged write FOnScrollOffsetChanged; ///

/// Called when the IME composition range has changed. |selected_range| is the /// range of characters that have been selected. |character_bounds| is the /// bounds of each character in view coordinates. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnIMECompositionRangeChanged : TOnIMECompositionRangeChanged read FOnIMECompositionRangeChanged write FOnIMECompositionRangeChanged; ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnTextSelectionChanged : TOnTextSelectionChanged read FOnTextSelectionChanged write FOnTextSelectionChanged; ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_render_handler_capi.h (cef_render_handler_t) /// property OnVirtualKeyboardRequested : TOnVirtualKeyboardRequested read FOnVirtualKeyboardRequested write FOnVirtualKeyboardRequested; ///

/// Called when an external drag event enters the browser window. |dragData| /// contains the drag event data and |mask| represents the type of drag /// operation. Return false (0) for default drag handling behavior or true (1) /// to cancel the drag event. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_drag_handler_capi.h (cef_drag_handler_t) /// property OnDragEnter : TOnDragEnter read FOnDragEnter write FOnDragEnter; ///

/// Called whenever draggable regions for the browser window change. These can /// be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If /// draggable regions are never defined in a document this function will also /// never be called. If the last draggable region is removed from a document /// this function will be called with an NULL vector. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_drag_handler_capi.h (cef_drag_handler_t) /// property OnDraggableRegionsChanged : TOnDraggableRegionsChanged read FOnDraggableRegionsChanged write FOnDraggableRegionsChanged; ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_find_handler_capi.h (cef_find_handler_t) /// property OnFindResult : TOnFindResult read FOnFindResult write FOnFindResult; ///

/// Called on the browser process UI thread immediately after the request /// context has been initialized. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_request_context_handler_capi.h (cef_request_context_handler_t) /// property OnRequestContextInitialized : TOnRequestContextInitialized read FOnRequestContextInitialized write FOnRequestContextInitialized; ///

/// Called on the browser process IO thread before a resource request is /// initiated. The |browser| and |frame| values represent the source of the /// request, and may be NULL for requests originating from service workers or /// ICefUrlRequest. |request| represents the request contents and cannot be /// modified in this callback. |is_navigation| will be true (1) if the /// resource request is a navigation. |is_download| will be true (1) if the /// resource request is a download. |request_initiator| is the origin (scheme /// + domain) of the page that initiated the request. Set /// |disable_default_handling| to true (1) to disable default handling of the /// request, in which case it will need to be handled via /// ICefResourceRequestHandler.GetResourceHandler or it will be canceled. /// To allow the resource load to proceed with default handling return NULL. /// To specify a handler for the resource return a /// ICefResourceRequestHandler object. This function will not be called if /// the client associated with |browser| returns a non-NULL value from /// ICefRequestHandler.GetResourceRequestHandler for the same request /// (identified by ICefRequest.GetIdentifier). ///

/// /// This event will be called on the browser process CEF IO thread. /// CEF source file: /include/capi/cef_request_context_handler_capi.h (cef_request_context_handler_t) /// property OnGetResourceRequestHandler_ReqCtxHdlr : TOnGetResourceRequestHandler read FOnGetResourceRequestHandler_ReqCtxHdlr write FOnGetResourceRequestHandler_ReqCtxHdlr; ///

/// The list of available media sinks has changed or /// ICefMediaRouter.NotifyCurrentSinks was called. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_media_router_capi.h (cef_media_observer_t) /// property OnSinks : TOnSinksEvent read FOnSinks write FOnSinks; ///

/// The list of available media routes has changed or /// ICefMediaRouter.NotifyCurrentRoutes was called. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_media_router_capi.h (cef_media_observer_t) /// property OnRoutes : TOnRoutesEvent read FOnRoutes write FOnRoutes; ///

/// The connection state of |route| has changed. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_media_router_capi.h (cef_media_observer_t) /// property OnRouteStateChanged : TOnRouteStateChangedEvent read FOnRouteStateChanged write FOnRouteStateChanged; ///

/// A message was recieved over |route|. |message| is only valid for the scope /// of this callback and should be copied if necessary. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_media_router_capi.h (cef_media_observer_t) /// property OnRouteMessageReceived : TOnRouteMessageReceivedEvent read FOnRouteMessageReceived write FOnRouteMessageReceived; ///

/// Called on the UI thread to allow configuration of audio stream parameters. /// Return true (1) to proceed with audio stream capture, or false (0) to /// cancel it. All members of |params| can optionally be configured here, but /// they are also pre-filled with some sensible defaults. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_audio_handler_capi.h (cef_audio_handler_t) /// property OnGetAudioParameters : TOnGetAudioParametersEvent read FOnGetAudioParameters write FOnGetAudioParameters; ///

/// Called on a browser audio capture thread when the browser starts streaming /// audio. OnAudioStreamStopped will always be called after /// OnAudioStreamStarted; both functions may be called multiple times for the /// same browser. |params| contains the audio parameters like sample rate and /// channel layout. |channels| is the number of channels. ///

/// /// This event will be called on a browser audio capture thread. /// CEF source file: /include/capi/cef_audio_handler_capi.h (cef_audio_handler_t) /// property OnAudioStreamStarted : TOnAudioStreamStartedEvent read FOnAudioStreamStarted write FOnAudioStreamStarted; ///

/// Called on the audio stream thread when a PCM packet is received for the /// stream. |data| is an array representing the raw PCM data as a floating /// point type, i.e. 4-byte value(s). |frames| is the number of frames in the /// PCM packet. |pts| is the presentation timestamp (in milliseconds since the /// Unix Epoch) and represents the time at which the decompressed packet /// should be presented to the user. Based on |frames| and the /// |channel_layout| value passed to OnAudioStreamStarted you can calculate /// the size of the |data| array in bytes. ///

/// /// This event will be called on a browser audio capture thread. /// CEF source file: /include/capi/cef_audio_handler_capi.h (cef_audio_handler_t) /// property OnAudioStreamPacket : TOnAudioStreamPacketEvent read FOnAudioStreamPacket write FOnAudioStreamPacket; ///

/// Called on the UI thread when the stream has stopped. OnAudioSteamStopped /// will always be called after OnAudioStreamStarted; both functions may be /// called multiple times for the same stream. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_audio_handler_capi.h (cef_audio_handler_t) /// property OnAudioStreamStopped : TOnAudioStreamStoppedEvent read FOnAudioStreamStopped write FOnAudioStreamStopped; ///

/// Called on the UI or audio stream thread when an error occurred. During the /// stream creation phase this callback will be called on the UI thread while /// in the capturing phase it will be called on the audio stream thread. The /// stream will be stopped immediately. ///

/// /// This event will be called on the browser process CEF UI thread or a browser audio capture thread. /// CEF source file: /include/capi/cef_audio_handler_capi.h (cef_audio_handler_t) /// property OnAudioStreamError : TOnAudioStreamErrorEvent read FOnAudioStreamError write FOnAudioStreamError; ///

/// Method that will be called on receipt of a DevTools protocol message. /// |browser| is the originating browser instance. |message| is a UTF8-encoded /// JSON dictionary representing either a function result or an event. /// |message| is only valid for the scope of this callback and should be /// copied if necessary. Return true (1) if the message was handled or false /// (0) if the message should be further processed and passed to the /// OnDevToolsMethodResult or OnDevToolsEvent functions as appropriate. /// Method result dictionaries include an "id" (int) value that identifies the /// orginating function call sent from /// ICefBrowserHost.SendDevToolsMessage, and optionally either a "result" /// (dictionary) or "error" (dictionary) value. The "error" dictionary will /// contain "code" (int) and "message" (string) values. Event dictionaries /// include a "function" (string) value and optionally a "params" (dictionary) /// value. See the DevTools protocol documentation at /// https://chromedevtools.github.io/devtools-protocol/ for details of /// supported function calls and the expected "result" or "params" dictionary /// contents. JSON dictionaries can be parsed using the CefParseJSON function /// if desired, however be aware of performance considerations when parsing /// large messages (some of which may exceed 1MB in size). ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_devtools_message_observer_capi.h (cef_dev_tools_message_observer_t) /// property OnDevToolsMessage : TOnDevToolsMessageEvent read FOnDevToolsMessage write FOnDevToolsMessage; ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_devtools_message_observer_capi.h (cef_dev_tools_message_observer_t) /// property OnDevToolsRawMessage : TOnDevToolsRawMessageEvent read FOnDevToolsRawMessage write FOnDevToolsRawMessage; ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_devtools_message_observer_capi.h (cef_dev_tools_message_observer_t) /// property OnDevToolsMethodResult : TOnDevToolsMethodResultEvent read FOnDevToolsMethodResult write FOnDevToolsMethodResult; ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_devtools_message_observer_capi.h (cef_dev_tools_message_observer_t) /// property OnDevToolsMethodRawResult : TOnDevToolsMethodRawResultEvent read FOnDevToolsMethodRawResult write FOnDevToolsMethodRawResult; ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_devtools_message_observer_capi.h (cef_dev_tools_message_observer_t) /// property OnDevToolsEvent : TOnDevToolsEventEvent read FOnDevToolsEvent write FOnDevToolsEvent; ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_devtools_message_observer_capi.h (cef_dev_tools_message_observer_t) /// property OnDevToolsRawEvent : TOnDevToolsEventRawEvent read FOnDevToolsRawEvent write FOnDevToolsRawEvent; ///

/// Method that will be called when the DevTools agent has attached. |browser| /// is the originating browser instance. This will generally occur in response /// to the first message sent while the agent is detached. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_devtools_message_observer_capi.h (cef_dev_tools_message_observer_t) /// property OnDevToolsAgentAttached : TOnDevToolsAgentAttachedEvent read FOnDevToolsAgentAttached write FOnDevToolsAgentAttached; ///

/// Method that will be called when the DevTools agent has detached. |browser| /// is the originating browser instance. Any function results that were /// pending before the agent became detached will not be delivered, and any /// active event subscriptions will be canceled. ///

/// /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_devtools_message_observer_capi.h (cef_dev_tools_message_observer_t) /// property OnDevToolsAgentDetached : TOnDevToolsAgentDetachedEvent read FOnDevToolsAgentDetached write FOnDevToolsAgentDetached; ///

/// Called if the ICefRequestContext.LoadExtension request fails. |result| /// will be the error code. ///

/// /// WARNING: This function is deprecated and will be removed in ~M127. /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_extension_handler_capi.h (cef_extension_handler_t) /// property OnExtensionLoadFailed : TOnExtensionLoadFailedEvent read FOnExtensionLoadFailed write FOnExtensionLoadFailed; ///

/// Called if the ICefRequestContext.LoadExtension request succeeds. /// |extension| is the loaded extension. ///

/// /// WARNING: This function is deprecated and will be removed in ~M127. /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_extension_handler_capi.h (cef_extension_handler_t) /// property OnExtensionLoaded : TOnExtensionLoadedEvent read FOnExtensionLoaded write FOnExtensionLoaded; ///

/// Called after the ICefExtension.Unload request has completed. ///

/// /// WARNING: This function is deprecated and will be removed in ~M127. /// This event will be called on the browser process CEF UI thread. /// CEF source file: /include/capi/cef_extension_handler_capi.h (cef_extension_handler_t) /// property OnExtensionUnloaded : TOnExtensionUnloadedEvent read FOnExtensionUnloaded write FOnExtensionUnloaded; ///

/// Called when an extension needs a browser to host a background script /// specified via the "background" manifest key. The browser will have no /// visible window and cannot be displayed. |extension| is the extension that /// is loading the background script. |url| is an internally generated /// reference to an HTML page that will be used to load the background script /// via a "