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

implemented removing, re-adding, updating project dependencies

Browse Source 
git-svn-id: trunk@4086 -
This commit is contained in:
mattias 2003-04-20 20:32:40 +00:00
parent a9c753a035
commit 59957529dc
10 changed files with 334 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ide/addtoprojectdlg.pas
View File

@ -97,6 +97,8 @@ type
function ShowAddToProjectDlg(AProject: TProject;
var AddResult: TAddToProjectResult): TModalResult;
function CheckAddingDependency(LazProject: TProject;
NewDependency: TPkgDependency): boolean;
implementation

33
ide/project.pp
View File

@ -384,6 +384,7 @@ type
procedure DeleteRequiredDependency(Dependency: TPkgDependency);
procedure DeleteRemovedDependency(Dependency: TPkgDependency);
procedure RemoveRemovedDependency(Dependency: TPkgDependency);
procedure ReaddRemovedDependency(Dependency: TPkgDependency);
procedure MoveRequiredDependencyUp(Dependency: TPkgDependency);
procedure MoveRequiredDependencyDown(Dependency: TPkgDependency);
function Requires(APackage: TLazPackage): boolean;
@ -432,6 +433,7 @@ type
property UnitOutputDirectory: String
read fUnitOutputDirectory write fUnitOutputDirectory;
property Units[Index: integer]:TUnitInfo read GetUnits write SetUnits;
property UpdateLock: integer read FUpdateLock;
end;
const
@ -1428,7 +1430,7 @@ begin
// load the dependencies
LoadPkgDependencyList(XMLConfig,'ProjectOptions/RequiredPackages/',
FFirstRequiredDependency,pdlRequires,Self);
FFirstRequiredDependency,pdlRequires,Self,true);
finally
{$IFDEF IDE_MEM_CHECK}CheckHeapWrtMemCnt('TProject.ReadProject freeing xml');{$ENDIF}
xmlconfig.Free;
@ -2156,47 +2158,73 @@ end;
procedure TProject.AddRequiredDependency(Dependency: TPkgDependency);
begin
BeginUpdate(true);
Dependency.AddToList(FFirstRequiredDependency,pdlRequires);
Dependency.Owner:=Self;
Dependency.HoldPackage:=true;
Modified:=true;
EndUpdate;
end;
procedure TProject.RemoveRequiredDependency(Dependency: TPkgDependency);
begin
BeginUpdate(true);
Dependency.RemoveFromList(FFirstRequiredDependency,pdlRequires);
Dependency.RequiredPackage:=nil;
Dependency.AddToList(FFirstRemovedDependency,pdlRequires);
Dependency.Removed:=true;
Modified:=true;
EndUpdate;
end;
procedure TProject.DeleteRequiredDependency(Dependency: TPkgDependency);
begin
BeginUpdate(true);
Dependency.RequiredPackage:=nil;
Dependency.RemoveFromList(FFirstRequiredDependency,pdlRequires);
Dependency.Free;
EndUpdate;
end;
procedure TProject.DeleteRemovedDependency(Dependency: TPkgDependency);
begin
BeginUpdate(true);
Dependency.RequiredPackage:=nil;
Dependency.RemoveFromList(FFirstRemovedDependency,pdlRequires);
Dependency.Free;
EndUpdate;
end;
procedure TProject.RemoveRemovedDependency(Dependency: TPkgDependency);
begin
BeginUpdate(true);
Dependency.RemoveFromList(FFirstRemovedDependency,pdlRequires);
Dependency.Removed:=false;
EndUpdate;
end;
procedure TProject.ReaddRemovedDependency(Dependency: TPkgDependency);
begin
BeginUpdate(true);
RemoveRemovedDependency(Dependency);
AddRequiredDependency(Dependency);
EndUpdate;
end;
procedure TProject.MoveRequiredDependencyUp(Dependency: TPkgDependency);
begin
if Dependency.PrevRequiresDependency=nil then exit;
BeginUpdate(true);
Dependency.MoveUpInList(FFirstRequiredDependency,pdlRequires);
EndUpdate;
end;
procedure TProject.MoveRequiredDependencyDown(Dependency: TPkgDependency);
begin
if Dependency.NextRequiresDependency=nil then exit;
BeginUpdate(true);
Dependency.MoveDownInList(FFirstRequiredDependency,pdlRequires);
EndUpdate;
end;
function TProject.Requires(APackage: TLazPackage): boolean;
@ -2527,6 +2555,9 @@ end.
{
$Log$
Revision 1.111 2003/04/20 20:32:40 mattias
implemented removing, re-adding, updating project dependencies
Revision 1.110 2003/04/20 09:52:07 mattias
implemented saving loading project dependencies

100
ide/projectinspector.pas
View File

@ -66,10 +66,13 @@ type
procedure ItemsPopupMenuPopup(Sender: TObject);
procedure ItemsTreeViewDblClick(Sender: TObject);
procedure ItemsTreeViewSelectionChanged(Sender: TObject);
procedure MoveDependencyUpClick(Sender: TObject);
procedure MoveDependencyDownClick(Sender: TObject);
procedure OpenBitBtnClick(Sender: TObject);
procedure OptionsBitBtnClick(Sender: TObject);
procedure ProjectInspectorFormResize(Sender: TObject);
procedure ProjectInspectorFormShow(Sender: TObject);
procedure ReAddMenuItemClick(Sender: TObject);
procedure RemoveBitBtnClick(Sender: TObject);
private
FOnAddUnitToProject: TOnAddUnitToProject;
@ -170,6 +173,26 @@ begin
UpdateButtons;
end;
procedure TProjectInspectorForm.MoveDependencyUpClick(Sender: TObject);
var
Dependency: TPkgDependency;
begin
Dependency:=GetSelectedDependency;
if (Dependency=nil) or (Dependency.Removed)
or (Dependency.PrevRequiresDependency=nil) then exit;
LazProject.MoveRequiredDependencyUp(Dependency);
end;
procedure TProjectInspectorForm.MoveDependencyDownClick(Sender: TObject);
var
Dependency: TPkgDependency;
begin
Dependency:=GetSelectedDependency;
if (Dependency=nil) or (Dependency.Removed)
or (Dependency.NextRequiresDependency=nil) then exit;
LazProject.MoveRequiredDependencyDown(Dependency);
end;
procedure TProjectInspectorForm.AddBitBtnClick(Sender: TObject);
var
AddResult: TAddToProjectResult;
@ -209,8 +232,54 @@ begin
end;
procedure TProjectInspectorForm.ItemsPopupMenuPopup(Sender: TObject);
begin
var
ItemCnt: integer;
procedure AddPopupMenuItem(const ACaption: string; AnEvent: TNotifyEvent;
EnabledFlag: boolean);
var
CurMenuItem: TMenuItem;
begin
if ItemsPopupMenu.Items.Count<=ItemCnt then begin
CurMenuItem:=TMenuItem.Create(Self);
ItemsPopupMenu.Items.Add(CurMenuItem);
end else
CurMenuItem:=ItemsPopupMenu.Items[ItemCnt];
CurMenuItem.Caption:=ACaption;
CurMenuItem.OnClick:=AnEvent;
CurMenuItem.Enabled:=EnabledFlag;
inc(ItemCnt);
end;
var
CurFile: TUnitInfo;
CurDependency: TPkgDependency;
begin
ItemCnt:=0;
CurFile:=GetSelectedFile;
if CurFile<>nil then begin
AddPopupMenuItem('Open file',@OpenBitBtnClick,true);
AddPopupMenuItem('Remove file',@RemoveBitBtnClick,RemoveBitBtn.Enabled);
end;
CurDependency:=GetSelectedDependency;
if CurDependency<>nil then begin
if CurDependency.Removed then begin
AddPopupMenuItem('Open package',@OpenBitBtnClick,true);
AddPopupMenuItem('Re-Add dependency',@ReAddMenuItemClick,
AddBitBtn.Enabled);
end else begin
AddPopupMenuItem('Open package',@OpenBitBtnClick,true);
AddPopupMenuItem('Remove dependency',@RemoveBitBtnClick,
RemoveBitBtn.Enabled);
AddPopupMenuItem('Move dependency up',@MoveDependencyUpClick,
(CurDependency.PrevRequiresDependency<>nil));
AddPopupMenuItem('Move dependency down',@MoveDependencyDownClick,
(CurDependency.NextRequiresDependency<>nil));
end;
end;
while ItemsPopupMenu.Items.Count>ItemCnt do
ItemsPopupMenu.Items.Delete(ItemsPopupMenu.Items.Count-1);
end;
procedure TProjectInspectorForm.OpenBitBtnClick(Sender: TObject);
@ -228,20 +297,45 @@ begin
UpdateAll;
end;
procedure TProjectInspectorForm.RemoveBitBtnClick(Sender: TObject);
procedure TProjectInspectorForm.ReAddMenuItemClick(Sender: TObject);
var
Dependency: TPkgDependency;
RequiredPackage: TLazPackage;
begin
Dependency:=GetSelectedDependency;
if (Dependency=nil) or (not Dependency.Removed)
or (not CheckAddingDependency(LazProject,Dependency)) then exit;
BeginUpdate;
LazProject.ReaddRemovedDependency(Dependency);
PackageGraph.OpenDependency(Dependency,RequiredPackage);
EndUpdate;
end;
procedure TProjectInspectorForm.RemoveBitBtnClick(Sender: TObject);
var
CurDependency: TPkgDependency;
begin
CurDependency:=GetSelectedDependency;
if (CurDependency<>nil) and (not CurDependency.Removed) then begin
if MessageDlg('Confirm deleting dependency',
'Delete dependency for '+CurDependency.AsString+'?',
mtConfirmation,[mbYes,mbNo],0)<>mrYes
then exit;
LazProject.RemoveRequiredDependency(CurDependency);
end;
end;
procedure TProjectInspectorForm.SetLazProject(const AValue: TProject);
begin
if FLazProject=AValue then exit;
if FLazProject<>nil then begin
dec(FUpdateLock,LazProject.UpdateLock);
FLazProject.OnBeginUpdate:=nil;
FLazProject.OnEndUpdate:=nil;
end;
FLazProject:=AValue;
if FLazProject<>nil then begin
inc(FUpdateLock,LazProject.UpdateLock);
FLazProject.OnBeginUpdate:=@OnProjectBeginUpdate;
FLazProject.OnEndUpdate:=@OnProjectEndUpdate;
end;
@ -447,7 +541,7 @@ begin
CurNode.Free;
CurNode:=NextNode;
end;
DependenciesNode.Expanded:=true;
RemovedDependenciesNode.Expanded:=true;
end else begin
// delete removed dependency nodes
if RemovedDependenciesNode<>nil then

96
lcl/calendar.pp
View File

@ -58,26 +58,30 @@ Type
FDayChanged: TNotifyEvent;
FMonthChanged: TNotifyEvent;
FYearChanged: TNotifyEvent;
FPropsChanged: boolean;
function ReadOnlyIsStored: boolean;
procedure SetReadOnly(const AValue: Boolean);
Procedure GetProps;
Procedure SetProps;
function GetDisplaySettings: TDisplaySettings;
procedure SetDisplaySettings(const AValue: TDisplaySettings);
function GetDate: String;
procedure SetDate(const AValue: String);
protected
procedure LMMonthChanged(var Message: TLMessage); message LM_MONTHCHANGED;
procedure LMYEARChanged(var Message: TLMessage); message LM_YEARCHANGED;
procedure LMDAYChanged(var Message: TLMessage); message LM_DAYCHANGED;
procedure LMYearChanged(var Message: TLMessage); message LM_YEARCHANGED;
procedure LMDayChanged(var Message: TLMessage); message LM_DAYCHANGED;
public
constructor Create(AOwner: TComponent); override;
constructor Create(TheOwner: TComponent); override;
destructor Destroy; override;
procedure Loaded; override;
procedure InitializeWnd; override;
procedure AddControl; override;
published
Property Date : String read GetDate write SetDate;
property DisplaySettings : TDisplaySettings read GetDisplaySettings write SetDisplaySettings;
// Property Date : TDate read GetDate write SetDate;
property ReadOnly : Boolean read FReadOnly write SetReadOnly;
property ReadOnly : Boolean read FReadOnly write SetReadOnly stored ReadOnlyIsStored;
property Visible;
// property OnChange;
property OnClick;
@ -99,37 +103,54 @@ end;
{ TCalendar }
constructor TCalendar.Create(AOwner: TComponent);
constructor TCalendar.Create(TheOwner: TComponent);
begin
inherited Create(AOwner);
inherited Create(TheOwner);
fCompStyle := csCalendar;
SetBounds(0,0,250,150);
fDisplaySettings := [dsShowHeadings, dsShowDayNames];
Date := FormatDateTime('dd-mm-yyyy',Now);
ControlStyle:=ControlStyle-csMultiClicks-[csAcceptsControls];
Date := FormatDateTime('dd-mm-yyyy',Now);
end;
destructor TCalendar.Destroy;
begin
Inherited;
Inherited Destroy;
end;
procedure TCalendar.Loaded;
begin
inherited Loaded;
if FPropsChanged then SetProps;
end;
procedure TCalendar.InitializeWnd;
begin
inherited InitializeWnd;
if FPropsChanged then SetProps;
end;
procedure TCalendar.AddControl;
begin
inherited AddControl;
end;
function TCalendar.GetDate: String;
begin
Result := '';
GetPRops;
GetProps;
Result := FDate;
end;
procedure TCalendar.SetDate(const AValue: String);
begin
try
StrtoDate(AValue); //test to see if valid date....
FDate := AValue;
SetProps;
except
raise EInvalidDate.CreateFmt(rsInvalidDate, [AValue]);
end;
try
StrtoDate(AValue); //test to see if valid date....
FDate := AValue;
except
raise EInvalidDate.CreateFmt(rsInvalidDate, [AValue]);
end;
SetProps;
end;
function TCalendar.GetDisplaySettings: TDisplaySettings;
@ -147,35 +168,42 @@ end;
procedure TCalendar.SetReadOnly(const AValue: Boolean);
begin
if (FReadOnly <> aValue) then
Begin
FReadOnly := aValue;
SetProps;
end;
Begin
FReadOnly := aValue;
SetProps;
end;
end;
function TCalendar.ReadOnlyIsStored: boolean;
begin
Result:=FReadOnly;
end;
Procedure TCalendar.GetProps;
var
Temp : TLMCalendar;
begin
if HandleAllocated then
begin
CNSendMessage(LM_GETVALUE, Self, @temp); // Get the info
FDate := FormatDateTime('dd-mm-yyyy',Temp.Date);
end;
if HandleAllocated then
begin
CNSendMessage(LM_GETVALUE, Self, @temp); // Get the info
FDate := FormatDateTime('dd-mm-yyyy',Temp.Date);
end;
end;
Procedure TCalendar.SetProps;
var
Temp : TLMCalendar;
begin
if HandleAllocated then
begin
Temp.Date := StrToDate(FDate);
Temp.DisplaySettings := FDisplaySettings;
Temp.ReadOnly := fReadOnly;
CNSendMessage(LM_SETVALUE, Self, @temp); // Get the info
End;
if HandleAllocated and (not (csLoading in ComponentState)) then
begin
FPropsChanged:=false;
Temp.Date := StrToDate(FDate);
Temp.DisplaySettings := FDisplaySettings;
Temp.ReadOnly := fReadOnly;
CNSendMessage(LM_SETVALUE, Self, @temp); // Get the info
End else begin
FPropsChanged:=true;
end;
end;
procedure TCalendar.LMDAYChanged(var Message: TLMessage);

10
packager/basepkgmanager.pas
View File

@ -44,7 +44,7 @@ uses
{$IFDEF IDE_MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, Forms, PackageDefs;
Classes, SysUtils, Forms, PackageDefs, Project;
type
TPkgSaveFlag = (
@ -76,7 +76,11 @@ type
function GetDefaultSaveDirectoryForFile(const Filename: string): string; virtual; abstract;
procedure LoadInstalledPackages; virtual; abstract;
function OpenProjectDependencies(AProject: TProject): TModalResult; virtual; abstract;
procedure AddDefaultDependencies(AProject: TProject); virtual; abstract;
procedure AddProjectDependency(AProject: TProject; APackage: TLazPackage); virtual; abstract;
procedure AddProjectLCLDependency(AProject: TProject); virtual; abstract;
function ShowConfigureCustomComponents: TModalResult; virtual; abstract;
function DoNewPackage: TModalResult; virtual; abstract;
function DoShowOpenInstalledPckDlg: TModalResult; virtual; abstract;
@ -95,6 +99,8 @@ type
Flags: TPkgCompileFlags): TModalResult; virtual; abstract;
function OnRenameFile(const OldFilename,
NewFilename: string): TModalResult; virtual; abstract;
function OnProjectInspectorOpen(Sender: TObject): boolean; virtual; abstract;
end;
var

31
packager/packagedefs.pas
View File

@ -195,6 +195,7 @@ type
TPkgDependency = class
private
FFlags: TPkgDependencyFlags;
FHoldPackage: boolean;
FLoadPackageResult: TLoadPackageResult;
FOwner: TObject;
FMaxVersion: TPkgVersion;
@ -203,6 +204,7 @@ type
FRemoved: boolean;
FRequiredPackage: TLazPackage;
procedure SetFlags(const AValue: TPkgDependencyFlags);
procedure SetHoldPackage(const AValue: boolean);
procedure SetLoadPackageResult(const AValue: TLoadPackageResult);
procedure SetMaxVersion(const AValue: TPkgVersion);
procedure SetMinVersion(const AValue: TPkgVersion);
@ -248,6 +250,7 @@ type
property Owner: TObject read FOwner write FOwner;
property RequiredPackage: TLazPackage read FRequiredPackage write SetRequiredPackage;
property LoadPackageResult: TLoadPackageResult read FLoadPackageResult write SetLoadPackageResult;
property HoldPackage: boolean read FHoldPackage write SetHoldPackage;
end;
PPkgDependency = ^TPkgDependency;
@ -422,6 +425,7 @@ type
FFirstRequiredDependency: TPkgDependency;
FFirstUsedByDependency: TPkgDependency;
FFlags: TLazPackageFlags;
FHoldPackageCount: integer;
FIconFile: string;
FInstalled: TPackageInstallType;
FLastCompilerFilename: string;
@ -561,6 +565,7 @@ type
read FFirstRequiredDependency;
property FirstUsedByDependency: TPkgDependency read FFirstUsedByDependency;
property Flags: TLazPackageFlags read FFlags write SetFlags;
property HoldPackageCount: integer read FHoldPackageCount;
property IconFile: string read FIconFile write SetIconFile;
property Installed: TPackageInstallType read FInstalled write SetInstalled;
property LastCompilerFilename: string read FLastCompilerFilename
@ -624,7 +629,8 @@ function LazPackageTypeIdentToType(const s: string): TLazPackageType;
procedure SortDependencyList(Dependencies: TList);
procedure LoadPkgDependencyList(XMLConfig: TXMLConfig; const ThePath: string;
var First: TPkgDependency; ListType: TPkgDependencyList; Owner: TObject);
var First: TPkgDependency; ListType: TPkgDependencyList; Owner: TObject;
HoldPackages: boolean);
procedure SavePkgDependencyList(XMLConfig: TXMLConfig; const ThePath: string;
First: TPkgDependency; ListType: TPkgDependencyList);
@ -666,7 +672,8 @@ begin
end;
procedure LoadPkgDependencyList(XMLConfig: TXMLConfig; const ThePath: string;
var First: TPkgDependency; ListType: TPkgDependencyList; Owner: TObject);
var First: TPkgDependency; ListType: TPkgDependencyList; Owner: TObject;
HoldPackages: boolean);
var
i: Integer;
PkgDependency: TPkgDependency;
@ -681,6 +688,7 @@ begin
PkgDependency:=TPkgDependency.Create;
PkgDependency.LoadFromXMLConfig(XMLConfig,ThePath+'Item'+IntToStr(i+1)+'/',
FileVersion);
PkgDependency.HoldPackage:=HoldPackages;
if PkgDependency.MakeSense then
List.Add(PkgDependency)
else
@ -1075,6 +1083,18 @@ begin
FFlags:=AValue;
end;
procedure TPkgDependency.SetHoldPackage(const AValue: boolean);
begin
if FHoldPackage=AValue then exit;
FHoldPackage:=AValue;
if RequiredPackage<>nil then begin
if FHoldPackage then
inc(RequiredPackage.FHoldPackageCount)
else
dec(RequiredPackage.FHoldPackageCount);
end;
end;
procedure TPkgDependency.SetLoadPackageResult(const AValue: TLoadPackageResult
);
begin
@ -1819,7 +1839,7 @@ begin
FPackageType:=LazPackageTypeIdentToType(XMLConfig.GetValue(Path+'Type/Value',
LazPackageTypeIdents[lptRunTime]));
LoadPkgDependencyList(XMLConfig,Path+'RequiredPkgs/',
FFirstRequiredDependency,pdlRequires,Self);
FFirstRequiredDependency,pdlRequires,Self,false);
FUsageOptions.LoadFromXMLConfig(XMLConfig,Path+'UsageOptions/');
LoadRect(XMLConfig,Path+'EditorRect/',fEditorRect);
EndUpdate;
@ -2105,6 +2125,7 @@ end;
procedure TLazPackage.RemoveRequiredDependency(Dependency: TPkgDependency);
begin
Dependency.RemoveFromList(FFirstRequiredDependency,pdlRequires);
Dependency.RequiredPackage:=nil;
Dependency.AddToList(FFirstRemovedDependency,pdlRequires);
Dependency.Removed:=true;
Modified:=true;
@ -2169,11 +2190,15 @@ end;
procedure TLazPackage.AddUsedByDependency(Dependency: TPkgDependency);
begin
Dependency.AddToList(FFirstUsedByDependency,pdlUsedBy);
if Dependency.HoldPackage then
inc(FHoldPackageCount);
end;
procedure TLazPackage.RemoveUsedByDependency(Dependency: TPkgDependency);
begin
Dependency.RemoveFromList(FFirstUsedByDependency,pdlUsedBy);
if Dependency.HoldPackage then
dec(FHoldPackageCount);
end;
procedure TLazPackage.ChangeID(const NewName: string; NewVersion: TPkgVersion);

