paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2025-10-28 18:11:35 +01:00
Code Issues Packages Projects Releases Wiki Activity

OpkMan: Rename PackageFile to LazarusPackage in type and variable names.

Browse Source 
git-svn-id: trunk@54419 -
This commit is contained in:
juha 2017-03-16 17:49:39 +00:00
parent 8631eaec16
commit 1a173eeae9
9 changed files with 434 additions and 427 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
components/onlinepackagemanager/frames/opkman_createrepositorypackagefr.pas
View File

@ -906,7 +906,7 @@ var
JSON: TJSONStringType; JSON: TJSONStringType;
Ms: TMemoryStream; Ms: TMemoryStream;
UpdatePackage: TUpdatePackage; UpdatePackage: TUpdatePackage;
UpdatePackageFiles: TUpdatePackageFiles; UpdateLazPkgs: TUpdateLazPackages;
begin begin
Result := False; Result := False;
pnMessage.Caption := rsCreateRepositoryPackageFrm_Message6; pnMessage.Caption := rsCreateRepositoryPackageFrm_Message6;
@ -927,11 +927,11 @@ begin
if FVSTPackages.CheckState[Node] = csCheckedNormal then if FVSTPackages.CheckState[Node] = csCheckedNormal then
begin begin
Data := FVSTPackages.GetNodeData(Node); Data := FVSTPackages.GetNodeData(Node);
UpdatePackageFiles := TUpdatePackageFiles(UpdatePackage.UpdatePackageFiles.Add); UpdateLazPkgs := TUpdateLazPackages(UpdatePackage.UpdateLazPackages.Add);
UpdatePackageFiles.Name := Data^.FName; UpdateLazPkgs.Name := Data^.FName;
UpdatePackageFiles.Version := Data^.FVersionAsString; UpdateLazPkgs.Version := Data^.FVersionAsString;
UpdatePackageFiles.ForceNotify := False; UpdateLazPkgs.ForceNotify := False;
UpdatePackageFiles.InternalVersion := 1; UpdateLazPkgs.InternalVersion := 1;
end; end;
Node := FVSTPackages.GetNextSibling(Node); Node := FVSTPackages.GetNextSibling(Node);
end; end;
@ -961,7 +961,7 @@ function TCreateRepositoryPackagefr.CreateJSON(var AErrMsg: String): Boolean;
var var
SerializablePackages: TSerializablePackages; SerializablePackages: TSerializablePackages;
Package: TPackage; Package: TPackage;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
RootNode, Node: PVirtualNode; RootNode, Node: PVirtualNode;
RootData, Data: PData; RootData, Data: PData;
JSON: TJSONStringType; JSON: TJSONStringType;
@ -995,20 +995,20 @@ begin
if FVSTPackages.CheckState[Node] = csCheckedNormal then if FVSTPackages.CheckState[Node] = csCheckedNormal then
begin begin
Data := FVSTPackages.GetNodeData(Node); Data := FVSTPackages.GetNodeData(Node);
PackageFile := TPackageFile(Package.PackageFiles.Add); LazarusPkg := TLazarusPackage(Package.LazarusPackages.Add);
PackageFile.Name := Data^.FName; LazarusPkg.Name := Data^.FName;
PackageFile.PackageRelativePath := Data^.FPackageRelativePath; LazarusPkg.PackageRelativePath := Data^.FPackageRelativePath;
PackageFile.Version := TPackageVersion.Create; LazarusPkg.Version := TPackageVersion.Create;
PackageFile.Version.AsString := Data^.FVersionAsString; LazarusPkg.Version.AsString := Data^.FVersionAsString;
PackageFile.Description := Data^.FDescription; LazarusPkg.Description := Data^.FDescription;
PackageFile.Author := Data^.FAuthor; LazarusPkg.Author := Data^.FAuthor;
PackageFile.LazCompatibility := Data^.FLazCompatibility; LazarusPkg.LazCompatibility := Data^.FLazCompatibility;
PackageFile.FPCCompatibility := Data^.FFPCCompatibility; LazarusPkg.FPCCompatibility := Data^.FFPCCompatibility;
PackageFile.SupportedWidgetSet := Data^.FSupportedWidgetSet; LazarusPkg.SupportedWidgetSet := Data^.FSupportedWidgetSet;
PackageFile.PackageType := Data^.FPackageType; LazarusPkg.PackageType := Data^.FPackageType;
PackageFile.Dependencies := TPackageDependencies.Create(TPackageDependency); LazarusPkg.Dependencies := TPackageDependencies.Create(TPackageDependency);
PackageFile.Dependencies.SetDependenciesAsString(Data^.FDependenciesAsString); LazarusPkg.Dependencies.SetDependenciesAsString(Data^.FDependenciesAsString);
PackageFile.License := Data^.FLicense; LazarusPkg.License := Data^.FLicense;
end; end;
Node := FVSTPackages.GetNextSibling(Node); Node := FVSTPackages.GetNextSibling(Node);
end; end;
@ -1038,7 +1038,7 @@ end;
procedure TCreateRepositoryPackagefr.DoOnZipCompleted(Sender: TObject); procedure TCreateRepositoryPackagefr.DoOnZipCompleted(Sender: TObject);
var var
ErrMsg: String; ErrMsg, JsonUpd: String;
begin begin
ErrMsg := ''; ErrMsg := '';
if not CreateJSON(ErrMsg) then if not CreateJSON(ErrMsg) then
@ -1074,9 +1074,11 @@ begin
Uploader.OnUploadError := @DoOnUploadError; Uploader.OnUploadError := @DoOnUploadError;
Uploader.OnUploadCompleted := @DoOnUploadCompleted; Uploader.OnUploadCompleted := @DoOnUploadCompleted;
if cbJSONForUpdates.Checked then if cbJSONForUpdates.Checked then
Uploader.StartUpload(cSubmitURL_Zip, cSubmitURL_JSON, FPackageFile, FDestDir + FPackageName + '.json', FDestDir + 'update_' + FPackageName + '.json') JsonUpd := FDestDir + 'update_' + FPackageName + '.json'
else else
Uploader.StartUpload(cSubmitURL_Zip, cSubmitURL_JSON, FPackageFile, FDestDir + FPackageName + '.json', '') JsonUpd := '';
Uploader.StartUpload(cSubmitURL_Zip, cSubmitURL_JSON, FPackageFile,
FDestDir + FPackageName + '.json', JsonUpd);
end; end;
end; end;
end; end;

2
components/onlinepackagemanager/opkman_const.pas
View File

@ -65,7 +65,7 @@ resourcestring
//main form //main form
rsPackagesFound = '(%s packages found)'; rsPackagesFound = '(%s packages found)';
rsMainFrm_VSTHeaderColumn_PackageName = 'Packages'; rsMainFrm_VSTHeaderColumn_PackageName = 'Packages';
rsMainFrm_VSTHeaderColumn_PackageFile = 'Package file (.lpk)'; rsMainFrm_VSTHeaderColumn_LazarusPackage = 'Lazarus Package (.lpk)';
rsMainFrm_VSTHeaderColumn_Repository = 'Repository'; rsMainFrm_VSTHeaderColumn_Repository = 'Repository';
rsMainFrm_VSTHeaderColumn_Installed = 'Installed'; rsMainFrm_VSTHeaderColumn_Installed = 'Installed';
rsMainFrm_VSTHeaderColumn_Update = 'Update'; rsMainFrm_VSTHeaderColumn_Update = 'Update';

38
components/onlinepackagemanager/opkman_createjsonforupdates.pas
View File

@ -184,8 +184,8 @@ end;
procedure TCreateJSONForUpdatesFrm.bCreateClick(Sender: TObject); procedure TCreateJSONForUpdatesFrm.bCreateClick(Sender: TObject);
var var
UpdatePackage: TUpdatePackage; UpdatePkg: TUpdatePackage;
UpdatePackageFiles: TUpdatePackageFiles; UpdateLazPkgs: TUpdateLazPackages;
JSON: TJSONStringType; JSON: TJSONStringType;
Ms: TMemoryStream; Ms: TMemoryStream;
Node: PVirtualNode; Node: PVirtualNode;
@ -205,10 +205,10 @@ begin
SD.FileName := 'update_' + FPackage.Name; SD.FileName := 'update_' + FPackage.Name;
if SD.Execute then if SD.Execute then
begin begin
UpdatePackage := TUpdatePackage.Create; UpdatePkg := TUpdatePackage.Create;
try try
UpdatePackage.UpdatePackageData.Name := FPackage.Name; UpdatePkg.UpdatePackageData.Name := FPackage.Name;
UpdatePackage.UpdatePackageData.DownloadZipURL := edLinkToZip.Text; UpdatePkg.UpdatePackageData.DownloadZipURL := edLinkToZip.Text;
Node := FVST.GetFirst; Node := FVST.GetFirst;
while Assigned(Node) do while Assigned(Node) do
@ -216,16 +216,16 @@ begin
if FVST.CheckState[Node] = csCheckedNormal then if FVST.CheckState[Node] = csCheckedNormal then
begin begin
Data := FVST.GetNodeData(Node); Data := FVST.GetNodeData(Node);
UpdatePackageFiles := TUpdatePackageFiles(UpdatePackage.UpdatePackageFiles.Add); UpdateLazPkgs := TUpdateLazPackages(UpdatePkg.UpdateLazPackages.Add);
UpdatePackageFiles.Name := Data^.FName; UpdateLazPkgs.Name := Data^.FName;
UpdatePackageFiles.Version := Data^.FVersion; UpdateLazPkgs.Version := Data^.FVersion;
UpdatePackageFiles.ForceNotify := Data^.FForceNotify; UpdateLazPkgs.ForceNotify := Data^.FForceNotify;
UpdatePackageFiles.InternalVersion := Data^.FInternalVersion; UpdateLazPkgs.InternalVersion := Data^.FInternalVersion;
end; end;
Node := FVST.GetNext(Node); Node := FVST.GetNext(Node);
end; end;
JSON := ''; JSON := '';
if UpdatePackage.SaveToJSON(JSON) then if UpdatePkg.SaveToJSON(JSON) then
begin begin
JSON := StringReplace(JSON, '\/', '/', [rfReplaceAll]); JSON := StringReplace(JSON, '\/', '/', [rfReplaceAll]);
Ms := TMemoryStream.Create; Ms := TMemoryStream.Create;
@ -241,11 +241,11 @@ begin
end end
else else
begin begin
ErrMsg := StringReplace(UpdatePackage.LastError, '"', '', [rfReplaceAll]); ErrMsg := StringReplace(UpdatePkg.LastError, '"', '', [rfReplaceAll]);
MessageDlgEx(rsCreateJSONForUpdatesFrm_Error1 + sLineBreak + '"' + ErrMsg + '"', mtError, [mbOk], Self); MessageDlgEx(rsCreateJSONForUpdatesFrm_Error1 + sLineBreak + '"' + ErrMsg + '"', mtError, [mbOk], Self);
end; end;
finally finally
UpdatePackage.Free; UpdatePkg.Free;
end; end;
end; end;
if CanClose then if CanClose then
@ -340,7 +340,7 @@ var
I, J: Integer; I, J: Integer;
Node: PVirtualNode; Node: PVirtualNode;
Data: PData; Data: PData;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
for I := 0 to SerializablePackages.Count - 1 do for I := 0 to SerializablePackages.Count - 1 do
begin begin
@ -348,17 +348,17 @@ begin
if FPackage.Checked then if FPackage.Checked then
begin begin
Caption := Caption + ' "' + FPackage.DisplayName +'"'; Caption := Caption + ' "' + FPackage.DisplayName +'"';
for J := 0 to FPackage.PackageFiles.Count - 1 do for J := 0 to FPackage.LazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(FPackage.PackageFiles.Items[J]); LazarusPkg := TLazarusPackage(FPackage.LazarusPackages.Items[J]);
if PackageFile.Checked then if LazarusPkg.Checked then
begin begin
Node := FVST.AddChild(nil); Node := FVST.AddChild(nil);
Node^.CheckType := ctTriStateCheckBox; Node^.CheckType := ctTriStateCheckBox;
FVST.CheckState[Node] := csCheckedNormal; FVST.CheckState[Node] := csCheckedNormal;
Data := FVST.GetNodeData(Node); Data := FVST.GetNodeData(Node);
Data^.FName := PackageFile.Name; Data^.FName := LazarusPkg.Name;
Data^.FVersion := PackageFile.VersionAsString; Data^.FVersion := LazarusPkg.VersionAsString;
Data^.FForceNotify := False; Data^.FForceNotify := False;
Data^.FInternalVersion := 1; Data^.FInternalVersion := 1;
Data^.FImageIndex := 1; Data^.FImageIndex := 1;

131
components/onlinepackagemanager/opkman_installer.pas
View File

