pascal/CEF4Delphi
1
0
Fork 0
mirror of https://github.com/salvadordf/CEF4Delphi.git synced 2025-01-03 10:15:38 +02:00
Code Issues Actions Releases Activity

Update to CEF 81.3.1

Browse Source
This commit is contained in:
Salvador Díaz Fau 2020-04-30 17:28:41 +02:00
parent ee831e85bd
commit ccdb41b357
14 changed files with 615 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
README.md
View File

@ -3,10 +3,10 @@ CEF4Delphi is an open source project created by Salvador D
CEF4Delphi is based on DCEF3, made by Henri Gourvest. The original license of DCEF3 still applies to CEF4Delphi. Read the license terms in the first lines of any *.pas file. CEF4Delphi is based on DCEF3, made by Henri Gourvest. The original license of DCEF3 still applies to CEF4Delphi. Read the license terms in the first lines of any *.pas file.
CEF4Delphi uses CEF 81.2.25 which includes Chromium 81.0.4044.113. CEF4Delphi uses CEF 81.3.1 which includes Chromium 81.0.4044.113.
The CEF binaries used by CEF4Delphi are available for download at spotify : The CEF binaries used by CEF4Delphi are available for download at spotify :
* [32 bits](http://opensource.spotify.com/cefbuilds/cef_binary_81.2.25%2Bg3afea62%2Bchromium-81.0.4044.113_windows32.tar.bz2) * [32 bits](http://opensource.spotify.com/cefbuilds/cef_binary_81.3.1%2Bgb2b49f1%2Bchromium-81.0.4044.113_windows32.tar.bz2)
* [64 bits](http://opensource.spotify.com/cefbuilds/cef_binary_81.2.25%2Bg3afea62%2Bchromium-81.0.4044.113_windows64.tar.bz2) * [64 bits](http://opensource.spotify.com/cefbuilds/cef_binary_81.3.1%2Bgb2b49f1%2Bchromium-81.0.4044.113_windows64.tar.bz2)
CEF4Delphi was developed and tested on Delphi 10.3.3 and it has been tested in Delphi 7, Delphi XE, Delphi 10, Delphi 10.2 and Lazarus 2.0.8/FPC 3.0.4. CEF4Delphi includes VCL, FireMonkey (FMX) and Lazarus components. CEF4Delphi was developed and tested on Delphi 10.3.3 and it has been tested in Delphi 7, Delphi XE, Delphi 10, Delphi 10.2 and Lazarus 2.0.8/FPC 3.0.4. CEF4Delphi includes VCL, FireMonkey (FMX) and Lazarus components.

6
demos/Delphi_VCL/MediaRouter/uMediaRouterFrm.dfm
View File

@ -125,13 +125,11 @@ object MediaRouterFrm: TMediaRouterFrm
object SourceURNLbl: TLabel object SourceURNLbl: TLabel
Left = 0 Left = 0
Top = 0 Top = 0
Width = 65 Width = 57
Height = 21 Height = 13
Align = alClient Align = alClient
Caption = 'Source URN' Caption = 'Source URN'
Layout = tlCenter Layout = tlCenter
ExplicitWidth = 57
ExplicitHeight = 13
end end
end end
object SourceURNCbx: TComboBox object SourceURNCbx: TComboBox

23
demos/Delphi_VCL/MediaRouter/uMediaRouterFrm.pas
View File

@ -569,6 +569,7 @@ begin
FSinks[i].ID := aSinks[i].ID; FSinks[i].ID := aSinks[i].ID;
FSinks[i].Name := aSinks[i].Name; FSinks[i].Name := aSinks[i].Name;
FSinks[i].Description := aSinks[i].Description; FSinks[i].Description := aSinks[i].Description;
FSinks[i].IconType := aSinks[i].IconType;
FSinks[i].Valid := aSinks[i].IsValid; FSinks[i].Valid := aSinks[i].IsValid;
FSinks[i].SinkIntf := aSinks[i]; FSinks[i].SinkIntf := aSinks[i];
@ -683,6 +684,7 @@ end;
procedure TMediaRouterFrm.UpdateAvailableSinks; procedure TMediaRouterFrm.UpdateAvailableSinks;
var var
i : integer; i : integer;
TempItem : string;
begin begin
try try
FMediaCS.Acquire; FMediaCS.Acquire;
@ -693,12 +695,27 @@ begin
i := 0; i := 0;
while (i < length(FSinks)) do while (i < length(FSinks)) do
begin begin
TempItem := FSinks[i].Name;
case FSinks[i].SinkType of case FSinks[i].SinkType of
mtCast : SinksLbx.Items.Add(FSinks[i].Name + ' (CAST)'); mtCast : TempItem := TempItem + ' (CAST';
mtDial : SinksLbx.Items.Add(FSinks[i].Name + ' (DIAL)'); mtDial : TempItem := TempItem + ' (DIAL';
else SinksLbx.Items.Add(FSinks[i].Name + ' (UNKNOWN)'); else TempItem := TempItem + ' (UNKNOWN';
end; end;
case FSinks[i].IconType of
CEF_MSIT_CAST : TempItem := TempItem + ', CAST)';
CEF_MSIT_CAST_AUDIO_GROUP : TempItem := TempItem + ', CAST_AUDIO_GROUP)';
CEF_MSIT_CAST_AUDIO : TempItem := TempItem + ', CAST_AUDIO)';
CEF_MSIT_MEETING : TempItem := TempItem + ', MEETING)';
CEF_MSIT_HANGOUT : TempItem := TempItem + ', HANGOUT)';
CEF_MSIT_EDUCATION : TempItem := TempItem + ', EDUCATION)';
CEF_MSIT_WIRED_DISPLAY : TempItem := TempItem + ', WIRED_DISPLAY)';
CEF_MSIT_GENERIC : TempItem := TempItem + ', GENERIC)';
else TempItem := TempItem + ', UNKNOWN)';
end;
SinksLbx.Items.Add(TempItem);
inc(i); inc(i);
end; end;
end; end;

10
demos/Lazarus/MediaRouter/MediaRouter.lps
View File

@ -22,19 +22,23 @@
<ResourceBaseClass Value="Form"/> <ResourceBaseClass Value="Form"/>
<IsVisibleTab Value="True"/> <IsVisibleTab Value="True"/>
<EditorIndex Value="1"/> <EditorIndex Value="1"/>
<TopLine Value="553"/> <TopLine Value="683"/>
<CursorPos X="29" Y="49"/> <CursorPos X="73" Y="699"/>
<UsageCount Value="20"/> <UsageCount Value="20"/>
<Loaded Value="True"/> <Loaded Value="True"/>
<LoadedDesigner Value="True"/> <LoadedDesigner Value="True"/>
<DefaultSyntaxHighlighter Value="Delphi"/> <DefaultSyntaxHighlighter Value="Delphi"/>
</Unit1> </Unit1>
</Units> </Units>
<JumpHistory Count="1"> <JumpHistory Count="2" HistoryIndex="1">
<Position1> <Position1>
<Filename Value="MediaRouter.lpr"/> <Filename Value="MediaRouter.lpr"/>
<Caret Line="49" Column="11" TopLine="42"/> <Caret Line="49" Column="11" TopLine="42"/>
</Position1> </Position1>
<Position2>
<Filename Value="uMediaRouterFrm.pas"/>
<Caret Line="576" Column="50" TopLine="554"/>
</Position2>
</JumpHistory> </JumpHistory>
<RunParams> <RunParams>
<FormatVersion Value="2"/> <FormatVersion Value="2"/>

23
demos/Lazarus/MediaRouter/uMediaRouterFrm.pas
View File

@ -565,6 +565,7 @@ begin
FSinks[i].ID := aSinks[i].ID; FSinks[i].ID := aSinks[i].ID;
FSinks[i].Name := aSinks[i].Name; FSinks[i].Name := aSinks[i].Name;
FSinks[i].Description := aSinks[i].Description; FSinks[i].Description := aSinks[i].Description;
FSinks[i].IconType := aSinks[i].IconType;
FSinks[i].Valid := aSinks[i].IsValid; FSinks[i].Valid := aSinks[i].IsValid;
FSinks[i].SinkIntf := aSinks[i]; FSinks[i].SinkIntf := aSinks[i];
@ -679,6 +680,7 @@ end;
procedure TMediaRouterFrm.UpdateAvailableSinks; procedure TMediaRouterFrm.UpdateAvailableSinks;
var var
i : integer; i : integer;
TempItem : string;
begin begin
try try
FMediaCS.Acquire; FMediaCS.Acquire;
@ -689,12 +691,27 @@ begin
i := 0; i := 0;
while (i < length(FSinks)) do while (i < length(FSinks)) do
begin begin
TempItem := FSinks[i].Name;
case FSinks[i].SinkType of case FSinks[i].SinkType of
mtCast : SinksLbx.Items.Add(FSinks[i].Name + ' (CAST)'); mtCast : TempItem := TempItem + ' (CAST';
mtDial : SinksLbx.Items.Add(FSinks[i].Name + ' (DIAL)'); mtDial : TempItem := TempItem + ' (DIAL';
else SinksLbx.Items.Add(FSinks[i].Name + ' (UNKNOWN)'); else TempItem := TempItem + ' (UNKNOWN';
end; end;
case FSinks[i].IconType of
CEF_MSIT_CAST : TempItem := TempItem + ', CAST)';
CEF_MSIT_CAST_AUDIO_GROUP : TempItem := TempItem + ', CAST_AUDIO_GROUP)';
CEF_MSIT_CAST_AUDIO : TempItem := TempItem + ', CAST_AUDIO)';
CEF_MSIT_MEETING : TempItem := TempItem + ', MEETING)';
CEF_MSIT_HANGOUT : TempItem := TempItem + ', HANGOUT)';
CEF_MSIT_EDUCATION : TempItem := TempItem + ', EDUCATION)';
CEF_MSIT_WIRED_DISPLAY : TempItem := TempItem + ', WIRED_DISPLAY)';
CEF_MSIT_GENERIC : TempItem := TempItem + ', GENERIC)';
else TempItem := TempItem + ', UNKNOWN)';
end;
SinksLbx.Items.Add(TempItem);
inc(i); inc(i);
end; end;
end; end;

2
packages/cef4delphi_lazarus.lpk
View File

@ -21,7 +21,7 @@
</CompilerOptions> </CompilerOptions>
<Description Value="CEF4Delphi is an open source project created by Salvador Díaz Fau to embed Chromium-based browsers in applications made with Delphi or Lazarus/FPC."/> <Description Value="CEF4Delphi is an open source project created by Salvador Díaz Fau to embed Chromium-based browsers in applications made with Delphi or Lazarus/FPC."/>
<License Value="MPL 1.1"/> <License Value="MPL 1.1"/>
<Version Major="81" Minor="2" Release="25"/> <Version Major="81" Minor="3" Release="1"/>
<Files Count="175"> <Files Count="175">
<Item1> <Item1>
<Filename Value="..\source\uCEFAccessibilityHandler.pas"/> <Filename Value="..\source\uCEFAccessibilityHandler.pas"/>

5
source/uCEFApplicationCore.pas
View File

@ -61,8 +61,8 @@ uses
const const
CEF_SUPPORTED_VERSION_MAJOR = 81; CEF_SUPPORTED_VERSION_MAJOR = 81;
CEF_SUPPORTED_VERSION_MINOR = 2; CEF_SUPPORTED_VERSION_MINOR = 3;
CEF_SUPPORTED_VERSION_RELEASE = 25; CEF_SUPPORTED_VERSION_RELEASE = 1;
CEF_SUPPORTED_VERSION_BUILD = 0; CEF_SUPPORTED_VERSION_BUILD = 0;
CEF_CHROMEELF_VERSION_MAJOR = 81; CEF_CHROMEELF_VERSION_MAJOR = 81;
@ -1235,6 +1235,7 @@ begin
try try
TempFiles.Add('Cookies'); TempFiles.Add('Cookies');
TempFiles.Add('Cookies-journal'); TempFiles.Add('Cookies-journal');
TempFiles.Add('LocalPrefs.json');
DeleteDirContents(aDirectory, TempFiles); DeleteDirContents(aDirectory, TempFiles);
finally finally

33
source/uCEFInterfaces.pas
View File

@ -165,6 +165,7 @@ type
Valid : boolean; Valid : boolean;
Name : ustring; Name : ustring;
Description : ustring; Description : ustring;
IconType : TCefMediaSinkIconType;
SinkType : TCefMediaType; SinkType : TCefMediaType;
SinkIntf : ICefMediaSink; SinkIntf : ICefMediaSink;
end; end;
@ -1338,13 +1339,15 @@ type
function IsValid: boolean; function IsValid: boolean;
function GetName: ustring; function GetName: ustring;
function GetDescription: ustring; function GetDescription: ustring;
function GetIconType: TCefMediaSinkIconType;
function IsCastSink: boolean; function IsCastSink: boolean;
function IsDialSink: boolean; function IsDialSink: boolean;
function IsCompatibleWith(const source: ICefMediaSource): boolean; function IsCompatibleWith(const source: ICefMediaSource): boolean;
property ID : ustring read GetId; property ID : ustring read GetId;
property Name : ustring read GetName; property Name : ustring read GetName;
property Description : ustring read GetDescription; property Description : ustring read GetDescription;
property IconType : TCefMediaSinkIconType read GetIconType;
end; end;
// TCefMediaSource // TCefMediaSource
@ -2518,10 +2521,10 @@ type
// /include/capi/views/cef_view_delegate_capi.h (cef_view_delegate_t) // /include/capi/views/cef_view_delegate_capi.h (cef_view_delegate_t)
ICefViewDelegate = interface(ICefBaseRefCounted) ICefViewDelegate = interface(ICefBaseRefCounted)
['{5F900206-B969-4E51-B56C-0FF38D749C72}'] ['{5F900206-B969-4E51-B56C-0FF38D749C72}']
function GetPreferredSize(const view: ICefView): TCefSize; procedure OnGetPreferredSize(const view: ICefView; var aResult : TCefSize);
function GetMinimumSize(const view: ICefView): TCefSize; procedure OnGetMinimumSize(const view: ICefView; var aResult : TCefSize);
function GetMaximumSize(const view: ICefView): TCefSize; procedure OnGetMaximumSize(const view: ICefView; var aResult : TCefSize);
function GetHeightForWidth(const view: ICefView; width: Integer): Integer; procedure OnGetHeightForWidth(const view: ICefView; width: Integer; var aResult: Integer);
procedure OnParentViewChanged(const view: ICefView; added: boolean; const parent: ICefView); procedure OnParentViewChanged(const view: ICefView; added: boolean; const parent: ICefView);
procedure OnChildViewChanged(const view: ICefView; added: boolean; const child: ICefView); procedure OnChildViewChanged(const view: ICefView; added: boolean; const child: ICefView);
procedure OnFocus(const view: ICefView); procedure OnFocus(const view: ICefView);
@ -2759,14 +2762,14 @@ type
['{52D4EE2C-303B-42B6-A35F-30D03834A23F}'] ['{52D4EE2C-303B-42B6-A35F-30D03834A23F}']
procedure OnWindowCreated(const window: ICefWindow); procedure OnWindowCreated(const window: ICefWindow);
procedure OnWindowDestroyed(const window: ICefWindow); procedure OnWindowDestroyed(const window: ICefWindow);
function GetParentWindow(const window: ICefWindow; is_menu, can_activate_menu: boolean): ICefWindow; procedure OnGetParentWindow(const window: ICefWindow; var is_menu, can_activate_menu: boolean; var aResult : ICefWindow);
function IsFrameless(const window: ICefWindow): boolean; procedure OnIsFrameless(const window: ICefWindow; var aResult : boolean);
function CanResize(const window: ICefWindow): boolean; procedure OnCanResize(const window: ICefWindow; var aResult : boolean);
function CanMaximize(const window: ICefWindow): boolean; procedure OnCanMaximize(const window: ICefWindow; var aResult : boolean);
function CanMinimize(const window: ICefWindow): boolean; procedure OnCanMinimize(const window: ICefWindow; var aResult : boolean);
function CanClose(const window: ICefWindow): boolean; procedure OnCanClose(const window: ICefWindow; var aResult : boolean);
function OnAccelerator(const window: ICefWindow; command_id: Integer): boolean; procedure OnAccelerator(const window: ICefWindow; command_id: Integer; var aResult : boolean);
function OnKeyEvent(const window: ICefWindow; const event: TCefKeyEvent): boolean; procedure OnKeyEvent(const window: ICefWindow; const event: TCefKeyEvent; var aResult : boolean);
end; end;
implementation implementation

6
source/uCEFMediaSink.pas
View File

@ -58,6 +58,7 @@ type
function IsValid: boolean; function IsValid: boolean;
function GetName: ustring; function GetName: ustring;
function GetDescription: ustring; function GetDescription: ustring;
function GetIconType: TCefMediaSinkIconType;
function IsCastSink: boolean; function IsCastSink: boolean;
function IsDialSink: boolean; function IsDialSink: boolean;
function IsCompatibleWith(const source: ICefMediaSource): boolean; function IsCompatibleWith(const source: ICefMediaSource): boolean;
@ -90,6 +91,11 @@ begin
Result := CefStringFreeAndGet(PCefMediaSink(FData)^.get_description(PCefMediaSink(FData))); Result := CefStringFreeAndGet(PCefMediaSink(FData)^.get_description(PCefMediaSink(FData)));
end; end;
function TCefMediaSinkRef.GetIconType: TCefMediaSinkIconType;
begin
Result := PCefMediaSink(FData)^.get_icon_type(PCefMediaSink(FData));
end;
function TCefMediaSinkRef.IsCastSink: Boolean; function TCefMediaSinkRef.IsCastSink: Boolean;
begin begin
Result := PCefMediaSink(FData)^.is_cast_sink(PCefMediaSink(FData)) <> 0; Result := PCefMediaSink(FData)^.is_cast_sink(PCefMediaSink(FData)) <> 0;

20
source/uCEFPanelDelegate.pas
View File

@ -62,8 +62,17 @@ type
class function UnWrap(data: Pointer): ICefPanelDelegate; class function UnWrap(data: Pointer): ICefPanelDelegate;
end; end;
TCefPanelDelegateOwn = class(TCefViewDelegateOwn, ICefPanelDelegate)
public
constructor Create; override;
end;
implementation implementation
// **************************************************************
// ******************** TCefPanelDelegateRef ********************
// **************************************************************
class function TCefPanelDelegateRef.UnWrap(data: Pointer): ICefPanelDelegate; class function TCefPanelDelegateRef.UnWrap(data: Pointer): ICefPanelDelegate;
begin begin
if (data <> nil) then if (data <> nil) then
@ -72,5 +81,16 @@ begin
Result := nil; Result := nil;
end; end;
// **************************************************************
// ******************** TCefPanelDelegateOwn ********************
// **************************************************************
constructor TCefPanelDelegateOwn.Create;
begin
inherited CreateData(SizeOf(TCefPanelDelegate));
InitializeCEFMethods;
end;
end. end.

14
source/uCEFTypes.pas
View File

@ -566,6 +566,19 @@ type
CEF_MRCS_TERMINATED CEF_MRCS_TERMINATED
); );
// /include/internal/cef_types.h (cef_media_sink_icon_type_t)
TCefMediaSinkIconType = (
CEF_MSIT_CAST,
CEF_MSIT_CAST_AUDIO_GROUP,
CEF_MSIT_CAST_AUDIO,
CEF_MSIT_MEETING,
CEF_MSIT_HANGOUT,
CEF_MSIT_EDUCATION,
CEF_MSIT_WIRED_DISPLAY,
CEF_MSIT_GENERIC,
CEF_MSIT_TOTAL_COUNT
);
// /include/internal/cef_types.h (cef_referrer_policy_t) // /include/internal/cef_types.h (cef_referrer_policy_t)
TCefReferrerPolicy = ( TCefReferrerPolicy = (
REFERRER_POLICY_CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE, // same value as REFERRER_POLICY_DEFAULT REFERRER_POLICY_CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE, // same value as REFERRER_POLICY_DEFAULT
@ -1533,6 +1546,7 @@ type
is_valid : function(self: PCefMediaSink): Integer; stdcall; is_valid : function(self: PCefMediaSink): Integer; stdcall;
get_name : function(self: PCefMediaSink): PCefStringUserFree; stdcall; get_name : function(self: PCefMediaSink): PCefStringUserFree; stdcall;
get_description : function(self: PCefMediaSink): PCefStringUserFree; stdcall; get_description : function(self: PCefMediaSink): PCefStringUserFree; stdcall;
get_icon_type : function(self: PCefMediaSink): TCefMediaSinkIconType; stdcall;
is_cast_sink : function(self: PCefMediaSink): Integer; stdcall; is_cast_sink : function(self: PCefMediaSink): Integer; stdcall;
is_dial_sink : function(self: PCefMediaSink): Integer; stdcall; is_dial_sink : function(self: PCefMediaSink): Integer; stdcall;
is_compatible_with : function(self: PCefMediaSink; source: PCefMediaSource): Integer; stdcall; is_compatible_with : function(self: PCefMediaSink; source: PCefMediaSource): Integer; stdcall;

233
source/uCEFViewDelegate.pas
View File

@ -59,10 +59,10 @@ uses
type type
TCefViewDelegateRef = class(TCefBaseRefCountedRef, ICefViewDelegate) TCefViewDelegateRef = class(TCefBaseRefCountedRef, ICefViewDelegate)
protected protected
function GetPreferredSize(const view: ICefView): TCefSize; procedure OnGetPreferredSize(const view: ICefView; var aResult : TCefSize);
function GetMinimumSize(const view: ICefView): TCefSize; procedure OnGetMinimumSize(const view: ICefView; var aResult : TCefSize);
function GetMaximumSize(const view: ICefView): TCefSize; procedure OnGetMaximumSize(const view: ICefView; var aResult : TCefSize);
function GetHeightForWidth(const view: ICefView; width: Integer): Integer; procedure OnGetHeightForWidth(const view: ICefView; width: Integer; var aResult: Integer);
procedure OnParentViewChanged(const view: ICefView; added: boolean; const parent: ICefView); procedure OnParentViewChanged(const view: ICefView; added: boolean; const parent: ICefView);
procedure OnChildViewChanged(const view: ICefView; added: boolean; const child: ICefView); procedure OnChildViewChanged(const view: ICefView; added: boolean; const child: ICefView);
procedure OnFocus(const view: ICefView); procedure OnFocus(const view: ICefView);
@ -72,34 +72,55 @@ type
class function UnWrap(data: Pointer): ICefViewDelegate; class function UnWrap(data: Pointer): ICefViewDelegate;
end; end;
TCefViewDelegateOwn = class(TCefBaseRefCountedOwn, ICefViewDelegate)
protected
procedure OnGetPreferredSize(const view: ICefView; var aResult : TCefSize); virtual;
procedure OnGetMinimumSize(const view: ICefView; var aResult : TCefSize); virtual;
procedure OnGetMaximumSize(const view: ICefView; var aResult : TCefSize); virtual;
procedure OnGetHeightForWidth(const view: ICefView; width: Integer; var aResult: Integer); virtual;
procedure OnParentViewChanged(const view: ICefView; added: boolean; const parent: ICefView); virtual;
procedure OnChildViewChanged(const view: ICefView; added: boolean; const child: ICefView); virtual;
procedure OnFocus(const view: ICefView); virtual;
procedure OnBlur(const view: ICefView); virtual;
procedure InitializeCEFMethods; virtual;
public
constructor Create; virtual;
end;
implementation implementation
uses uses
uCEFLibFunctions, uCEFMiscFunctions; uCEFLibFunctions, uCEFMiscFunctions, uCEFView;
function TCefViewDelegateRef.GetPreferredSize(const view: ICefView): TCefSize;
// **************************************************************
// ******************** TCefViewDelegateRef *********************
// **************************************************************
procedure TCefViewDelegateRef.OnGetPreferredSize(const view: ICefView; var aResult : TCefSize);
begin begin
Result := PCefViewDelegate(FData)^.get_preferred_size(PCefViewDelegate(FData), aResult := PCefViewDelegate(FData)^.get_preferred_size(PCefViewDelegate(FData),
CefGetData(view)); CefGetData(view));
end; end;
function TCefViewDelegateRef.GetMinimumSize(const view: ICefView): TCefSize; procedure TCefViewDelegateRef.OnGetMinimumSize(const view: ICefView; var aResult : TCefSize);
begin begin
Result := PCefViewDelegate(FData)^.get_minimum_size(PCefViewDelegate(FData), aResult := PCefViewDelegate(FData)^.get_minimum_size(PCefViewDelegate(FData),
CefGetData(view)); CefGetData(view));
end; end;
function TCefViewDelegateRef.GetMaximumSize(const view: ICefView): TCefSize; procedure TCefViewDelegateRef.OnGetMaximumSize(const view: ICefView; var aResult : TCefSize);
begin begin
Result := PCefViewDelegate(FData)^.get_maximum_size(PCefViewDelegate(FData), aResult := PCefViewDelegate(FData)^.get_maximum_size(PCefViewDelegate(FData),
CefGetData(view)); CefGetData(view));
end; end;
function TCefViewDelegateRef.GetHeightForWidth(const view: ICefView; width: Integer): Integer; procedure TCefViewDelegateRef.OnGetHeightForWidth(const view: ICefView; width: Integer; var aResult: Integer);
begin begin
Result := PCefViewDelegate(FData)^.get_height_for_width(PCefViewDelegate(FData), aResult := PCefViewDelegate(FData)^.get_height_for_width(PCefViewDelegate(FData),
CefGetData(view), CefGetData(view),
width); width);
end; end;
procedure TCefViewDelegateRef.OnParentViewChanged(const view: ICefView; added: boolean; const parent: ICefView); procedure TCefViewDelegateRef.OnParentViewChanged(const view: ICefView; added: boolean; const parent: ICefView);
@ -138,5 +159,181 @@ begin
Result := nil; Result := nil;
end; end;
// **************************************************************
// ******************** TCefViewDelegateOwn *********************
// **************************************************************
function cef_view_delegate_get_preferred_size(self: PCefViewDelegate; view: PCefView): TCefSize; stdcall;
var
TempObject : TObject;
TempSize : TCefSize;
begin
TempObject := CefGetObject(self);
TempSize.width := 50;
TempSize.height := 50;
if (TempObject <> nil) and (TempObject is TCefViewDelegateOwn) then
TCefViewDelegateOwn(TempObject).OnGetPreferredSize(TCefViewRef.UnWrap(view),
TempSize);
Result := TempSize;
end;
function cef_view_delegate_get_minimum_size(self: PCefViewDelegate; view: PCefView): TCefSize; stdcall;
var
TempObject : TObject;
TempSize : TCefSize;
begin
TempObject := CefGetObject(self);
TempSize.width := 10;
TempSize.height := 10;
if (TempObject <> nil) and (TempObject is TCefViewDelegateOwn) then
TCefViewDelegateOwn(TempObject).OnGetMinimumSize(TCefViewRef.UnWrap(view),
TempSize);
Result := TempSize;
end;
function cef_view_delegate_get_maximum_size(self: PCefViewDelegate; view: PCefView): TCefSize; stdcall;
var
TempObject : TObject;
TempSize : TCefSize;
begin
TempObject := CefGetObject(self);
TempSize.width := 1000;
TempSize.height := 1000;
if (TempObject <> nil) and (TempObject is TCefViewDelegateOwn) then
TCefViewDelegateOwn(TempObject).OnGetMaximumSize(TCefViewRef.UnWrap(view),
TempSize);
Result := TempSize;
end;
function cef_view_delegate_get_height_for_width(self: PCefViewDelegate; view: PCefView; width: Integer): Integer; stdcall;
var
TempObject : TObject;
TempHeight : integer;
begin
TempObject := CefGetObject(self);
TempHeight := 0;
if (TempObject <> nil) and (TempObject is TCefViewDelegateOwn) then
TCefViewDelegateOwn(TempObject).OnGetHeightForWidth(TCefViewRef.UnWrap(view),
width,
TempHeight);
Result := TempHeight;
end;
procedure cef_view_delegate_on_parent_view_changed(self: PCefViewDelegate; view: PCefView; added: Integer; parent: PCefView); stdcall;
var
TempObject : TObject;
begin
TempObject := CefGetObject(self);
if (TempObject <> nil) and (TempObject is TCefViewDelegateOwn) then
TCefViewDelegateOwn(TempObject).OnParentViewChanged(TCefViewRef.UnWrap(view),
added <> 0,
TCefViewRef.UnWrap(parent));
end;
procedure cef_view_delegate_on_child_view_changed(self: PCefViewDelegate; view: PCefView; added: Integer; child: PCefView); stdcall;
var
TempObject : TObject;
begin
TempObject := CefGetObject(self);
if (TempObject <> nil) and (TempObject is TCefViewDelegateOwn) then
TCefViewDelegateOwn(TempObject).OnChildViewChanged(TCefViewRef.UnWrap(view),
added <> 0,
TCefViewRef.UnWrap(child));
end;
procedure cef_view_delegate_on_focus(self: PCefViewDelegate; view: PCefView); stdcall;
var
TempObject : TObject;
begin
TempObject := CefGetObject(self);
if (TempObject <> nil) and (TempObject is TCefViewDelegateOwn) then
TCefViewDelegateOwn(TempObject).OnFocus(TCefViewRef.UnWrap(view));
end;
procedure cef_view_delegate_on_blur(self: PCefViewDelegate; view: PCefView); stdcall;
var
TempObject : TObject;
begin
TempObject := CefGetObject(self);
if (TempObject <> nil) and (TempObject is TCefViewDelegateOwn) then
TCefViewDelegateOwn(TempObject).OnBlur(TCefViewRef.UnWrap(view));
end;
constructor TCefViewDelegateOwn.Create;
begin
inherited CreateData(SizeOf(TCefViewDelegate));
InitializeCEFMethods;
end;
procedure TCefViewDelegateOwn.InitializeCEFMethods;
begin
with PCefViewDelegate(FData)^ do
begin
get_preferred_size := {$IFDEF FPC}@{$ENDIF}cef_view_delegate_get_preferred_size;
get_minimum_size := {$IFDEF FPC}@{$ENDIF}cef_view_delegate_get_minimum_size;
get_maximum_size := {$IFDEF FPC}@{$ENDIF}cef_view_delegate_get_maximum_size;
get_height_for_width := {$IFDEF FPC}@{$ENDIF}cef_view_delegate_get_height_for_width;
on_parent_view_changed := {$IFDEF FPC}@{$ENDIF}cef_view_delegate_on_parent_view_changed;
on_child_view_changed := {$IFDEF FPC}@{$ENDIF}cef_view_delegate_on_child_view_changed;
on_focus := {$IFDEF FPC}@{$ENDIF}cef_view_delegate_on_focus;
on_blur := {$IFDEF FPC}@{$ENDIF}cef_view_delegate_on_blur;
end;
end;
procedure TCefViewDelegateOwn.OnGetPreferredSize(const view: ICefView; var aResult : TCefSize);
begin
//
end;
procedure TCefViewDelegateOwn.OnGetMinimumSize(const view: ICefView; var aResult : TCefSize);
begin
//
end;
procedure TCefViewDelegateOwn.OnGetMaximumSize(const view: ICefView; var aResult : TCefSize);
begin
//
end;
procedure TCefViewDelegateOwn.OnGetHeightForWidth(const view: ICefView; width: Integer; var aResult: Integer);
begin
//
end;
procedure TCefViewDelegateOwn.OnParentViewChanged(const view: ICefView; added: boolean; const parent: ICefView);
begin
//
end;
procedure TCefViewDelegateOwn.OnChildViewChanged(const view: ICefView; added: boolean; const child: ICefView);
begin
//
end;
procedure TCefViewDelegateOwn.OnFocus(const view: ICefView);
begin
//
end;
procedure TCefViewDelegateOwn.OnBlur(const view: ICefView);
begin
//
end;
end. end.

310
source/uCEFWindowDelegate.pas
View File

@ -61,24 +61,47 @@ type
protected protected
procedure OnWindowCreated(const window: ICefWindow); procedure OnWindowCreated(const window: ICefWindow);
procedure OnWindowDestroyed(const window: ICefWindow); procedure OnWindowDestroyed(const window: ICefWindow);
function GetParentWindow(const window: ICefWindow; is_menu, can_activate_menu: boolean): ICefWindow; procedure OnGetParentWindow(const window: ICefWindow; var is_menu, can_activate_menu: boolean; var aResult : ICefWindow);
function IsFrameless(const window: ICefWindow): boolean; procedure OnIsFrameless(const window: ICefWindow; var aResult : boolean);
function CanResize(const window: ICefWindow): boolean; procedure OnCanResize(const window: ICefWindow; var aResult : boolean);
function CanMaximize(const window: ICefWindow): boolean; procedure OnCanMaximize(const window: ICefWindow; var aResult : boolean);
function CanMinimize(const window: ICefWindow): boolean; procedure OnCanMinimize(const window: ICefWindow; var aResult : boolean);
function CanClose(const window: ICefWindow): boolean; procedure OnCanClose(const window: ICefWindow; var aResult : boolean);
function OnAccelerator(const window: ICefWindow; command_id: Integer): boolean; procedure OnAccelerator(const window: ICefWindow; command_id: Integer; var aResult : boolean);
function OnKeyEvent(const window: ICefWindow; const event: TCefKeyEvent): boolean; procedure OnKeyEvent(const window: ICefWindow; const event: TCefKeyEvent; var aResult : boolean);
public public
class function UnWrap(data: Pointer): ICefWindowDelegate; class function UnWrap(data: Pointer): ICefWindowDelegate;
end; end;
TCefWindowDelegateOwn = class(TCefPanelDelegateOwn, ICefWindowDelegate)
protected
procedure OnWindowCreated(const window: ICefWindow); virtual;
procedure OnWindowDestroyed(const window: ICefWindow); virtual;
procedure OnGetParentWindow(const window: ICefWindow; var is_menu, can_activate_menu: boolean; var aResult : ICefWindow); virtual;
procedure OnIsFrameless(const window: ICefWindow; var aResult : boolean); virtual;
procedure OnCanResize(const window: ICefWindow; var aResult : boolean); virtual;
procedure OnCanMaximize(const window: ICefWindow; var aResult : boolean); virtual;
procedure OnCanMinimize(const window: ICefWindow; var aResult : boolean); virtual;
procedure OnCanClose(const window: ICefWindow; var aResult : boolean); virtual;
procedure OnAccelerator(const window: ICefWindow; command_id: Integer; var aResult : boolean); virtual;
procedure OnKeyEvent(const window: ICefWindow; const event: TCefKeyEvent; var aResult : boolean); virtual;
procedure InitializeCEFMethods; override;
public
constructor Create; override;
end;
implementation implementation
uses uses
uCEFLibFunctions, uCEFMiscFunctions, uCEFWindow; uCEFLibFunctions, uCEFMiscFunctions, uCEFWindow;
// **************************************************************
// ******************* TCefWindowDelegateRef ********************
// **************************************************************
procedure TCefWindowDelegateRef.OnWindowCreated(const window: ICefWindow); procedure TCefWindowDelegateRef.OnWindowCreated(const window: ICefWindow);
begin begin
PCefWindowDelegate(FData)^.on_window_created(PCefWindowDelegate(FData), CefGetData(window)); PCefWindowDelegate(FData)^.on_window_created(PCefWindowDelegate(FData), CefGetData(window));
@ -89,53 +112,56 @@ begin
PCefWindowDelegate(FData)^.on_window_destroyed(PCefWindowDelegate(FData), CefGetData(window)); PCefWindowDelegate(FData)^.on_window_destroyed(PCefWindowDelegate(FData), CefGetData(window));
end; end;
function TCefWindowDelegateRef.GetParentWindow(const window : ICefWindow; procedure TCefWindowDelegateRef.OnGetParentWindow(const window : ICefWindow;
is_menu : boolean; var is_menu : boolean;
can_activate_menu : boolean): ICefWindow; var can_activate_menu : boolean;
var aResult : ICefWindow);
var var
TempIsMenu, TempCanActivateMenu : integer; TempIsMenu, TempCanActivateMenu : integer;
begin begin
TempIsMenu := ord(is_menu); TempIsMenu := ord(is_menu);
TempCanActivateMenu := ord(can_activate_menu); TempCanActivateMenu := ord(can_activate_menu);
Result := TCefWindowRef.UnWrap(PCefWindowDelegate(FData)^.get_parent_window(PCefWindowDelegate(FData), aResult := TCefWindowRef.UnWrap(PCefWindowDelegate(FData)^.get_parent_window(PCefWindowDelegate(FData),
CefGetData(window), CefGetData(window),
@TempIsMenu, @TempIsMenu,
@TempCanActivateMenu)); @TempCanActivateMenu));
is_menu := TempIsMenu <> 0;
can_activate_menu := TempCanActivateMenu <> 0;
end; end;
function TCefWindowDelegateRef.IsFrameless(const window: ICefWindow): boolean; procedure TCefWindowDelegateRef.OnIsFrameless(const window: ICefWindow; var aResult : boolean);
begin begin
Result := (PCefWindowDelegate(FData)^.is_frameless(PCefWindowDelegate(FData), CefGetData(window)) <> 0); aResult := (PCefWindowDelegate(FData)^.is_frameless(PCefWindowDelegate(FData), CefGetData(window)) <> 0);
end; end;
function TCefWindowDelegateRef.CanResize(const window: ICefWindow): boolean; procedure TCefWindowDelegateRef.OnCanResize(const window: ICefWindow; var aResult : boolean);
begin begin
Result := (PCefWindowDelegate(FData)^.can_resize(PCefWindowDelegate(FData), CefGetData(window)) <> 0); aResult := (PCefWindowDelegate(FData)^.can_resize(PCefWindowDelegate(FData), CefGetData(window)) <> 0);
end; end;
function TCefWindowDelegateRef.CanMaximize(const window: ICefWindow): boolean; procedure TCefWindowDelegateRef.OnCanMaximize(const window: ICefWindow; var aResult : boolean);
begin begin
Result := (PCefWindowDelegate(FData)^.can_maximize(PCefWindowDelegate(FData), CefGetData(window)) <> 0); aResult := (PCefWindowDelegate(FData)^.can_maximize(PCefWindowDelegate(FData), CefGetData(window)) <> 0);
end; end;
function TCefWindowDelegateRef.CanMinimize(const window: ICefWindow): boolean; procedure TCefWindowDelegateRef.OnCanMinimize(const window: ICefWindow; var aResult : boolean);
begin begin
Result := (PCefWindowDelegate(FData)^.can_minimize(PCefWindowDelegate(FData), CefGetData(window)) <> 0); aResult := (PCefWindowDelegate(FData)^.can_minimize(PCefWindowDelegate(FData), CefGetData(window)) <> 0);
end; end;
function TCefWindowDelegateRef.CanClose(const window: ICefWindow): boolean; procedure TCefWindowDelegateRef.OnCanClose(const window: ICefWindow; var aResult : boolean);
begin begin
Result := (PCefWindowDelegate(FData)^.can_close(PCefWindowDelegate(FData), CefGetData(window)) <> 0); aResult := (PCefWindowDelegate(FData)^.can_close(PCefWindowDelegate(FData), CefGetData(window)) <> 0);
end; end;
function TCefWindowDelegateRef.OnAccelerator(const window: ICefWindow; command_id: Integer): boolean; procedure TCefWindowDelegateRef.OnAccelerator(const window: ICefWindow; command_id: Integer; var aResult : boolean);
begin begin
Result := (PCefWindowDelegate(FData)^.on_accelerator(PCefWindowDelegate(FData), CefGetData(window), command_id) <> 0); aResult := (PCefWindowDelegate(FData)^.on_accelerator(PCefWindowDelegate(FData), CefGetData(window), command_id) <> 0);
end; end;
function TCefWindowDelegateRef.OnKeyEvent(const window: ICefWindow; const event: TCefKeyEvent): boolean; procedure TCefWindowDelegateRef.OnKeyEvent(const window: ICefWindow; const event: TCefKeyEvent; var aResult : boolean);
begin begin
Result := (PCefWindowDelegate(FData)^.on_key_event(PCefWindowDelegate(FData), CefGetData(window), @event) <> 0); aResult := (PCefWindowDelegate(FData)^.on_key_event(PCefWindowDelegate(FData), CefGetData(window), @event) <> 0);
end; end;
class function TCefWindowDelegateRef.UnWrap(data: Pointer): ICefWindowDelegate; class function TCefWindowDelegateRef.UnWrap(data: Pointer): ICefWindowDelegate;
@ -146,5 +172,237 @@ begin
Result := nil; Result := nil;
end; end;
// **************************************************************
// ******************* TCefWindowDelegateOwn ********************
// **************************************************************
procedure cef_window_delegate_on_window_created(self: PCefWindowDelegate; window: PCefWindow); stdcall;
var
TempObject : TObject;
begin
TempObject := CefGetObject(self);
if (TempObject <> nil) and (TempObject is TCefWindowDelegateOwn) then
TCefWindowDelegateOwn(TempObject).OnWindowCreated(TCefWindowRef.UnWrap(window));
end;
procedure cef_window_delegate_on_window_destroyed(self: PCefWindowDelegate; window: PCefWindow); stdcall;
var
TempObject : TObject;
begin
TempObject := CefGetObject(self);
if (TempObject <> nil) and (TempObject is TCefWindowDelegateOwn) then
TCefWindowDelegateOwn(TempObject).OnWindowDestroyed(TCefWindowRef.UnWrap(window));
end;
function cef_window_delegate_get_parent_window(self : PCefWindowDelegate;
window : PCefWindow;
is_menu : PInteger;
can_activate_menu : PInteger): PCefWindow; stdcall;
var
TempObject : TObject;
TempWindow : ICefWindow;
TempIsMenu, TempCanActivateMenu : boolean;
begin
TempObject := CefGetObject(self);
TempWindow := nil;
if (TempObject <> nil) and (TempObject is TCefWindowDelegateOwn) and (is_menu <> nil) and (can_activate_menu <> nil) then
begin
TempIsMenu := (is_menu^ <> 0);
TempCanActivateMenu := (can_activate_menu^ <> 0);
TCefWindowDelegateOwn(TempObject).OnGetParentWindow(TCefWindowRef.UnWrap(window),
TempIsMenu,
TempCanActivateMenu,
TempWindow);
is_menu^ := ord(TempIsMenu);
can_activate_menu^ := ord(TempCanActivateMenu);
end;
Result := CefGetData(TempWindow);
end;
function cef_window_delegate_is_frameless(self: PCefWindowDelegate; window: PCefWindow): Integer; stdcall;
var
TempObject : TObject;
TempIsFrameless : boolean;
begin
TempObject := CefGetObject(self);
TempIsFrameless := False;
if (TempObject <> nil) and (TempObject is TCefWindowDelegateOwn) then
TCefWindowDelegateOwn(TempObject).OnIsFrameless(TCefWindowRef.UnWrap(window), TempIsFrameless);
Result := ord(TempIsFrameless);
end;
function cef_window_delegate_can_resize(self: PCefWindowDelegate; window: PCefWindow): Integer; stdcall;
var
TempObject : TObject;
TempCanResize : boolean;
begin
TempObject := CefGetObject(self);
TempCanResize := True;
if (TempObject <> nil) and (TempObject is TCefWindowDelegateOwn) then
TCefWindowDelegateOwn(TempObject).OnCanResize(TCefWindowRef.UnWrap(window), TempCanResize);
Result := ord(TempCanResize);
end;
function cef_window_delegate_can_maximize(self: PCefWindowDelegate; window: PCefWindow): Integer; stdcall;
var
TempObject : TObject;
TempCanMaximize : boolean;
begin
TempObject := CefGetObject(self);
TempCanMaximize := True;
if (TempObject <> nil) and (TempObject is TCefWindowDelegateOwn) then
TCefWindowDelegateOwn(TempObject).OnCanMaximize(TCefWindowRef.UnWrap(window), TempCanMaximize);
Result := ord(TempCanMaximize);
end;
function cef_window_delegate_can_minimize(self: PCefWindowDelegate; window: PCefWindow): Integer; stdcall;
var
TempObject : TObject;
TempCanMinimize : boolean;
begin
TempObject := CefGetObject(self);
TempCanMinimize := True;
if (TempObject <> nil) and (TempObject is TCefWindowDelegateOwn) then
TCefWindowDelegateOwn(TempObject).OnCanMinimize(TCefWindowRef.UnWrap(window), TempCanMinimize);
Result := ord(TempCanMinimize);
end;
function cef_window_delegate_can_close(self: PCefWindowDelegate; window: PCefWindow): Integer; stdcall;
var
TempObject : TObject;
TempCanClose : boolean;
begin
TempObject := CefGetObject(self);
TempCanClose := True;
if (TempObject <> nil) and (TempObject is TCefWindowDelegateOwn) then
TCefWindowDelegateOwn(TempObject).OnCanClose(TCefWindowRef.UnWrap(window), TempCanClose);
Result := ord(TempCanClose);
end;
function cef_window_delegate_on_accelerator(self : PCefWindowDelegate;
window : PCefWindow;
command_id : Integer): Integer; stdcall;
var
TempObject : TObject;
TempResult : boolean;
begin
TempObject := CefGetObject(self);
TempResult := False;
if (TempObject <> nil) and (TempObject is TCefWindowDelegateOwn) then
TCefWindowDelegateOwn(TempObject).OnAccelerator(TCefWindowRef.UnWrap(window), command_id, TempResult);
Result := ord(TempResult);
end;
function cef_window_delegate_on_key_event( self : PCefWindowDelegate;
window : PCefWindow;
const event : PCefKeyEvent): Integer; stdcall;
var
TempObject : TObject;
TempResult : boolean;
begin
TempObject := CefGetObject(self);
TempResult := False;
if (TempObject <> nil) and (TempObject is TCefWindowDelegateOwn) then
TCefWindowDelegateOwn(TempObject).OnKeyEvent(TCefWindowRef.UnWrap(window), event^, TempResult);
Result := ord(TempResult);
end;
constructor TCefWindowDelegateOwn.Create;
begin
inherited CreateData(SizeOf(TCefWindowDelegate));
InitializeCEFMethods;
end;
procedure TCefWindowDelegateOwn.InitializeCEFMethods;
begin
inherited InitializeCEFMethods;
with PCefWindowDelegate(FData)^ do
begin
on_window_created := {$IFDEF FPC}@{$ENDIF}cef_window_delegate_on_window_created;
on_window_destroyed := {$IFDEF FPC}@{$ENDIF}cef_window_delegate_on_window_destroyed;
get_parent_window := {$IFDEF FPC}@{$ENDIF}cef_window_delegate_get_parent_window;
is_frameless := {$IFDEF FPC}@{$ENDIF}cef_window_delegate_is_frameless;
can_resize := {$IFDEF FPC}@{$ENDIF}cef_window_delegate_can_resize;
can_maximize := {$IFDEF FPC}@{$ENDIF}cef_window_delegate_can_maximize;
can_minimize := {$IFDEF FPC}@{$ENDIF}cef_window_delegate_can_minimize;
can_close := {$IFDEF FPC}@{$ENDIF}cef_window_delegate_can_close;
on_accelerator := {$IFDEF FPC}@{$ENDIF}cef_window_delegate_on_accelerator;
on_key_event := {$IFDEF FPC}@{$ENDIF}cef_window_delegate_on_key_event;
end;
end;
procedure TCefWindowDelegateOwn.OnWindowCreated(const window: ICefWindow);
begin
//
end;
procedure TCefWindowDelegateOwn.OnWindowDestroyed(const window: ICefWindow);
begin
//
end;
procedure TCefWindowDelegateOwn.OnGetParentWindow(const window: ICefWindow; var is_menu, can_activate_menu: boolean; var aResult : ICefWindow);
begin
//
end;
procedure TCefWindowDelegateOwn.OnIsFrameless(const window: ICefWindow; var aResult : boolean);
begin
//
end;
procedure TCefWindowDelegateOwn.OnCanResize(const window: ICefWindow; var aResult : boolean);
begin
//
end;
procedure TCefWindowDelegateOwn.OnCanMaximize(const window: ICefWindow; var aResult : boolean);
begin
//
end;
procedure TCefWindowDelegateOwn.OnCanMinimize(const window: ICefWindow; var aResult : boolean);
begin
//
end;
procedure TCefWindowDelegateOwn.OnCanClose(const window: ICefWindow; var aResult : boolean);
begin
//
end;
procedure TCefWindowDelegateOwn.OnAccelerator(const window: ICefWindow; command_id: Integer; var aResult : boolean);
begin
//
end;
procedure TCefWindowDelegateOwn.OnKeyEvent(const window: ICefWindow; const event: TCefKeyEvent; var aResult : boolean);
begin
//
end;
end. end.

4
update_CEF4Delphi.json
View File

@ -2,9 +2,9 @@
"UpdateLazPackages" : [ "UpdateLazPackages" : [
{ {
"ForceNotify" : true, "ForceNotify" : true,
"InternalVersion" : 128, "InternalVersion" : 129,
"Name" : "cef4delphi_lazarus.lpk", "Name" : "cef4delphi_lazarus.lpk",
"Version" : "81.2.25.0" "Version" : "81.3.1.0"
} }
], ],
"UpdatePackageData" : { "UpdatePackageData" : {