started package system (packager)

git-svn-id: trunk@2646 -
2026-01-04 15:30:40 +01:00 · 2002-08-17 23:41:33 +00:00 · 2002-08-17 23:41:33 +00:00 · 2cf2827549
commit 2cf2827549
parent 20a41ca57c
3 changed files with 766 additions and 1 deletions
--- a/.gitattributes
+++ b/.gitattributes
@ -698,6 +698,7 @@ lcl/vclglobals.pp svneol=native#text/pascal
 packager/addfiletoapackagedlg.pas svneol=native#text/pascal
 packager/brokendependenciesdlg.pas svneol=native#text/pascal
 packager/lazaruspackageintf.pas svneol=native#text/pascal
+packager/packagedefs.pas svneol=native#text/pascal
 packager/pkggraphexporer.pas svneol=native#text/pascal
 tools/apiwizz/apiwizard.pp svneol=native#text/pascal
 tools/apiwizz/apiwizz.pp svneol=native#text/pascal
--- a/lcl/interfacebase.pp
+++ b/lcl/interfacebase.pp
@ -95,7 +95,6 @@ var

 implementation

-
 {$I interfacebase.inc}

 initialization
@ -109,6 +108,9 @@ end.

 {
  $Log$
+  Revision 1.29  2003/02/28 10:14:28  mattias
+  started package system (packager)
+
  Revision 1.28  2002/02/09 01:48:23  mattias
  renamed TinterfaceObject.Init to AppInit and TWinControls can now contain childs in gtk

--- a/packager/packagedefs.pas
+++ b/packager/packagedefs.pas
@ -0,0 +1,762 @@
+{  $Id$  }
+{
+ /***************************************************************************
+                            packagedefs.pas
+                            ---------------
+
+
+ ***************************************************************************/
+
+ ***************************************************************************
+ *                                                                         *
+ *   This source is free software; you can redistribute it and/or modify   *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This code is distributed in the hope that it will be useful, but      *
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
+ *   General Public License for more details.                              *
+ *                                                                         *
+ *   A copy of the GNU General Public License is available on the World    *
+ *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also      *
+ *   obtain it by writing to the Free Software Foundation,                 *
+ *   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.        *
+ *                                                                         *
+ ***************************************************************************
+
+  Author: Mattias Gaertner
+
+  What is a package:
+  A lazarus package is a collection of units and components, containing
+  information how they can be compiled and how they can be used by projects or
+  other packages or the IDE. In contrary to Delphi, packages are not limited
+  to libraries and they can be OS independent.
+  (Delphi: a package is a specially compiled library used by applications,
+  the IDE or both. Delphi packages require compiler magic, which fpc is not
+  capable of at the moment and of course this magic is not OS independent.)
+
+}
+unit PackageDefs;
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils, Laz_XMLCfg, IDEProcs, CompilerOptions;
+
+type
+  { TPkgVersion }
+
+  TPkgVersion = class
+  public
+    Major: integer;
+    Minor: integer;
+    Build: integer;
+    Release: integer;
+    procedure Clear;
+    procedure LoadFromXMLConfig(XMLConfig: TXMLConfig; const Path: string;
+      FileVersion: integer);
+    procedure SaveToXMLConfig(XMLConfig: TXMLConfig; const Path: string);
+  end;
+  
+  
+  { TPkgFile }
+
+  TPkgFileType = (
+    pftUnit,   // file is pascal unit
+    pftText    // file is text (e.g. copyright or install notes)
+    );
+  TPkgFileTypes = set of TPkgFileType;
+
+  TPkgFileFlag = (
+    pffHasRegisterProc // file is unit and has a 'register' procedure
+    );
+  TPkgFileFlags = set of TPkgFileFlag;
+  
+  TPkgFile = class
+  private
+    FFilename: string;
+    FFileType: TPkgFileType;
+    FFlags: TPkgFileFlags;
+    function GetHasRegisteredProc: boolean;
+    procedure SetFilename(const AValue: string);
+    procedure SetFileType(const AValue: TPkgFileType);
+    procedure SetFlags(const AValue: TPkgFileFlags);
+    procedure SetHasRegisteredProc(const AValue: boolean);
+  public
+    constructor Create;
+    destructor Destroy; override;
+    procedure Clear;
+    procedure LoadFromXMLConfig(XMLConfig: TXMLConfig; const Path: string;
+      FileVersion: integer);
+    procedure SaveToXMLConfig(XMLConfig: TXMLConfig; const Path: string);
+  public
+    property Filename: string read FFilename write SetFilename;
+    property FileType: TPkgFileType read FFileType write SetFileType;
+    property Flags: TPkgFileFlags read FFlags write SetFlags;
+    property HasRegisteredProc: boolean
+      read GetHasRegisteredProc write SetHasRegisteredProc;
+  end;
+  
+  
+  { TPkgDependency }
+  
+  TPkgDependencyFlag = (
+    pdfMinVersion, // >= MinVersion
+    pdfMaxVersion  // <= MaxVersion
+    );
+  TPkgDependencyFlags = set of TPkgDependencyFlag;
+  
+  TPkgDependency = class
+  private
+    FFlags: TPkgDependencyFlags;
+    FMaxVersion: TPkgVersion;
+    FMinVersion: TPkgVersion;
+    FPackageName: string;
+    procedure SetFlags(const AValue: TPkgDependencyFlags);
+    procedure SetMaxVersion(const AValue: TPkgVersion);
+    procedure SetMinVersion(const AValue: TPkgVersion);
+    procedure SetPackageName(const AValue: string);
+  public
+    constructor Create;
+    destructor Destroy; override;
+    procedure Clear;
+    procedure LoadFromXMLConfig(XMLConfig: TXMLConfig; const Path: string;
+      FileVersion: integer);
+    procedure SaveToXMLConfig(XMLConfig: TXMLConfig; const Path: string);
+  public
+    property PackageName: string read FPackageName write SetPackageName;
+    property Flags: TPkgDependencyFlags read FFlags write SetFlags;
+    property MinVersion: TPkgVersion read FMinVersion write SetMinVersion;
+    property MaxVersion: TPkgVersion read FMaxVersion write SetMaxVersion;
+  end;
+  
+  
+  { TPkgCompilerOptions }
+  
+  TPkgCompilerOptions = class(TBaseCompilerOptions)
+  end;
+  
+  
+  { TLazPackage }
+  
+  TLazPackageType = (
+    lptRunTime,         // RunTime packages can't register anything in the IDE.
+    lptDesignTime,      // DesignTime packages can register anything in the IDE
+                        // and should not be compiled into projects.
+                        // The IDE calls the 'register' procedures of each unit.
+    lptRunAndDesignTime // RunAndDesignTime packages can do anything.
+    );
+    
+  TLazPackageFlag = (
+    lpfAutoIncrementVersionOnBuild, // increment version before
+    lpfModified,           // package needs saving
+    lpfAutoUpdate          // auto compile, if this package
+                           // or any required package has been modified
+    );
+  TLazPackageFlags = set of TLazPackageFlag;
+
+  TLazPackage = class
+  private
+    FAuthor: string;
+    FConflictPkgs: TList; // TList of TPkgDependency
+    FCompilerOptions: TPkgCompilerOptions;
+    FDescription: string;
+    FDirectory: string;
+    FVersion: TPkgVersion;
+    FFilename: string;
+    FFiles: TList; // TList of TPkgFile
+    FFlags: TLazPackageFlags;
+    FIconFile: string;
+    FName: string;
+    FModifiedLock: integer;
+    FPackageType: TLazPackageType;
+    FRequiredPkgs: TList; // TList of TPkgDependency
+    FTitle: string;
+    FUsageOptions: TAdditionalCompilerOptions;
+    function GetAutoIncrementVersionOnBuild: boolean;
+    function GetAutoUpdate: boolean;
+    function GetConflictPkgCount: integer;
+    function GetConflictPkgs(Index: integer): TPkgDependency;
+    function GetDirectory: string;
+    function GetFileCount: integer;
+    function GetFiles(Index: integer): TPkgFile;
+    function GetModified: boolean;
+    function GetRequiredPkgCount: integer;
+    function GetRequiredPkgs(Index: integer): TPkgDependency;
+    procedure SetAuthor(const AValue: string);
+    procedure SetAutoIncrementVersionOnBuild(const AValue: boolean);
+    procedure SetAutoUpdate(const AValue: boolean);
+    procedure SetDescription(const AValue: string);
+    procedure SetFilename(const AValue: string);
+    procedure SetFlags(const AValue: TLazPackageFlags);
+    procedure SetIconFile(const AValue: string);
+    procedure SetModified(const AValue: boolean);
+    procedure SetName(const AValue: string);
+    procedure SetPackageType(const AValue: TLazPackageType);
+    procedure SetTitle(const AValue: string);
+  public
+    constructor Create;
+    destructor Destroy; override;
+    procedure Clear;
+    procedure LockModified;
+    procedure UnlockModified;
+    procedure LoadFromXMLConfig(XMLConfig: TXMLConfig; const Path: string);
+    procedure SaveToXMLConfig(XMLConfig: TXMLConfig; const Path: string);
+  public
+    property Name: string read FName write SetName;
+    property Title: string read FTitle write SetTitle;
+    property Author: string read FAuthor write SetAuthor;
+    property Description: string read FDescription write SetDescription;
+    property Version: TPkgVersion read FVersion;
+    property Filename: string read FFilename write SetFilename; // the .lpk filename
+    property Directory: string read GetDirectory; // the path of the .lpk file
+    property IconFile: string read FIconFile write SetIconFile;
+    property PackageType: TLazPackageType
+      read FPackageType write SetPackageType;
+    property Flags: TLazPackageFlags read FFlags write SetFlags;
+    property Files[Index: integer]: TPkgFile read GetFiles;
+    property FileCount: integer read GetFileCount;
+    property RequiredPkgs[Index: integer]: TPkgDependency read GetRequiredPkgs;
+    property RequiredPkgCount: integer read GetRequiredPkgCount;
+    property ConflictPkgs[Index: integer]: TPkgDependency read GetConflictPkgs;
+    property ConflictPkgCount: integer read GetConflictPkgCount;
+    property Modified: boolean read GetModified write SetModified;
+    property CompilerOptions: TPkgCompilerOptions
+      read FCompilerOptions;
+    property AutoIncrementVersionOnBuild: boolean
+      read GetAutoIncrementVersionOnBuild write SetAutoIncrementVersionOnBuild;
+    property AutoUpdate: boolean read GetAutoUpdate write SetAutoUpdate;
+    property UsageOptions: TAdditionalCompilerOptions
+      read FUsageOptions;
+  end;
+
+const
+  LazPkgXMLFileVersion = 1;
+
+  PkgFileTypeNames: array[TPkgFileType] of string = (
+    'pftUnit', 'pftText' );
+  PkgFileTypeIdents: array[TPkgFileType] of string = (
+    'Unit', 'Text' );
+  PkgFileFlag: array[TPkgFileFlag] of string = (
+    'pffHasRegisterProc');
+  PkgDependencyFlagNames: array[TPkgDependencyFlag] of string = (
+    'pdfMinVersion', 'pdfMaxVersion');
+  LazPackageTypeNames: array[TLazPackageType] of string = (
+    'lptRunTime', 'lptDesignTime', 'lptRunAndDesignTime');
+  LazPackageTypeIdents: array[TLazPackageType] of string = (
+    'RunTime', 'DesignTime', 'RunAndDesignTime');
+  LazPackageFlagNames: array[TLazPackageFlag] of string = (
+    'lpfAutoIncrementVersionOnBuild', 'lpfModified', 'lpfAutoUpdate');
+    
+
+function PkgFileTypeIdentToType(const s: string): TPkgFileType;
+function LazPackageTypeIdentToType(const s: string): TLazPackageType;
+
+
+implementation
+
+
+function PkgFileTypeIdentToType(const s: string): TPkgFileType;
+begin
+  for Result:=Low(TPkgFileType) to High(TPkgFileType) do
+    if AnsiCompareText(s,PkgFileTypeIdents[Result])=0 then exit;
+  Result:=pftUnit;
+end;
+
+function LazPackageTypeIdentToType(const s: string): TLazPackageType;
+begin
+  for Result:=Low(TLazPackageType) to High(TLazPackageType) do
+    if AnsiCompareText(s,LazPackageTypeIdents[Result])=0 then exit;
+  Result:=lptRunTime;
+end;
+
+{ TPkgFile }
+
+procedure TPkgFile.SetFilename(const AValue: string);
+begin
+  if FFilename=AValue then exit;
+  FFilename:=AValue;
+end;
+
+function TPkgFile.GetHasRegisteredProc: boolean;
+begin
+  Result:=pffHasRegisterProc in FFlags;
+end;
+
+procedure TPkgFile.SetFileType(const AValue: TPkgFileType);
+begin
+  if FFileType=AValue then exit;
+  FFileType:=AValue;
+end;
+
+procedure TPkgFile.SetFlags(const AValue: TPkgFileFlags);
+begin
+  if FFlags=AValue then exit;
+  FFlags:=AValue;
+end;
+
+procedure TPkgFile.SetHasRegisteredProc(const AValue: boolean);
+begin
+  if HasRegisteredProc=AValue then exit;
+  if AValue then
+    Include(FFlags,pffHasRegisterProc)
+  else
+    Exclude(FFlags,pffHasRegisterProc);
+end;
+
+constructor TPkgFile.Create;
+begin
+  Clear;
+end;
+
+destructor TPkgFile.Destroy;
+begin
+  inherited Destroy;
+end;
+
+procedure TPkgFile.Clear;
+begin
+  FFilename:='';
+  FFlags:=[];
+  FFileType:=pftUnit;
+end;
+
+procedure TPkgFile.LoadFromXMLConfig(XMLConfig: TXMLConfig; const Path: string;
+  FileVersion: integer);
+begin
+  if FileVersion=1 then ;
+  Clear;
+  FFilename:=XMLConfig.GetValue(Path+'Filename/Value','');
+  HasRegisteredProc:=XMLConfig.GetValue(Path+'HasRegisteredProc/Value',false);
+  FileType:=PkgFileTypeIdentToType(XMLConfig.GetValue(Path+'Type/Value',''));
+end;
+
+procedure TPkgFile.SaveToXMLConfig(XMLConfig: TXMLConfig; const Path: string);
+begin
+  XMLConfig.SetDeleteValue(Path+'Filename/Value',Filename,'');
+  XMLConfig.SetDeleteValue(Path+'HasRegisteredProc/Value',HasRegisteredProc,
+                           false);
+  XMLConfig.SetDeleteValue(Path+'Type/Value',PkgFileTypeIdents[FileType],
+                           PkgFileTypeIdents[pftUnit]);
+end;
+
+{ TPkgDependency }
+
+procedure TPkgDependency.SetFlags(const AValue: TPkgDependencyFlags);
+begin
+  if FFlags=AValue then exit;
+  FFlags:=AValue;
+end;
+
+procedure TPkgDependency.SetMaxVersion(const AValue: TPkgVersion);
+begin
+  if FMaxVersion=AValue then exit;
+  FMaxVersion:=AValue;
+end;
+
+procedure TPkgDependency.SetMinVersion(const AValue: TPkgVersion);
+begin
+  if FMinVersion=AValue then exit;
+  FMinVersion:=AValue;
+end;
+
+procedure TPkgDependency.SetPackageName(const AValue: string);
+begin
+  if FPackageName=AValue then exit;
+  FPackageName:=AValue;
+end;
+
+constructor TPkgDependency.Create;
+begin
+  MinVersion:=TPkgVersion.Create;
+  MaxVersion:=TPkgVersion.Create;
+  Clear;
+end;
+
+destructor TPkgDependency.Destroy;
+begin
+  FreeAndNil(fMinVersion);
+  FreeAndNil(fMaxVersion);
+  inherited Destroy;
+end;
+
+procedure TPkgDependency.Clear;
+begin
+  FFlags:=[];
+  FMaxVersion.Clear;
+  FMinVersion.Clear;
+  FPackageName:='';
+end;
+
+procedure TPkgDependency.LoadFromXMLConfig(XMLConfig: TXMLConfig;
+  const Path: string; FileVersion: integer);
+begin
+  if FileVersion=1 then ;
+  Clear;
+  FPackageName:=XMLConfig.GetValue(Path+'PackageName/Value','');
+  MaxVersion.LoadFromXMLConfig(XMLConfig,Path+'MaxVersion/',FileVersion);
+  MinVersion.LoadFromXMLConfig(XMLConfig,Path+'MinVersion/',FileVersion);
+  if XMLConfig.GetValue(Path+'MaxVersion/Valid',false) then
+    Include(FFlags,pdfMaxVersion);
+  if XMLConfig.GetValue(Path+'MinVersion/Valid',false) then
+    Include(FFlags,pdfMinVersion);
+end;
+
+procedure TPkgDependency.SaveToXMLConfig(XMLConfig: TXMLConfig;
+  const Path: string);
+begin
+  XMLConfig.SetDeleteValue(Path+'PackageName/Value',PackageName,'');
+  MaxVersion.SaveToXMLConfig(XMLConfig,Path+'MaxVersion/');
+  MinVersion.SaveToXMLConfig(XMLConfig,Path+'MinVersion/');
+  XMLConfig.SetDeleteValue(Path+'MaxVersion/Value',pdfMaxVersion in FFlags,false);
+  XMLConfig.SetDeleteValue(Path+'MinVersion/Value',pdfMinVersion in FFlags,false);
+end;
+
+{ TPkgVersion }
+
+procedure TPkgVersion.Clear;
+begin
+  Major:=0;
+  Minor:=0;
+  Build:=0;
+  Release:=0;
+end;
+
+procedure TPkgVersion.LoadFromXMLConfig(XMLConfig: TXMLConfig;
+  const Path: string; FileVersion: integer);
+begin
+  if FileVersion=1 then ;
+  Clear;
+  Major:=XMLConfig.GetValue(Path+'Major',0);
+  Minor:=XMLConfig.GetValue(Path+'Minor',0);
+  Build:=XMLConfig.GetValue(Path+'Build',0);
+  Release:=XMLConfig.GetValue(Path+'Release',0);
+end;
+
+procedure TPkgVersion.SaveToXMLConfig(XMLConfig: TXMLConfig; const Path: string
+  );
+begin
+  XMLConfig.SetDeleteValue(Path+'Major',Major,0);
+  XMLConfig.SetDeleteValue(Path+'Minor',Minor,0);
+  XMLConfig.SetDeleteValue(Path+'Build',Build,0);
+  XMLConfig.SetDeleteValue(Path+'Release',Release,0);
+end;
+
+{ TLazPackage }
+
+function TLazPackage.GetAutoIncrementVersionOnBuild: boolean;
+begin
+  Result:=lpfAutoIncrementVersionOnBuild in FFlags;
+end;
+
+function TLazPackage.GetAutoUpdate: boolean;
+begin
+  Result:=lpfAutoUpdate in FFlags;
+end;
+
+function TLazPackage.GetConflictPkgCount: integer;
+begin
+  Result:=FConflictPkgs.Count;
+end;
+
+function TLazPackage.GetConflictPkgs(Index: integer): TPkgDependency;
+begin
+  Result:=TPkgDependency(FConflictPkgs[Index]);
+end;
+
+function TLazPackage.GetDirectory: string;
+begin
+  Result:=FDirectory;
+end;
+
+function TLazPackage.GetFileCount: integer;
+begin
+  Result:=FFiles.Count;
+end;
+
+function TLazPackage.GetFiles(Index: integer): TPkgFile;
+begin
+  Result:=TPkgFile(FFiles[Index]);
+end;
+
+function TLazPackage.GetModified: boolean;
+begin
+  Result:=lpfModified in FFlags;
+end;
+
+function TLazPackage.GetRequiredPkgCount: integer;
+begin
+  Result:=FRequiredPkgs.Count;
+end;
+
+function TLazPackage.GetRequiredPkgs(Index: integer): TPkgDependency;
+begin
+  Result:=TPkgDependency(FRequiredPkgs[Index]);
+end;
+
+procedure TLazPackage.SetAuthor(const AValue: string);
+begin
+  if FAuthor=AValue then exit;
+  FAuthor:=AValue;
+  Modified:=true;
+end;
+
+procedure TLazPackage.SetAutoIncrementVersionOnBuild(const AValue: boolean);
+begin
+  if AutoIncrementVersionOnBuild=AValue then exit;
+  if AValue then
+    Include(FFlags,lpfAutoIncrementVersionOnBuild)
+  else
+    Exclude(FFlags,lpfAutoIncrementVersionOnBuild);
+  Modified:=true;
+end;
+
+procedure TLazPackage.SetAutoUpdate(const AValue: boolean);
+begin
+  if AValue=AutoUpdate then exit;
+  if AValue then
+    Include(FFlags,lpfAutoUpdate)
+  else
+    Exclude(FFlags,lpfAutoUpdate);
+  Modified:=true;
+end;
+
+procedure TLazPackage.SetDescription(const AValue: string);
+begin
+  if FDescription=AValue then exit;
+  FDescription:=AValue;
+  Modified:=true;
+end;
+
+procedure TLazPackage.SetFilename(const AValue: string);
+begin
+  if FFilename=AValue then exit;
+  FFilename:=AValue;
+  FDirectory:=ExtractFilePath(FFilename);
+  Modified:=true;
+end;
+
+procedure TLazPackage.SetFlags(const AValue: TLazPackageFlags);
+begin
+  if FFlags=AValue then exit;
+  FFlags:=AValue;
+  Modified:=true;
+end;
+
+procedure TLazPackage.SetIconFile(const AValue: string);
+begin
+  if FIconFile=AValue then exit;
+  FIconFile:=AValue;
+  Modified:=true;
+end;
+
+procedure TLazPackage.SetModified(const AValue: boolean);
+begin
+  if FModifiedLock>0 then exit;
+  if AValue then
+    Include(FFlags,lpfModified)
+  else
+    Exclude(FFlags,lpfModified);
+end;
+
+procedure TLazPackage.SetName(const AValue: string);
+begin
+  if FName=AValue then exit;
+  FName:=AValue;
+  Modified:=true;
+end;
+
+procedure TLazPackage.SetPackageType(const AValue: TLazPackageType);
+begin
+  if FPackageType=AValue then exit;
+  FPackageType:=AValue;
+  Modified:=true;
+end;
+
+procedure TLazPackage.SetTitle(const AValue: string);
+begin
+  if FTitle=AValue then exit;
+  FTitle:=AValue;
+  Modified:=true;
+end;
+
+constructor TLazPackage.Create;
+begin
+  FVersion:=TPkgVersion.Create;
+  FConflictPkgs:=TList.Create;
+  FRequiredPkgs:=TList.Create;
+  FFiles:=TList.Create;
+end;
+
+destructor TLazPackage.Destroy;
+begin
+  Clear;
+  FreeAndNil(FFiles);
+  FreeAndNil(FConflictPkgs);
+  FreeAndNil(FRequiredPkgs);
+  FreeAndNil(FVersion);
+  inherited Destroy;
+end;
+
+procedure TLazPackage.Clear;
+var
+  i: Integer;
+begin
+  FAuthor:='';
+  for i:=0 to FConflictPkgs.Count-1 do ConflictPkgs[i].Free;
+  FConflictPkgs.Clear;
+  FCompilerOptions.Clear;
+  FDescription:='';
+  FDirectory:='';
+  FVersion.Clear;
+  FFilename:='';
+  for i:=0 to FFiles.Count-1 do Files[i].Free;
+  FFiles.Clear;
+  FFlags:=[lpfAutoIncrementVersionOnBuild,lpfAutoUpdate];
+  FIconFile:='';
+  FName:='';
+  FPackageType:=lptRunTime;
+  for i:=0 to FRequiredPkgs.Count-1 do RequiredPkgs[i].Free;
+  FRequiredPkgs.Clear;
+  FTitle:='';
+  FUsageOptions.Clear;
+end;
+
+procedure TLazPackage.LockModified;
+begin
+  inc(FModifiedLock);
+end;
+
+procedure TLazPackage.UnlockModified;
+begin
+  if FModifiedLock<=0 then
+    RaiseException('TLazPackage.UnlockModified');
+  dec(FModifiedLock);
+end;
+
+procedure TLazPackage.LoadFromXMLConfig(XMLConfig: TXMLConfig;
+  const Path: string);
+var
+  FileVersion: integer;
+
+  procedure LoadPkgDependencyList(const ThePath: string; List: TList);
+  var
+    i: Integer;
+    PkgDependency: TPkgDependency;
+    NewCount: Integer;
+  begin
+    NewCount:=XMLConfig.GetValue(ThePath+'Count',0);
+    for i:=0 to NewCount-1 do begin
+      PkgDependency:=TPkgDependency.Create;
+      PkgDependency.LoadFromXMLConfig(XMLConfig,ThePath+'Item'+IntToStr(i)+'/',
+                                      FileVersion);
+      List.Add(PkgDependency);
+    end;
+  end;
+
+  procedure LoadFiles(const ThePath: string; List: TList);
+  var
+    i: Integer;
+    NewCount: Integer;
+    PkgFile: TPkgFile;
+  begin
+    NewCount:=XMLConfig.GetValue(ThePath+'Count',0);
+    for i:=0 to NewCount-1 do begin
+      PkgFile:=TPkgFile.Create;
+      PkgFile.LoadFromXMLConfig(XMLConfig,ThePath+'Item'+IntToStr(i)+'/',
+                                FileVersion);
+      List.Add(PkgFile);
+    end;
+  end;
+  
+  procedure LoadFlags(const ThePath: string);
+  begin
+    if XMLConfig.GetValue(ThePath+'AutoIncrementVersionOnBuild/Value',true) then
+      Include(FFlags,lpfAutoIncrementVersionOnBuild)
+    else
+      Exclude(FFlags,lpfAutoIncrementVersionOnBuild);
+    if XMLConfig.GetValue(ThePath+'AutoUpdate/Value',true) then
+      Include(FFlags,lpfAutoUpdate)
+    else
+      Exclude(FFlags,lpfAutoUpdate);
+  end;
+
+begin
+  FileVersion:=XMLConfig.GetValue(Path+'Version',0);
+  if FileVersion=1 then ;
+  Clear;
+  LockModified;
+  FAuthor:=XMLConfig.GetValue(Path+'Author/Value','');
+  LoadPkgDependencyList(Path+'ConflictPkgs/',FConflictPkgs);
+  FCompilerOptions.LoadFromXMLConfig(XMLConfig,Path+'CompilerOptions/');
+  FDescription:=XMLConfig.GetValue(Path+'Description','');
+  FVersion.LoadFromXMLConfig(XMLConfig,Path+'Version/',FileVersion);
+  LoadFiles(Path+'Files/',FFiles);
+  LoadFlags(Path);
+  FIconFile:=XMLConfig.GetValue(Path+'IconFile/Value','');
+  FName:=XMLConfig.GetValue(Path+'Name/Value','');
+  FPackageType:=LazPackageTypeIdentToType(XMLConfig.GetValue(Path+'Type/Value',
+                                          LazPackageTypeIdents[lptRunTime]));
+  LoadPkgDependencyList(Path+'RequiredPkgs/',FRequiredPkgs);
+  FTitle:=XMLConfig.GetValue(Path+'Title/Value','');
+  FUsageOptions.LoadFromXMLConfig(XMLConfig,Path+'UsageOptions/');
+  UnlockModified;
+end;
+
+procedure TLazPackage.SaveToXMLConfig(XMLConfig: TXMLConfig; const Path: string
+  );
+  
+  procedure SavePkgDependencyList(const ThePath: string; List: TList);
+  var
+    i: Integer;
+    PkgDependency: TPkgDependency;
+  begin
+    XMLConfig.SetDeleteValue(Path+'Count',List.Count,0);
+    for i:=0 to List.Count-1 do begin
+      PkgDependency:=TPkgDependency(List[i]);
+      PkgDependency.SaveToXMLConfig(XMLConfig,ThePath+'Item'+IntToStr(i)+'/');
+    end;
+  end;
+
+  procedure SaveFiles(const ThePath: string; List: TList);
+  var
+    i: Integer;
+    PkgFile: TPkgFile;
+  begin
+    XMLConfig.SetDeleteValue(Path+'Count',List.Count,0);
+    for i:=0 to List.Count-1 do begin
+      PkgFile:=TPkgFile(List[i]);
+      PkgFile.SaveToXMLConfig(XMLConfig,ThePath+'Item'+IntToStr(i)+'/');
+    end;
+  end;
+  
+  procedure SaveFlags(const ThePath: string);
+  begin
+    XMLConfig.SetDeleteValue(ThePath+'AutoIncrementVersionOnBuild/Value',
+      AutoIncrementVersionOnBuild,true);
+    XMLConfig.SetDeleteValue(ThePath+'AutoUpdate/Value',AutoUpdate,true);
+  end;
+
+begin
+  XMLConfig.SetDeleteValue(Path+'Author/Value',FAuthor,'');
+  SavePkgDependencyList(Path+'ConflictPkgs/',FConflictPkgs);
+  FCompilerOptions.SaveToXMLConfig(XMLConfig,Path+'CompilerOptions/');
+  XMLConfig.SetDeleteValue(Path+'Description',FDescription,'');
+  FVersion.SaveToXMLConfig(XMLConfig,Path+'Version/');
+  SaveFiles(Path+'Files/',FFiles);
+  SaveFlags(Path);
+  XMLConfig.SetDeleteValue(Path+'IconFile/Value',FIconFile,'');
+  XMLConfig.SetDeleteValue(Path+'Name/Value',FName,'');
+  XMLConfig.SetDeleteValue(Path+'Type/Value',LazPackageTypeIdents[FPackageType],
+                           LazPackageTypeIdents[lptRunTime]);
+  SavePkgDependencyList(Path+'RequiredPkgs/',FRequiredPkgs);
+  XMLConfig.SetDeleteValue(Path+'Title/Value',FTitle,'');
+  FUsageOptions.SaveToXMLConfig(XMLConfig,Path+'UsageOptions/');
+end;
+
+end.
+