@ -50,6 +50,7 @@ type
TOnPackageInstallProgress = procedure(Sender: TObject; ACnt, ATotCnt: Integer; APackgaName: String; AInstallMessage: TInstallMessage) of object; TOnPackageInstallProgress = procedure(Sender: TObject; ACnt, ATotCnt: Integer; APackgaName: String; AInstallMessage: TInstallMessage) of object;
TOnPackageInstallError = procedure(Sender: TObject; APackageName, AErrMsg: String) of object; TOnPackageInstallError = procedure(Sender: TObject; APackageName, AErrMsg: String) of object;
TOnPackageInstallCompleted = procedure(Sender: TObject; ANeedToRebuild: Boolean; AInstallStatus: TInstallStatus) of object; TOnPackageInstallCompleted = procedure(Sender: TObject; ANeedToRebuild: Boolean; AInstallStatus: TInstallStatus) of object;
TPackageInstaller = class TPackageInstaller = class
private private
FNeedToBreak: Boolean; FNeedToBreak: Boolean;
@ -59,18 +60,18 @@ type
FStarted: Boolean; FStarted: Boolean;
FInstallStatus: TInstallStatus; FInstallStatus: TInstallStatus;
FToInstall: TStringList; FToInstall: TStringList;
FPackageFileName: String; FFileName: String;
FUnresolvedPackageFileName: String; FUnresolvedFileName: String;
FOnPackageInstallProgress: TOnPackageInstallProgress; FOnPackageInstallProgress: TOnPackageInstallProgress;
FOnPackageInstallError: TOnPackageInstallError; FOnPackageInstallError: TOnPackageInstallError;
FOnPackageInstallCompleted: TOnPackageInstallCompleted; FOnPackageInstallCompleted: TOnPackageInstallCompleted;
function OpenPackage(const APackageFileName: String): TIDEPackage; function OpenPackage(const AFileName: String): TIDEPackage;
function IsPackageInTheList(const APackageFileName: String): Boolean; function IsPackageInTheList(const AFileName: String): Boolean;
function HasUnresolvedDependency(AName: String): Boolean; function HasUnresolvedDependency(AName: String): Boolean;
function CompilePackage(const AIDEPackage: TIDEPackage; APackageFile: TPackageFile): Integer; function CompilePackage(const AIDEPackage: TIDEPackage; ALazarusPkg: TLazarusPackage): Integer;
function InstallPackage: Boolean; function InstallPackage: Boolean;
procedure DoOnPackageInstallProgress(const AInstallMessage: TInstallMessage; APackageFile: TPackageFile); procedure DoOnPackageInstallProgress(const AInstallMessage: TInstallMessage; ALazarusPkg: TLazarusPackage);
procedure DoOnPackageInstallError(const AInstallMessage: TInstallMessage; APackageFile: TPackageFile); procedure DoOnPackageInstallError(const AInstallMessage: TInstallMessage; ALazarusPkg: TLazarusPackage);
procedure Execute; procedure Execute;
public public
constructor Create; constructor Create;
@ -102,16 +103,16 @@ begin
inherited Destroy; inherited Destroy;
end; end;
function TPackageInstaller.OpenPackage(const APackageFileName: String): TIDEPackage; function TPackageInstaller.OpenPackage(const AFileName: String): TIDEPackage;
var var
I: Integer; I: Integer;
begin begin
Result := nil; Result := nil;
if PackageEditingInterface.DoOpenPackageFile(APackageFileName, [pofRevert, pofDoNotOpenEditor], True) = mrOk then if PackageEditingInterface.DoOpenPackageFile(AFileName, [pofRevert, pofDoNotOpenEditor], True) = mrOk then
begin begin
for I := 0 to PackageEditingInterface.GetPackageCount - 1 do for I := 0 to PackageEditingInterface.GetPackageCount - 1 do
begin begin
if UpperCase(PackageEditingInterface.GetPackages(I).Filename) = UpperCase(APackageFileName) then if UpperCase(PackageEditingInterface.GetPackages(I).Filename) = UpperCase(AFileName) then
begin begin
Result := PackageEditingInterface.GetPackages(I); Result := PackageEditingInterface.GetPackages(I);
Break; Break;
@ -120,20 +121,20 @@ begin
end; end;
end; end;
function TPackageInstaller.IsPackageInTheList(const APackageFileName: String): Boolean; function TPackageInstaller.IsPackageInTheList(const AFileName: String): Boolean;
var var
P, I: Integer; P, I: Integer;
PackageFileName: String; PkgFileName: String;
begin begin
Result := False; Result := False;
for I := 0 to FToInstall.Count - 1 do for I := 0 to FToInstall.Count - 1 do
begin begin
P := Pos(' ', FToInstall.Strings[I]); P := Pos(' ', FToInstall.Strings[I]);
if P <> 0 then if P <> 0 then
PackageFileName := Copy(FToInstall.Strings[I], 1, P - 1) PkgFileName := Copy(FToInstall.Strings[I], 1, P - 1)
else else
PackageFileName := FToInstall.Strings[I]; PkgFileName := FToInstall.Strings[I];
if UpperCase(PackageFileName) = UpperCase(APackageFileName) then if UpperCase(PkgFileName) = UpperCase(AFileName) then
begin begin
Result := True; Result := True;
Break; Break;
@ -149,23 +150,23 @@ begin
P := Pos(' ', AName); P := Pos(' ', AName);
if P > 0 then if P > 0 then
begin begin
FPackageFileName := Copy(AName, 1, P - 1); FFileName := Copy(AName, 1, P - 1);
Delete(AName, 1, P); Delete(AName, 1, P);
FUnresolvedPackageFileName := Trim(AName); FUnresolvedFileName := Trim(AName);
Result := True; Result := True;
end end
else else
FPackageFileName := AName; FFileName := AName;
end; end;
function TPackageInstaller.CompilePackage(const AIDEPackage: TIDEPackage; function TPackageInstaller.CompilePackage(const AIDEPackage: TIDEPackage;
APackageFile: TPackageFile): Integer; ALazarusPkg: TLazarusPackage): Integer;
begin begin
Result := -1; Result := -1;
{$if declared(lcl_version)} {$if declared(lcl_version)}
{$if (lcl_major > 0) and (lcl_minor > 6)} {$if (lcl_major > 0) and (lcl_minor > 6)}
//DoCompilePackage function is only available with Laz 1.7 + //DoCompilePackage function is only available with Laz 1.7 +
DoOnPackageInstallProgress(imCompilePackage, APackageFile); DoOnPackageInstallProgress(imCompilePackage, ALazarusPkg);
Result := PackageEditingInterface.DoCompilePackage(AIDEPackage, [pcfCleanCompile, pcfDoNotSaveEditorFiles], False); Result := PackageEditingInterface.DoCompilePackage(AIDEPackage, [pcfCleanCompile, pcfDoNotSaveEditorFiles], False);
{$endif} {$endif}
{$endif} {$endif}
@ -178,10 +179,10 @@ var
NewPackageID: TLazPackageID; NewPackageID: TLazPackageID;
begin begin
Result := False; Result := False;
P := Pos('.lpk', FPackageFileName); P := Pos('.lpk', FFileName);
if P <> 0 then if P <> 0 then
begin begin
PackageName := Copy(FPackageFileName, 1, P - 1); PackageName := Copy(FFileName, 1, P - 1);
NewPackageID := TLazPackageID.Create; NewPackageID := TLazPackageID.Create;
if NewPackageID.StringToID(PackageName) then if NewPackageID.StringToID(PackageName) then
begin begin
@ -192,18 +193,18 @@ begin
end; end;
procedure TPackageInstaller.DoOnPackageInstallProgress(const AInstallMessage: TInstallMessage; procedure TPackageInstaller.DoOnPackageInstallProgress(const AInstallMessage: TInstallMessage;
APackageFile: TPackageFile); ALazarusPkg: TLazarusPackage);
begin begin
if AInstallMessage = imPackageCompleted then if AInstallMessage = imPackageCompleted then
APackageFile.PackageStates := APackageFile.PackageStates + [psInstalled]; ALazarusPkg.PackageStates := ALazarusPkg.PackageStates + [psInstalled];
if Assigned(FOnPackageInstallProgress) then if Assigned(FOnPackageInstallProgress) then
FOnPackageInstallProgress(Self, FCnt, FTotCnt, FPackageFileName, AInstallMessage); FOnPackageInstallProgress(Self, FCnt, FTotCnt, FFileName, AInstallMessage);
if AInstallMessage <> imPackageCompleted then if AInstallMessage <> imPackageCompleted then
Sleep(1000); Sleep(1000);
end; end;
procedure TPackageInstaller.DoOnPackageInstallError(const AInstallMessage: TInstallMessage; procedure TPackageInstaller.DoOnPackageInstallError(const AInstallMessage: TInstallMessage;
APackageFile: TPackageFile); ALazarusPkg: TLazarusPackage);
var var
ErrMsg: String; ErrMsg: String;
begin begin
@ -215,12 +216,12 @@ begin
imInstallPackageError: imInstallPackageError:
ErrMsg := rsProgressFrm_Error9; ErrMsg := rsProgressFrm_Error9;
imDependencyError: imDependencyError:
ErrMsg := Format(rsProgressFrm_Error4, [FUnresolvedPackageFileName]); ErrMsg := Format(rsProgressFrm_Error4, [FUnresolvedFileName]);
end; end;
APackageFile.PackageStates := APackageFile.PackageStates - [psInstalled]; ALazarusPkg.PackageStates := ALazarusPkg.PackageStates - [psInstalled];
APackageFile.PackageStates := APackageFile.PackageStates + [psError]; ALazarusPkg.PackageStates := ALazarusPkg.PackageStates + [psError];
if Assigned(FOnPackageInstallError) then if Assigned(FOnPackageInstallError) then
FOnPackageInstallError(Self, FPackageFileName, ErrMsg); FOnPackageInstallError(Self, FFileName, ErrMsg);
Sleep(1000); Sleep(1000);
end; end;
@ -230,7 +231,7 @@ var
IDEPackage: TIDEPackage; IDEPackage: TIDEPackage;
PkgInstallInIDEFlags: TPkgInstallInIDEFlags; PkgInstallInIDEFlags: TPkgInstallInIDEFlags;
ErrCnt: Integer; ErrCnt: Integer;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
CanGo: Boolean; CanGo: Boolean;
CompRes: Integer; CompRes: Integer;
begin begin
@ -242,63 +243,63 @@ begin
if NeedToBreak then if NeedToBreak then
Break; Break;
CanGo := not HasUnresolvedDependency(FToInstall.Strings[I]); CanGo := not HasUnresolvedDependency(FToInstall.Strings[I]);
PackageFile := SerializablePackages.FindPackageFile(FPackageFileName); LazarusPkg := SerializablePackages.FindLazarusPackage(FFileName);
if CanGo then if CanGo then
begin begin
Inc(FCnt); Inc(FCnt);
if not FNeedToRebuild then if not FNeedToRebuild then
FNeedToRebuild := PackageFile.PackageType in [ptRunAndDesignTime, ptDesigntime]; FNeedToRebuild := LazarusPkg.PackageType in [ptRunAndDesignTime, ptDesigntime];
DoOnPackageInstallProgress(imOpenPackage, PackageFile); DoOnPackageInstallProgress(imOpenPackage, LazarusPkg);
IDEPackage := OpenPackage(PackageFile.PackageAbsolutePath); IDEPackage := OpenPackage(LazarusPkg.PackageAbsolutePath);
if IDEPackage <> nil then if IDEPackage <> nil then
begin begin
DoOnPackageInstallProgress(imOpenPackageSuccess, PackageFile); DoOnPackageInstallProgress(imOpenPackageSuccess, LazarusPkg);
CompRes := CompilePackage(IDEPAckage, PackageFile); CompRes := CompilePackage(IDEPAckage, LazarusPkg);
case CompRes of case CompRes of
-1, 1: -1, 1:
begin begin
if CompRes = 1 then if CompRes = 1 then
begin begin
DoOnPackageInstallProgress(imCompilePackageSuccess, PackageFile); DoOnPackageInstallProgress(imCompilePackageSuccess, LazarusPkg);
if PackageAction = paUpdate then if PackageAction = paUpdate then
if PackageFile.ForceNotify then if LazarusPkg.ForceNotify then
if PackageFile.InternalVersion > PackageFile.InternalVersionOld then if LazarusPkg.InternalVersion > LazarusPkg.InternalVersionOld then
PackageFile.InternalVersionOld := PackageFile.InternalVersion; LazarusPkg.InternalVersionOld := LazarusPkg.InternalVersion;
end; end;
if PackageFile.PackageType in [ptRunAndDesignTime, ptDesigntime] then if LazarusPkg.PackageType in [ptRunAndDesignTime, ptDesigntime] then
begin begin
DoOnPackageInstallProgress(imInstallPackage, PackageFile); DoOnPackageInstallProgress(imInstallPackage, LazarusPkg);
if InstallPackage then if InstallPackage then
DoOnPackageInstallProgress(imInstallpackageSuccess, PackageFile) DoOnPackageInstallProgress(imInstallpackageSuccess, LazarusPkg)
else else
begin begin
Inc(ErrCnt); Inc(ErrCnt);
DoOnPackageInstallError(imInstallPackageError, PackageFile); DoOnPackageInstallError(imInstallPackageError, LazarusPkg);
end; end;
end; end;
end; end;
else else
begin begin
Inc(ErrCnt); Inc(ErrCnt);
DoOnPackageInstallError(imCompilePackageError, PackageFile); DoOnPackageInstallError(imCompilePackageError, LazarusPkg);
end; end;
end; end;
end end
else else
begin begin
Inc(ErrCnt); Inc(ErrCnt);
DoOnPackageInstallError(imOpenPackageError, PackageFile); DoOnPackageInstallError(imOpenPackageError, LazarusPkg);
end; end;
DoOnPackageInstallProgress(imPackageCompleted, PackageFile); DoOnPackageInstallProgress(imPackageCompleted, LazarusPkg);
end end
else else
begin begin
Inc(FCnt); Inc(FCnt);
DoOnPackageInstallProgress(imOpenPackage, PackageFile); DoOnPackageInstallProgress(imOpenPackage, LazarusPkg);
DoOnPackageInstallProgress(imOpenPackageSuccess, PackageFile); DoOnPackageInstallProgress(imOpenPackageSuccess, LazarusPkg);
Inc(ErrCnt); Inc(ErrCnt);
DoOnPackageInstallError(imDependencyError, PackageFile); DoOnPackageInstallError(imDependencyError, LazarusPkg);
DoOnPackageInstallProgress(imPackageCompleted, PackageFile); DoOnPackageInstallProgress(imPackageCompleted, LazarusPkg);
end; end;
end; end;
if InstallPackageList.Count > 0 then if InstallPackageList.Count > 0 then
@ -323,7 +324,7 @@ procedure TPackageInstaller.StartInstall;
var var
I, J, K: Integer; I, J, K: Integer;
PackageList: TObjectList; PackageList: TObjectList;
PackageFile, DependecyPackage: TPackageFile; LazarusPkg, DependecyPackage: TLazarusPackage;
PackageDependency: TPackageDependency; PackageDependency: TPackageDependency;
DependencyFound: Boolean; DependencyFound: Boolean;
begin begin
@ -335,24 +336,26 @@ begin
try try
for I := 0 to SerializablePackages.Count - 1 do for I := 0 to SerializablePackages.Count - 1 do
begin begin
for J := 0 to SerializablePackages.Items[I].PackageFiles.Count - 1 do for J := 0 to SerializablePackages.Items[I].LazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(SerializablePackages.Items[I].PackageFiles.Items[J]); LazarusPkg := TLazarusPackage(SerializablePackages.Items[I].LazarusPackages.Items[J]);
if PackageFile.IsInstallable then if LazarusPkg.IsInstallable then
begin begin
SerializablePackages.GetPackageDependencies(PackageFile.Name, PackageList, True, True); SerializablePackages.GetPackageDependencies(LazarusPkg.Name, PackageList, True, True);
if PackageList.Count > 0 then if PackageList.Count > 0 then
begin begin
DependencyFound := True; DependencyFound := True;
for K := 0 to PackageList.Count - 1 do for K := 0 to PackageList.Count - 1 do
begin begin
PackageDependency := TPackageDependency(PackageList.Items[K]); PackageDependency := TPackageDependency(PackageList.Items[K]);
DependecyPackage := SerializablePackages.FindPackageFile(TPackageDependency(PackageList.Items[k]).PackageFileName + '.lpk'); DependecyPackage := SerializablePackages.FindLazarusPackage(PackageDependency.PkgFileName + '.lpk');
if DependecyPackage <> nil then if DependecyPackage <> nil then
begin begin
if not ((DependecyPackage.PackageState = psInstalled) and (SerializablePackages.IsInstalledVersionOk(PackageDependency, DependecyPackage.VersionAsString))) then if not ((DependecyPackage.PackageState = psInstalled)
and (SerializablePackages.IsInstalledVersionOk(PackageDependency, DependecyPackage.VersionAsString))) then
begin begin
if ((DependecyPackage.IsInstallable) and (SerializablePackages.IsDependencyOk(PackageDependency, DependecyPackage))) then if ((DependecyPackage.IsInstallable)
and (SerializablePackages.IsDependencyOk(PackageDependency, DependecyPackage))) then
begin begin
if not IsPackageInTheList(DependecyPackage.Name) then if not IsPackageInTheList(DependecyPackage.Name) then
FToInstall.Add(DependecyPackage.Name); FToInstall.Add(DependecyPackage.Name);
@ -367,12 +370,12 @@ begin
end; end;
if (not DependencyFound) then if (not DependencyFound) then
begin begin
if (not IsPackageInTheList(PackageFile.Name)) then if (not IsPackageInTheList(LazarusPkg.Name)) then
FToInstall.Add(PackageFile.Name + ' ' + DependecyPackage.Name) FToInstall.Add(LazarusPkg.Name + ' ' + DependecyPackage.Name)
end end
end; end;
if (not IsPackageInTheList(PackageFile.Name)) then if (not IsPackageInTheList(LazarusPkg.Name)) then
FToInstall.Add(PackageFile.Name); FToInstall.Add(LazarusPkg.Name);
end; end;
end; end;
end; end;

