paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2025-04-07 18:58:04 +02:00
Code Issues Packages Projects Releases Wiki Activity

IDE: Use class type instead of name when searching for components in various places.

Browse Source 
git-svn-id: trunk@64184 -
This commit is contained in:
juha 2020-12-08 19:34:44 +00:00
parent 96027c20c3
commit 1c047add57
6 changed files with 68 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
components/buildintf/packageintf.pas
View File

@ -329,9 +329,8 @@ type
Flags: TPkgIntfRequiredFlags = []) virtual; abstract;
function AddDependencyToOwners(OwnerList: TFPList; APackage: TIDEPackage;
OnlyTestIfPossible: boolean = false): TModalResult; virtual; abstract; // mrOk or mrIgnore for already connected
function AddUnitDependenciesForComponentClasses(const UnitFilename: string;
ComponentClassnames: TStrings;
Quiet: boolean = false): TModalResult; virtual; abstract;
function AddUnitDepsForCompClasses(const UnitFilename: string;
ComponentClasses: TClassList; Quiet: boolean = false): TModalResult; virtual; abstract;
function RedirectPackageDependency(APackage: TIDEPackage): TIDEPackage; virtual; abstract;
// package editors

17
converter/missingpropertiesdlg.pas
View File

@ -88,7 +88,7 @@ type
procedure FillReplaceGrids;
function ShowConvertLFMWizard: TModalResult;
protected
function FixMissingComponentClasses(aMissingTypes: TStringList): TModalResult; override;
function FixMissingComponentClasses(aMissingTypes: TClassList): TModalResult; override;
procedure LoadLFM;
public
constructor Create(ACTLink: TCodeToolLink; ALFMBuffer: TCodeBuffer);
@ -585,12 +585,12 @@ begin
end;
end;
function TLFMFixer.FixMissingComponentClasses(aMissingTypes: TStringList): TModalResult;
function TLFMFixer.FixMissingComponentClasses(aMissingTypes: TClassList): TModalResult;
// This is called from TLFMChecker.FindAndFixMissingComponentClasses.
// Add needed units to uses section using methods already defined in fUsedUnitsTool.
var
RegComp: TRegisteredComponent;
ClassUnitInfo: TUnitInfo;
//ClassUnitInfo: TUnitInfo;
i: Integer;
NeededUnitName: String;
begin
@ -600,17 +600,20 @@ begin
begin
RegComp:=IDEComponentPalette.FindRegComponent(aMissingTypes[i]);
NeededUnitName:='';
if (RegComp<>nil) then begin
if RegComp.ComponentClass<>nil then begin
if Assigned(RegComp) then
begin
if RegComp.ComponentClass<>nil then
begin
NeededUnitName:=RegComp.ComponentClass.UnitName;
if NeededUnitName='' then
NeededUnitName:=RegComp.GetUnitName;
end;
end
else begin
ClassUnitInfo:=Project1.UnitWithComponentClassName(aMissingTypes[i]);
Assert(False, 'TLFMFixer.FixMissingComponentClasses: RegComp=Nil');
{ ClassUnitInfo:=Project1.UnitWithComponentClass(aMissingTypes[i] as TComponentClass);
if ClassUnitInfo<>nil then
NeededUnitName:=ClassUnitInfo.GetUsesUnitName;
NeededUnitName:=ClassUnitInfo.GetUsesUnitName; }
end;
if (NeededUnitName<>'')
and fUsedUnitsTool.AddUnitImmediately(NeededUnitName) then

28
ide/checklfmdlg.pas
View File

