implemented removing, re-adding, updating project dependencies

git-svn-id: trunk@4086 -

ide/addtoprojectdlg.pas

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

ide/project.pp

@@ -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
 

ide/projectinspector.pas

@@ -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

lcl/calendar.pp

@@ -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 LMYearChanged(var Message: TLMessage); message LM_YEARCHANGED;
-    procedure LMDAYChanged(var Message: TLMessage); message LM_DAYCHANGED;
+    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
+  try
-     StrtoDate(AValue);  //test to see if valid date....
+    StrtoDate(AValue);  //test to see if valid date....
-     FDate := AValue;
+    FDate := AValue;
-     SetProps;
+  except
-   except
+    raise EInvalidDate.CreateFmt(rsInvalidDate, [AValue]);
-     raise EInvalidDate.CreateFmt(rsInvalidDate, [AValue]);
+  end;
-   end;
+  SetProps;
 end;
 
 function TCalendar.GetDisplaySettings: TDisplaySettings;
@@ -147,35 +168,42 @@ end;
 procedure TCalendar.SetReadOnly(const AValue: Boolean);
 begin
   if (FReadOnly <> aValue) then
-    Begin
+  Begin
-      FReadOnly := aValue;
+    FReadOnly := aValue;
-      SetProps;
+    SetProps;
-    end;
+  end;
+end;
+
+function TCalendar.ReadOnlyIsStored: boolean;
+begin
+  Result:=FReadOnly;
 end;
 
 Procedure TCalendar.GetProps;
 var
   Temp : TLMCalendar;
 begin
-   if HandleAllocated then
+  if HandleAllocated then
-      begin
+  begin
-        CNSendMessage(LM_GETVALUE, Self, @temp);	// Get the info
+    CNSendMessage(LM_GETVALUE, Self, @temp);	// Get the info
-        FDate := FormatDateTime('dd-mm-yyyy',Temp.Date);
+    FDate := FormatDateTime('dd-mm-yyyy',Temp.Date);
-      end;
+  end;
 end;
 
 Procedure TCalendar.SetProps;
 var
   Temp : TLMCalendar;
 begin
-   if HandleAllocated then
+  if HandleAllocated and (not (csLoading in ComponentState)) then
-      begin
+  begin
-        Temp.Date := StrToDate(FDate);
+    FPropsChanged:=false;
-        Temp.DisplaySettings := FDisplaySettings;
+    Temp.Date := StrToDate(FDate);
-        Temp.ReadOnly := fReadOnly;
+    Temp.DisplaySettings := FDisplaySettings;
-        CNSendMessage(LM_SETVALUE, Self, @temp);	// Get the info
+    Temp.ReadOnly := fReadOnly;
-      End;
+    CNSendMessage(LM_SETVALUE, Self, @temp);	// Get the info
-
+  End else begin
+    FPropsChanged:=true;
+  end;
 end;
 
 procedure TCalendar.LMDAYChanged(var Message: TLMessage);

packager/basepkgmanager.pas

@@ -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

packager/packagedefs.pas

@@ -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);

packager/packageeditor.pas

@@ -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;

packager/packagesystem.pas

@@ -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

packager/pkggraphexplorer.pas

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

packager/pkgmanager.pas

@@ -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