14
components/onlinepackagemanager/opkman_mainfrm.pas
View File

@ -394,19 +394,19 @@ procedure TMainFrm.DoOnUpdate(Sender: TObject);
var var
I, J: Integer; I, J: Integer;
Package: TPackage; Package: TPackage;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
VisualTree.UpdatePackageUStatus; VisualTree.UpdatePackageUStatus;
// Pass the online package info as package links to IDE. // Pass the online package info as package links to IDE.
for I := 0 to SerializablePackages.Count - 1 do for I := 0 to SerializablePackages.Count - 1 do
begin begin
Package := SerializablePackages.Items[I]; Package := SerializablePackages.Items[I];
for J := 0 to Package.PackageFiles.Count - 1 do for J := 0 to Package.LazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(Package.PackageFiles.Items[J]); LazarusPkg := TLazarusPackage(Package.LazarusPackages.Items[J]);
//DebugLn(['OPM DoOnUpdate: Package.Name=', Package.Name, //DebugLn(['OPM DoOnUpdate: Package.Name=', Package.Name,
// ', Package.DisplayName=', Package.DisplayName]); // ', Package.DisplayName=', Package.DisplayName]);
PkgLinks.AddOnlineLink(Package.DownloadZipURL, Package.Name, PackageFile.Version); PkgLinks.AddOnlineLink(Package.DownloadZipURL, Package.Name, LazarusPkg.Version);
end; end;
end; end;
end; end;
@ -954,7 +954,7 @@ begin
begin begin
Data := VisualTree.VST.GetNodeData(Node); Data := VisualTree.VST.GetNodeData(Node);
if (Data^.DataType = 2) then if (Data^.DataType = 2) then
SL.Add(Data^.PackageFileName); SL.Add(Data^.LazarusPackageName);
end; end;
Node := VisualTree.VST.GetNext(Node); Node := VisualTree.VST.GetNext(Node);
end; end;
@ -991,7 +991,7 @@ begin
while Node <> nil do while Node <> nil do
begin begin
Data := VisualTree.VST.GetNodeData(Node); Data := VisualTree.VST.GetNodeData(Node);
if UpperCase(Trim(Data^.PackageFileName)) = UpperCase(Trim(SL.Strings[I])) then if UpperCase(Trim(Data^.LazarusPackageName)) = UpperCase(Trim(SL.Strings[I])) then
begin begin
VisualTree.VST.CheckState[Node] := csCheckedNormal; VisualTree.VST.CheckState[Node] := csCheckedNormal;
Inc(CheckCount); Inc(CheckCount);
@ -1084,7 +1084,7 @@ begin
cbFilterBy.Clear; cbFilterBy.Clear;
cbFilterBy.Items.Add(rsMainFrm_VSTHeaderColumn_PackageName); cbFilterBy.Items.Add(rsMainFrm_VSTHeaderColumn_PackageName);
cbFilterBy.Items.Add(rsMainFrm_VSTHeaderColumn_PackageFile); cbFilterBy.Items.Add(rsMainFrm_VSTHeaderColumn_LazarusPackage);
cbFilterBy.Items.Add(rsMainFrm_VSTText_PackageCategory); cbFilterBy.Items.Add(rsMainFrm_VSTText_PackageCategory);
cbFilterBy.Items.Add(rsMainFrm_VSTText_PackageStatus); cbFilterBy.Items.Add(rsMainFrm_VSTText_PackageStatus);
cbFilterBy.Items.Add(rsMainFrm_VSTText_Version); cbFilterBy.Items.Add(rsMainFrm_VSTText_Version);

10
components/onlinepackagemanager/opkman_packagelistfrm.pas
View File

@ -130,7 +130,7 @@ var
I, J: Integer; I, J: Integer;
Node: PVirtualNode; Node: PVirtualNode;
Data: PData; Data: PData;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
ChkCnt, InvCnt: Integer; ChkCnt, InvCnt: Integer;
begin begin
SetupControls(ATyp); SetupControls(ATyp);
@ -140,14 +140,14 @@ begin
begin begin
if ATyp = 0 then if ATyp = 0 then
begin begin
for J := 0 to SerializablePackages.Items[I].PackageFiles.Count - 1 do for J := 0 to SerializablePackages.Items[I].LazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(SerializablePackages.Items[I].PackageFiles.Items[J]); LazarusPkg := TLazarusPackage(SerializablePackages.Items[I].LazarusPackages.Items[J]);
if (PackageFile.Checked) and (psInstalled in PackageFile.PackageStates) then if (LazarusPkg.Checked) and (psInstalled in LazarusPkg.PackageStates) then
begin begin
Node := FVST.AddChild(nil); Node := FVST.AddChild(nil);
Data := FVST.GetNodeData(Node); Data := FVST.GetNodeData(Node);
Data^.FName := PackageFile.Name + '(' + PackageFile.InstalledFileVersion + ')'; Data^.FName := LazarusPkg.Name + '(' + LazarusPkg.InstalledFileVersion + ')';
Data^.FImageIndex := 1; Data^.FImageIndex := 1;
end; end;
end; end;

370
components/onlinepackagemanager/opkman_serializablepackages.pas
View File