2
packager/packageeditor.pas
View File

@ -339,7 +339,7 @@ begin
AddBitBtn.Enabled);
end else if (CurNode.Parent=RemovedRequiredNode) then begin
AddPopupMenuItem('Open package',@OpenFileMenuItemClick,true);
AddPopupMenuItem('Add dependency',@ReAddMenuItemClick,
AddPopupMenuItem('Re-Add dependency',@ReAddMenuItemClick,
AddBitBtn.Enabled);
end;
end;

31
packager/packagesystem.pas
View File

@ -114,8 +114,12 @@ type
function CreateUniquePkgName(const Prefix: string;
IgnorePackage: TLazPackage): string;
function CreateUniqueUnitName(const Prefix: string): string;
function DependencyExists(Dependency: TPkgDependency;
Flags: TFindPackageFlags): boolean;
function FindAPackageWithName(const PkgName: string;
IgnorePackage: TLazPackage): TLazPackage;
function FindBrokenDependencyPath(APackage: TLazPackage): TList;
function FindCircleDependencyPath(APackage: TLazPackage): TList;
function FindFileInAllPackages(const TheFilename: string;
ResolveLinks, IgnoreDeleted: boolean): TPkgFile;
function FindLowestPkgNodeByName(const PkgName: string): TAVLTreeNode;
@ -131,14 +135,13 @@ type
WithRequiredPackages, IgnoreDeleted: boolean): TPkgFile;
function FindUnitInAllPackages(const TheUnitName: string;
IgnoreDeleted: boolean): TPkgFile;
function GetAutoCompilationOrder(APackage: TLazPackage): TList;
function GetBrokenDependenciesWhenChangingPkgID(APackage: TLazPackage;
const NewName: string; NewVersion: TPkgVersion): TList;
function PackageCanBeReplaced(OldPackage, NewPackage: TLazPackage): boolean;
function PackageIsNeeded(APackage: TLazPackage): boolean;
function PackageNameExists(const PkgName: string;
IgnorePackage: TLazPackage): boolean;
function DependencyExists(Dependency: TPkgDependency;
Flags: TFindPackageFlags): boolean;
procedure ConsistencyCheck;
procedure GetAllRequiredPackages(FirstDependency: TPkgDependency;
var List: TList);
@ -152,9 +155,6 @@ type
Event: TIteratePackagesEvent);
procedure MarkAllPackagesAsNotVisited;
procedure MarkNeededPackages;
function FindBrokenDependencyPath(APackage: TLazPackage): TList;
function FindCircleDependencyPath(APackage: TLazPackage): TList;
function GetAutoCompilationOrder(APackage: TLazPackage): TList;
public
// packages handling
function CreateNewPackage(const Prefix: string): TLazPackage;
@ -183,6 +183,7 @@ type
procedure ChangeDependency(Dependency, NewDependency: TPkgDependency);
function OpenDependency(Dependency: TPkgDependency;
var APackage: TLazPackage): TLoadPackageResult;
procedure OpenRequiredDependencyList(FirstDependency: TPkgDependency);
procedure MoveRequiredDependencyUp(ADependency: TPkgDependency);
procedure MoveRequiredDependencyDown(ADependency: TPkgDependency);
public
@ -206,6 +207,7 @@ type
property RegistrationPackage: TLazPackage read FRegistrationPackage
write SetRegistrationPackage;
property RegistrationUnitName: string read FRegistrationUnitName;
property UpdateLock: integer read FUpdateLock;
end;
var
@ -1168,13 +1170,15 @@ begin
end;
function TLazPackageGraph.PackageIsNeeded(APackage: TLazPackage): boolean;
// check if package is currently in use (installed, autoinstall, editor open)
// check if package is currently in use (installed, autoinstall, editor open,
// or used by a needed dependency)
// !!! it does not check if any needed package needs this package
begin
Result:=true;
// check if package is open, installed or will be installed
if (APackage.Installed<>pitNope) or (APackage.AutoInstall<>pitNope)
or ((APackage.Editor<>nil) and (APackage.Editor.Visible)) then
or ((APackage.Editor<>nil) and (APackage.Editor.Visible))
or (APackage.HoldPackageCount>0) then
begin
exit;
end;
@ -1308,6 +1312,19 @@ begin
Result:=Dependency.LoadPackageResult;
end;
procedure TLazPackageGraph.OpenRequiredDependencyList(
FirstDependency: TPkgDependency);
var
Dependency: TPkgDependency;
RequiredPackage: TLazPackage;
begin
Dependency:=FirstDependency;
while Dependency<>nil do begin
OpenDependency(Dependency,RequiredPackage);
Dependency:=Dependency.NextRequiresDependency;
end;
end;
procedure TLazPackageGraph.MoveRequiredDependencyUp(
ADependency: TPkgDependency);
begin

