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

2
components/onlinepackagemanager/opkman_const.pas
View File

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

38
components/onlinepackagemanager/opkman_createjsonforupdates.pas
View File

@ -184,8 +184,8 @@ end;
procedure TCreateJSONForUpdatesFrm.bCreateClick(Sender: TObject);
var
UpdatePackage: TUpdatePackage;
UpdatePackageFiles: TUpdatePackageFiles;
UpdatePkg: TUpdatePackage;
UpdateLazPkgs: TUpdateLazPackages;
JSON: TJSONStringType;
Ms: TMemoryStream;
Node: PVirtualNode;
@ -205,10 +205,10 @@ begin
SD.FileName := 'update_' + FPackage.Name;
if SD.Execute then
begin
UpdatePackage := TUpdatePackage.Create;
UpdatePkg := TUpdatePackage.Create;
try
UpdatePackage.UpdatePackageData.Name := FPackage.Name;
UpdatePackage.UpdatePackageData.DownloadZipURL := edLinkToZip.Text;
UpdatePkg.UpdatePackageData.Name := FPackage.Name;
UpdatePkg.UpdatePackageData.DownloadZipURL := edLinkToZip.Text;
Node := FVST.GetFirst;
while Assigned(Node) do
@ -216,16 +216,16 @@ begin
if FVST.CheckState[Node] = csCheckedNormal then
begin
Data := FVST.GetNodeData(Node);
UpdatePackageFiles := TUpdatePackageFiles(UpdatePackage.UpdatePackageFiles.Add);
UpdatePackageFiles.Name := Data^.FName;
UpdatePackageFiles.Version := Data^.FVersion;
UpdatePackageFiles.ForceNotify := Data^.FForceNotify;
UpdatePackageFiles.InternalVersion := Data^.FInternalVersion;
UpdateLazPkgs := TUpdateLazPackages(UpdatePkg.UpdateLazPackages.Add);
UpdateLazPkgs.Name := Data^.FName;
UpdateLazPkgs.Version := Data^.FVersion;
UpdateLazPkgs.ForceNotify := Data^.FForceNotify;
UpdateLazPkgs.InternalVersion := Data^.FInternalVersion;
end;
Node := FVST.GetNext(Node);
end;
JSON := '';
if UpdatePackage.SaveToJSON(JSON) then
if UpdatePkg.SaveToJSON(JSON) then
begin
JSON := StringReplace(JSON, '\/', '/', [rfReplaceAll]);
Ms := TMemoryStream.Create;
@ -241,11 +241,11 @@ begin
end
else
begin
ErrMsg := StringReplace(UpdatePackage.LastError, '"', '', [rfReplaceAll]);
ErrMsg := StringReplace(UpdatePkg.LastError, '"', '', [rfReplaceAll]);
MessageDlgEx(rsCreateJSONForUpdatesFrm_Error1 + sLineBreak + '"' + ErrMsg + '"', mtError, [mbOk], Self);
end;
finally
UpdatePackage.Free;
UpdatePkg.Free;
end;
end;
if CanClose then
@ -340,7 +340,7 @@ var
I, J: Integer;
Node: PVirtualNode;
Data: PData;
PackageFile: TPackageFile;
LazarusPkg: TLazarusPackage;
begin
for I := 0 to SerializablePackages.Count - 1 do
begin
@ -348,17 +348,17 @@ begin
if FPackage.Checked then
begin
Caption := Caption + ' "' + FPackage.DisplayName +'"';
for J := 0 to FPackage.PackageFiles.Count - 1 do
for J := 0 to FPackage.LazarusPackages.Count - 1 do
begin
PackageFile := TPackageFile(FPackage.PackageFiles.Items[J]);
if PackageFile.Checked then
LazarusPkg := TLazarusPackage(FPackage.LazarusPackages.Items[J]);
if LazarusPkg.Checked then
begin
Node := FVST.AddChild(nil);
Node^.CheckType := ctTriStateCheckBox;
FVST.CheckState[Node] := csCheckedNormal;
Data := FVST.GetNodeData(Node);
Data^.FName := PackageFile.Name;
Data^.FVersion := PackageFile.VersionAsString;
Data^.FName := LazarusPkg.Name;
Data^.FVersion := LazarusPkg.VersionAsString;
Data^.FForceNotify := False;
Data^.FInternalVersion := 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;
TOnPackageInstallError = procedure(Sender: TObject; APackageName, AErrMsg: String) of object;
TOnPackageInstallCompleted = procedure(Sender: TObject; ANeedToRebuild: Boolean; AInstallStatus: TInstallStatus) of object;
TPackageInstaller = class
private
FNeedToBreak: Boolean;
@ -59,18 +60,18 @@ type
FStarted: Boolean;
FInstallStatus: TInstallStatus;
FToInstall: TStringList;
FPackageFileName: String;
FUnresolvedPackageFileName: String;
FFileName: String;
FUnresolvedFileName: String;
FOnPackageInstallProgress: TOnPackageInstallProgress;
FOnPackageInstallError: TOnPackageInstallError;
FOnPackageInstallCompleted: TOnPackageInstallCompleted;
function OpenPackage(const APackageFileName: String): TIDEPackage;
function IsPackageInTheList(const APackageFileName: String): Boolean;
function OpenPackage(const AFileName: String): TIDEPackage;
function IsPackageInTheList(const AFileName: 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;
procedure DoOnPackageInstallProgress(const AInstallMessage: TInstallMessage; APackageFile: TPackageFile);
procedure DoOnPackageInstallError(const AInstallMessage: TInstallMessage; APackageFile: TPackageFile);
procedure DoOnPackageInstallProgress(const AInstallMessage: TInstallMessage; ALazarusPkg: TLazarusPackage);
procedure DoOnPackageInstallError(const AInstallMessage: TInstallMessage; ALazarusPkg: TLazarusPackage);
procedure Execute;
public
constructor Create;
@ -102,16 +103,16 @@ begin
inherited Destroy;
end;
function TPackageInstaller.OpenPackage(const APackageFileName: String): TIDEPackage;
function TPackageInstaller.OpenPackage(const AFileName: String): TIDEPackage;
var
I: Integer;
begin
Result := nil;
if PackageEditingInterface.DoOpenPackageFile(APackageFileName, [pofRevert, pofDoNotOpenEditor], True) = mrOk then
if PackageEditingInterface.DoOpenPackageFile(AFileName, [pofRevert, pofDoNotOpenEditor], True) = mrOk then
begin
for I := 0 to PackageEditingInterface.GetPackageCount - 1 do
begin
if UpperCase(PackageEditingInterface.GetPackages(I).Filename) = UpperCase(APackageFileName) then
if UpperCase(PackageEditingInterface.GetPackages(I).Filename) = UpperCase(AFileName) then
begin
Result := PackageEditingInterface.GetPackages(I);
Break;
@ -120,20 +121,20 @@ begin
end;
end;
function TPackageInstaller.IsPackageInTheList(const APackageFileName: String): Boolean;
function TPackageInstaller.IsPackageInTheList(const AFileName: String): Boolean;
var
P, I: Integer;
PackageFileName: String;
PkgFileName: String;
begin
Result := False;
for I := 0 to FToInstall.Count - 1 do
begin
P := Pos(' ', FToInstall.Strings[I]);
if P <> 0 then
PackageFileName := Copy(FToInstall.Strings[I], 1, P - 1)
PkgFileName := Copy(FToInstall.Strings[I], 1, P - 1)
else
PackageFileName := FToInstall.Strings[I];
if UpperCase(PackageFileName) = UpperCase(APackageFileName) then
PkgFileName := FToInstall.Strings[I];
if UpperCase(PkgFileName) = UpperCase(AFileName) then
begin
Result := True;
Break;
@ -149,23 +150,23 @@ begin
P := Pos(' ', AName);
if P > 0 then
begin
FPackageFileName := Copy(AName, 1, P - 1);
FFileName := Copy(AName, 1, P - 1);
Delete(AName, 1, P);
FUnresolvedPackageFileName := Trim(AName);
FUnresolvedFileName := Trim(AName);
Result := True;
end
else
FPackageFileName := AName;
FFileName := AName;
end;
function TPackageInstaller.CompilePackage(const AIDEPackage: TIDEPackage;
APackageFile: TPackageFile): Integer;
ALazarusPkg: TLazarusPackage): Integer;
begin
Result := -1;
{$if declared(lcl_version)}
{$if (lcl_major > 0) and (lcl_minor > 6)}
//DoCompilePackage function is only available with Laz 1.7 +
DoOnPackageInstallProgress(imCompilePackage, APackageFile);
DoOnPackageInstallProgress(imCompilePackage, ALazarusPkg);
Result := PackageEditingInterface.DoCompilePackage(AIDEPackage, [pcfCleanCompile, pcfDoNotSaveEditorFiles], False);
{$endif}
{$endif}
@ -178,10 +179,10 @@ var
NewPackageID: TLazPackageID;
begin
Result := False;
P := Pos('.lpk', FPackageFileName);
P := Pos('.lpk', FFileName);
if P <> 0 then
begin
PackageName := Copy(FPackageFileName, 1, P - 1);
PackageName := Copy(FFileName, 1, P - 1);
NewPackageID := TLazPackageID.Create;
if NewPackageID.StringToID(PackageName) then
begin
@ -192,18 +193,18 @@ begin
end;
procedure TPackageInstaller.DoOnPackageInstallProgress(const AInstallMessage: TInstallMessage;
APackageFile: TPackageFile);
ALazarusPkg: TLazarusPackage);
begin
if AInstallMessage = imPackageCompleted then
APackageFile.PackageStates := APackageFile.PackageStates + [psInstalled];
ALazarusPkg.PackageStates := ALazarusPkg.PackageStates + [psInstalled];
if Assigned(FOnPackageInstallProgress) then
FOnPackageInstallProgress(Self, FCnt, FTotCnt, FPackageFileName, AInstallMessage);
FOnPackageInstallProgress(Self, FCnt, FTotCnt, FFileName, AInstallMessage);
if AInstallMessage <> imPackageCompleted then
Sleep(1000);
end;
procedure TPackageInstaller.DoOnPackageInstallError(const AInstallMessage: TInstallMessage;
APackageFile: TPackageFile);
ALazarusPkg: TLazarusPackage);
var
ErrMsg: String;
begin
@ -215,12 +216,12 @@ begin
imInstallPackageError:
ErrMsg := rsProgressFrm_Error9;
imDependencyError:
ErrMsg := Format(rsProgressFrm_Error4, [FUnresolvedPackageFileName]);
ErrMsg := Format(rsProgressFrm_Error4, [FUnresolvedFileName]);
end;
APackageFile.PackageStates := APackageFile.PackageStates - [psInstalled];
APackageFile.PackageStates := APackageFile.PackageStates + [psError];
ALazarusPkg.PackageStates := ALazarusPkg.PackageStates - [psInstalled];
ALazarusPkg.PackageStates := ALazarusPkg.PackageStates + [psError];
if Assigned(FOnPackageInstallError) then
FOnPackageInstallError(Self, FPackageFileName, ErrMsg);
FOnPackageInstallError(Self, FFileName, ErrMsg);
Sleep(1000);
end;
@ -230,7 +231,7 @@ var
IDEPackage: TIDEPackage;
PkgInstallInIDEFlags: TPkgInstallInIDEFlags;
ErrCnt: Integer;
PackageFile: TPackageFile;
LazarusPkg: TLazarusPackage;
CanGo: Boolean;
CompRes: Integer;
begin
@ -242,63 +243,63 @@ begin
if NeedToBreak then
Break;
CanGo := not HasUnresolvedDependency(FToInstall.Strings[I]);
PackageFile := SerializablePackages.FindPackageFile(FPackageFileName);
LazarusPkg := SerializablePackages.FindLazarusPackage(FFileName);
if CanGo then
begin
Inc(FCnt);
if not FNeedToRebuild then
FNeedToRebuild := PackageFile.PackageType in [ptRunAndDesignTime, ptDesigntime];
DoOnPackageInstallProgress(imOpenPackage, PackageFile);
IDEPackage := OpenPackage(PackageFile.PackageAbsolutePath);
FNeedToRebuild := LazarusPkg.PackageType in [ptRunAndDesignTime, ptDesigntime];
DoOnPackageInstallProgress(imOpenPackage, LazarusPkg);
IDEPackage := OpenPackage(LazarusPkg.PackageAbsolutePath);
if IDEPackage <> nil then
begin
DoOnPackageInstallProgress(imOpenPackageSuccess, PackageFile);
CompRes := CompilePackage(IDEPAckage, PackageFile);
DoOnPackageInstallProgress(imOpenPackageSuccess, LazarusPkg);
CompRes := CompilePackage(IDEPAckage, LazarusPkg);
case CompRes of
-1, 1:
begin
if CompRes = 1 then
begin
DoOnPackageInstallProgress(imCompilePackageSuccess, PackageFile);
DoOnPackageInstallProgress(imCompilePackageSuccess, LazarusPkg);
if PackageAction = paUpdate then
if PackageFile.ForceNotify then
if PackageFile.InternalVersion > PackageFile.InternalVersionOld then
PackageFile.InternalVersionOld := PackageFile.InternalVersion;
if LazarusPkg.ForceNotify then
if LazarusPkg.InternalVersion > LazarusPkg.InternalVersionOld then
LazarusPkg.InternalVersionOld := LazarusPkg.InternalVersion;
end;
if PackageFile.PackageType in [ptRunAndDesignTime, ptDesigntime] then
if LazarusPkg.PackageType in [ptRunAndDesignTime, ptDesigntime] then
begin
DoOnPackageInstallProgress(imInstallPackage, PackageFile);
DoOnPackageInstallProgress(imInstallPackage, LazarusPkg);
if InstallPackage then
DoOnPackageInstallProgress(imInstallpackageSuccess, PackageFile)
DoOnPackageInstallProgress(imInstallpackageSuccess, LazarusPkg)
else
begin
Inc(ErrCnt);
DoOnPackageInstallError(imInstallPackageError, PackageFile);
DoOnPackageInstallError(imInstallPackageError, LazarusPkg);
end;
end;
end;
else
begin
Inc(ErrCnt);
DoOnPackageInstallError(imCompilePackageError, PackageFile);
DoOnPackageInstallError(imCompilePackageError, LazarusPkg);
end;
end;
end
else
begin
Inc(ErrCnt);
DoOnPackageInstallError(imOpenPackageError, PackageFile);
DoOnPackageInstallError(imOpenPackageError, LazarusPkg);
end;
DoOnPackageInstallProgress(imPackageCompleted, PackageFile);
DoOnPackageInstallProgress(imPackageCompleted, LazarusPkg);
end
else
begin
Inc(FCnt);
DoOnPackageInstallProgress(imOpenPackage, PackageFile);
DoOnPackageInstallProgress(imOpenPackageSuccess, PackageFile);
DoOnPackageInstallProgress(imOpenPackage, LazarusPkg);
DoOnPackageInstallProgress(imOpenPackageSuccess, LazarusPkg);
Inc(ErrCnt);
DoOnPackageInstallError(imDependencyError, PackageFile);
DoOnPackageInstallProgress(imPackageCompleted, PackageFile);
DoOnPackageInstallError(imDependencyError, LazarusPkg);
DoOnPackageInstallProgress(imPackageCompleted, LazarusPkg);
end;
end;
if InstallPackageList.Count > 0 then
@ -323,7 +324,7 @@ procedure TPackageInstaller.StartInstall;
var
I, J, K: Integer;
PackageList: TObjectList;
PackageFile, DependecyPackage: TPackageFile;
LazarusPkg, DependecyPackage: TLazarusPackage;
PackageDependency: TPackageDependency;
DependencyFound: Boolean;
begin
@ -335,24 +336,26 @@ begin
try
for I := 0 to SerializablePackages.Count - 1 do
begin
for J := 0 to SerializablePackages.Items[I].PackageFiles.Count - 1 do
for J := 0 to SerializablePackages.Items[I].LazarusPackages.Count - 1 do
begin
PackageFile := TPackageFile(SerializablePackages.Items[I].PackageFiles.Items[J]);
if PackageFile.IsInstallable then
LazarusPkg := TLazarusPackage(SerializablePackages.Items[I].LazarusPackages.Items[J]);
if LazarusPkg.IsInstallable then
begin
SerializablePackages.GetPackageDependencies(PackageFile.Name, PackageList, True, True);
SerializablePackages.GetPackageDependencies(LazarusPkg.Name, PackageList, True, True);
if PackageList.Count > 0 then
begin
DependencyFound := True;
for K := 0 to PackageList.Count - 1 do
begin
PackageDependency := TPackageDependency(PackageList.Items[K]);
DependecyPackage := SerializablePackages.FindPackageFile(TPackageDependency(PackageList.Items[k]).PackageFileName + '.lpk');
DependecyPackage := SerializablePackages.FindLazarusPackage(PackageDependency.PkgFileName + '.lpk');
if DependecyPackage <> nil then
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
if ((DependecyPackage.IsInstallable) and (SerializablePackages.IsDependencyOk(PackageDependency, DependecyPackage))) then
if ((DependecyPackage.IsInstallable)
and (SerializablePackages.IsDependencyOk(PackageDependency, DependecyPackage))) then
begin
if not IsPackageInTheList(DependecyPackage.Name) then
FToInstall.Add(DependecyPackage.Name);
@ -367,12 +370,12 @@ begin
end;
if (not DependencyFound) then
begin
if (not IsPackageInTheList(PackageFile.Name)) then
FToInstall.Add(PackageFile.Name + ' ' + DependecyPackage.Name)
if (not IsPackageInTheList(LazarusPkg.Name)) then
FToInstall.Add(LazarusPkg.Name + ' ' + DependecyPackage.Name)
end
end;
if (not IsPackageInTheList(PackageFile.Name)) then
FToInstall.Add(PackageFile.Name);
if (not IsPackageInTheList(LazarusPkg.Name)) then
FToInstall.Add(LazarusPkg.Name);
end;
end;
end;

14
components/onlinepackagemanager/opkman_mainfrm.pas
View File

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

10
components/onlinepackagemanager/opkman_packagelistfrm.pas
View File

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

370
components/onlinepackagemanager/opkman_serializablepackages.pas
View File

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

120
components/onlinepackagemanager/opkman_updates.pas
View File

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

126
components/onlinepackagemanager/opkman_visualtree.pas
View File

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