@ -76,7 +76,7 @@ type
function FindListBoxError: TLFMError;
procedure WriteLFMErrors;
function FindAndFixMissingComponentClasses: TModalResult;
function FixMissingComponentClasses(aMissingTypes: TStringList): TModalResult; virtual;
function FixMissingComponentClasses(aMissingTypes: TClassList): TModalResult; virtual;
procedure FillErrorsListBox;
procedure JumpToError(LFMError: TLFMError);
procedure AddReplacement(LFMChangeList: TObjectList; StartPos, EndPos: integer;
@ -451,31 +451,27 @@ function TLFMChecker.FindAndFixMissingComponentClasses: TModalResult;
// returns true, if after adding units to uses section all errors are fixed
var
CurError: TLFMError;
MissingObjectTypes: TStringList;
AClassName: String;
MissingObjectTypes: TClassList;
RegComp: TRegisteredComponent;
AClassName: String;
i: Integer;
begin
Result:=mrOK;
MissingObjectTypes:=TStringList.Create;
MissingObjectTypes:=TClassList.Create;
try
// collect all missing object types
CurError:=fLFMTree.FirstError;
while CurError<>nil do begin
if CurError.IsMissingObjectType then begin
AClassName:=(CurError.Node as TLFMObjectNode).TypeName;
if MissingObjectTypes.IndexOf(AClassName)<0 then
MissingObjectTypes.Add(AClassName);
RegComp:=IDEComponentPalette.FindRegComponent(AClassName);
if Assigned(RegComp) and (RegComp.GetUnitName<>'')
and (MissingObjectTypes.IndexOf(RegComp.ComponentClass)<0)
then
MissingObjectTypes.Add(RegComp.ComponentClass);
end;
CurError:=CurError.NextError;
end;
// keep missing object types only with a registered component class
for i:=MissingObjectTypes.Count-1 downto 0 do begin
RegComp:=IDEComponentPalette.FindRegComponent(MissingObjectTypes[i]);
if (RegComp=nil) or (RegComp.GetUnitName='') then
MissingObjectTypes.Delete(i);
end;
// Now the list contains only types that are found in IDE.
if MissingObjectTypes.Count>0 then
Result:=FixMissingComponentClasses(MissingObjectTypes); // Fix them.
@ -484,11 +480,11 @@ begin
end;
end;
function TLFMChecker.FixMissingComponentClasses(aMissingTypes: TStringList): TModalResult;
function TLFMChecker.FixMissingComponentClasses(aMissingTypes: TClassList): TModalResult;
begin
// add units for the missing object types with registered component classes
Result:=PackageEditingInterface.AddUnitDependenciesForComponentClasses(
fPascalBuffer.Filename, aMissingTypes);
Result:=PackageEditingInterface.AddUnitDepsForCompClasses(fPascalBuffer.Filename,
aMissingTypes);
end;
function TLFMChecker.CheckUnit: boolean;

29
ide/main.pp
View File

@ -59,7 +59,7 @@ uses
MemCheck,
{$ENDIF}
// fpc packages
Math, Classes, SysUtils, TypInfo, types, strutils, process, Laz_AVL_Tree,
Math, Classes, SysUtils, TypInfo, types, strutils, Contnrs, process, Laz_AVL_Tree,
// LCL
LCLProc, LCLType, LCLIntf, LResources, HelpIntfs, InterfaceBase, LCLPlatformDef,
ComCtrls, Forms, Buttons, Menus, Controls, GraphType, Graphics, ExtCtrls,
@ -13295,12 +13295,11 @@ procedure TMainIDE.PropHookPersistentAdded(APersistent: TPersistent; Select: boo
var
RegComp: TRegisteredComponent;
ADesigner: TDesigner;
AComponent: TComponent;
AComponent, Ancestor: TComponent;
ActiveSrcEdit: TSourceEditor;
ActiveUnitInfo: TUnitInfo;
Ancestor: TComponent;
ComponentClassNames: TStringList;
ClassUnitInfo: TUnitInfo;
ActiveUnitInfo, ClassUnitInfo: TUnitInfo;
ComponentClasses: TClassList;
ct: TClass;
i: Integer;
begin
if ConsoleVerbosity>0 then
@ -13343,18 +13342,18 @@ begin
// add needed package to required packages
if ADesigner.LookupRoot.ComponentCount>0 then
begin
ComponentClassNames:=TStringList.Create;
ComponentClassNames.Sorted:=True;
ComponentClassNames.Duplicates:=dupIgnore;
ComponentClassNames.CaseSensitive:=False;
DebugLn('TMainIDE.OnPropHookPersistentAdded Creating ComponentClassNames.');
ComponentClasses:=TClassList.Create;
try
for i:=0 to ADesigner.LookupRoot.ComponentCount-1 do
ComponentClassNames.Add(ADesigner.LookupRoot.Components[i].ClassName);
//DebugLn(['TMainIDE.OnPropHookPersistentAdded ComponentClassNames=',ComponentClassNames.Text]);
PkgBoss.AddUnitDependenciesForComponentClasses(ActiveUnitInfo.Filename,
ComponentClassNames,true);
begin
ct := ADesigner.LookupRoot.Components[i].ClassType;
if ComponentClasses.IndexOf(ct)<=0 then
ComponentClasses.Add(ct);
end;
PkgBoss.AddUnitDepsForCompClasses(ActiveUnitInfo.Filename,ComponentClasses,true);
finally
ComponentClassNames.Free;
ComponentClasses.Free;
end;
end;

3
ide/project.pp
View File

@ -5537,8 +5537,7 @@ begin
Result:=Result.fNext[uilWithComponent];
end;
function TProject.UnitWithComponentClassName(const AClassName: string
): TUnitInfo;
function TProject.UnitWithComponentClassName(const AClassName: string): TUnitInfo;
begin
Result := fFirst[uilWithComponent];
while (Result<>nil)

60
packager/pkgmanager.pas
View File

@ -205,11 +205,11 @@ type
function ResolveBrokenDependenciesOnline(ABrokenDependencies: TFPList): TModalResult;
function ShowBrokenDependenciesReport(Dependencies: TFPList): TModalResult;
// Components
function FilterMissingDependenciesForUnit(const UnitFilename: string;
InputPackageList: TPackagePackageArray;
out OutputPackageList: TOwnerPackageArray): TModalResult;
function GetUnitsAndDependenciesForComponents(ComponentClassNames: TStrings;
out PackageList: TPackagePackageArray; out UnitList: TStringList): TModalResult;
function FilterMissingDepsForUnit(const UnitFilename: string;
InputPackageList: TPackagePackageArray;
out OutputPackageList: TOwnerPackageArray): TModalResult;
function GetUnitsAndDepsForComps(ComponentClasses: TClassList;
out PackageList: TPackagePackageArray; out UnitList: TStringList): TModalResult;
public
constructor Create(TheOwner: TComponent); override;
destructor Destroy; override;
@ -357,9 +357,8 @@ type
ShowDialog: boolean): TModalResult;
// components
function AddUnitDependenciesForComponentClasses(const UnitFilename: string;
ComponentClassnames: TStrings;
Quiet: boolean = false): TModalResult; override;
function AddUnitDepsForCompClasses(const UnitFilename: string;
ComponentClasses: TClassList; Quiet: boolean): TModalResult; override;
{ function GetMissingDependenciesForUnit(const UnitFilename: string;
ComponentClassnames: TStrings;
var List: TOwnerPackageArray): TModalResult;
@ -4294,9 +4293,8 @@ begin
PackageList.AddObject(APackageID.Name,APackageID);
end;
function TPkgManager.AddUnitDependenciesForComponentClasses(
const UnitFilename: string; ComponentClassnames: TStrings;
Quiet: boolean): TModalResult;
function TPkgManager.AddUnitDepsForCompClasses(const UnitFilename: string;
ComponentClasses: TClassList; Quiet: boolean): TModalResult;
var
UnitBuf: TCodeBuffer;
UnitNames: TStringList;
@ -4449,13 +4447,12 @@ begin
Dependencies:=nil;
MissingDependencies:=nil;
try
Result:=GetUnitsAndDependenciesForComponents(ComponentClassnames,
Dependencies,UnitNames);
Result:=GetUnitsAndDepsForComps(ComponentClasses, Dependencies, UnitNames);
if Result<>mrOk then exit;
if (Dependencies<>nil) then
begin
Result:=FilterMissingDependenciesForUnit(UnitFilename,Dependencies,MissingDependencies);
Result:=FilterMissingDepsForUnit(UnitFilename,Dependencies,MissingDependencies);
if Result<>mrOk then exit;
end;
@ -4484,15 +4481,14 @@ begin
end;
end;
function TPkgManager.GetUnitsAndDependenciesForComponents(
ComponentClassNames: TStrings; out PackageList: TPackagePackageArray;
out UnitList: TStringList): TModalResult;
function TPkgManager.GetUnitsAndDepsForComps(ComponentClasses: TClassList;
out PackageList: TPackagePackageArray; out UnitList: TStringList): TModalResult;
// returns a list of packages and units needed to use the Component in the unit
var
CurClassID: Integer;
CurUnitIdx, CurPackageIdx: Integer;
CurCompClass: string;
CurRegisteredComponent: TRegisteredComponent;
CurCompClass: TClass;
CurRegComp: TRegisteredComponent;
PkgFile: TPkgFile;
RequiredPackage: TLazPackageID;
CurUnitName: String;
@ -4508,11 +4504,11 @@ begin
AllPackages:=nil;
CurUnitNames:=TStringList.Create;
try
for CurClassID:=0 to ComponentClassnames.Count-1 do
for CurClassID:=0 to ComponentClasses.Count-1 do
begin
CurCompClass:=ComponentClassnames[CurClassID];
CurRegisteredComponent:=IDEComponentPalette.FindRegComponent(CurCompClass);
if CurRegisteredComponent is TPkgComponent then
CurCompClass:=ComponentClasses[CurClassID];
CurRegComp:=IDEComponentPalette.FindRegComponent(CurCompClass);
if CurRegComp is TPkgComponent then
begin
CurUnitName:='';
CurUnitNames.Clear;
@ -4525,14 +4521,16 @@ begin
UnitList.CaseSensitive:=False;
end;
try
if CurRegisteredComponent.ComponentClass<>nil then
if CurRegComp.ComponentClass<>nil then
begin
CurUnitName:=GetClassUnitName(CurRegisteredComponent.ComponentClass);
CurCompReq:=GetComponentRequirements(CurRegisteredComponent.ComponentClass);
CurUnitName:=CurRegComp.ComponentClass.UnitName;
CurCompReq:=GetComponentRequirements(CurRegComp.ComponentClass);
end;
//DebugLn(['TPkgManager.GetUnitsAndDependenciesForComponents CurUnitName=',CurUnitName]);
if CurUnitName='' then
CurUnitName:=CurRegisteredComponent.GetUnitName;
CurUnitName:=CurRegComp.GetUnitName;
Assert(CurUnitNames.IndexOf(CurUnitName)<0,
'TPkgManager.GetUnitsAndDependenciesForComponents: Name already in CurUnitNames.');
CurUnitNames.Add(CurUnitName);
if CurCompReq<>nil then
CurCompReq.RequiredUnits(CurUnitNames);
@ -4543,7 +4541,7 @@ begin
PkgFile:=PackageGraph.FindUnitInAllPackages(CurUnitName,true);
//DebugLn(['TPkgManager.GetUnitsAndDependenciesForComponents PkgFile=',PkgFile<>nil]);
if PkgFile=nil then
PkgFile:=TPkgComponent(CurRegisteredComponent).PkgFile;
PkgFile:=TPkgComponent(CurRegComp).PkgFile;
if PkgFile<>nil then
begin
RequiredPackage:=PkgFile.LazPackage;
@ -4578,12 +4576,12 @@ begin
end;
end;
end;
end;
end; // for CurUnitIdx:=
finally
CurCompReq.Free;
end;
end;
end;
end; // for CurClassID:=...
if Assigned(AllPackages) and (AllPackages.Count>0) then
begin
PackageList:=TPackagePackageArray.Create;
@ -4598,7 +4596,7 @@ begin
Result:=mrOk;
end;
function TPkgManager.FilterMissingDependenciesForUnit(const UnitFilename: string;
function TPkgManager.FilterMissingDepsForUnit(const UnitFilename: string;
InputPackageList: TPackagePackageArray;
out OutputPackageList: TOwnerPackageArray): TModalResult;
// returns a list of packages that are not yet used by the project the unit belongs to