1
packager/pkggraphexplorer.pas
View File

@ -468,6 +468,7 @@ var
ALayout: TIDEWindowLayout;
begin
inherited Create(TheOwner);
FUpdateLock:=PackageGraph.UpdateLock;
fSortedPackages:=TAVLTree.Create(@CompareLazPackageID);
Name:=NonModalIDEWindowNames[nmiwPkgGraphExplorer];
Caption:='Package Graph';

80
packager/pkgmanager.pas
View File

@ -51,10 +51,12 @@ uses
PackageEditor, AddToPackageDlg, PackageDefs, PackageLinks, PackageSystem,
OpenInstalledPkgDlg, PkgGraphExplorer, BrokenDependenciesDlg, CompilerOptions,
ExtToolDialog, ExtToolEditDlg, EditDefineTree, DefineTemplates,
ProjectInspector,
BasePkgManager, MainBar;
type
TPkgManager = class(TBasePkgManager)
// events
function OnPackageEditorCompilePackage(Sender: TObject;
APackage: TLazPackage; CompileAll: boolean): TModalResult;
function OnPackageEditorCreateFile(Sender: TObject;
@ -83,6 +85,7 @@ type
procedure PackageGraphDependencyModified(ADependency: TPkgDependency);
procedure PackageGraphEndUpdate(Sender: TObject; GraphChanged: boolean);
private
// helper functions
function DoShowSavePackageAsDialog(APackage: TLazPackage): TModalResult;
function CompileRequiredPackages(APackage: TLazPackage): TModalResult;
function CheckPackageGraphForCompilation(APackage: TLazPackage): TModalResult;
@ -109,7 +112,11 @@ type
procedure LoadInstalledPackages; override;
function AddPackageToGraph(APackage: TLazPackage): TModalResult;
function OpenProjectDependencies(AProject: TProject): TModalResult; override;
procedure AddDefaultDependencies(AProject: TProject); override;
procedure AddProjectDependency(AProject: TProject; APackage: TLazPackage); override;
procedure AddProjectLCLDependency(AProject: TProject); override;
function ShowConfigureCustomComponents: TModalResult; override;
function DoNewPackage: TModalResult; override;
function DoShowOpenInstalledPckDlg: TModalResult; override;
@ -129,6 +136,8 @@ type
Flags: TPkgCompileFlags): TModalResult; override;
function OnRenameFile(const OldFilename,
NewFilename: string): TModalResult; override;
function OnProjectInspectorOpen(Sender: TObject): boolean; override;
end;
implementation
@ -326,6 +335,8 @@ begin
if GraphChanged then begin
if PackageEditors<>nil then
PackageEditors.UpdateAllEditors;
if ProjInspector<>nil then
ProjInspector.UpdateItems;
end;
end;
@ -985,6 +996,57 @@ begin
Result:=mrOk;
end;
function TPkgManager.OpenProjectDependencies(AProject: TProject): TModalResult;
begin
PackageGraph.OpenRequiredDependencyList(AProject.FirstRequiredDependency);
Result:=mrOk;
end;
procedure TPkgManager.AddDefaultDependencies(AProject: TProject);
var
ds: char;
begin
case AProject.ProjectType of
ptApplication:
begin
// add lcl pp/pas dirs to source search path
ds:=PathDelim;
AProject.SrcPath:=
'$(LazarusDir)'+ds+'lcl'
+';'+
'$(LazarusDir)'+ds+'lcl'+ds+'interfaces'+ds+'$(LCLWidgetType)';
{$IFDEF EnablePkgs}
AddProjectLCLDependency(AProject);
{$ELSE}
// add lcl ppu dirs to unit search path
Project1.CompilerOptions.OtherUnitFiles:=
'$(LazarusDir)'+ds+'lcl'+ds+'units'
+';'+
'$(LazarusDir)'+ds+'lcl'+ds+'units'+ds+'$(LCLWidgetType)';
{$ENDIF}
end;
end;
OpenProjectDependencies(AProject);
end;
procedure TPkgManager.AddProjectDependency(AProject: TProject;
APackage: TLazPackage);
begin
// check if the dependency is already there
if FindDependencyByNameInList(AProject.FirstRequiredDependency,pdlRequires,
APackage.Name)<>nil
then exit;
// add a dependency for the package to the project
AProject.AddRequiredDependency(APackage.CreateDependencyForThisPkg);
end;
procedure TPkgManager.AddProjectLCLDependency(AProject: TProject);
begin
AddProjectDependency(AProject,PackageGraph.LCLPackage);
end;
function TPkgManager.ShowConfigureCustomComponents: TModalResult;
begin
Result:=ShowConfigureCustomComponentDlg(EnvironmentOptions.LazarusDirectory);
@ -1488,6 +1550,22 @@ begin
Result:=mrOk;
end;
function TPkgManager.OnProjectInspectorOpen(Sender: TObject): boolean;
var
Dependency: TPkgDependency;
RequiredPackage: TLazPackage;
begin
Result:=false;
if (Sender=nil) or (not (Sender is TProjectInspectorForm)) then exit;
Dependency:=TProjectInspectorForm(Sender).GetSelectedDependency;
if Dependency=nil then exit;
// user has selected a dependency -> open package
Result:=true;
if PackageGraph.OpenDependency(Dependency,RequiredPackage)<>lprSuccess then
exit;
DoOpenPackage(RequiredPackage);
end;
function TPkgManager.DoClosePackageEditor(APackage: TLazPackage): TModalResult;
begin
if APackage.Editor<>nil then begin