From b78978ec330fa5c10fe6db3d2e7248340bc975f3 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 12:59:32 -0300 Subject: [PATCH 01/42] Adding TScreen wrapper --- Source/fmx/WrapFmxForms.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxForms.pas b/Source/fmx/WrapFmxForms.pas index 6c31996c..ea3205d6 100644 --- a/Source/fmx/WrapFmxForms.pas +++ b/Source/fmx/WrapFmxForms.pas @@ -72,6 +72,17 @@ TPyDelphiFrame = class(TPyDelphiControl) property DelphiObject: TFrame read GetDelphiObject write SetDelphiObject; end; + TPyDelphiScreen = class(TPyDelphiComponent) + private + function GetDelphiObject: TScreen; + procedure SetDelphiObject(const Value: TScreen); + public + // Class methods + class function DelphiObjectClass: TClass; override; + // Properties + property DelphiObject: TScreen read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -118,6 +129,7 @@ procedure TFormsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPopupForm); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiForm); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFrame); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiScreen); end; { TPyDelphiApplication } @@ -224,6 +236,23 @@ procedure TPyDelphiFrame.SetDelphiObject(const Value: TFrame); inherited DelphiObject := Value; end; +{ TPyDelphiScreen } + +class function TPyDelphiScreen.DelphiObjectClass: TClass; +begin + Result := TScreen; +end; + +function TPyDelphiScreen.GetDelphiObject: TScreen; +begin + Result := TScreen(inherited DelphiObject); +end; + +procedure TPyDelphiScreen.SetDelphiObject(const Value: TScreen); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TFormsRegistration.Create); From 46f5320fa5416b2974ce837009f623a63a366299 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 15:52:03 -0300 Subject: [PATCH 02/42] Adding TLayout wrapper --- Source/fmx/WrapFmxLayouts.pas | 69 +++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 Source/fmx/WrapFmxLayouts.pas diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas new file mode 100644 index 00000000..db2fb506 --- /dev/null +++ b/Source/fmx/WrapFmxLayouts.pas @@ -0,0 +1,69 @@ +unit WrapFmxLayouts; + +interface + +uses + FMX.Layouts, WrapFmxControls, WrapDelphi; + +type + TPyDelphiLayout = class(TPyDelphiControl) + private + function GetDelphiObject: TLayout; + procedure SetDelphiObject(const Value: TLayout); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TLayout read GetDelphiObject write SetDelphiObject; + end; + +implementation + +{ Register the wrappers, the globals and the constants } +type + TLayoutsRegistration = class(TRegisteredUnit) + public + function Name : string; override; + procedure RegisterWrappers(APyDelphiWrapper : TPyDelphiWrapper); override; + procedure DefineVars(APyDelphiWrapper : TPyDelphiWrapper); override; + end; + +{ TPyDelphiLayout } + +class function TPyDelphiLayout.DelphiObjectClass: TClass; +begin + Result := TLayout; +end; + +function TPyDelphiLayout.GetDelphiObject: TLayout; +begin + Result := TLayout(inherited DelphiObject); +end; + +procedure TPyDelphiLayout.SetDelphiObject(const Value: TLayout); +begin + inherited DelphiObject := Value; +end; + +{ TLayoutsRegistration } + +procedure TLayoutsRegistration.DefineVars(APyDelphiWrapper: TPyDelphiWrapper); +begin + inherited; +end; + +function TLayoutsRegistration.Name: string; +begin + Result := 'Layouts'; +end; + +procedure TLayoutsRegistration.RegisterWrappers( + APyDelphiWrapper: TPyDelphiWrapper); +begin + inherited; + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiLayout); +end; + +initialization + RegisteredUnits.Add(TLayoutsRegistration.Create); + +end. From 3720e6ef8564b13f6e08b16a798e890b232fec62 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 15:53:22 -0300 Subject: [PATCH 03/42] Adding TScaledLayout wrapper --- Source/fmx/WrapFmxLayouts.pas | 46 ++++++++++++++++++++++++++++------- 1 file changed, 37 insertions(+), 9 deletions(-) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index db2fb506..287da40a 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -16,6 +16,16 @@ TPyDelphiLayout = class(TPyDelphiControl) property DelphiObject: TLayout read GetDelphiObject write SetDelphiObject; end; + TPyDelphiScaledLayout = class(TPyDelphiControl) + private + function GetDelphiObject: TScaledLayout; + procedure SetDelphiObject(const Value: TScaledLayout); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TScaledLayout read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -27,6 +37,26 @@ TLayoutsRegistration = class(TRegisteredUnit) procedure DefineVars(APyDelphiWrapper : TPyDelphiWrapper); override; end; +{ TLayoutsRegistration } + +procedure TLayoutsRegistration.DefineVars(APyDelphiWrapper: TPyDelphiWrapper); +begin + inherited; +end; + +function TLayoutsRegistration.Name: string; +begin + Result := 'Layouts'; +end; + +procedure TLayoutsRegistration.RegisterWrappers( + APyDelphiWrapper: TPyDelphiWrapper); +begin + inherited; + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiLayout); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiScaledLayout); +end; + { TPyDelphiLayout } class function TPyDelphiLayout.DelphiObjectClass: TClass; @@ -44,23 +74,21 @@ procedure TPyDelphiLayout.SetDelphiObject(const Value: TLayout); inherited DelphiObject := Value; end; -{ TLayoutsRegistration } +{ TPyDelphiScaledLayout } -procedure TLayoutsRegistration.DefineVars(APyDelphiWrapper: TPyDelphiWrapper); +class function TPyDelphiScaledLayout.DelphiObjectClass: TClass; begin - inherited; + Result := TScaledLayout; end; -function TLayoutsRegistration.Name: string; +function TPyDelphiScaledLayout.GetDelphiObject: TScaledLayout; begin - Result := 'Layouts'; + Result := TScaledLayout(inherited DelphiObject); end; -procedure TLayoutsRegistration.RegisterWrappers( - APyDelphiWrapper: TPyDelphiWrapper); +procedure TPyDelphiScaledLayout.SetDelphiObject(const Value: TScaledLayout); begin - inherited; - APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiLayout); + inherited DelphiObject := Value; end; initialization From 3da2b3152a745c14e14502647dae58dd40ef92aa Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 15:54:49 -0300 Subject: [PATCH 04/42] Adding TCustomScrollBox wrapper --- Source/fmx/WrapFmxLayouts.pas | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index 287da40a..88fdff4e 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -3,7 +3,7 @@ interface uses - FMX.Layouts, WrapFmxControls, WrapDelphi; + FMX.Layouts, WrapDelphi, WrapFmxControls; type TPyDelphiLayout = class(TPyDelphiControl) @@ -26,6 +26,16 @@ TPyDelphiScaledLayout = class(TPyDelphiControl) property DelphiObject: TScaledLayout read GetDelphiObject write SetDelphiObject; end; + TPyDelphiCustomScrollBox = class(TPyDelphiStyledControl) + private + function GetDelphiObject: TCustomScrollBox; + procedure SetDelphiObject(const Value: TCustomScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCustomScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -55,6 +65,7 @@ procedure TLayoutsRegistration.RegisterWrappers( inherited; APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiLayout); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiScaledLayout); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomScrollBox); end; { TPyDelphiLayout } @@ -91,6 +102,24 @@ procedure TPyDelphiScaledLayout.SetDelphiObject(const Value: TScaledLayout); inherited DelphiObject := Value; end; +{ TPyDelphiCustomScrollBox } + +class function TPyDelphiCustomScrollBox.DelphiObjectClass: TClass; +begin + Result := TCustomScrollBox; +end; + +function TPyDelphiCustomScrollBox.GetDelphiObject: TCustomScrollBox; +begin + Result := TCustomScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiCustomScrollBox.SetDelphiObject( + const Value: TCustomScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TLayoutsRegistration.Create); From bdc56719e24813c50792c8aedde8a93a7ec3c28f Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:04:59 -0300 Subject: [PATCH 05/42] Adding TVertScrollBox wrapper --- Source/fmx/WrapFmxLayouts.pas | 56 +++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index 88fdff4e..4bc9d5d4 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -36,6 +36,26 @@ TPyDelphiCustomScrollBox = class(TPyDelphiStyledControl) property DelphiObject: TCustomScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiScrollBox = class(TPyDelphiCustomScrollBox) + private + function GetDelphiObject: TScrollBox; + procedure SetDelphiObject(const Value: TScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TScrollBox read GetDelphiObject write SetDelphiObject; + end; + + TPyDelphiVertScrollBox = class(TPyDelphiCustomScrollBox) + private + function GetDelphiObject: TVertScrollBox; + procedure SetDelphiObject(const Value: TVertScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TVertScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -66,6 +86,8 @@ procedure TLayoutsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiLayout); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiScaledLayout); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiVertScrollBox); end; { TPyDelphiLayout } @@ -120,6 +142,40 @@ procedure TPyDelphiCustomScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiScrollBox } + +class function TPyDelphiScrollBox.DelphiObjectClass: TClass; +begin + Result := TScrollBox; +end; + +function TPyDelphiScrollBox.GetDelphiObject: TScrollBox; +begin + Result := TScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiScrollBox.SetDelphiObject(const Value: TScrollBox); +begin + inherited DelphiObject := Value; +end; + +{ TPyDelphiVertScrollBox } + +class function TPyDelphiVertScrollBox.DelphiObjectClass: TClass; +begin + Result := TVertScrollBox; +end; + +function TPyDelphiVertScrollBox.GetDelphiObject: TVertScrollBox; +begin + Result := TVertScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiVertScrollBox.SetDelphiObject(const Value: TVertScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TLayoutsRegistration.Create); From b0345e45f1dbaca448237dee765228da8d756d03 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:06:03 -0300 Subject: [PATCH 06/42] Adding THorzScrollBox wrapper --- Source/fmx/WrapFmxLayouts.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index 4bc9d5d4..7c51be52 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -56,6 +56,16 @@ TPyDelphiVertScrollBox = class(TPyDelphiCustomScrollBox) property DelphiObject: TVertScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiHorzScrollBox = class(TPyDelphiCustomScrollBox) + private + function GetDelphiObject: THorzScrollBox; + procedure SetDelphiObject(const Value: THorzScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: THorzScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -88,6 +98,7 @@ procedure TLayoutsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiVertScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiHorzScrollBox); end; { TPyDelphiLayout } @@ -176,6 +187,23 @@ procedure TPyDelphiVertScrollBox.SetDelphiObject(const Value: TVertScrollBox); inherited DelphiObject := Value; end; +{ TPyDelphiHorzScrollBox } + +class function TPyDelphiHorzScrollBox.DelphiObjectClass: TClass; +begin + Result := THorzScrollBox; +end; + +function TPyDelphiHorzScrollBox.GetDelphiObject: THorzScrollBox; +begin + Result := THorzScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiHorzScrollBox.SetDelphiObject(const Value: THorzScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TLayoutsRegistration.Create); From 6220122157b458ccad9a2b6eb9add00f82d8d7a0 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:07:08 -0300 Subject: [PATCH 07/42] Addint TFramedScrollBox wrapper --- Source/fmx/WrapFmxLayouts.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index 7c51be52..af6cbfbf 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -66,6 +66,16 @@ TPyDelphiHorzScrollBox = class(TPyDelphiCustomScrollBox) property DelphiObject: THorzScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiFramedScrollBox = class(TPyDelphiCustomScrollBox) + private + function GetDelphiObject: TFramedScrollBox; + procedure SetDelphiObject(const Value: TFramedScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TFramedScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -99,6 +109,7 @@ procedure TLayoutsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiVertScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiHorzScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFramedScrollBox); end; { TPyDelphiLayout } @@ -204,6 +215,24 @@ procedure TPyDelphiHorzScrollBox.SetDelphiObject(const Value: THorzScrollBox); inherited DelphiObject := Value; end; +{ TPyDelphiFramedScrollBox } + +class function TPyDelphiFramedScrollBox.DelphiObjectClass: TClass; +begin + Result := TFramedScrollBox; +end; + +function TPyDelphiFramedScrollBox.GetDelphiObject: TFramedScrollBox; +begin + Result := TFramedScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiFramedScrollBox.SetDelphiObject( + const Value: TFramedScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TLayoutsRegistration.Create); From 0be1fe219652d5348c1488d0fdd3c5411be1454f Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:08:46 -0300 Subject: [PATCH 08/42] Adding TFramedVertScrollBox wrapper --- Source/fmx/WrapFmxLayouts.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index af6cbfbf..46a3f0c0 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -76,6 +76,16 @@ TPyDelphiFramedScrollBox = class(TPyDelphiCustomScrollBox) property DelphiObject: TFramedScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiFramedVertScrollBox = class(TPyDelphiVertScrollBox) + private + function GetDelphiObject: TFramedVertScrollBox; + procedure SetDelphiObject(const Value: TFramedVertScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TFramedVertScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -110,6 +120,7 @@ procedure TLayoutsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiVertScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiHorzScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFramedScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFramedVertScrollBox); end; { TPyDelphiLayout } @@ -233,6 +244,24 @@ procedure TPyDelphiFramedScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiFramedVertScrollBox } + +class function TPyDelphiFramedVertScrollBox.DelphiObjectClass: TClass; +begin + Result := TFramedVertScrollBox; +end; + +function TPyDelphiFramedVertScrollBox.GetDelphiObject: TFramedVertScrollBox; +begin + Result := TFramedVertScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiFramedVertScrollBox.SetDelphiObject( + const Value: TFramedVertScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TLayoutsRegistration.Create); From 5ea48ad978de8f49523aa0efabaf726105d55a72 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:09:56 -0300 Subject: [PATCH 09/42] Adding TGridLayout wrapper --- Source/fmx/WrapFmxLayouts.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index 46a3f0c0..6e922d07 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -86,6 +86,16 @@ TPyDelphiFramedVertScrollBox = class(TPyDelphiVertScrollBox) property DelphiObject: TFramedVertScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiGridLayout = class(TPyDelphiControl) + private + function GetDelphiObject: TGridLayout; + procedure SetDelphiObject(const Value: TGridLayout); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TGridLayout read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -121,6 +131,7 @@ procedure TLayoutsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiHorzScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFramedScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFramedVertScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGridLayout); end; { TPyDelphiLayout } @@ -262,6 +273,23 @@ procedure TPyDelphiFramedVertScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiGridLayout } + +class function TPyDelphiGridLayout.DelphiObjectClass: TClass; +begin + Result := TGridLayout; +end; + +function TPyDelphiGridLayout.GetDelphiObject: TGridLayout; +begin + Result := TGridLayout(inherited DelphiObject); +end; + +procedure TPyDelphiGridLayout.SetDelphiObject(const Value: TGridLayout); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TLayoutsRegistration.Create); From 83ff884443aa8c86e4477788a494708e7d380d94 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:11:01 -0300 Subject: [PATCH 10/42] Adding TGridPanelLayout wrapper --- Source/fmx/WrapFmxLayouts.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index 6e922d07..bdac2a77 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -96,6 +96,16 @@ TPyDelphiGridLayout = class(TPyDelphiControl) property DelphiObject: TGridLayout read GetDelphiObject write SetDelphiObject; end; + TPyDelphiGridPanelLayout = class(TPyDelphiControl) + private + function GetDelphiObject: TGridPanelLayout; + procedure SetDelphiObject(const Value: TGridPanelLayout); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TGridPanelLayout read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -132,6 +142,7 @@ procedure TLayoutsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFramedScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFramedVertScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGridLayout); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGridPanelLayout); end; { TPyDelphiLayout } @@ -290,6 +301,24 @@ procedure TPyDelphiGridLayout.SetDelphiObject(const Value: TGridLayout); inherited DelphiObject := Value; end; +{ TPyDelphiGridPanelLayout } + +class function TPyDelphiGridPanelLayout.DelphiObjectClass: TClass; +begin + Result := TGridPanelLayout; +end; + +function TPyDelphiGridPanelLayout.GetDelphiObject: TGridPanelLayout; +begin + Result := TGridPanelLayout(inherited DelphiObject); +end; + +procedure TPyDelphiGridPanelLayout.SetDelphiObject( + const Value: TGridPanelLayout); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TLayoutsRegistration.Create); From 7ee89471134d658297ec621a5139c81eb630775f Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:12:29 -0300 Subject: [PATCH 11/42] Adding TFlowLayout wrapper --- Source/fmx/WrapFmxLayouts.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index bdac2a77..0fe810e1 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -106,6 +106,16 @@ TPyDelphiGridPanelLayout = class(TPyDelphiControl) property DelphiObject: TGridPanelLayout read GetDelphiObject write SetDelphiObject; end; + TPyDelphiFlowLayout = class(TPyDelphiControl) + private + function GetDelphiObject: TFlowLayout; + procedure SetDelphiObject(const Value: TFlowLayout); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TFlowLayout read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -143,6 +153,7 @@ procedure TLayoutsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFramedVertScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGridLayout); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGridPanelLayout); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFlowLayout); end; { TPyDelphiLayout } @@ -319,6 +330,23 @@ procedure TPyDelphiGridPanelLayout.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiFlowLayout } + +class function TPyDelphiFlowLayout.DelphiObjectClass: TClass; +begin + Result := TFlowLayout; +end; + +function TPyDelphiFlowLayout.GetDelphiObject: TFlowLayout; +begin + Result := TFlowLayout(inherited DelphiObject); +end; + +procedure TPyDelphiFlowLayout.SetDelphiObject(const Value: TFlowLayout); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TLayoutsRegistration.Create); From e70c253e9b09eb2a0376ea123c3921fdf5a89c55 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:16:17 -0300 Subject: [PATCH 12/42] Adding TCustomBufferedLayout wrapper --- Source/fmx/WrapFmxLayouts.pas | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index 0fe810e1..0ed2fa40 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -3,7 +3,7 @@ interface uses - FMX.Layouts, WrapDelphi, WrapFmxControls; + FMX.Layouts, FMX.BufferedLayout, WrapDelphi, WrapFmxControls; type TPyDelphiLayout = class(TPyDelphiControl) @@ -116,6 +116,16 @@ TPyDelphiFlowLayout = class(TPyDelphiControl) property DelphiObject: TFlowLayout read GetDelphiObject write SetDelphiObject; end; + TPyDelphiCustomBufferedLayout = class(TPyDelphiLayout) + private + function GetDelphiObject: TCustomBufferedLayout; + procedure SetDelphiObject(const Value: TCustomBufferedLayout); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCustomBufferedLayout read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -154,6 +164,7 @@ procedure TLayoutsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGridLayout); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGridPanelLayout); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFlowLayout); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomBufferedLayout); end; { TPyDelphiLayout } @@ -347,6 +358,24 @@ procedure TPyDelphiFlowLayout.SetDelphiObject(const Value: TFlowLayout); inherited DelphiObject := Value; end; +{ TPyDelphiCustomBufferedLayout } + +class function TPyDelphiCustomBufferedLayout.DelphiObjectClass: TClass; +begin + Result := TCustomBufferedLayout; +end; + +function TPyDelphiCustomBufferedLayout.GetDelphiObject: TCustomBufferedLayout; +begin + Result := TCustomBufferedLayout(inherited DelphiObject); +end; + +procedure TPyDelphiCustomBufferedLayout.SetDelphiObject( + const Value: TCustomBufferedLayout); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TLayoutsRegistration.Create); From 5b94b1f459c6cf5bedba2205ca0abcb7489673b9 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:17:20 -0300 Subject: [PATCH 13/42] Adding TBufferedLayout wrapper --- Source/fmx/WrapFmxLayouts.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index 0ed2fa40..3ef89abd 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -126,6 +126,16 @@ TPyDelphiCustomBufferedLayout = class(TPyDelphiLayout) property DelphiObject: TCustomBufferedLayout read GetDelphiObject write SetDelphiObject; end; + TPyDelphiBufferedLayout = class(TPyDelphiCustomBufferedLayout) + private + function GetDelphiObject: TBufferedLayout; + procedure SetDelphiObject(const Value: TBufferedLayout); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TBufferedLayout read GetDelphiObject write SetDelphiObject; + end; + implementation { Register the wrappers, the globals and the constants } @@ -165,6 +175,7 @@ procedure TLayoutsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGridPanelLayout); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFlowLayout); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomBufferedLayout); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiBufferedLayout); end; { TPyDelphiLayout } @@ -376,6 +387,23 @@ procedure TPyDelphiCustomBufferedLayout.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiBufferedLayout } + +class function TPyDelphiBufferedLayout.DelphiObjectClass: TClass; +begin + Result := TBufferedLayout; +end; + +function TPyDelphiBufferedLayout.GetDelphiObject: TBufferedLayout; +begin + Result := TBufferedLayout(inherited DelphiObject); +end; + +procedure TPyDelphiBufferedLayout.SetDelphiObject(const Value: TBufferedLayout); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TLayoutsRegistration.Create); From f40f1eec90433b55505fdf65a9cda8034d074546 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:33:42 -0300 Subject: [PATCH 14/42] Adding missed definitions.inc --- Source/fmx/WrapFmxComCtrls.pas | 2 ++ Source/fmx/WrapFmxDialogs.pas | 2 ++ Source/fmx/WrapFmxForms.pas | 2 ++ Source/fmx/WrapFmxLayouts.pas | 2 ++ Source/fmx/WrapFmxShapes.pas | 2 ++ 5 files changed, 10 insertions(+) diff --git a/Source/fmx/WrapFmxComCtrls.pas b/Source/fmx/WrapFmxComCtrls.pas index 56ef5497..a8f5ddd9 100644 --- a/Source/fmx/WrapFmxComCtrls.pas +++ b/Source/fmx/WrapFmxComCtrls.pas @@ -1,3 +1,5 @@ +{$I Definition.Inc} + unit WrapFmxComCtrls; interface diff --git a/Source/fmx/WrapFmxDialogs.pas b/Source/fmx/WrapFmxDialogs.pas index 7a474ea2..26926f68 100644 --- a/Source/fmx/WrapFmxDialogs.pas +++ b/Source/fmx/WrapFmxDialogs.pas @@ -1,3 +1,5 @@ +{$I Definition.Inc} + unit WrapFmxDialogs; interface diff --git a/Source/fmx/WrapFmxForms.pas b/Source/fmx/WrapFmxForms.pas index ea3205d6..646bfd03 100644 --- a/Source/fmx/WrapFmxForms.pas +++ b/Source/fmx/WrapFmxForms.pas @@ -1,3 +1,5 @@ +{$I Definition.Inc} + unit WrapFmxForms; interface diff --git a/Source/fmx/WrapFmxLayouts.pas b/Source/fmx/WrapFmxLayouts.pas index 3ef89abd..6df4e249 100644 --- a/Source/fmx/WrapFmxLayouts.pas +++ b/Source/fmx/WrapFmxLayouts.pas @@ -1,3 +1,5 @@ +{$I Definition.Inc} + unit WrapFmxLayouts; interface diff --git a/Source/fmx/WrapFmxShapes.pas b/Source/fmx/WrapFmxShapes.pas index 95daa234..06c0fa5b 100644 --- a/Source/fmx/WrapFmxShapes.pas +++ b/Source/fmx/WrapFmxShapes.pas @@ -1,3 +1,5 @@ +{$I Definition.Inc} + unit WrapFmxShapes; interface From 732261acf1dd6ba1710cef73fa04d27e1e8e2434 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:15:20 -0300 Subject: [PATCH 15/42] Adding TCustomPresentedScrollBox wrapper --- Source/fmx/WrapFmxScrollBox.pas | 73 +++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 Source/fmx/WrapFmxScrollBox.pas diff --git a/Source/fmx/WrapFmxScrollBox.pas b/Source/fmx/WrapFmxScrollBox.pas new file mode 100644 index 00000000..ed376ec5 --- /dev/null +++ b/Source/fmx/WrapFmxScrollBox.pas @@ -0,0 +1,73 @@ +unit WrapFmxScrollBox; + +interface + +uses + FMX.ScrollBox, WrapFmxControls; + +type + TPyDelphiCustomPresentedScrollBox = class(TPyDelphiPresentedControl) + private + function GetDelphiObject: TCustomPresentedScrollBox; + procedure SetDelphiObject(const Value: TCustomPresentedScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCustomPresentedScrollBox read GetDelphiObject write SetDelphiObject; + end; + +implementation + +uses + WrapDelphi; + +{ Register the wrappers, the globals and the constants } +type + TScrollBoxRegistration = class(TRegisteredUnit) + public + function Name : string; override; + procedure RegisterWrappers(APyDelphiWrapper : TPyDelphiWrapper); override; + procedure DefineVars(APyDelphiWrapper : TPyDelphiWrapper); override; + end; + +{ TScrollBoxRegistration } + +procedure TScrollBoxRegistration.DefineVars(APyDelphiWrapper: TPyDelphiWrapper); +begin + inherited; +end; + +function TScrollBoxRegistration.Name: string; +begin + Result := 'ScrollBox'; +end; + +procedure TScrollBoxRegistration.RegisterWrappers( + APyDelphiWrapper: TPyDelphiWrapper); +begin + inherited; + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedScrollBox); +end; + +{ TPyDelphiCustomPresentedScrollBox } + +class function TPyDelphiCustomPresentedScrollBox.DelphiObjectClass: TClass; +begin + Result := TCustomPresentedScrollBox; +end; + +function TPyDelphiCustomPresentedScrollBox.GetDelphiObject: TCustomPresentedScrollBox; +begin + Result := TCustomPresentedScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiCustomPresentedScrollBox.SetDelphiObject( + const Value: TCustomPresentedScrollBox); +begin + inherited DelphiObject := Value; +end; + +initialization + RegisteredUnits.Add(TScrollBoxRegistration.Create); + +end. From 0a99442d3e512451f720c54cb827088008b95b31 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:16:31 -0300 Subject: [PATCH 16/42] Adding TPresentedScrollBox wrapper --- Source/fmx/WrapFmxScrollBox.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxScrollBox.pas b/Source/fmx/WrapFmxScrollBox.pas index ed376ec5..cdf2a9cc 100644 --- a/Source/fmx/WrapFmxScrollBox.pas +++ b/Source/fmx/WrapFmxScrollBox.pas @@ -16,6 +16,16 @@ TPyDelphiCustomPresentedScrollBox = class(TPyDelphiPresentedControl) property DelphiObject: TCustomPresentedScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiPresentedScrollBox = class(TPyDelphiCustomPresentedScrollBox) + private + function GetDelphiObject: TPresentedScrollBox; + procedure SetDelphiObject(const Value: TPresentedScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TPresentedScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -47,6 +57,7 @@ procedure TScrollBoxRegistration.RegisterWrappers( begin inherited; APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedScrollBox); end; { TPyDelphiCustomPresentedScrollBox } @@ -67,6 +78,24 @@ procedure TPyDelphiCustomPresentedScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiPresentedScrollBox } + +class function TPyDelphiPresentedScrollBox.DelphiObjectClass: TClass; +begin + Result := TPresentedScrollBox; +end; + +function TPyDelphiPresentedScrollBox.GetDelphiObject: TPresentedScrollBox; +begin + Result := TPresentedScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiPresentedScrollBox.SetDelphiObject( + const Value: TPresentedScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TScrollBoxRegistration.Create); From 8713f95d54941a3ac6f2c6c4cbae35d8443c3c2d Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:17:45 -0300 Subject: [PATCH 17/42] Adding TCustomPresentedVertScrollBox wrapper --- Source/fmx/WrapFmxScrollBox.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxScrollBox.pas b/Source/fmx/WrapFmxScrollBox.pas index cdf2a9cc..57123f32 100644 --- a/Source/fmx/WrapFmxScrollBox.pas +++ b/Source/fmx/WrapFmxScrollBox.pas @@ -26,6 +26,16 @@ TPyDelphiPresentedScrollBox = class(TPyDelphiCustomPresentedScrollBox) property DelphiObject: TPresentedScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiCustomPresentedVertScrollBox = class(TPyDelphiCustomPresentedScrollBox) + private + function GetDelphiObject: TCustomPresentedVertScrollBox; + procedure SetDelphiObject(const Value: TCustomPresentedVertScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCustomPresentedVertScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -58,6 +68,7 @@ procedure TScrollBoxRegistration.RegisterWrappers( inherited; APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedVertScrollBox); end; { TPyDelphiCustomPresentedScrollBox } @@ -96,6 +107,24 @@ procedure TPyDelphiPresentedScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiCustomPresentedVertScrollBox } + +class function TPyDelphiCustomPresentedVertScrollBox.DelphiObjectClass: TClass; +begin + Result := TCustomPresentedVertScrollBox; +end; + +function TPyDelphiCustomPresentedVertScrollBox.GetDelphiObject: TCustomPresentedVertScrollBox; +begin + Result := TCustomPresentedVertScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiCustomPresentedVertScrollBox.SetDelphiObject( + const Value: TCustomPresentedVertScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TScrollBoxRegistration.Create); From 48ecc22f2ccaf71d3efe606cbc20888e8cfd41e8 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:18:42 -0300 Subject: [PATCH 18/42] Adding TPresentedVertScrollBox wrapper --- Source/fmx/WrapFmxScrollBox.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxScrollBox.pas b/Source/fmx/WrapFmxScrollBox.pas index 57123f32..b80c3dd5 100644 --- a/Source/fmx/WrapFmxScrollBox.pas +++ b/Source/fmx/WrapFmxScrollBox.pas @@ -36,6 +36,16 @@ TPyDelphiCustomPresentedVertScrollBox = class(TPyDelphiCustomPresentedScrollBo property DelphiObject: TCustomPresentedVertScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiPresentedVertScrollBox = class(TPyDelphiCustomPresentedVertScrollBox) + private + function GetDelphiObject: TPresentedVertScrollBox; + procedure SetDelphiObject(const Value: TPresentedVertScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TPresentedVertScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -69,6 +79,7 @@ procedure TScrollBoxRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedVertScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedVertScrollBox); end; { TPyDelphiCustomPresentedScrollBox } @@ -125,6 +136,24 @@ procedure TPyDelphiCustomPresentedVertScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiPresentedVertScrollBox } + +class function TPyDelphiPresentedVertScrollBox.DelphiObjectClass: TClass; +begin + Result := TPresentedVertScrollBox; +end; + +function TPyDelphiPresentedVertScrollBox.GetDelphiObject: TPresentedVertScrollBox; +begin + Result := TPresentedVertScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiPresentedVertScrollBox.SetDelphiObject( + const Value: TPresentedVertScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TScrollBoxRegistration.Create); From 8e18b15abcb2cbf6e97832d2084431f7f4cde79f Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:19:57 -0300 Subject: [PATCH 19/42] Adding TCustomPresentedHorzScrollBox wrapper --- Source/fmx/WrapFmxScrollBox.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxScrollBox.pas b/Source/fmx/WrapFmxScrollBox.pas index b80c3dd5..8543a9f7 100644 --- a/Source/fmx/WrapFmxScrollBox.pas +++ b/Source/fmx/WrapFmxScrollBox.pas @@ -46,6 +46,16 @@ TPyDelphiPresentedVertScrollBox = class(TPyDelphiCustomPresentedVertScrollBox) property DelphiObject: TPresentedVertScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiCustomPresentedHorzScrollBox = class(TPyDelphiCustomPresentedScrollBox) + private + function GetDelphiObject: TCustomPresentedHorzScrollBox; + procedure SetDelphiObject(const Value: TCustomPresentedHorzScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCustomPresentedHorzScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -80,6 +90,7 @@ procedure TScrollBoxRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedVertScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedVertScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedHorzScrollBox); end; { TPyDelphiCustomPresentedScrollBox } @@ -154,6 +165,24 @@ procedure TPyDelphiPresentedVertScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiCustomPresentedHorzScrollBox } + +class function TPyDelphiCustomPresentedHorzScrollBox.DelphiObjectClass: TClass; +begin + Result := TCustomPresentedHorzScrollBox; +end; + +function TPyDelphiCustomPresentedHorzScrollBox.GetDelphiObject: TCustomPresentedHorzScrollBox; +begin + Result := TCustomPresentedHorzScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiCustomPresentedHorzScrollBox.SetDelphiObject( + const Value: TCustomPresentedHorzScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TScrollBoxRegistration.Create); From e59171af558528aa2129efb34085af452a0f3200 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:22:20 -0300 Subject: [PATCH 20/42] Adding TCustomPresentedFramedScrollBox wrapper --- Source/fmx/WrapFmxScrollBox.pas | 58 +++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/Source/fmx/WrapFmxScrollBox.pas b/Source/fmx/WrapFmxScrollBox.pas index 8543a9f7..c19341fd 100644 --- a/Source/fmx/WrapFmxScrollBox.pas +++ b/Source/fmx/WrapFmxScrollBox.pas @@ -56,6 +56,26 @@ TPyDelphiCustomPresentedHorzScrollBox = class(TPyDelphiCustomPresentedScrollBo property DelphiObject: TCustomPresentedHorzScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiPresentedHorzScrollBox = class(TPyDelphiCustomPresentedHorzScrollBox) + private + function GetDelphiObject: TPresentedHorzScrollBox; + procedure SetDelphiObject(const Value: TPresentedHorzScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TPresentedHorzScrollBox read GetDelphiObject write SetDelphiObject; + end; + + TPyDelphiCustomPresentedFrameScrollBox = class(TPyDelphiCustomPresentedScrollBox) + private + function GetDelphiObject: TCustomPresentedFramedScrollBox; + procedure SetDelphiObject(const Value: TCustomPresentedFramedScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCustomPresentedFramedScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -91,6 +111,8 @@ procedure TScrollBoxRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedVertScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedVertScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedHorzScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedHorzScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedFrameScrollBox); end; { TPyDelphiCustomPresentedScrollBox } @@ -183,6 +205,42 @@ procedure TPyDelphiCustomPresentedHorzScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiPresentedHorzScrollBox } + +class function TPyDelphiPresentedHorzScrollBox.DelphiObjectClass: TClass; +begin + Result := TPresentedHorzScrollBox; +end; + +function TPyDelphiPresentedHorzScrollBox.GetDelphiObject: TPresentedHorzScrollBox; +begin + Result := TPresentedHorzScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiPresentedHorzScrollBox.SetDelphiObject( + const Value: TPresentedHorzScrollBox); +begin + inherited DelphiObject := Value; +end; + +{ TPyDelphiCustomPresentedFrameScrollBox } + +class function TPyDelphiCustomPresentedFrameScrollBox.DelphiObjectClass: TClass; +begin + Result := TCustomPresentedFramedScrollBox; +end; + +function TPyDelphiCustomPresentedFrameScrollBox.GetDelphiObject: TCustomPresentedFramedScrollBox; +begin + Result := TCustomPresentedFramedScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiCustomPresentedFrameScrollBox.SetDelphiObject( + const Value: TCustomPresentedFramedScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TScrollBoxRegistration.Create); From b72052653837682a9f945b6b9577b37fca5937c5 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:23:31 -0300 Subject: [PATCH 21/42] Adding TPresentedFramedScrollBox wrapper --- Source/fmx/WrapFmxScrollBox.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxScrollBox.pas b/Source/fmx/WrapFmxScrollBox.pas index c19341fd..311d99ca 100644 --- a/Source/fmx/WrapFmxScrollBox.pas +++ b/Source/fmx/WrapFmxScrollBox.pas @@ -76,6 +76,16 @@ TPyDelphiCustomPresentedFrameScrollBox = class(TPyDelphiCustomPresentedScrollB property DelphiObject: TCustomPresentedFramedScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiPresentedFrameScrollBox = class(TPyDelphiCustomPresentedFrameScrollBox) + private + function GetDelphiObject: TPresentedFramedScrollBox; + procedure SetDelphiObject(const Value: TPresentedFramedScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TPresentedFramedScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -113,6 +123,7 @@ procedure TScrollBoxRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedHorzScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedHorzScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedFrameScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedFrameScrollBox); end; { TPyDelphiCustomPresentedScrollBox } @@ -241,6 +252,24 @@ procedure TPyDelphiCustomPresentedFrameScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiPresentedFrameScrollBox } + +class function TPyDelphiPresentedFrameScrollBox.DelphiObjectClass: TClass; +begin + Result := TPresentedFramedScrollBox; +end; + +function TPyDelphiPresentedFrameScrollBox.GetDelphiObject: TPresentedFramedScrollBox; +begin + Result := TPresentedFramedScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiPresentedFrameScrollBox.SetDelphiObject( + const Value: TPresentedFramedScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TScrollBoxRegistration.Create); From f0822c4f57ab585dfa2262a3fb1b6eaf88ae31d3 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:24:57 -0300 Subject: [PATCH 22/42] Adding TCustomPresentedFramedVertScrollBox wrapper --- Source/fmx/WrapFmxScrollBox.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxScrollBox.pas b/Source/fmx/WrapFmxScrollBox.pas index 311d99ca..37894c73 100644 --- a/Source/fmx/WrapFmxScrollBox.pas +++ b/Source/fmx/WrapFmxScrollBox.pas @@ -86,6 +86,16 @@ TPyDelphiPresentedFrameScrollBox = class(TPyDelphiCustomPresentedFrameScrollBo property DelphiObject: TPresentedFramedScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiCustomPresentedFramedVertScrollBox = class(TPyDelphiCustomPresentedVertScrollBox) + private + function GetDelphiObject: TCustomPresentedFramedVertScrollBox; + procedure SetDelphiObject(const Value: TCustomPresentedFramedVertScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCustomPresentedFramedVertScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -124,6 +134,7 @@ procedure TScrollBoxRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedHorzScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedFrameScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedFrameScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedFramedVertScrollBox); end; { TPyDelphiCustomPresentedScrollBox } @@ -270,6 +281,24 @@ procedure TPyDelphiPresentedFrameScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiCustomPresentedFramedVertScrollBox } + +class function TPyDelphiCustomPresentedFramedVertScrollBox.DelphiObjectClass: TClass; +begin + Result := TCustomPresentedFramedVertScrollBox; +end; + +function TPyDelphiCustomPresentedFramedVertScrollBox.GetDelphiObject: TCustomPresentedFramedVertScrollBox; +begin + Result := TCustomPresentedFramedVertScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiCustomPresentedFramedVertScrollBox.SetDelphiObject( + const Value: TCustomPresentedFramedVertScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TScrollBoxRegistration.Create); From bddf92c18f48bde47f940e8f436f63ca531cddcd Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:26:16 -0300 Subject: [PATCH 23/42] Adding TPresentedFramedVertScrollBox wrapper --- Source/fmx/WrapFmxScrollBox.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxScrollBox.pas b/Source/fmx/WrapFmxScrollBox.pas index 37894c73..5caa2b47 100644 --- a/Source/fmx/WrapFmxScrollBox.pas +++ b/Source/fmx/WrapFmxScrollBox.pas @@ -96,6 +96,16 @@ TPyDelphiCustomPresentedFramedVertScrollBox = class(TPyDelphiCustomPresentedVe property DelphiObject: TCustomPresentedFramedVertScrollBox read GetDelphiObject write SetDelphiObject; end; + TPyDelphiPresentedFramedVertScrollBox = class(TPyDelphiCustomPresentedFramedVertScrollBox) + private + function GetDelphiObject: TPresentedFramedVertScrollBox; + procedure SetDelphiObject(const Value: TPresentedFramedVertScrollBox); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TPresentedFramedVertScrollBox read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -135,6 +145,7 @@ procedure TScrollBoxRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedFrameScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedFrameScrollBox); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomPresentedFramedVertScrollBox); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPresentedFramedVertScrollBox); end; { TPyDelphiCustomPresentedScrollBox } @@ -299,6 +310,24 @@ procedure TPyDelphiCustomPresentedFramedVertScrollBox.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiPresentedFramedVertScrollBox } + +class function TPyDelphiPresentedFramedVertScrollBox.DelphiObjectClass: TClass; +begin + Result := TPresentedFramedVertScrollBox; +end; + +function TPyDelphiPresentedFramedVertScrollBox.GetDelphiObject: TPresentedFramedVertScrollBox; +begin + Result := TPresentedFramedVertScrollBox(inherited DelphiObject); +end; + +procedure TPyDelphiPresentedFramedVertScrollBox.SetDelphiObject( + const Value: TPresentedFramedVertScrollBox); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TScrollBoxRegistration.Create); From 34599a61e6cfe15e33e03939c3a4667bc1278677 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:51:15 -0300 Subject: [PATCH 24/42] Adding TColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 72 +++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 Source/fmx/WrapFmxGrids.pas diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas new file mode 100644 index 00000000..29e8fda8 --- /dev/null +++ b/Source/fmx/WrapFmxGrids.pas @@ -0,0 +1,72 @@ +unit WrapFmxGrids; + +interface + +uses + FMX.Grid, WrapFmxControls; + +type + TPyDelphiColumn = class(TPyDelphiControl) + private + function GetDelphiObject: TColumn; + procedure SetDelphiObject(const Value: TColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TColumn read GetDelphiObject write SetDelphiObject; + end; + +implementation + +uses + WrapDelphi; + +{ Register the wrappers, the globals and the constants } +type + TGridsRegistration = class(TRegisteredUnit) + public + function Name : string; override; + procedure RegisterWrappers(APyDelphiWrapper : TPyDelphiWrapper); override; + procedure DefineVars(APyDelphiWrapper : TPyDelphiWrapper); override; + end; + +{ TGridsRegistration } + +procedure TGridsRegistration.DefineVars(APyDelphiWrapper: TPyDelphiWrapper); +begin + inherited; +end; + +function TGridsRegistration.Name: string; +begin + Result := 'Grids'; +end; + +procedure TGridsRegistration.RegisterWrappers( + APyDelphiWrapper: TPyDelphiWrapper); +begin + inherited; + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiColumn); +end; + +{ TPyDelphiColumn } + +class function TPyDelphiColumn.DelphiObjectClass: TClass; +begin + Result := TColumn; +end; + +function TPyDelphiColumn.GetDelphiObject: TColumn; +begin + Result := TColumn(inherited DelphiObject); +end; + +procedure TPyDelphiColumn.SetDelphiObject(const Value: TColumn); +begin + inherited DelphiObject := Value; +end; + +initialization + RegisteredUnits.Add(TGridsRegistration.Create); + +end. From 76784fc365da6a795f3d08e1a8cd0d5364a9c2d1 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:52:38 -0300 Subject: [PATCH 25/42] Adding TStringColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index 29e8fda8..963eb77a 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -16,6 +16,16 @@ TPyDelphiColumn = class(TPyDelphiControl) property DelphiObject: TColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiStringColumn = class(TPyDelphiColumn) + private + function GetDelphiObject: TStringColumn; + procedure SetDelphiObject(const Value: TStringColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TStringColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -47,6 +57,7 @@ procedure TGridsRegistration.RegisterWrappers( begin inherited; APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiStringColumn); end; { TPyDelphiColumn } @@ -66,6 +77,23 @@ procedure TPyDelphiColumn.SetDelphiObject(const Value: TColumn); inherited DelphiObject := Value; end; +{ TPyDelphiStringColumn } + +class function TPyDelphiStringColumn.DelphiObjectClass: TClass; +begin + Result := TStringColumn; +end; + +function TPyDelphiStringColumn.GetDelphiObject: TStringColumn; +begin + Result := TStringColumn(inherited DelphiObject); +end; + +procedure TPyDelphiStringColumn.SetDelphiObject(const Value: TStringColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From 88b1f7a6243d5caa5d9951b1e10f50151458a823 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:53:42 -0300 Subject: [PATCH 26/42] Adding TProgressColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index 963eb77a..bcac8b1a 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -26,6 +26,16 @@ TPyDelphiStringColumn = class(TPyDelphiColumn) property DelphiObject: TStringColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiProgressColumn = class(TPyDelphiColumn) + private + function GetDelphiObject: TProgressColumn; + procedure SetDelphiObject(const Value: TProgressColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TProgressColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -58,6 +68,7 @@ procedure TGridsRegistration.RegisterWrappers( inherited; APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiStringColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiProgressColumn); end; { TPyDelphiColumn } @@ -94,6 +105,23 @@ procedure TPyDelphiStringColumn.SetDelphiObject(const Value: TStringColumn); inherited DelphiObject := Value; end; +{ TPyDelphiProgressColumn } + +class function TPyDelphiProgressColumn.DelphiObjectClass: TClass; +begin + Result := TProgressColumn; +end; + +function TPyDelphiProgressColumn.GetDelphiObject: TProgressColumn; +begin + Result := TProgressColumn(inherited DelphiObject); +end; + +procedure TPyDelphiProgressColumn.SetDelphiObject(const Value: TProgressColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From 5a0c11057c2ee66c6c060bb93fe1d028172f9ead Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:54:42 -0300 Subject: [PATCH 27/42] Adding TCheckColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index bcac8b1a..514f0e0d 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -36,6 +36,16 @@ TPyDelphiProgressColumn = class(TPyDelphiColumn) property DelphiObject: TProgressColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiCheckColumn = class(TPyDelphiColumn) + private + function GetDelphiObject: TCheckColumn; + procedure SetDelphiObject(const Value: TCheckColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCheckColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -69,6 +79,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiStringColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiProgressColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCheckColumn); end; { TPyDelphiColumn } @@ -122,6 +133,23 @@ procedure TPyDelphiProgressColumn.SetDelphiObject(const Value: TProgressColumn); inherited DelphiObject := Value; end; +{ TPyDelphiCheckColumn } + +class function TPyDelphiCheckColumn.DelphiObjectClass: TClass; +begin + Result := TCheckColumn; +end; + +function TPyDelphiCheckColumn.GetDelphiObject: TCheckColumn; +begin + Result := TCheckColumn(inherited DelphiObject); +end; + +procedure TPyDelphiCheckColumn.SetDelphiObject(const Value: TCheckColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From f05a4dd26dc38c82d23b174ebd4cd00f8ce225a2 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:55:48 -0300 Subject: [PATCH 28/42] Adding TDateTimeColumnBase wrapper --- Source/fmx/WrapFmxGrids.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index 514f0e0d..0e0e0d6c 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -46,6 +46,16 @@ TPyDelphiCheckColumn = class(TPyDelphiColumn) property DelphiObject: TCheckColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiDateTimeColumnBase = class(TPyDelphiColumn) + private + function GetDelphiObject: TDateTimeColumnBase; + procedure SetDelphiObject(const Value: TDateTimeColumnBase); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TDateTimeColumnBase read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -80,6 +90,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiStringColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiProgressColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCheckColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateTimeColumnBase); end; { TPyDelphiColumn } @@ -150,6 +161,24 @@ procedure TPyDelphiCheckColumn.SetDelphiObject(const Value: TCheckColumn); inherited DelphiObject := Value; end; +{ TPyDelphiDateTimeColumnBase } + +class function TPyDelphiDateTimeColumnBase.DelphiObjectClass: TClass; +begin + Result := TDateTimeColumnBase; +end; + +function TPyDelphiDateTimeColumnBase.GetDelphiObject: TDateTimeColumnBase; +begin + Result := TDateTimeColumnBase(inherited DelphiObject); +end; + +procedure TPyDelphiDateTimeColumnBase.SetDelphiObject( + const Value: TDateTimeColumnBase); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From c442532b6b5e5b3ba7c93043c7e553aeff650e38 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:56:44 -0300 Subject: [PATCH 29/42] Adding TDateTimeColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index 0e0e0d6c..68256a1b 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -56,6 +56,16 @@ TPyDelphiDateTimeColumnBase = class(TPyDelphiColumn) property DelphiObject: TDateTimeColumnBase read GetDelphiObject write SetDelphiObject; end; + TPyDelphiDateTimeColumn = class(TPyDelphiColumn) + private + function GetDelphiObject: TDateTimeColumn; + procedure SetDelphiObject(const Value: TDateTimeColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TDateTimeColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -91,6 +101,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiProgressColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCheckColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateTimeColumnBase); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateTimeColumn); end; { TPyDelphiColumn } @@ -179,6 +190,23 @@ procedure TPyDelphiDateTimeColumnBase.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiDateTimeColumn } + +class function TPyDelphiDateTimeColumn.DelphiObjectClass: TClass; +begin + Result := TDateTimeColumn; +end; + +function TPyDelphiDateTimeColumn.GetDelphiObject: TDateTimeColumn; +begin + Result := TDateTimeColumn(inherited DelphiObject); +end; + +procedure TPyDelphiDateTimeColumn.SetDelphiObject(const Value: TDateTimeColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From 4860fe2c32e4eb15f7d4e3d832309180f8650e75 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:57:35 -0300 Subject: [PATCH 30/42] Adding TTimeColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index 68256a1b..e23c9765 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -66,6 +66,16 @@ TPyDelphiDateTimeColumn = class(TPyDelphiColumn) property DelphiObject: TDateTimeColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiTimeColumn = class(TPyDelphiColumn) + private + function GetDelphiObject: TTimeColumn; + procedure SetDelphiObject(const Value: TTimeColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TTimeColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -102,6 +112,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCheckColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateTimeColumnBase); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateTimeColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiTimeColumn); end; { TPyDelphiColumn } @@ -207,6 +218,23 @@ procedure TPyDelphiDateTimeColumn.SetDelphiObject(const Value: TDateTimeColumn); inherited DelphiObject := Value; end; +{ TPyDelphiTimeColumn } + +class function TPyDelphiTimeColumn.DelphiObjectClass: TClass; +begin + Result := TTimeColumn; +end; + +function TPyDelphiTimeColumn.GetDelphiObject: TTimeColumn; +begin + Result := TTimeColumn(inherited DelphiObject); +end; + +procedure TPyDelphiTimeColumn.SetDelphiObject(const Value: TTimeColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From e98e63ad43fafaff1ec6b9d5f2edc4de407f2bc5 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:58:39 -0300 Subject: [PATCH 31/42] Adding TDateColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index e23c9765..a03a42b9 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -76,6 +76,16 @@ TPyDelphiTimeColumn = class(TPyDelphiColumn) property DelphiObject: TTimeColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiDateColumn = class(TPyDelphiColumn) + private + function GetDelphiObject: TDateColumn; + procedure SetDelphiObject(const Value: TDateColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TDateColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -113,6 +123,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateTimeColumnBase); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateTimeColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiTimeColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateColumn); end; { TPyDelphiColumn } @@ -235,6 +246,23 @@ procedure TPyDelphiTimeColumn.SetDelphiObject(const Value: TTimeColumn); inherited DelphiObject := Value; end; +{ TPyDelphiDateColumn } + +class function TPyDelphiDateColumn.DelphiObjectClass: TClass; +begin + Result := TDateColumn; +end; + +function TPyDelphiDateColumn.GetDelphiObject: TDateColumn; +begin + Result := TDateColumn(inherited DelphiObject); +end; + +procedure TPyDelphiDateColumn.SetDelphiObject(const Value: TDateColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From b5a9a760c707204a9dbcf5dabda20792e4add779 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 16:59:12 -0300 Subject: [PATCH 32/42] Changing date and time wrappers base class --- Source/fmx/WrapFmxGrids.pas | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index a03a42b9..b62d8cd0 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -56,7 +56,7 @@ TPyDelphiDateTimeColumnBase = class(TPyDelphiColumn) property DelphiObject: TDateTimeColumnBase read GetDelphiObject write SetDelphiObject; end; - TPyDelphiDateTimeColumn = class(TPyDelphiColumn) + TPyDelphiDateTimeColumn = class(TPyDelphiDateTimeColumnBase) private function GetDelphiObject: TDateTimeColumn; procedure SetDelphiObject(const Value: TDateTimeColumn); @@ -66,7 +66,7 @@ TPyDelphiDateTimeColumn = class(TPyDelphiColumn) property DelphiObject: TDateTimeColumn read GetDelphiObject write SetDelphiObject; end; - TPyDelphiTimeColumn = class(TPyDelphiColumn) + TPyDelphiTimeColumn = class(TPyDelphiDateTimeColumnBase) private function GetDelphiObject: TTimeColumn; procedure SetDelphiObject(const Value: TTimeColumn); @@ -76,7 +76,7 @@ TPyDelphiTimeColumn = class(TPyDelphiColumn) property DelphiObject: TTimeColumn read GetDelphiObject write SetDelphiObject; end; - TPyDelphiDateColumn = class(TPyDelphiColumn) + TPyDelphiDateColumn = class(TPyDelphiDateTimeColumnBase) private function GetDelphiObject: TDateColumn; procedure SetDelphiObject(const Value: TDateColumn); From 422e37b3f51d06715c8ba61e6f83a98c04ea03c8 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:00:25 -0300 Subject: [PATCH 33/42] Adding TPopupColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index b62d8cd0..d441cb26 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -86,6 +86,16 @@ TPyDelphiDateColumn = class(TPyDelphiDateTimeColumnBase) property DelphiObject: TDateColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiPopupColumn = class(TPyDelphiColumn) + private + function GetDelphiObject: TPopupColumn; + procedure SetDelphiObject(const Value: TPopupColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TPopupColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -124,6 +134,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateTimeColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiTimeColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPopupColumn); end; { TPyDelphiColumn } @@ -263,6 +274,23 @@ procedure TPyDelphiDateColumn.SetDelphiObject(const Value: TDateColumn); inherited DelphiObject := Value; end; +{ TPyDelphiPopupColumn } + +class function TPyDelphiPopupColumn.DelphiObjectClass: TClass; +begin + Result := TPopupColumn; +end; + +function TPyDelphiPopupColumn.GetDelphiObject: TPopupColumn; +begin + Result := TPopupColumn(inherited DelphiObject); +end; + +procedure TPyDelphiPopupColumn.SetDelphiObject(const Value: TPopupColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From 533fece8b458f480ff985b7a7b0edf164bffc66c Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:01:20 -0300 Subject: [PATCH 34/42] Adding TImageColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index d441cb26..1a3c1e94 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -96,6 +96,16 @@ TPyDelphiPopupColumn = class(TPyDelphiColumn) property DelphiObject: TPopupColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiImageColumn = class(TPyDelphiColumn) + private + function GetDelphiObject: TImageColumn; + procedure SetDelphiObject(const Value: TImageColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TImageColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -135,6 +145,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiTimeColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPopupColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiImageColumn); end; { TPyDelphiColumn } @@ -291,6 +302,23 @@ procedure TPyDelphiPopupColumn.SetDelphiObject(const Value: TPopupColumn); inherited DelphiObject := Value; end; +{ TPyDelphiImageColumn } + +class function TPyDelphiImageColumn.DelphiObjectClass: TClass; +begin + Result := TImageColumn; +end; + +function TPyDelphiImageColumn.GetDelphiObject: TImageColumn; +begin + Result := TImageColumn(inherited DelphiObject); +end; + +procedure TPyDelphiImageColumn.SetDelphiObject(const Value: TImageColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From 6080c2306797766c3f8055d17787c1187a3b728b Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:02:26 -0300 Subject: [PATCH 35/42] Adding TCustomNumberColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index 1a3c1e94..48409e18 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -106,6 +106,16 @@ TPyDelphiImageColumn = class(TPyDelphiColumn) property DelphiObject: TImageColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiCustomNumberColumn = class(TPyDelphiColumn) + private + function GetDelphiObject: TCustomNumberColumn; + procedure SetDelphiObject(const Value: TCustomNumberColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCustomNumberColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -146,6 +156,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiDateColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPopupColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiImageColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomNumberColumn); end; { TPyDelphiColumn } @@ -319,6 +330,24 @@ procedure TPyDelphiImageColumn.SetDelphiObject(const Value: TImageColumn); inherited DelphiObject := Value; end; +{ TPyDelphiCustomNumberColumn } + +class function TPyDelphiCustomNumberColumn.DelphiObjectClass: TClass; +begin + Result := TCustomNumberColumn; +end; + +function TPyDelphiCustomNumberColumn.GetDelphiObject: TCustomNumberColumn; +begin + Result := TCustomNumberColumn(inherited DelphiObject); +end; + +procedure TPyDelphiCustomNumberColumn.SetDelphiObject( + const Value: TCustomNumberColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From f09262016629074e574ca58847ad715be91572ba Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:03:27 -0300 Subject: [PATCH 36/42] Addint TCurrencyColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index 48409e18..d6d651d5 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -116,6 +116,16 @@ TPyDelphiCustomNumberColumn = class(TPyDelphiColumn) property DelphiObject: TCustomNumberColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiCurrencyColumn = class(TPyDelphiCustomNumberColumn) + private + function GetDelphiObject: TCurrencyColumn; + procedure SetDelphiObject(const Value: TCurrencyColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCurrencyColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -157,6 +167,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiPopupColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiImageColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomNumberColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCurrencyColumn); end; { TPyDelphiColumn } @@ -348,6 +359,23 @@ procedure TPyDelphiCustomNumberColumn.SetDelphiObject( inherited DelphiObject := Value; end; +{ TPyDelphiCurrencyColumn } + +class function TPyDelphiCurrencyColumn.DelphiObjectClass: TClass; +begin + Result := TCurrencyColumn; +end; + +function TPyDelphiCurrencyColumn.GetDelphiObject: TCurrencyColumn; +begin + Result := TCurrencyColumn(inherited DelphiObject); +end; + +procedure TPyDelphiCurrencyColumn.SetDelphiObject(const Value: TCurrencyColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From 18f27719e690794980b3b769c78d271ae8a69917 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:04:44 -0300 Subject: [PATCH 37/42] Adding TFloatColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index d6d651d5..f16dfd72 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -126,6 +126,16 @@ TPyDelphiCurrencyColumn = class(TPyDelphiCustomNumberColumn) property DelphiObject: TCurrencyColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiFloatColumn = class(TPyDelphiCustomNumberColumn) + private + function GetDelphiObject: TFloatColumn; + procedure SetDelphiObject(const Value: TFloatColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TFloatColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -168,6 +178,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiImageColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomNumberColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCurrencyColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFloatColumn); end; { TPyDelphiColumn } @@ -376,6 +387,23 @@ procedure TPyDelphiCurrencyColumn.SetDelphiObject(const Value: TCurrencyColumn); inherited DelphiObject := Value; end; +{ TPyDelphiFloatColumn } + +class function TPyDelphiFloatColumn.DelphiObjectClass: TClass; +begin + Result := TFloatColumn; +end; + +function TPyDelphiFloatColumn.GetDelphiObject: TFloatColumn; +begin + Result := TFloatColumn(inherited DelphiObject); +end; + +procedure TPyDelphiFloatColumn.SetDelphiObject(const Value: TFloatColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From c425fbf56bf9553212804ed3137e3e39b419dc35 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:05:32 -0300 Subject: [PATCH 38/42] Adding TIntegerColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index f16dfd72..f0e51289 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -136,6 +136,16 @@ TPyDelphiFloatColumn = class(TPyDelphiCustomNumberColumn) property DelphiObject: TFloatColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiIntegerColumn = class(TPyDelphiCustomNumberColumn) + private + function GetDelphiObject: TIntegerColumn; + procedure SetDelphiObject(const Value: TIntegerColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TIntegerColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -179,6 +189,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomNumberColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCurrencyColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFloatColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiIntegerColumn); end; { TPyDelphiColumn } @@ -404,6 +415,23 @@ procedure TPyDelphiFloatColumn.SetDelphiObject(const Value: TFloatColumn); inherited DelphiObject := Value; end; +{ TPyDelphiIntegerColumn } + +class function TPyDelphiIntegerColumn.DelphiObjectClass: TClass; +begin + Result := TIntegerColumn; +end; + +function TPyDelphiIntegerColumn.GetDelphiObject: TIntegerColumn; +begin + Result := TIntegerColumn(inherited DelphiObject); +end; + +procedure TPyDelphiIntegerColumn.SetDelphiObject(const Value: TIntegerColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From d39e51fa1b4e1c3ea8df64c5d1d84d8fc08700f9 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:07:11 -0300 Subject: [PATCH 39/42] Adding TGlyphColumn wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index f0e51289..9364cac7 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -146,6 +146,16 @@ TPyDelphiIntegerColumn = class(TPyDelphiCustomNumberColumn) property DelphiObject: TIntegerColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiGlyphColumn = class(TPyDelphiColumn) + private + function GetDelphiObject: TGlyphColumn; + procedure SetDelphiObject(const Value: TGlyphColumn); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TGlyphColumn read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -190,6 +200,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCurrencyColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFloatColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiIntegerColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGlyphColumn); end; { TPyDelphiColumn } @@ -432,6 +443,23 @@ procedure TPyDelphiIntegerColumn.SetDelphiObject(const Value: TIntegerColumn); inherited DelphiObject := Value; end; +{ TPyDelphiGlyphColumn } + +class function TPyDelphiGlyphColumn.DelphiObjectClass: TClass; +begin + Result := TGlyphColumn; +end; + +function TPyDelphiGlyphColumn.GetDelphiObject: TGlyphColumn; +begin + Result := TGlyphColumn(inherited DelphiObject); +end; + +procedure TPyDelphiGlyphColumn.SetDelphiObject(const Value: TGlyphColumn); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From 65ff572de62d1524559bf6a2e4957ed0819427f7 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:32:04 -0300 Subject: [PATCH 40/42] Adding TCustomGrid wrapper --- Source/fmx/WrapFmxGrids.pas | 30 +++++++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index 9364cac7..96b61930 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -3,7 +3,7 @@ interface uses - FMX.Grid, WrapFmxControls; + FMX.Grid, WrapFmxControls, WrapFmxScrollBox; type TPyDelphiColumn = class(TPyDelphiControl) @@ -156,6 +156,16 @@ TPyDelphiGlyphColumn = class(TPyDelphiColumn) property DelphiObject: TGlyphColumn read GetDelphiObject write SetDelphiObject; end; + TPyDelphiGlyphCustomGrid = class(TPyDelphiCustomPresentedScrollBox) + private + function GetDelphiObject: TCustomGrid; + procedure SetDelphiObject(const Value: TCustomGrid); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TCustomGrid read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -201,6 +211,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFloatColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiIntegerColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGlyphColumn); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGlyphCustomGrid); end; { TPyDelphiColumn } @@ -460,6 +471,23 @@ procedure TPyDelphiGlyphColumn.SetDelphiObject(const Value: TGlyphColumn); inherited DelphiObject := Value; end; +{ TPyDelphiGlyphCustomGrid } + +class function TPyDelphiGlyphCustomGrid.DelphiObjectClass: TClass; +begin + Result := TCustomGrid; +end; + +function TPyDelphiGlyphCustomGrid.GetDelphiObject: TCustomGrid; +begin + Result := TCustomGrid(inherited DelphiObject); +end; + +procedure TPyDelphiGlyphCustomGrid.SetDelphiObject(const Value: TCustomGrid); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create); From 200ed63f1e402886d79a9de04c730098742997c5 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:33:51 -0300 Subject: [PATCH 41/42] Adding TGrid wrapper --- Source/fmx/WrapFmxGrids.pas | 38 ++++++++++++++++++++++++++++++++----- 1 file changed, 33 insertions(+), 5 deletions(-) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index 96b61930..7518d307 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -156,7 +156,7 @@ TPyDelphiGlyphColumn = class(TPyDelphiColumn) property DelphiObject: TGlyphColumn read GetDelphiObject write SetDelphiObject; end; - TPyDelphiGlyphCustomGrid = class(TPyDelphiCustomPresentedScrollBox) + TPyDelphiCustomGrid = class(TPyDelphiCustomPresentedScrollBox) private function GetDelphiObject: TCustomGrid; procedure SetDelphiObject(const Value: TCustomGrid); @@ -166,6 +166,16 @@ TPyDelphiGlyphCustomGrid = class(TPyDelphiCustomPresentedScrollBox) property DelphiObject: TCustomGrid read GetDelphiObject write SetDelphiObject; end; + TPyDelphiGrid = class(TPyDelphiCustomGrid) + private + function GetDelphiObject: TGrid; + procedure SetDelphiObject(const Value: TGrid); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TGrid read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -211,7 +221,8 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiFloatColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiIntegerColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGlyphColumn); - APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGlyphCustomGrid); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomGrid); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGrid); end; { TPyDelphiColumn } @@ -473,17 +484,34 @@ procedure TPyDelphiGlyphColumn.SetDelphiObject(const Value: TGlyphColumn); { TPyDelphiGlyphCustomGrid } -class function TPyDelphiGlyphCustomGrid.DelphiObjectClass: TClass; +class function TPyDelphiCustomGrid.DelphiObjectClass: TClass; begin Result := TCustomGrid; end; -function TPyDelphiGlyphCustomGrid.GetDelphiObject: TCustomGrid; +function TPyDelphiCustomGrid.GetDelphiObject: TCustomGrid; begin Result := TCustomGrid(inherited DelphiObject); end; -procedure TPyDelphiGlyphCustomGrid.SetDelphiObject(const Value: TCustomGrid); +procedure TPyDelphiCustomGrid.SetDelphiObject(const Value: TCustomGrid); +begin + inherited DelphiObject := Value; +end; + +{ TPyDelphiGrid } + +class function TPyDelphiGrid.DelphiObjectClass: TClass; +begin + Result := TGrid; +end; + +function TPyDelphiGrid.GetDelphiObject: TGrid; +begin + Result := TGrid(inherited DelphiObject); +end; + +procedure TPyDelphiGrid.SetDelphiObject(const Value: TGrid); begin inherited DelphiObject := Value; end; From 0b04a65bc8d58fa46d13910d1dc3bc28fc4f6e35 Mon Sep 17 00:00:00 2001 From: Lucas Moura Belo Date: Mon, 21 Dec 2020 17:35:09 -0300 Subject: [PATCH 42/42] Adding TStringGrid wrapper --- Source/fmx/WrapFmxGrids.pas | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Source/fmx/WrapFmxGrids.pas b/Source/fmx/WrapFmxGrids.pas index 7518d307..d7b714c8 100644 --- a/Source/fmx/WrapFmxGrids.pas +++ b/Source/fmx/WrapFmxGrids.pas @@ -176,6 +176,16 @@ TPyDelphiGrid = class(TPyDelphiCustomGrid) property DelphiObject: TGrid read GetDelphiObject write SetDelphiObject; end; + TPyDelphiStringGrid = class(TPyDelphiCustomGrid) + private + function GetDelphiObject: TStringGrid; + procedure SetDelphiObject(const Value: TStringGrid); + public + class function DelphiObjectClass : TClass; override; + // Properties + property DelphiObject: TStringGrid read GetDelphiObject write SetDelphiObject; + end; + implementation uses @@ -223,6 +233,7 @@ procedure TGridsRegistration.RegisterWrappers( APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGlyphColumn); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiCustomGrid); APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiGrid); + APyDelphiWrapper.RegisterDelphiWrapper(TPyDelphiStringGrid); end; { TPyDelphiColumn } @@ -516,6 +527,23 @@ procedure TPyDelphiGrid.SetDelphiObject(const Value: TGrid); inherited DelphiObject := Value; end; +{ TPyDelphiStringGrid } + +class function TPyDelphiStringGrid.DelphiObjectClass: TClass; +begin + Result := TStringGrid; +end; + +function TPyDelphiStringGrid.GetDelphiObject: TStringGrid; +begin + Result := TStringGrid(inherited DelphiObject); +end; + +procedure TPyDelphiStringGrid.SetDelphiObject(const Value: TStringGrid); +begin + inherited DelphiObject := Value; +end; + initialization RegisteredUnits.Add(TGridsRegistration.Create);