@ -84,7 +84,7 @@ type
private private
FMaxVersion: TPackageVersion; FMaxVersion: TPackageVersion;
FMinVersion: TPackageVersion; FMinVersion: TPackageVersion;
FPackageFileName: String; FPkgFileName: String;
procedure SetMinVersion(const AValue: TPackageVersion); procedure SetMinVersion(const AValue: TPackageVersion);
procedure SetMaxVersion(const AValue: TPackageVersion); procedure SetMaxVersion(const AValue: TPackageVersion);
public public
@ -92,7 +92,7 @@ type
constructor Create(ACollection: TCollection); override; constructor Create(ACollection: TCollection); override;
destructor Destroy; override; destructor Destroy; override;
published published
property PackageFileName: String read FPackageFileName write FPackageFileName; property PkgFileName: String read FPkgFileName write FPkgFileName;
property MinVersion: TPackageVersion read FMinVersion write SetMinVersion; property MinVersion: TPackageVersion read FMinVersion write SetMinVersion;
property MaxVersion: TPackageVersion read FMaxVersion write SetMaxVersion; property MaxVersion: TPackageVersion read FMaxVersion write SetMaxVersion;
end; end;
@ -109,8 +109,9 @@ type
property Dependencies[AIndex: Integer]: TPackageDependency read GetDependency write SetDependency; default; property Dependencies[AIndex: Integer]: TPackageDependency read GetDependency write SetDependency; default;
end; end;
{ TPackageFile } { TLazarusPackage }
TPackageFile = class(TCollectionItem)
TLazarusPackage = class(TCollectionItem)
private private
FName: String; FName: String;
FDescription: String; FDescription: String;
@ -202,14 +203,14 @@ type
FIsDirZipped: Boolean; FIsDirZipped: Boolean;
FZippedBaseDir: String; FZippedBaseDir: String;
FRating: Integer; FRating: Integer;
FPackageFiles: TCollection; FLazarusPackages: TCollection;
function GetDownloadable: Boolean; function GetDownloadable: Boolean;
function GetExtractable: Boolean; function GetExtractable: Boolean;
public public
constructor Create; reintroduce; constructor Create; reintroduce;
destructor Destroy; override; destructor Destroy; override;
procedure ChangePackageStates(const AChangeType: TChangeType; APackageState: TPackageState); procedure ChangePackageStates(const AChangeType: TChangeType; APackageState: TPackageState);
function FindPackageFile(const APackageFileName: String): TPackageFile; function FindLazarusPackage(const APackageName: String): TLazarusPackage;
public public
property PackageStates: TPackageStates read FPackageStates; property PackageStates: TPackageStates read FPackageStates;
property PackageState: TPackageState read FPackageState; property PackageState: TPackageState read FPackageState;
@ -232,7 +233,7 @@ type
property RepositoryFileHash: String read FRepositoryFileHash write FRepositoryFileHash; property RepositoryFileHash: String read FRepositoryFileHash write FRepositoryFileHash;
property RepositoryDate: TDate read FRepositoryDate write FRepositoryDate; property RepositoryDate: TDate read FRepositoryDate write FRepositoryDate;
property PackageBaseDir: String read FPackageBaseDir write FPackageBaseDir; property PackageBaseDir: String read FPackageBaseDir write FPackageBaseDir;
property PackageFiles: TCollection read FPackageFiles write FPackageFiles; property LazarusPackages: TCollection read FLazarusPackages write FLazarusPackages;
property HomePageURL: String read FHomePageURL write FHomePageURL; property HomePageURL: String read FHomePageURL write FHomePageURL;
property DownloadURL: String read FDownloadURL write FDownloadURL; property DownloadURL: String read FDownloadURL write FDownloadURL;
property SVNURL: String read FSVNURL write FSVNURL; property SVNURL: String read FSVNURL write FSVNURL;
@ -252,15 +253,15 @@ type
function GetInstallCount: Integer; function GetInstallCount: Integer;
function GetItem(const AIndex: Integer): TPackage; function GetItem(const AIndex: Integer): TPackage;
procedure SetItem(const AIndex: Integer; const APackage: TPackage); procedure SetItem(const AIndex: Integer; const APackage: TPackage);
procedure DoGetPackageDependencies(const APackageFileName: String; ASL: TStringList; ALevel: Integer); procedure DoGetPackageDependencies(const APkgFileName: String; ASL: TStringList; ALevel: Integer);
function JSONToPackageData(const APackageData: TJSONData; var APackage: TPackage): Boolean; function JSONToPackageData(const APackageData: TJSONData; var APackage: TPackage): Boolean;
function JSONToPackageFiles(const APackageData: TJSONData; var APackage: TPackage): Boolean; function JSONToLazarusPackages(const APackageData: TJSONData; var APackage: TPackage): Boolean;
function PackageDataToJSON(APackage: TPackage; var APackageData: TJSONObject): Boolean; function PackageDataToJSON(APackage: TPackage; var APackageData: TJSONObject): Boolean;
function PackageFilesToJSON(APackage: TPackage; var APackageFiles: TJSONArray): Boolean; function LazarusPackagesToJSON(APackage: TPackage; var ALazarusPkgsArr: TJSONArray): Boolean;
function IsPackageDownloaded(const APackage: TPackage): Boolean; function IsPackageDownloaded(const APackage: TPackage): Boolean;
function IsPackageExtracted(const APackage: TPackage): Boolean; function IsPackageExtracted(const APackage: TPackage): Boolean;
function IsPackageInstalled(const APackageFile: TPackageFile; const APackageBaseDir: String): Boolean; function IsPackageInstalled(const ALazarusPkg: TLazarusPackage; const APackageBaseDir: String): Boolean;
function IsAtLeastOnePackageFileInstalled(const APackage: TPackage): Boolean; function AtLeastOneLazPkgInstalled(const APackage: TPackage): Boolean;
function GetPackageVersion(const APath: String): String; function GetPackageVersion(const APath: String): String;
function GetPackageDescription(const APath: String): String; function GetPackageDescription(const APath: String): String;
function GetPackageLicense(const APath: String): String; function GetPackageLicense(const APath: String): String;
@ -273,15 +274,15 @@ type
procedure DeletePackage(const AIndex: Integer); procedure DeletePackage(const AIndex: Integer);
function FindPackage(const AValue: String; const AFindPackageBy: TFindPackageBy): TPackage; function FindPackage(const AValue: String; const AFindPackageBy: TFindPackageBy): TPackage;
function FindPackageIndex(const AValue: String; const AFindPackageBy: TFindPackageBy): Integer; function FindPackageIndex(const AValue: String; const AFindPackageBy: TFindPackageBy): Integer;
function FindPackageFile(const APackageFileName: String): TPackageFile; function FindLazarusPackage(const APackageName: String): TLazarusPackage;
function JSONToPackages(JSON: TJSONStringType): Boolean; function JSONToPackages(JSON: TJSONStringType): Boolean;
function PackagesToJSON(var JSON: TJSONStringType): Boolean; function PackagesToJSON(var JSON: TJSONStringType): Boolean;
procedure GetPackageDependencies(const APackageFileName: String; List: TObjectList; Recurse, OnlyUnresolved: Boolean); procedure GetPackageDependencies(const APkgFileName: String; List: TObjectList; Recurse, OnlyUnresolved: Boolean);
procedure GetPackageStates; procedure GetPackageStates;
procedure RemoveErrorState; procedure RemoveErrorState;
procedure MarkRuntimePackages; procedure MarkRuntimePackages;
function Cleanup: Integer; function Cleanup: Integer;
function IsDependencyOk(PackageDependency: TPackageDependency; DependencyPackage: TPackageFile): Boolean; function IsDependencyOk(PackageDependency: TPackageDependency; DependencyPackage: TLazarusPackage): Boolean;
function IsInstalledVersionOk(PackageDependency: TPackageDependency; InstalledVersion: String): Boolean; function IsInstalledVersionOk(PackageDependency: TPackageDependency; InstalledVersion: String): Boolean;
function GetPackageInstallState(const APackage: TPackage): Integer; overload; function GetPackageInstallState(const APackage: TPackage): Integer; overload;
procedure DeleteDownloadedZipFiles; procedure DeleteDownloadedZipFiles;
@ -321,7 +322,7 @@ begin
if ASource is TPackageDependency then if ASource is TPackageDependency then
begin begin
Source := ASource as TPackageDependency; Source := ASource as TPackageDependency;
FPackageFileName := Source.PackageFileName; FPkgFileName := Source.PkgFileName;
if Assigned(Source.MinVersion) then if Assigned(Source.MinVersion) then
FMinVersion.Assign(Source.MinVersion); FMinVersion.Assign(Source.MinVersion);
if Assigned(Source.MaxVersion) then if Assigned(Source.MaxVersion) then
@ -385,9 +386,9 @@ begin
MaxVer := '(' + Dependencies[I].FMaxVersion.AsString + ')' MaxVer := '(' + Dependencies[I].FMaxVersion.AsString + ')'
end; end;
if Result = '' then if Result = '' then
Result := Dependencies[I].PackageFileName + MinVer + MaxVer Result := Dependencies[I].PkgFileName + MinVer + MaxVer
else else
Result := Result + ', ' + Dependencies[I].PackageFileName + MinVer + MaxVer; Result := Result + ', ' + Dependencies[I].PkgFileName + MinVer + MaxVer;
end; end;
end; end;
@ -415,28 +416,28 @@ begin
P2 := Pos(')', Str); P2 := Pos(')', Str);
if (P1 <> 0) and (P2 <> 0) then if (P1 <> 0) and (P2 <> 0) then
begin begin
PackageDependency.PackageFileName := Trim(Copy(Str, 1, P1 - 1)); PackageDependency.PkgFileName := Trim(Copy(Str, 1, P1 - 1));
PackageDependency.FMinVersion.AsString := Trim(Copy(Str, P1 + 1, P2 - P1 - 1)); PackageDependency.FMinVersion.AsString := Trim(Copy(Str, P1 + 1, P2 - P1 - 1));
System.Delete(Str, 1, P2); System.Delete(Str, 1, P2);
if Length(Trim(Str)) > 0 then if Length(Trim(Str)) > 0 then
PackageDependency.FMaxVersion.AsString := Trim(Copy(Str, 2, Length(Str) - 2)); PackageDependency.FMaxVersion.AsString := Trim(Copy(Str, 2, Length(Str) - 2));
end end
else else
PackageDependency.PackageFileName := Trim(Str); PackageDependency.PkgFileName := Trim(Str);
end; end;
finally finally
SL.Free; SL.Free;
end; end;
end; end;
{ TPackageFile } { TLazarusPackage }
function TPackageFile.GetVersionAsString: String; function TLazarusPackage.GetVersionAsString: String;
begin begin
Result := FVersion.AsString; Result := FVersion.AsString;
end; end;
procedure TPackageFile.SetVersionAsString(const AValue: String); procedure TLazarusPackage.SetVersionAsString(const AValue: String);
begin begin
if not Assigned(FVersion) then if not Assigned(FVersion) then
begin begin
@ -447,12 +448,12 @@ begin
FVersionAsString := AValue; FVersionAsString := AValue;
end; end;
function TPackageFile.GetDependenciesAsString: String; function TLazarusPackage.GetDependenciesAsString: String;
begin begin
Result := FDependencies.GetDependenciesAsString(False); Result := FDependencies.GetDependenciesAsString(False);
end; end;
procedure TPackageFile.SetDependenciesAsString(const AValue: String); procedure TLazarusPackage.SetDependenciesAsString(const AValue: String);
begin begin
if not Assigned(FDependencies) then if not Assigned(FDependencies) then
begin begin
@ -462,7 +463,7 @@ begin
FDependenciesAsString := AValue; FDependenciesAsString := AValue;
end; end;
function TPackageFile.GetInstallable: Boolean; function TLazarusPackage.GetInstallable: Boolean;
begin begin
case PackageAction of case PackageAction of
paDownloadTo: paDownloadTo:
@ -474,7 +475,7 @@ begin
end; end;
end; end;
constructor TPackageFile.Create; constructor TLazarusPackage.Create;
begin begin
FVersion := TPackageVersion.Create; FVersion := TPackageVersion.Create;
FVersion.Clear; FVersion.Clear;
@ -482,7 +483,7 @@ begin
FDependencies := TPackageDependencies.Create(TPackageDependency); FDependencies := TPackageDependencies.Create(TPackageDependency);
end; end;
destructor TPackageFile.Destroy; destructor TLazarusPackage.Destroy;
begin begin
if Assigned(FVersion) then if Assigned(FVersion) then
FreeAndNil(FVersion); FreeAndNil(FVersion);
@ -520,17 +521,17 @@ end;
constructor TPackage.Create; constructor TPackage.Create;
begin begin
FPackageFiles := TCollection.Create(TPackageFile); FLazarusPackages := TCollection.Create(TLazarusPackage);
end; end;
destructor TPackage.Destroy; destructor TPackage.Destroy;
var var
I: Integer; I: Integer;
begin begin
FPackageFiles.Clear; FLazarusPackages.Clear;
for I := FPackageFiles.Count - 1 downto 0 do for I := FLazarusPackages.Count - 1 downto 0 do
FPackageFiles.Items[I].Free; FLazarusPackages.Items[I].Free;
FPackageFiles.Free; FLazarusPackages.Free;
inherited Destroy; inherited Destroy;
end; end;
@ -538,7 +539,7 @@ procedure TPackage.ChangePackageStates(const AChangeType: TChangeType;
APackageState: TPackageState); APackageState: TPackageState);
var var
I: Integer; I: Integer;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
if APackageState = psInstalled then if APackageState = psInstalled then
Exit; Exit;
@ -547,38 +548,36 @@ begin
ctAdd: ctAdd:
begin begin
FPackageStates := FPackageStates + [APackageState]; FPackageStates := FPackageStates + [APackageState];
for I := 0 to PackageFiles.Count - 1 do for I := 0 to LazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(PackageFiles.Items[I]); LazarusPkg := TLazarusPackage(LazarusPackages.Items[I]);
PackageFile.PackageStates := PackageFile.PackageStates + [APackageState]; LazarusPkg.PackageStates := LazarusPkg.PackageStates + [APackageState];
PackageFile.PackageState := APackageState; LazarusPkg.PackageState := APackageState;
end; end;
end; end;
ctRemove: ctRemove:
begin begin
FPackageStates := FPackageStates - [APackageState]; FPackageStates := FPackageStates - [APackageState];
for I := 0 to PackageFiles.Count - 1 do for I := 0 to LazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(PackageFiles.Items[I]); LazarusPkg := TLazarusPackage(LazarusPackages.Items[I]);
PackageFile.PackageStates := PackageFile.PackageStates - [APackageState]; LazarusPkg.PackageStates := LazarusPkg.PackageStates - [APackageState];
end; end;
end; end;
end; end;
end; end;
function TPackage.FindPackageFile(const APackageFileName: String): TPackageFile; function TPackage.FindLazarusPackage(const APackageName: String): TLazarusPackage;
var var
I: Integer; I: Integer;
begin begin
Result := nil; for I := 0 to FLazarusPackages.Count - 1 do
for I := 0 to FPackageFiles.Count - 1 do
begin begin
if UpperCase(TPackageFile(FPackageFiles.Items[I]).Name) = UpperCase(APackageFileName) then Result := TLazarusPackage(FLazarusPackages.Items[I]);
begin if UpperCase(Result.Name) = UpperCase(APackageName) then
Result := TPackageFile(FPackageFiles.Items[I]); Exit;
Break;
end;
end; end;
Result := nil;
end; end;
{ TSerializablePackages } { TSerializablePackages }
@ -635,8 +634,8 @@ var
begin begin
Result := 0; Result := 0;
for I := 0 to Count - 1 do for I := 0 to Count - 1 do
for J := 0 to Items[I].FPackageFiles.Count - 1 do for J := 0 to Items[I].FLazarusPackages.Count - 1 do
if TPackageFile(Items[I].FPackageFiles.Items[J]).IsInstallable then if TLazarusPackage(Items[I].FLazarusPackages.Items[J]).IsInstallable then
Inc(Result); Inc(Result);
end; end;
@ -656,27 +655,27 @@ begin
FPackages.Items[AIndex] := TPackage(APackage); FPackages.Items[AIndex] := TPackage(APackage);
end; end;
procedure TSerializablePackages.DoGetPackageDependencies( procedure TSerializablePackages.DoGetPackageDependencies(const APkgFileName: String;
const APackageFileName: String; ASL: TStringList; ALevel: Integer); ASL: TStringList; ALevel: Integer);
var var
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
D2, D1: TPackageDependency; D2, D1: TPackageDependency;
I, J: Integer; I, J: Integer;
begin begin
if (ALevel > 10) then if (ALevel > 10) then
Exit; Exit;
PackageFile := FindPackageFile(APackageFileName); LazarusPkg := FindLazarusPackage(APkgFileName);
if PackageFile = nil then if LazarusPkg = nil then
Exit; Exit;
for I := 0 to PackageFile.Dependencies.Count - 1 do for I := 0 to LazarusPkg.Dependencies.Count - 1 do
begin begin
D1 := PackageFile.Dependencies[I]; D1 := LazarusPkg.Dependencies[I];
J := ASL.IndexOf(APackageFileName); J := ASL.IndexOf(APkgFileName);
If J = -1 then If J = -1 then
begin begin
D2 := TPackageDependency.Create(nil); D2 := TPackageDependency.Create(nil);
D2.Assign(D1); D2.Assign(D1);
ASL.AddObject(D2.PackageFileName, D2); ASL.AddObject(D2.PkgFileName, D2);
end end
else else
begin begin
@ -685,7 +684,7 @@ begin
D2.MinVersion.Assign(D1.MinVersion); D2.MinVersion.Assign(D1.MinVersion);
end; end;
if (ALevel >= 0) and (J = -1) Then if (ALevel >= 0) and (J = -1) Then
DoGetPackageDependencies(D2.PackageFileName, ASL, ALevel + 1); DoGetPackageDependencies(D2.PkgFileName, ASL, ALevel + 1);
end; end;
end; end;
@ -701,7 +700,7 @@ begin
Exit; Exit;
end; end;
Result := TPackage(FPackages.Add); Result := TPackage(FPackages.Add);
Result.FPackageFiles := TCollection.Create(TPackageFile); Result.FLazarusPackages := TCollection.Create(TLazarusPackage);
Result.Name := AName; Result.Name := AName;
end; end;
@ -755,18 +754,18 @@ begin
end; end;
function TSerializablePackages.FindPackageFile(const APackageFileName: String): TPackageFile; function TSerializablePackages.FindLazarusPackage(const APackageName: String): TLazarusPackage;
var var
I, J: Integer; I, J: Integer;
begin begin
Result := nil; Result := nil;
for I := 0 to Count - 1 do for I := 0 to Count - 1 do
begin begin
for J := 0 to Items[I].FPackageFiles.Count - 1 do for J := 0 to Items[I].FLazarusPackages.Count - 1 do
begin begin
if UpperCase(TPackageFile(Items[I].FPackageFiles.Items[J]).Name) = UpperCase(APackageFileName) then if UpperCase(TLazarusPackage(Items[I].FLazarusPackages.Items[J]).Name) = UpperCase(APackageName) then
begin begin
Result := TPackageFile(Items[I].FPackageFiles.Items[J]); Result := TLazarusPackage(Items[I].FLazarusPackages.Items[J]);
Break; Break;
end; end;
end; end;
@ -805,45 +804,45 @@ begin
end; end;
end; end;
function TSerializablePackages.JSONToPackageFiles(const APackageData: TJSONData; function TSerializablePackages.JSONToLazarusPackages(const APackageData: TJSONData;
var APackage: TPackage): Boolean; var APackage: TPackage): Boolean;
var var
PackageFiles: TJSONArray; LazarusPkgsArr: TJSONArray;
PackageFilesObject: TJSONObject; LazarusPkgsObj: TJSONObject;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
I: Integer; I: Integer;
begin begin
Result := True; Result := True;
try try
PackageFiles := TJSONArray(APackageData); LazarusPkgsArr := TJSONArray(APackageData);
APackage.PackageFiles := TCollection.Create(TPackageFile); APackage.LazarusPackages := TCollection.Create(TLazarusPackage);
for I := 0 to PackageFiles.Count - 1 do for I := 0 to LazarusPkgsArr.Count - 1 do
begin begin
if PackageFiles.Items[I].JSONType = jtObject then if LazarusPkgsArr.Items[I].JSONType = jtObject then
begin begin
PackageFilesObject := TJSONObject(PackageFiles.Items[I]); LazarusPkgsObj := TJSONObject(LazarusPkgsArr.Items[I]);
PackageFile := TPackageFile(APackage.PackageFiles.Add); LazarusPkg := TLazarusPackage(APackage.LazarusPackages.Add);
//need to change //need to change
PackageFile.Name := PackageFilesObject.Get('Name'); LazarusPkg.Name := LazarusPkgsObj.Get('Name');
PackageFile.Description := PackageFilesObject.Get('Description'); LazarusPkg.Description := LazarusPkgsObj.Get('Description');
PackageFile.Author := PackageFilesObject.Get('Author'); LazarusPkg.Author := LazarusPkgsObj.Get('Author');
PackageFile.License := PackageFilesObject.Get('License'); LazarusPkg.License := LazarusPkgsObj.Get('License');
PackageFile.PackageRelativePath := PackageFilesObject.Get('RelativeFilePath'); LazarusPkg.PackageRelativePath := LazarusPkgsObj.Get('RelativeFilePath');
if PackageFile.PackageRelativePath <> '' then if LazarusPkg.PackageRelativePath <> '' then
PackageFile.PackageRelativePath := StringReplace(PackageFile.PackageRelativePath, '\/', PathDelim, [rfReplaceAll]); LazarusPkg.PackageRelativePath := StringReplace(LazarusPkg.PackageRelativePath, '\/', PathDelim, [rfReplaceAll]);
PackageFile.VersionAsString := PackageFilesObject.Get('VersionAsString'); LazarusPkg.VersionAsString := LazarusPkgsObj.Get('VersionAsString');
PackageFile.LazCompatibility := PackageFilesObject.Get('LazCompatibility'); LazarusPkg.LazCompatibility := LazarusPkgsObj.Get('LazCompatibility');
PackageFile.FPCCompatibility := PackageFilesObject.Get('FPCCompatibility'); LazarusPkg.FPCCompatibility := LazarusPkgsObj.Get('FPCCompatibility');
PackageFile.SupportedWidgetSet := PackageFilesObject.Get('SupportedWidgetSet'); LazarusPkg.SupportedWidgetSet := LazarusPkgsObj.Get('SupportedWidgetSet');
PackageFile.PackageType := TPackageType(PackageFilesObject.Get('PackageType')); LazarusPkg.PackageType := TPackageType(LazarusPkgsObj.Get('PackageType'));
PackageFile.DependenciesAsString := PackageFilesObject.Get('DependenciesAsString'); LazarusPkg.DependenciesAsString := LazarusPkgsObj.Get('DependenciesAsString');
end; end;
end; end;
except except
on E: Exception do on E: Exception do
begin begin
Result := False; Result := False;
FlastError := '"' + PackageFile.Name + '": ' + E.Message; FlastError := '"' + LazarusPkg.Name + '": ' + E.Message;
end; end;
end; end;
end; end;
@ -882,7 +881,7 @@ begin
end end
else if Data.Items[I].JSONType = jtArray then else if Data.Items[I].JSONType = jtArray then
begin begin
if not JSONToPackageFiles(Data.Items[I], Package) then if not JSONToLazarusPackages(Data.Items[I], Package) then
Result := False; Result := False;
end; end;
end; end;
@ -900,46 +899,46 @@ begin
end; end;
end; end;
function TSerializablePackages.PackageFilesToJSON(APackage: TPackage; function TSerializablePackages.LazarusPackagesToJSON(APackage: TPackage;
var APackageFiles: TJSONArray): Boolean; var ALazarusPkgsArr: TJSONArray): Boolean;
var var
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
PackageFileObject: TJSONObject; LazarusPkgObj: TJSONObject;
I: Integer; I: Integer;
PackageRelativePath: String; RelPath: String;
begin begin
Result := True; Result := True;
try try
APackageFiles := TJSONArray.Create; ALazarusPkgsArr := TJSONArray.Create;
for I := 0 to APackage.FPackageFiles.Count - 1 do for I := 0 to APackage.FLazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(APackage.FPackageFiles.Items[I]); LazarusPkg := TLazarusPackage(APackage.FLazarusPackages.Items[I]);
PackageFileObject := TJSONObject.Create; LazarusPkgObj := TJSONObject.Create;
//need to change //need to change
PackageFileObject.Add('Name', PackageFile.Name); LazarusPkgObj.Add('Name', LazarusPkg.Name);
PackageFileObject.Add('Description', PackageFile.Description); LazarusPkgObj.Add('Description', LazarusPkg.Description);
PackageFileObject.Add('Author', PackageFile.Author); LazarusPkgObj.Add('Author', LazarusPkg.Author);
PackageFileObject.Add('License', PackageFile.License); LazarusPkgObj.Add('License', LazarusPkg.License);
PackageRelativePath := PackageFile.PackageRelativePath; RelPath := LazarusPkg.PackageRelativePath;
if Trim(PackageRelativePath) <> '' then if Trim(RelPath) <> '' then
begin begin
PackageRelativePath := AppendPathDelim(PackageRelativePath); RelPath := AppendPathDelim(RelPath);
PackageRelativePath := StringReplace(PackageRelativePath, PathDelim, '\/', [rfReplaceAll]); RelPath := StringReplace(RelPath, PathDelim, '\/', [rfReplaceAll]);
end; end;
PackageFileObject.Add('RelativeFilePath', PackageRelativePath); LazarusPkgObj.Add('RelativeFilePath', RelPath);
PackageFileObject.Add('VersionAsString', PackageFile.VersionAsString); LazarusPkgObj.Add('VersionAsString', LazarusPkg.VersionAsString);
PackageFileObject.Add('LazCompatibility', PackageFile.LazCompatibility); LazarusPkgObj.Add('LazCompatibility', LazarusPkg.LazCompatibility);
PackageFileObject.Add('FPCCompatibility', PackageFile.FPCCompatibility); LazarusPkgObj.Add('FPCCompatibility', LazarusPkg.FPCCompatibility);
PackageFileObject.Add('SupportedWidgetSet', PackageFile.SupportedWidgetSet); LazarusPkgObj.Add('SupportedWidgetSet', LazarusPkg.SupportedWidgetSet);
PackageFileObject.Add('PackageType', Ord(PackageFile.PackageType)); LazarusPkgObj.Add('PackageType', Ord(LazarusPkg.PackageType));
PackageFileObject.Add('DependenciesAsString', PackageFile.DependenciesAsString); LazarusPkgObj.Add('DependenciesAsString', LazarusPkg.DependenciesAsString);
APackageFiles.Add(PackageFileObject); ALazarusPkgsArr.Add(LazarusPkgObj);
end; end;
except except
on E: Exception do on E: Exception do
begin begin
Result := False; Result := False;
FlastError := '"' + PackageFile.Name + '": ' + E.Message; FlastError := '"' + LazarusPkg.Name + '": ' + E.Message;
end; end;
end; end;
end; end;
@ -957,15 +956,15 @@ end;
function TSerializablePackages.IsPackageExtracted(const APackage: TPackage): Boolean; function TSerializablePackages.IsPackageExtracted(const APackage: TPackage): Boolean;
var var
I: Integer; I: Integer;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
Result := True; Result := True;
for I := 0 to APackage.FPackageFiles.Count - 1 do for I := 0 to APackage.FLazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(APackage.FPackageFiles.Items[I]); LazarusPkg := TLazarusPackage(APackage.FLazarusPackages.Items[I]);
PackageFile.FPackageAbsolutePath := Options.LocalRepositoryPackages + APackage.PackageBaseDir LazarusPkg.FPackageAbsolutePath := Options.LocalRepositoryPackages + APackage.PackageBaseDir
+ PackageFile.FPackageRelativePath + PackageFile.Name; + LazarusPkg.FPackageRelativePath + LazarusPkg.Name;
if not FileExists(PackageFile.FPackageAbsolutePath) then if not FileExists(LazarusPkg.FPackageAbsolutePath) then
begin begin
Result := False; Result := False;
Break; Break;
@ -1035,7 +1034,7 @@ begin
end; end;
function TSerializablePackages.IsPackageInstalled(const APackageFile: TPackageFile; function TSerializablePackages.IsPackageInstalled(const ALazarusPkg: TLazarusPackage;
const APackageBaseDir: String): Boolean; const APackageBaseDir: String): Boolean;
function CheckIDEPackages: Boolean; function CheckIDEPackages: Boolean;
@ -1049,17 +1048,17 @@ function TSerializablePackages.IsPackageInstalled(const APackageFile: TPackageFi
for I := 0 to PackageCnt - 1 do for I := 0 to PackageCnt - 1 do
begin begin
Package := PackageEditingInterface.GetPackages(I); Package := PackageEditingInterface.GetPackages(I);
if ExtractFileName(Package.FileName) = APackageFile.Name then if ExtractFileName(Package.FileName) = ALazarusPkg.Name then
begin begin
APackageFile.InstalledFileName := Package.Filename; ALazarusPkg.InstalledFileName := Package.Filename;
APackageFile.InstalledFileVersion := IntToStr(Package.Version.Major) + '.' + ALazarusPkg.InstalledFileVersion := IntToStr(Package.Version.Major) + '.' +
IntToStr(Package.Version.Minor) + '.' + IntToStr(Package.Version.Minor) + '.' +
IntToStr(Package.Version.Release) + '.' + IntToStr(Package.Version.Release) + '.' +
IntToStr(Package.Version.Build); IntToStr(Package.Version.Build);
if FileExists(APackageFile.InstalledFileName) then if FileExists(ALazarusPkg.InstalledFileName) then
begin begin
APackageFile.InstalledFileDescription := GetPackageDescription(Package.Filename); ALazarusPkg.InstalledFileDescription := GetPackageDescription(Package.Filename);
APackageFile.InstalledFileLincese := GetPackageLicense(Package.Filename); ALazarusPkg.InstalledFileLincese := GetPackageLicense(Package.Filename);
end; end;
Result := True; Result := True;
Break; Break;
@ -1071,20 +1070,20 @@ var
FileName, RepoPath: String; FileName, RepoPath: String;
begin begin
Result := False; Result := False;
case APackageFile.PackageType of case ALazarusPkg.PackageType of
ptRunTime, ptRunTimeOnly: ptRunTime, ptRunTimeOnly:
begin begin
FileName := StringReplace(APackageFile.Name, '.lpk', '.opkman', [rfIgnoreCase]); FileName := StringReplace(ALazarusPkg.Name, '.lpk', '.opkman', [rfIgnoreCase]);
RepoPath := Options.LocalRepositoryPackages + APackageBaseDir + APackageFile.PackageRelativePath; RepoPath := Options.LocalRepositoryPackages + APackageBaseDir + ALazarusPkg.PackageRelativePath;
Result := (psExtracted in APackageFile.PackageStates) and FileExists(RepoPath + FileName); Result := (psExtracted in ALazarusPkg.PackageStates) and FileExists(RepoPath + FileName);
if Result then if Result then
begin begin
APackageFile.InstalledFileName := RepoPath + APackageFile.Name; ALazarusPkg.InstalledFileName := RepoPath + ALazarusPkg.Name;
if FileExists(APackageFile.InstalledFileName) then if FileExists(ALazarusPkg.InstalledFileName) then
begin begin
APackageFile.InstalledFileVersion := GetPackageVersion(APackageFile.InstalledFileName); ALazarusPkg.InstalledFileVersion := GetPackageVersion(ALazarusPkg.InstalledFileName);
APackageFile.InstalledFileDescription := GetPackageDescription(APackageFile.InstalledFileName); ALazarusPkg.InstalledFileDescription := GetPackageDescription(ALazarusPkg.InstalledFileName);
APackageFile.InstalledFileLincese := GetPackageLicense(APackageFile.InstalledFileName); ALazarusPkg.InstalledFileLincese := GetPackageLicense(ALazarusPkg.InstalledFileName);
end; end;
end end
else else
@ -1100,20 +1099,20 @@ end;
function TSerializablePackages.GetPackageInstallState(const APackage: TPackage): Integer; function TSerializablePackages.GetPackageInstallState(const APackage: TPackage): Integer;
var var
I: Integer; I: Integer;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
InstCnt: Integer; InstCnt: Integer;
begin begin
InstCnt := 0; InstCnt := 0;
for I := 0 to APackage.PackageFiles.Count - 1 do for I := 0 to APackage.LazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(APackage.PackageFiles.Items[I]); LazarusPkg := TLazarusPackage(APackage.LazarusPackages.Items[I]);
if IsPackageInstalled(PackageFile, APackage.PackageBaseDir) then if IsPackageInstalled(LazarusPkg, APackage.PackageBaseDir) then
Inc(InstCnt); Inc(InstCnt);
end; end;
case InstCnt of case InstCnt of
0: Result := 0; 0: Result := 0;
1..High(Integer): 1..High(Integer):
if InstCnt < APackage.PackageFiles.Count then if InstCnt < APackage.LazarusPackages.Count then
Result := 2 Result := 2
else else
Result := 1; Result := 1;
@ -1159,25 +1158,25 @@ function TSerializablePackages.PackagesToJSON(var JSON: TJSONStringType): Boolea
var var
PackageObject: TJSONObject; PackageObject: TJSONObject;
PackageData: TJSONObject; PackageData: TJSONObject;
PackageFiles: TJSONArray; LazarusPkgsArr: TJSONArray;
I: Integer; I: Integer;
Package: TPackage; Package: TPackage;
begin begin
Result := True; Result := True;
PackageObject := TJSONObject.Create; PackageObject := TJSONObject.Create;
try try
PackageFiles := nil; LazarusPkgsArr := nil;
PackageData := nil; PackageData := nil;
try try
for I := 0 to FPackages.Count - 1 do for I := 0 to FPackages.Count - 1 do
begin begin
Package := TPackage(FPackages.Items[I]); Package := TPackage(FPackages.Items[I]);
if not PackageFilesToJSON(Package, PackageFiles) then if not LazarusPackagesToJSON(Package, LazarusPkgsArr) then
Result := False; Result := False;
if not PackageDataToJSON(Package, PackageData) then if not PackageDataToJSON(Package, PackageData) then
Result := False; Result := False;
PackageObject.Add('PackageData' + IntToStr(I), PackageData); PackageObject.Add('PackageData' + IntToStr(I), PackageData);
PackageObject.Add('PackageFiles' + IntToStr(I), PackageFiles); PackageObject.Add('PackageFiles' + IntToStr(I), LazarusPkgsArr);
end; end;
if Result then if Result then
JSON := PackageObject.FormatJSON(DefaultFormat, DefaultIndentSize); JSON := PackageObject.FormatJSON(DefaultFormat, DefaultIndentSize);
@ -1189,34 +1188,34 @@ begin
end; end;
end; end;
procedure TSerializablePackages.GetPackageDependencies(const APackageFileName: String; procedure TSerializablePackages.GetPackageDependencies(const APkgFileName: String;
List: TObjectList; Recurse, OnlyUnresolved: Boolean); List: TObjectList; Recurse, OnlyUnresolved: Boolean);
var var
SL: TStringList; SL: TStringList;
I, J: Integer; I, J: Integer;
PackageFileName: String; PackageName: String;
Installed: Boolean; Installed: Boolean;
Package: TIDEPackage; IDEPackage: TIDEPackage;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
SL := TStringList.Create; SL := TStringList.Create;
try try
SL.Sorted := True; SL.Sorted := True;
DoGetPackageDependencies(APackageFileName, SL, Ord(Recurse) - 1); DoGetPackageDependencies(APkgFileName, SL, Ord(Recurse) - 1);
if OnlyUnresolved then if OnlyUnresolved then
begin begin
for I := SL.Count - 1 downto 0 do for I := SL.Count - 1 downto 0 do
begin begin
PackageFileName := TPackageDependency(SL.Objects[I]).PackageFileName + '.lpk'; PackageName := TPackageDependency(SL.Objects[I]).PkgFileName + '.lpk';
Installed := False; Installed := False;
for J := 0 to PackageEditingInterface.GetPackageCount - 1 do for J := 0 to PackageEditingInterface.GetPackageCount - 1 do
begin begin
Package := PackageEditingInterface.GetPackages(J); IDEPackage := PackageEditingInterface.GetPackages(J);
if UpperCase(ExtractFileName(Package.Filename)) = UpperCase(PackageFileName) then if UpperCase(ExtractFileName(IDEPackage.Filename)) = UpperCase(PackageName) then
begin begin
PackageFile := FindPackageFile(PackageFileName); LazarusPkg := FindLazarusPackage(PackageName);
if PackageFile <> nil then if LazarusPkg <> nil then
Installed := IsInstalledVersionOk(TPackageDependency(SL.Objects[I]), PackageFile.InstalledFileVersion) Installed := IsInstalledVersionOk(TPackageDependency(SL.Objects[I]), LazarusPkg.InstalledFileVersion)
else else
Installed := True; Installed := True;
Break; Break;
@ -1239,7 +1238,7 @@ end;
procedure TSerializablePackages.GetPackageStates; procedure TSerializablePackages.GetPackageStates;
var var
I, J: Integer; I, J: Integer;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
for I := 0 to Count - 1 do for I := 0 to Count - 1 do
begin begin
@ -1257,16 +1256,16 @@ begin
else else
Items[I].ChangePackageStates(ctRemove, psExtracted); Items[I].ChangePackageStates(ctRemove, psExtracted);
for J := 0 to Items[I].FPackageFiles.Count - 1 do for J := 0 to Items[I].FLazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(Items[I].FPackageFiles.Items[J]); LazarusPkg := TLazarusPackage(Items[I].FLazarusPackages.Items[J]);
if IsPackageInstalled(PackageFile, Items[I].PackageBaseDir) then if IsPackageInstalled(LazarusPkg, Items[I].PackageBaseDir) then
begin begin
PackageFile.PackageStates := PackageFile.PackageStates + [psInstalled]; LazarusPkg.PackageStates := LazarusPkg.PackageStates + [psInstalled];
PackageFile.PackageState := psInstalled; LazarusPkg.PackageState := psInstalled;
end end
else else
PackageFile.PackageStates := PackageFile.PackageStates - [psInstalled]; LazarusPkg.PackageStates := LazarusPkg.PackageStates - [psInstalled];
end; end;
end; end;
end; end;
@ -1274,14 +1273,18 @@ end;
procedure TSerializablePackages.RemoveErrorState; procedure TSerializablePackages.RemoveErrorState;
var var
I, J: Integer; I, J: Integer;
LazarusPkg: TLazarusPackage;
begin begin
for I := 0 to Count - 1 do for I := 0 to Count - 1 do
begin begin
if psError in Items[I].PackageStates then if psError in Items[I].PackageStates then
Items[I].ChangePackageStates(ctRemove, psError); Items[I].ChangePackageStates(ctRemove, psError);
for J := 0 to Items[I].FPackageFiles.Count - 1 do for J := 0 to Items[I].FLazarusPackages.Count - 1 do
if psError in TPackageFile(Items[I].FPackageFiles.Items[J]).PackageStates then begin
TPackageFile(Items[I].FPackageFiles.Items[J]).PackageStates := TPackageFile(Items[I].FPackageFiles.Items[J]).PackageStates - [psError]; LazarusPkg := TLazarusPackage(Items[I].FLazarusPackages.Items[J]);
//if psError in LazarusPkg.PackageStates then
LazarusPkg.PackageStates := LazarusPkg.PackageStates - [psError];
end;
end; end;
end; end;
@ -1289,34 +1292,33 @@ procedure TSerializablePackages.MarkRuntimePackages;
var var
I, J: Integer; I, J: Integer;
FileName: String; FileName: String;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
for I := 0 to Count - 1 do for I := 0 to Count - 1 do
begin begin
for J := 0 to Items[I].FPackageFiles.Count - 1 do for J := 0 to Items[I].FLazarusPackages.Count - 1 do
begin begin
PackageFile := TPackageFile(Items[I].FPackageFiles.Items[J]); LazarusPkg := TLazarusPackage(Items[I].FLazarusPackages.Items[J]);
if (PackageFile.Checked) and if (LazarusPkg.Checked) and
(psInstalled in PackageFile.PackageStates) and (psInstalled in LazarusPkg.PackageStates) and
(not (psError in PackageFile.PackageStates)) and (not (psError in LazarusPkg.PackageStates)) and
(PackageFile.PackageType in [ptRunTime, ptRunTimeOnly]) then (LazarusPkg.PackageType in [ptRunTime, ptRunTimeOnly]) then
begin begin
FileName := StringReplace(PackageFile.Name, '.lpk', '.opkman', [rfIgnoreCase]); FileName := StringReplace(LazarusPkg.Name, '.lpk', '.opkman', [rfIgnoreCase]);
FileCreate(Options.LocalRepositoryPackages + Items[I].PackageBaseDir + PackageFile.PackageRelativePath + FileName); FileCreate(Options.LocalRepositoryPackages + Items[I].PackageBaseDir + LazarusPkg.PackageRelativePath + FileName);
end; end;
end; end;
end; end;
end; end;
function TSerializablePackages.IsAtLeastOnePackageFileInstalled( function TSerializablePackages.AtLeastOneLazPkgInstalled(const APackage: TPackage): Boolean;
const APackage: TPackage): Boolean;
var var
I: Integer; I: Integer;
begin begin
Result := False; Result := False;
for I := 0 to APackage.PackageFiles.Count - 1 do for I := 0 to APackage.LazarusPackages.Count - 1 do
begin begin
if IsPackageInstalled(TPackageFile(APackage.FPackageFiles.Items[I]), APackage.PackageBaseDir) then if IsPackageInstalled(TLazarusPackage(APackage.FLazarusPackages.Items[I]), APackage.PackageBaseDir) then
begin begin
Result := True; Result := True;
Break; Break;
@ -1331,7 +1333,7 @@ begin
Result := 0; Result := 0;
for I := 0 to Count - 1 do for I := 0 to Count - 1 do
begin begin
if not IsAtLeastOnePackageFileInstalled(Items[I]) then if not AtLeastOneLazPkgInstalled(Items[I]) then
begin begin
if IsPackageDownloaded(Items[I]) then if IsPackageDownloaded(Items[I]) then
begin begin
@ -1420,7 +1422,7 @@ begin
end; end;
function TSerializablePackages.IsDependencyOk(PackageDependency: TPackageDependency; function TSerializablePackages.IsDependencyOk(PackageDependency: TPackageDependency;
DependencyPackage: TPackageFile): Boolean; DependencyPackage: TLazarusPackage): Boolean;
var var
MinVerOk: Boolean; MinVerOk: Boolean;
MaxVerOk: Boolean; MaxVerOk: Boolean;

120
components/onlinepackagemanager/opkman_updates.pas
View File

@ -44,9 +44,9 @@ const
type type
{ TUpdatePackageFiles } { TUpdateLazPackages }
TUpdatePackageFiles = class(TCollectionItem) TUpdateLazPackages = class(TCollectionItem)
private private
FName: String; FName: String;
FVersion: String; FVersion: String;
@ -81,7 +81,7 @@ type
TUpdatePackage = class(TPersistent) TUpdatePackage = class(TPersistent)
private private
FUpdatePackageData: TUpdatePackageData; FUpdatePackageData: TUpdatePackageData;
FUpdatePackageFiles: TCollection; FUpdateLazPackages: TCollection;
FLastError: String; FLastError: String;
procedure Clear; procedure Clear;
public public
@ -92,7 +92,7 @@ type
property LastError: String read FLastError; property LastError: String read FLastError;
published published
property UpdatePackageData: TUpdatePackageData read FUpdatePackageData write FUpdatePackageData; property UpdatePackageData: TUpdatePackageData read FUpdatePackageData write FUpdatePackageData;
property UpdatePackageFiles: TCollection read FUpdatePackageFiles write FUpdatePackageFiles; property UpdateLazPackages: TCollection read FUpdateLazPackages write FUpdateLazPackages;
end; end;
{ TUpdates } { TUpdates }
@ -143,15 +143,15 @@ var
I: Integer; I: Integer;
begin begin
FUpdatePackageData.Clear; FUpdatePackageData.Clear;
for I := FUpdatePackageFiles.Count - 1 downto 0 do for I := FUpdateLazPackages.Count - 1 downto 0 do
FUpdatePackageFiles.Items[I].Free; FUpdateLazPackages.Items[I].Free;
FUpdatePackageFiles.Clear; FUpdateLazPackages.Clear;
end; end;
constructor TUpdatePackage.Create; constructor TUpdatePackage.Create;
begin begin
FUpdatePackageData := TUpdatePackageData.Create; FUpdatePackageData := TUpdatePackageData.Create;
FUpdatePackageFiles := TCollection.Create(TUpdatePackageFiles); FUpdateLazPackages := TCollection.Create(TUpdateLazPackages);
end; end;
destructor TUpdatePackage.Destroy; destructor TUpdatePackage.Destroy;
@ -159,9 +159,9 @@ var
I: Integer; I: Integer;
begin begin
FUpdatePackageData.Free; FUpdatePackageData.Free;
for I := FUpdatePackageFiles.Count - 1 downto 0 do for I := FUpdateLazPackages.Count - 1 downto 0 do
FUpdatePackageFiles.Items[I].Free; FUpdateLazPackages.Items[I].Free;
FUpdatePackageFiles.Free; FUpdateLazPackages.Free;
inherited Destroy; inherited Destroy;
end; end;
@ -266,13 +266,13 @@ end;
procedure TUpdates.Load; procedure TUpdates.Load;
var var
PackageCount: Integer; PackageCount: Integer;
PackageFileCount: Integer; LazarusPkgCount: Integer;
I, J: Integer; I, J: Integer;
Path, SubPath: String; Path, SubPath: String;
PackageName: String; PackageName: String;
PackageFileName: String; LazarusPkgName: String;
Package: TPackage; Package: TPackage;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
HasUpdate: Boolean; HasUpdate: Boolean;
begin begin
if (not Assigned(SerializablePackages)) or (SerializablePackages.Count = 0) then if (not Assigned(SerializablePackages)) or (SerializablePackages.Count = 0) then
@ -291,25 +291,25 @@ begin
Package.DownloadZipURL := FXML.GetValue(Path + 'DownloadZipURL', ''); Package.DownloadZipURL := FXML.GetValue(Path + 'DownloadZipURL', '');
Package.DisableInOPM := FXML.GetValue(Path + 'DisableInOPM', False); Package.DisableInOPM := FXML.GetValue(Path + 'DisableInOPM', False);
Package.Rating := FXML.GetValue(Path + 'Rating', 0); Package.Rating := FXML.GetValue(Path + 'Rating', 0);
PackageFileCount := FXML.GetValue(Path + 'Count', 0); LazarusPkgCount := FXML.GetValue(Path + 'Count', 0);
for J := 0 to PackageFileCount - 1 do for J := 0 to LazarusPkgCount - 1 do
begin begin
SubPath := Path + 'PackageFile' + IntToStr(J) + '/'; SubPath := Path + 'PackageFile' + IntToStr(J) + '/';
PackageFileName := FXML.GetValue(SubPath + 'Name', ''); LazarusPkgName := FXML.GetValue(SubPath + 'Name', '');
PackageFile := Package.FindPackageFile(PackageFileName); LazarusPkg := Package.FindLazarusPackage(LazarusPkgName);
if PackageFile <> nil then if LazarusPkg <> nil then
begin begin
PackageFile.UpdateVersion := FXML.GetValue(SubPath + 'UpdateVersion', ''); LazarusPkg.UpdateVersion := FXML.GetValue(SubPath + 'UpdateVersion', '');
PackageFile.ForceNotify := FXML.GetValue(SubPath + 'ForceNotify', False); LazarusPkg.ForceNotify := FXML.GetValue(SubPath + 'ForceNotify', False);
PackageFile.InternalVersion := FXML.GetValue(SubPath + 'InternalVersion', 0);; LazarusPkg.InternalVersion := FXML.GetValue(SubPath + 'InternalVersion', 0);;
PackageFile.InternalVersionOld := FXML.GetValue(SubPath + 'InternalVersionOld', 0); LazarusPkg.InternalVersionOld := FXML.GetValue(SubPath + 'InternalVersionOld', 0);
PackageFile.HasUpdate := (PackageFile.UpdateVersion <> '') and (PackageFile.InstalledFileVersion <> '') and LazarusPkg.HasUpdate := (LazarusPkg.UpdateVersion <> '') and (LazarusPkg.InstalledFileVersion <> '') and
( (
((not PackageFile.ForceNotify) and (PackageFile.UpdateVersion > PackageFile.InstalledFileVersion)) or ((not LazarusPkg.ForceNotify) and (LazarusPkg.UpdateVersion > LazarusPkg.InstalledFileVersion)) or
((PackageFile.ForceNotify) and (PackageFile.InternalVersion > PackageFile.InternalVersionOld)) ((LazarusPkg.ForceNotify) and (LazarusPkg.InternalVersion > LazarusPkg.InternalVersionOld))
); );
if not HasUpdate then if not HasUpdate then
HasUpdate := PackageFile.HasUpdate; HasUpdate := LazarusPkg.HasUpdate;
end; end;
end; end;
Package.HasUpdate := HasUpdate; Package.HasUpdate := HasUpdate;
@ -323,7 +323,7 @@ var
I, J: Integer; I, J: Integer;
Path, SubPath: String; Path, SubPath: String;
Package: TPackage; Package: TPackage;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
if (not Assigned(SerializablePackages)) or (SerializablePackages.Count = 0) then if (not Assigned(SerializablePackages)) or (SerializablePackages.Count = 0) then
Exit; Exit;
@ -338,16 +338,16 @@ begin
FXML.SetDeleteValue(Path + 'DownloadZipURL', Package.DownloadZipURL, ''); FXML.SetDeleteValue(Path + 'DownloadZipURL', Package.DownloadZipURL, '');
FXML.SetDeleteValue(Path + 'DisableInOPM', Package.DisableInOPM, False); FXML.SetDeleteValue(Path + 'DisableInOPM', Package.DisableInOPM, False);
FXML.SetDeleteValue(Path + 'Rating', Package.Rating, 0); FXML.SetDeleteValue(Path + 'Rating', Package.Rating, 0);
FXML.SetDeleteValue(Path + 'Count', SerializablePackages.Items[I].PackageFiles.Count, 0); FXML.SetDeleteValue(Path + 'Count', SerializablePackages.Items[I].LazarusPackages.Count, 0);
for J := 0 to SerializablePackages.Items[I].PackageFiles.Count - 1 do for J := 0 to SerializablePackages.Items[I].LazarusPackages.Count - 1 do
begin begin
SubPath := Path + 'PackageFile' + IntToStr(J) + '/'; SubPath := Path + 'PackageFile' + IntToStr(J) + '/';
PackageFile := TPackageFile(SerializablePackages.Items[I].PackageFiles.Items[J]); LazarusPkg := TLazarusPackage(SerializablePackages.Items[I].LazarusPackages.Items[J]);
FXML.SetDeleteValue(SubPath + 'Name', PackageFile.Name, ''); FXML.SetDeleteValue(SubPath + 'Name', LazarusPkg.Name, '');
FXML.SetDeleteValue(SubPath + 'UpdateVersion', PackageFile.UpdateVersion, ''); FXML.SetDeleteValue(SubPath + 'UpdateVersion', LazarusPkg.UpdateVersion, '');
FXML.SetDeleteValue(SubPath + 'ForceNotify', PackageFile.ForceNotify, False); FXML.SetDeleteValue(SubPath + 'ForceNotify', LazarusPkg.ForceNotify, False);
FXML.SetDeleteValue(SubPath + 'InternalVersion', PackageFile.InternalVersion, 0); FXML.SetDeleteValue(SubPath + 'InternalVersion', LazarusPkg.InternalVersion, 0);
FXML.SetDeleteValue(SubPath + 'InternalVersionOld', PackageFile.InternalVersionOld, 0); FXML.SetDeleteValue(SubPath + 'InternalVersionOld', LazarusPkg.InternalVersionOld, 0);
end; end;
end; end;
FXML.Flush; FXML.Flush;
@ -357,26 +357,26 @@ procedure TUpdates.AssignPackageData(APackage: TPackage);
var var
I: Integer; I: Integer;
HasUpdate: Boolean; HasUpdate: Boolean;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
HasUpdate := False; HasUpdate := False;
APackage.DownloadZipURL := FUpdatePackage.FUpdatePackageData.DownloadZipURL; APackage.DownloadZipURL := FUpdatePackage.FUpdatePackageData.DownloadZipURL;
APackage.DisableInOPM := FUpdatePackage.FUpdatePackageData.DisableInOPM; APackage.DisableInOPM := FUpdatePackage.FUpdatePackageData.DisableInOPM;
for I := 0 to FUpdatePackage.FUpdatePackageFiles.Count - 1 do for I := 0 to FUpdatePackage.FUpdateLazPackages.Count - 1 do
begin begin
PackageFile := APackage.FindPackageFile(TUpdatePackageFiles(FUpdatePackage.FUpdatePackageFiles.Items[I]).Name); LazarusPkg := APackage.FindLazarusPackage(TUpdateLazPackages(FUpdatePackage.FUpdateLazPackages.Items[I]).Name);
if PackageFile <> nil then if LazarusPkg <> nil then
begin begin
PackageFile.UpdateVersion := TUpdatePackageFiles(FUpdatePackage.FUpdatePackageFiles.Items[I]).Version; LazarusPkg.UpdateVersion := TUpdateLazPackages(FUpdatePackage.FUpdateLazPackages.Items[I]).Version;
PackageFile.ForceNotify := TUpdatePackageFiles(FUpdatePackage.FUpdatePackageFiles.Items[I]).ForceNotify; LazarusPkg.ForceNotify := TUpdateLazPackages(FUpdatePackage.FUpdateLazPackages.Items[I]).ForceNotify;
PackageFile.InternalVersion := TUpdatePackageFiles(FUpdatePackage.FUpdatePackageFiles.Items[I]).InternalVersion; LazarusPkg.InternalVersion := TUpdateLazPackages(FUpdatePackage.FUpdateLazPackages.Items[I]).InternalVersion;
PackageFile.HasUpdate := (PackageFile.UpdateVersion <> '') and (PackageFile.InstalledFileVersion <> '') and LazarusPkg.HasUpdate := (LazarusPkg.UpdateVersion <> '') and (LazarusPkg.InstalledFileVersion <> '') and
( (
((not PackageFile.ForceNotify) and (PackageFile.UpdateVersion > PackageFile.InstalledFileVersion)) or ((not LazarusPkg.ForceNotify) and (LazarusPkg.UpdateVersion > LazarusPkg.InstalledFileVersion)) or
((PackageFile.ForceNotify) and (PackageFile.InternalVersion > PackageFile.InternalVersionOld)) ((LazarusPkg.ForceNotify) and (LazarusPkg.InternalVersion > LazarusPkg.InternalVersionOld))
); );
if not HasUpdate then if not HasUpdate then
HasUpdate := PackageFile.HasUpdate; HasUpdate := LazarusPkg.HasUpdate;
end; end;
end; end;
APackage.HasUpdate := HasUpdate; APackage.HasUpdate := HasUpdate;
@ -385,21 +385,21 @@ end;
procedure TUpdates.ResetPackageData(APackage: TPackage); procedure TUpdates.ResetPackageData(APackage: TPackage);
var var
I: Integer; I: Integer;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
APackage.DownloadZipURL := ''; APackage.DownloadZipURL := '';
APackage.DisableInOPM := False; APackage.DisableInOPM := False;
APackage.HasUpdate := False; APackage.HasUpdate := False;
for I := 0 to APackage.PackageFiles.Count - 1 do for I := 0 to APackage.LazarusPackages.Count - 1 do
begin begin
PackageFile := APackage.FindPackageFile(TPackageFile(APackage.PackageFiles.Items[I]).Name); LazarusPkg := APackage.FindLazarusPackage(TLazarusPackage(APackage.LazarusPackages.Items[I]).Name);
if PackageFile <> nil then if LazarusPkg <> nil then
begin begin
PackageFile.HasUpdate := False; LazarusPkg.HasUpdate := False;
PackageFile.UpdateVersion := ''; LazarusPkg.UpdateVersion := '';
PackageFile.ForceNotify := False; LazarusPkg.ForceNotify := False;
PackageFile.InternalVersion := 0; LazarusPkg.InternalVersion := 0;
PackageFile.InternalVersionOld := 0; LazarusPkg.InternalVersionOld := 0;
end; end;
end; end;
end; end;

126
components/onlinepackagemanager/opkman_visualtree.pas
View File

@ -49,7 +49,7 @@ type
PackageName: String; PackageName: String;
PackageDisplayName: String; PackageDisplayName: String;
Category: String; Category: String;
PackageFileName: String; LazarusPackageName: String;
Version: String; Version: String;
InstalledVersion: String; InstalledVersion: String;
UpdateVersion: String; UpdateVersion: String;
@ -78,7 +78,7 @@ type
Rating: Integer; Rating: Integer;
end; end;
TFilterBy = (fbPackageName, fbPackageFileName, fbPackageCategory, fbPackageState, TFilterBy = (fbPackageName, fbLazarusPackageName, fbPackageCategory, fbPackageState,
fbVersion, fbDescription, fbAuthor, fbLazCompatibility, fbFPCCompatibility, fbVersion, fbDescription, fbAuthor, fbLazCompatibility, fbFPCCompatibility,
fbSupportedWidgetsets, fbPackageType, fbDependecies, fbLicense); fbSupportedWidgetsets, fbPackageType, fbDependecies, fbLicense);
@ -296,7 +296,7 @@ var
I, J: Integer; I, J: Integer;
RootNode, Node, ChildNode, GrandChildNode: PVirtualNode; RootNode, Node, ChildNode, GrandChildNode: PVirtualNode;
RootData, Data, ChildData, GrandChildData: PData; RootData, Data, ChildData, GrandChildData: PData;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
UniqueID: Integer; UniqueID: Integer;
begin begin
FVST.OnExpanding := nil; FVST.OnExpanding := nil;
@ -328,31 +328,31 @@ begin
Data^.RepositoryDate := SerializablePackages.Items[I].RepositoryDate; Data^.RepositoryDate := SerializablePackages.Items[I].RepositoryDate;
FVST.IsDisabled[Node] := Data^.DisableInOPM; FVST.IsDisabled[Node] := Data^.DisableInOPM;
Data^.DataType := 1; Data^.DataType := 1;
for J := 0 to SerializablePackages.Items[I].PackageFiles.Count - 1 do for J := 0 to SerializablePackages.Items[I].LazarusPackages.Count - 1 do
begin begin
//add packagefiles(DataType = 2) //add LazarusPackages(DataType = 2)
PackageFile := TPackageFile(SerializablePackages.Items[I].PackageFiles.Items[J]); LazarusPkg := TLazarusPackage(SerializablePackages.Items[I].LazarusPackages.Items[J]);
ChildNode := FVST.AddChild(Node); ChildNode := FVST.AddChild(Node);
ChildNode^.CheckType := ctTriStateCheckBox; ChildNode^.CheckType := ctTriStateCheckBox;
FVST.IsDisabled[ChildNode] := FVST.IsDisabled[ChildNode^.Parent]; FVST.IsDisabled[ChildNode] := FVST.IsDisabled[ChildNode^.Parent];
ChildData := FVST.GetNodeData(ChildNode); ChildData := FVST.GetNodeData(ChildNode);
ChildData^.PID := I; ChildData^.PID := I;
ChildData^.PFID := J; ChildData^.PFID := J;
ChildData^.PackageFileName := PackageFile.Name; ChildData^.LazarusPackageName := LazarusPkg.Name;
ChildData^.InstalledVersion := PackageFile.InstalledFileVersion; ChildData^.InstalledVersion := LazarusPkg.InstalledFileVersion;
ChildData^.UpdateVersion := PackageFile.UpdateVersion; ChildData^.UpdateVersion := LazarusPkg.UpdateVersion;
ChildData^.Version := PackageFile.VersionAsString; ChildData^.Version := LazarusPkg.VersionAsString;
ChildData^.PackageState := PackageFile.PackageState; ChildData^.PackageState := LazarusPkg.PackageState;
ChildData^.HasUpdate := PackageFile.HasUpdate; ChildData^.HasUpdate := LazarusPkg.HasUpdate;
ChildData^.DataType := 2; ChildData^.DataType := 2;
//add description(DataType = 3) //add description(DataType = 3)
GrandChildNode := FVST.AddChild(ChildNode); GrandChildNode := FVST.AddChild(ChildNode);
FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent]; FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent];
GrandChildData := FVST.GetNodeData(GrandChildNode); GrandChildData := FVST.GetNodeData(GrandChildNode);
if ChildData^.InstalledVersion <> '' then if ChildData^.InstalledVersion <> '' then
GrandChildData^.Description := PackageFile.InstalledFileDescription GrandChildData^.Description := LazarusPkg.InstalledFileDescription
else else
GrandChildData^.Description := PackageFile.Description; GrandChildData^.Description := LazarusPkg.Description;
GrandChildData^.DataType := 3; GrandChildData^.DataType := 3;
Inc(UniqueID); Inc(UniqueID);
CreateButton(UniqueID, GrandChildData); CreateButton(UniqueID, GrandChildData);
@ -361,40 +361,40 @@ begin
GrandChildNode := FVST.AddChild(ChildNode); GrandChildNode := FVST.AddChild(ChildNode);
FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent]; FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent];
GrandChildData := FVST.GetNodeData(GrandChildNode); GrandChildData := FVST.GetNodeData(GrandChildNode);
GrandChildData^.Author := PackageFile.Author; GrandChildData^.Author := LazarusPkg.Author;
GrandChildData^.DataType := 4; GrandChildData^.DataType := 4;
//add lazcompatibility(DataType = 5) //add lazcompatibility(DataType = 5)
GrandChildNode := FVST.AddChild(ChildNode); GrandChildNode := FVST.AddChild(ChildNode);
FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent]; FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent];
GrandChildData := FVST.GetNodeData(GrandChildNode); GrandChildData := FVST.GetNodeData(GrandChildNode);
GrandChildData^.LazCompatibility := PackageFile.LazCompatibility; GrandChildData^.LazCompatibility := LazarusPkg.LazCompatibility;
GrandChildData^.DataType := 5; GrandChildData^.DataType := 5;
//add fpccompatibility(DataType = 6) //add fpccompatibility(DataType = 6)
GrandChildNode := FVST.AddChild(ChildNode); GrandChildNode := FVST.AddChild(ChildNode);
FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent]; FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent];
GrandChildData := FVST.GetNodeData(GrandChildNode); GrandChildData := FVST.GetNodeData(GrandChildNode);
GrandChildData^.FPCCompatibility := PackageFile.FPCCompatibility; GrandChildData^.FPCCompatibility := LazarusPkg.FPCCompatibility;
GrandChildData^.DataType := 6; GrandChildData^.DataType := 6;
//add widgetset(DataType = 7) //add widgetset(DataType = 7)
GrandChildNode := FVST.AddChild(ChildNode); GrandChildNode := FVST.AddChild(ChildNode);
FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent]; FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent];
GrandChildData := FVST.GetNodeData(GrandChildNode); GrandChildData := FVST.GetNodeData(GrandChildNode);
GrandChildData^.SupportedWidgetSet := PackageFile.SupportedWidgetSet; GrandChildData^.SupportedWidgetSet := LazarusPkg.SupportedWidgetSet;
GrandChildData^.DataType := 7; GrandChildData^.DataType := 7;
//add packagetype(DataType = 8) //add packagetype(DataType = 8)
GrandChildNode := FVST.AddChild(ChildNode); GrandChildNode := FVST.AddChild(ChildNode);
FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent]; FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent];
GrandChildData := FVST.GetNodeData(GrandChildNode); GrandChildData := FVST.GetNodeData(GrandChildNode);
GrandChildData^.PackageType := PackageFile.PackageType; GrandChildData^.PackageType := LazarusPkg.PackageType;
GrandChildData^.DataType := 8; GrandChildData^.DataType := 8;
//add license(DataType = 9) //add license(DataType = 9)
GrandChildNode := FVST.AddChild(ChildNode); GrandChildNode := FVST.AddChild(ChildNode);
FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent]; FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent];
GrandChildData := FVST.GetNodeData(GrandChildNode); GrandChildData := FVST.GetNodeData(GrandChildNode);
if ChildData^.InstalledVersion <> '' then if ChildData^.InstalledVersion <> '' then
GrandChildData^.License := PackageFile.InstalledFileLincese GrandChildData^.License := LazarusPkg.InstalledFileLincese
else else
GrandChildData^.License := PackageFile.License; GrandChildData^.License := LazarusPkg.License;
GrandChildData^.DataType := 9; GrandChildData^.DataType := 9;
Inc(UniqueID); Inc(UniqueID);
CreateButton(UniqueID, GrandChildData); CreateButton(UniqueID, GrandChildData);
@ -403,7 +403,7 @@ begin
GrandChildNode := FVST.AddChild(ChildNode); GrandChildNode := FVST.AddChild(ChildNode);
FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent]; FVST.IsDisabled[GrandChildNode] := FVST.IsDisabled[GrandChildNode^.Parent];
GrandChildData := FVST.GetNodeData(GrandChildNode); GrandChildData := FVST.GetNodeData(GrandChildNode);
GrandChildData^.Dependencies := PackageFile.DependenciesAsString; GrandChildData^.Dependencies := LazarusPkg.DependenciesAsString;
GrandChildData^.DataType := 10; GrandChildData^.DataType := 10;
end; end;
//add miscellaneous(DataType = 11) //add miscellaneous(DataType = 11)
@ -509,11 +509,11 @@ begin
case Data^.DataType of case Data^.DataType of
3: begin 3: begin
Text := Data^.Description; Text := Data^.Description;
FrmCaption := rsMainFrm_VSTText_Desc + ' "' + ParentData^.PackageFileName + '"'; FrmCaption := rsMainFrm_VSTText_Desc + ' "' + ParentData^.LazarusPackageName + '"';
end; end;
9: begin 9: begin
Text := Data^.License; Text := Data^.License;
FrmCaption := rsMainFrm_VSTText_Lic + ' "' + ParentData^.PackageFileName + '"'; FrmCaption := rsMainFrm_VSTText_Lic + ' "' + ParentData^.LazarusPackageName + '"';
end; end;
end; end;
Break; Break;
@ -802,11 +802,11 @@ procedure TVisualTree.FilterTree(const AFilterBy: TFilterBy; const AText:
procedure HideShowParentNodes(const ANode: PVirtualNode; AShow: Boolean); procedure HideShowParentNodes(const ANode: PVirtualNode; AShow: Boolean);
var var
Level: Integer; Level: Integer;
RepositoryNode, PackageNode, PackageFileNode: PVirtualNode; RepositoryNode, PackageNode, LazarusPkgNode: PVirtualNode;
begin begin
RepositoryNode := nil; RepositoryNode := nil;
PackageNode := nil; PackageNode := nil;
PackageFileNode := nil; LazarusPkgNode := nil;
Level := FVST.GetNodeLevel(ANode); Level := FVST.GetNodeLevel(ANode);
case Level of case Level of
1: begin 1: begin
@ -816,12 +816,12 @@ procedure TVisualTree.FilterTree(const AFilterBy: TFilterBy; const AText:
2: begin 2: begin
RepositoryNode := ANode^.Parent^.Parent; RepositoryNode := ANode^.Parent^.Parent;
PackageNode := ANode^.Parent; PackageNode := ANode^.Parent;
PackageFileNode := ANode; LazarusPkgNode := ANode;
end; end;
3: begin 3: begin
RepositoryNode := ANode^.Parent^.Parent^.Parent; RepositoryNode := ANode^.Parent^.Parent^.Parent;
PackageNode := ANode^.Parent^.Parent; PackageNode := ANode^.Parent^.Parent;
PackageFileNode := ANode^.Parent; LazarusPkgNode := ANode^.Parent;
end; end;
end; end;
if Level = 1 then if Level = 1 then
@ -852,14 +852,14 @@ procedure TVisualTree.FilterTree(const AFilterBy: TFilterBy; const AText:
begin begin
if AShow then if AShow then
begin begin
FVST.IsVisible[PackageFileNode] := True; FVST.IsVisible[LazarusPkgNode] := True;
FVST.IsVisible[PackageNode] := True; FVST.IsVisible[PackageNode] := True;
FVST.IsVisible[RepositoryNode] := True; FVST.IsVisible[RepositoryNode] := True;
end end
else else
begin begin
FVST.IsVisible[PackageFileNode] := False; FVST.IsVisible[LazarusPkgNode] := False;
HideShowParentNodes(PackageFileNode, AShow); HideShowParentNodes(LazarusPkgNode, AShow);
end; end;
end; end;
end; end;
@ -905,10 +905,10 @@ begin
if (Data^.DataType = 1) then if (Data^.DataType = 1) then
FilterNode(Node, Data^.PackageName); FilterNode(Node, Data^.PackageName);
end; end;
fbPackageFileName: fbLazarusPackageName:
begin begin
if (Data^.DataType = 2) then if (Data^.DataType = 2) then
FilterNode(Node, Data^.PackageFileName); FilterNode(Node, Data^.LazarusPackageName);
end; end;
fbPackageCategory: fbPackageCategory:
begin begin
@ -1045,7 +1045,7 @@ var
Node: PVirtualNode; Node: PVirtualNode;
Data: PData; Data: PData;
Package: TPackage; Package: TPackage;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
Node := FVST.GetFirst; Node := FVST.GetFirst;
while Assigned(Node) do while Assigned(Node) do
@ -1064,13 +1064,13 @@ begin
end; end;
if Data^.DataType = 2 then if Data^.DataType = 2 then
begin begin
PackageFile := TPackageFile(SerializablePackages.Items[Data^.PID].PackageFiles.Items[Data^.PFID]); LazarusPkg := TLazarusPackage(SerializablePackages.Items[Data^.PID].LazarusPackages.Items[Data^.PFID]);
if PackageFile <> nil then if LazarusPkg <> nil then
begin begin
if FVST.CheckState[Node] = csCheckedNormal then if FVST.CheckState[Node] = csCheckedNormal then
PackageFile.Checked := True LazarusPkg.Checked := True
else if FVST.CheckState[Node] = csUncheckedNormal then else if FVST.CheckState[Node] = csUncheckedNormal then
PackageFile.Checked := False LazarusPkg.Checked := False
end; end;
end; end;
Node := FVST.GetNext(Node); Node := FVST.GetNext(Node);
@ -1082,7 +1082,7 @@ var
Node: PVirtualNode; Node: PVirtualNode;
Data: PData; Data: PData;
Package: TPackage; Package: TPackage;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
SerializablePackages.GetPackageStates; SerializablePackages.GetPackageStates;
Node := FVST.GetFirst; Node := FVST.GetFirst;
@ -1102,11 +1102,11 @@ begin
end; end;
if Data^.DataType = 2 then if Data^.DataType = 2 then
begin begin
PackageFile := TPackageFile(SerializablePackages.Items[Data^.PID].PackageFiles.Items[Data^.PFID]); LazarusPkg := TLazarusPackage(SerializablePackages.Items[Data^.PID].LazarusPackages.Items[Data^.PFID]);
if PackageFile <> nil then if LazarusPkg <> nil then
begin begin
Data^.InstalledVersion := PackageFile.InstalledFileVersion; Data^.InstalledVersion := LazarusPkg.InstalledFileVersion;
Data^.PackageState := PackageFile.PackageState; Data^.PackageState := LazarusPkg.PackageState;
FVST.ReinitNode(Node, False); FVST.ReinitNode(Node, False);
FVST.RepaintNode(Node); FVST.RepaintNode(Node);
end; end;
@ -1120,7 +1120,7 @@ var
Node: PVirtualNode; Node: PVirtualNode;
Data, ParentData: PData; Data, ParentData: PData;
Package: TPackage; Package: TPackage;
PackageFile: TPackageFile; LazarusPkg: TLazarusPackage;
begin begin
Node := FVST.GetFirst; Node := FVST.GetFirst;
while Assigned(Node) do while Assigned(Node) do
@ -1142,11 +1142,11 @@ begin
end; end;
if Data^.DataType = 2 then if Data^.DataType = 2 then
begin begin
PackageFile := TPackageFile(SerializablePackages.Items[Data^.PID].PackageFiles.Items[Data^.PFID]); LazarusPkg := TLazarusPackage(SerializablePackages.Items[Data^.PID].LazarusPackages.Items[Data^.PFID]);
if PackageFile <> nil then if LazarusPkg <> nil then
begin begin
Data^.UpdateVersion := PackageFile.UpdateVersion; Data^.UpdateVersion := LazarusPkg.UpdateVersion;
Data^.HasUpdate := PackageFile.HasUpdate; Data^.HasUpdate := LazarusPkg.HasUpdate;
FVST.IsDisabled[Node] := FVST.IsDisabled[Node^.Parent]; FVST.IsDisabled[Node] := FVST.IsDisabled[Node^.Parent];
FVST.ReinitNode(Node, False); FVST.ReinitNode(Node, False);
FVST.RepaintNode(Node); FVST.RepaintNode(Node);
@ -1160,13 +1160,13 @@ begin
begin begin
case Data^.DataType of case Data^.DataType of
3: if ParentData^.InstalledVersion <> '' then 3: if ParentData^.InstalledVersion <> '' then
Data^.Description := PackageFile.InstalledFileDescription Data^.Description := LazarusPkg.InstalledFileDescription
else else
Data^.Description := PackageFile.Description; Data^.Description := LazarusPkg.Description;
9: if ParentData^.InstalledVersion <> '' then 9: if ParentData^.InstalledVersion <> '' then
Data^.License := PackageFile.InstalledFileLincese Data^.License := LazarusPkg.InstalledFileLincese
else else
Data^.License := PackageFile.License; Data^.License := LazarusPkg.License;
end; end;
if Assigned(Data^.Button) then if Assigned(Data^.Button) then
Data^.Button.Enabled := not FVST.IsDisabled[Node]; Data^.Button.Enabled := not FVST.IsDisabled[Node];
@ -1235,8 +1235,8 @@ var
Data, DataSearch: PData; Data, DataSearch: PData;
Msg: String; Msg: String;
PackageList: TObjectList; PackageList: TObjectList;
PackageFileName: String; PkgFileName: String;
DependencyPackage: TPackageFile; DependencyPkg: TLazarusPackage;
I: Integer; I: Integer;
begin begin
Result := mrNone; Result := mrNone;
@ -1250,10 +1250,10 @@ begin
begin begin
PackageList := TObjectList.Create(True); PackageList := TObjectList.Create(True);
try try
SerializablePackages.GetPackageDependencies(Data^.PackageFileName, PackageList, True, True); SerializablePackages.GetPackageDependencies(Data^.LazarusPackageName, PackageList, True, True);
for I := 0 to PackageList.Count - 1 do for I := 0 to PackageList.Count - 1 do
begin begin
PackageFileName := TPackageDependency(PackageList.Items[I]).PackageFileName + '.lpk'; PkgFileName := TPackageDependency(PackageList.Items[I]).PkgFileName + '.lpk';
NodeSearch := VST.GetFirst; NodeSearch := VST.GetFirst;
while Assigned(NodeSearch) do while Assigned(NodeSearch) do
begin begin
@ -1262,15 +1262,15 @@ begin
DataSearch := FVST.GetNodeData(NodeSearch); DataSearch := FVST.GetNodeData(NodeSearch);
if DataSearch^.DataType = 2 then if DataSearch^.DataType = 2 then
begin begin
DependencyPackage := TPackageFile(SerializablePackages.Items[DataSearch^.PID].PackageFiles.Items[DataSearch^.PFID]); DependencyPkg := TLazarusPackage(SerializablePackages.Items[DataSearch^.PID].LazarusPackages.Items[DataSearch^.PFID]);
if (FVST.CheckState[NodeSearch] <> csCheckedNormal) and if (FVST.CheckState[NodeSearch] <> csCheckedNormal) and
(UpperCase(DataSearch^.PackageFileName) = UpperCase(PackageFileName)) and (UpperCase(DataSearch^.LazarusPackageName) = UpperCase(PkgFileName)) and
((SerializablePackages.IsDependencyOk(TPackageDependency(PackageList.Items[I]), DependencyPackage)) and ((SerializablePackages.IsDependencyOk(TPackageDependency(PackageList.Items[I]), DependencyPkg)) and
((not (DependencyPackage.PackageState = psInstalled)) or ((DependencyPackage.PackageState = psInstalled) and (not (SerializablePackages.IsInstalledVersionOk(TPackageDependency(PackageList.Items[I]), DataSearch^.InstalledVersion)))))) then ((not (DependencyPkg.PackageState = psInstalled)) or ((DependencyPkg.PackageState = psInstalled) and (not (SerializablePackages.IsInstalledVersionOk(TPackageDependency(PackageList.Items[I]), DataSearch^.InstalledVersion)))))) then
begin begin
if (Result = mrNone) or (Result = mrYes) then if (Result = mrNone) or (Result = mrYes) then
begin begin
Msg := Format(rsMainFrm_rsPackageDependency0, [Data^.PackageFileName, DataSearch^.PackageFileName]); Msg := Format(rsMainFrm_rsPackageDependency0, [Data^.LazarusPackageName, DataSearch^.LazarusPackageName]);
Result := MessageDlgEx(Msg, mtConfirmation, [mbYes, mbYesToAll, mbNo, mbNoToAll, mbCancel], TForm(FVST.Parent.Parent)); Result := MessageDlgEx(Msg, mtConfirmation, [mbYes, mbYesToAll, mbNo, mbNoToAll, mbCancel], TForm(FVST.Parent.Parent));
if Result in [mrNo, mrNoToAll] then if Result in [mrNo, mrNoToAll] then
MessageDlgEx(rsMainFrm_rsPackageDependency1, mtInformation, [mbOk], TForm(FVST.Parent.Parent)); MessageDlgEx(rsMainFrm_rsPackageDependency1, mtInformation, [mbOk], TForm(FVST.Parent.Parent));
@ -1333,7 +1333,7 @@ begin
else if (Data1^.DataType > Data2^.DataType) then else if (Data1^.DataType > Data2^.DataType) then
Result := 1 Result := 1
else if (Data1^.DataType = 2) and (Data1^.DataType = 2) then else if (Data1^.DataType = 2) and (Data1^.DataType = 2) then
Result := CompareText(Data1^.PackageFileName, Data2^.PackageFileName); Result := CompareText(Data1^.LazarusPackageName, Data2^.LazarusPackageName);
end; end;
1: if (Data1^.DataType = 1) and (Data1^.DataType = 1) then 1: if (Data1^.DataType = 1) and (Data1^.DataType = 1) then
Result := Data2^.InstallState - Data1^.InstallState; Result := Data2^.InstallState - Data1^.InstallState;
@ -1409,7 +1409,7 @@ begin
CellText := Data^.PackageName CellText := Data^.PackageName
else else
CellText := Data^.PackageDisplayName; CellText := Data^.PackageDisplayName;
2: CellText := Data^.PackageFileName; 2: CellText := Data^.LazarusPackageName;
3: CellText := rsMainFrm_VSTText_Description; 3: CellText := rsMainFrm_VSTText_Description;
4: CellText := rsMainFrm_VSTText_Author; 4: CellText := rsMainFrm_VSTText_Author;
5: CellText := rsMainFrm_VSTText_LazCompatibility; 5: CellText := rsMainFrm_VSTText_LazCompatibility;