One of our main requirements was to be able to preview a backup as well as execute it and we have endowed our Project class with a Preview method. Now it’s time to implement it.

We need a place to display the preview – the list of actual files that would be backed up by the Backup method. We can add another tab to the Tab control and label it Preview. To this, add a DataGrid named PreviewGrid, and a button labeled Preview.

Again we need an ExpressionHandle to power this feature, add one and name it FileEntriesHandle. The RootHandle will once again be ProjectsCM, and the Expression will be self.FileEntries. Link the datagrid up by setting the DataSource to FileEntriesHandle. Once again it will show the unneeded Project column in the grid. Get rid of this as before by adding a TableStyle and defining just two columns for the FilePath and FileSize attributes.

Create a Click event for the Preview button. The code needed here is:

var p: Project;

begin

  p := ProjectsCM.CurrentElement(ProjectList).AsObject as Project;

  p.Preview;

end;

As elsewhere, we need to get access to the current Project. Then we call the Preview method of the Project.

Of course we don’t yet have any functionality in the Preview method. We’ll fix this now. Go to the model and right click on the Preview method in the Project class. Here you can click on “Go to Definition”. This takes you to the interface declaration of Preview (actually the attribute line above it). Move down to the Preview method and you can use Ctrl-Shift-DownArrow to move to the implementation section. In this method, you only need type one line:

  BuildEntryList;

Now of course we need to define the BuildEntryList method. We’re placing this in a separate method because our Backup method is also going to need to call this. Following is the BuildEntryList method. Note that you need to add the System.IO namespace to the unit’s Uses clause.

procedure Project.BuildEntryList;

var fld: Folder;

    di: DirectoryInfo;

  // find requested files for passed directory

  procedure ProcessMask(d: DirectoryInfo);

  var mask: FileMask;

      fi: FileInfo;

      files: array of FileInfo;

      fe: FileEntry;

  begin

    // apply each mask in turn

    for mask in FileMasks do

    begin

      files := d.GetFiles(mask.Mask);

      for fi in files do

      begin

        fe := FileEntry.Create(self.AsIObject.ServiceProvider);

        fi.Refresh;

        fe.FileSize := fi.Length;

        fe.FilePath := fi.FullName;

        self.FileEntrys.Add(fe);

      end;

    end;

  end;
  // recurse folders from passed starting point

  procedure RecurseFolders(di: DirectoryInfo);

  var dirs: array of DirectoryInfo;

      di2: DirectoryInfo;

  begin

    dirs := di.GetDirectories;

    for di2 in dirs do

    begin

      ProcessMask(di2);

      RecurseFolders(di2);

    end;

  end;
begin

  FileEntrys.Clear;

  for fld in Folders do

  begin

    di := DirectoryInfo.Create(fld.Path);

    ProcessMask(di);

    if fld.Recurse then

    begin

      RecurseFolders(di);

    end;

  end;

end;

This method makes use of Delphi nested procedures and should make the code easier to understand. The mainline of the method starts by clearing any existing FileEntry objects from the Project. It then loops through the list of Folder classes that have been added by the user for this Project. For each, it calls ProcessMask to find and add any matching files in that folder. It then checks to see if it should recurse sub-folders, and if so, calls RecurseFolders.

RecurseFolders is a recursive procedure. It asks the passed DirectoryInfo object for a list of sub-folders. If any are returned, it loops through them, calling ProcessMask and then calling itself in order to continue the recursion. This will continue for any depth of sub-folders.

ProcessMask loops through each of the FileMask objects the user has added and, for each, asks the passed DirectoryInfo object for a list of matching files (much easier then the equivalent FindFirst/FindNext/FindClose technique needed in Win32!). For each file found, a FileEntry object is created and added to the Project’s FileEntrys list. Note the FileInfo object returned by the system must be refreshed in order for it to correctly report the size of the file.

With this complete, we have some actual functionality, run the application and, with folders and masks defined, go to the Preview tab and click the button!

Before we can add the functionality, first we need to make a reference to the needed zip dll. As noted at the beginning of this article, you need to download and install SharpZipLib. We also need to reference the Indy components in order to use its FTP component. Right click on the References node in the Project Manager and click Add Reference.

Here in the list you should be able to find the needed Indy assemblies, these are IndyCore, IndyProtocols, and IndySystem. Highlight these 3 and click Add Reference.

You can then click the browse button to find the ICSharpCode.SharpZipLib.dll assembly, wherever you installed it.

Clicking OK on this dialog will add the four selected references to the project. You will then also be able to add these to the Uses clause.

Add a new button on the main form under the ProjectList datagrid and label it Backup. Name it as BackupButton and create a Click event for it. The Click event will contain the following code:

var p: Project;

begin

  BackupButton.Enabled := False;

  try

    p := ProjectsCM.CurrentElement(ProjectList).AsObject as Project;

    // clear the file list display

    p.FileEntrys.Clear;

    if PreviewGrid.Visible then

      PreviewGrid.Update;

    p.Backup;
  finally

    BackupButton.Enabled := True;

  end;

Here we use a try/finally block to disable the Backup button and re-enable it at completion, just to ensure it cannot be clicked again while a backup is in progress. As usual, we get the current Project object and clear out any FileEntry objects it may be holding. To make the display a little cleaner, we also update the PreviewGrid to show it empty prior to starting the backup. It will be regenerated by the backup process. Finally, we call the Backup method.

Find your way to the Project class’ Backup method. In that package unit, add the following references to the Uses clause: ICSharpCode.SharpZipLib.Zip, ICSharpCode.SharpZipLib.Core, IDFTP, and IDComponent.

Now we can add the code for the Backup method.

var fe: FileEntry;

    zip: ZipOutputStream;

    zentry: ZipEntry;

    infile: FileStream;

    memfile: MemoryStream;

    buffer: array of byte;

    ftp: TIdFtp;

begin

  BuildEntryList;

  if BackupName = ” then

    BackupName := BackupName.Format(’{0}{1}.zip’, self.Name,

      DateTime.Now.ToString(’yyyyMMddhhmmss’));
  memfile := MemoryStream.Create;

  zip := ZipOutputStream.Create(memfile);
  // now process the entries

  for fe in FileEntrys do

  begin

    zentry := ZipEntry.Create(fe.FilePath);

    infile := &File.OpenRead(fe.FilePath);

    SetLength(buffer, infile.Length);

    infile.Read(buffer, 0, infile.Length);

    zip.PutNextEntry(zentry);

    zip.Write(buffer, 0, infile.Length);

  end;

  zip.Finish;

  zip.Flush;

  memfile.Position := 0;
  // upload to a server?

  if ServerName <> ” then

  begin // yes

    ftp := TIdFtp.Create;

    try

      ftp.Host := ServerName;

      ftp.Username := ServerUserID;

      ftp.Password := ServerPassword;

      ftp.Connect();

      ftp.ChangeDir(ServerPath);

      ftp.Put(memfile, BackupName);

    finally

      ftp.Free;

    end;

  end else

  begin // save locally

    infile := &File.OpenWrite(ServerPath + ‘\’ + BackupName);

    memfile.WriteTo(infile);

    infile.Close;

  end;
  memfile.Free;

  zip.Close;

end;  

The first thing Backup does is call the BuildEntryList method we created earlier. This gives it an up-to-date list of files to be backed up. Then we make sure there’s a name for the backup file, if one was not specified then we generate one combining the Project name with the current timestamp. We then create a zip file using a memory stream and add each of the target files to it. Finally, if server information has been specified, we attempt to FTP the file to the specified location on the server, otherwise we assume the ServerPath attribute is a local file path and attempt to save the zip file to there.

We now have a fully functional backup utility. However, it has one major flaw: there is no feedback of any kind while it’s performing a backup, no way to see its progress. Typically, a backup utility is going to have a progress meter, and usually displays the file names as they are processed, so we’ll do that.

We’d like to get feedback from our Project object as it’s performing its work. However, under no circumstances do we want the model to know anything about our user interface, thus it cannot directly access our form. In order to get feedback, we need to observe our Project object. ECO implements the Observer (also know as Publish and Subscribe) pattern in all ECO classes you define and provides the necessary methods to let you set up such subscriptions. You can observe an object or a specific attribute (property) of an object.

We will add some new attributes to our Project class specifically to provide information about its progress. The attributes we will add are as follows:

BackupSize: Int64

ProgressPoint: Integer

ProgressState: string

Because these are only intended for use while the Project object is performing a backup, we do not want these attributes to be stored when saved to file. Therefore be sure to set the Persistence property of all three of these to Transient.

Now we need to add some code to make use of these attributes. Navigate to the BuildEntryList method and as the first line of its (main) code, add:

  ProgressState := ‘Preparing File List’;

We will want to report the status of the FTP process, so we need to provide a couple of event handlers to hook to. These will look as follows, use code-completion after entering the code in order to declare them in the class:

procedure Project.FTPStatus(ASender: TObject; const AStatus: TIDStatus;

const AStatusText: string);

begin

  ProgressState := AStatusText;

end;

procedure Project.FTPWork(ASender: TObject; AWorkMode: TWorkMode;

AWorkCount: integer);

begin

  ProgressState := ‘Writing ‘ + AWorkCount.ToString(’N0′) + ‘ of ‘

    + BackupSize.ToString(’N0′);

end;

In the Backup method, there are a number of additional lines to be added, rather than listing each one, here is the complete backup method again with the new lines in bold.

procedure Project.Backup;

var fe: FileEntry;

    zip: ZipOutputStream;

    zentry: ZipEntry;

    infile: FileStream;

    memfile: MemoryStream;

    buffer: array of byte;

    ftp: TIdFtp;

begin

  BuildEntryList;

  if BackupName = ” then

    BackupName := BackupName.Format(’{0}{1}.zip’, self.Name,

      DateTime.Now.ToString(’yyyyMMddhhmmss’));

  memfile := MemoryStream.Create;

  zip := ZipOutputStream.Create(memfile);
  ProgressState := ‘Compressing Files’;

  ProgressPoint := -1; // tell subscribers to initialize

  ProgressPoint := 0; // start
  // now process the entries

  for fe in FileEntrys do

  begin

    ProgressState := fe.FilePath;

    zentry := ZipEntry.Create(fe.FilePath);

    infile := &File.OpenRead(fe.FilePath);

    SetLength(buffer, infile.Length);

    infile.Read(buffer, 0, infile.Length);

    zip.PutNextEntry(zentry);

    zip.Write(buffer, 0, infile.Length);

    ProgressPoint := ProgressPoint + 1;

  end;

  zip.Finish;

  zip.Flush;
  BackupSize := zip.Length;

  ProgressState := ‘Writing Backup File’;
  memfile.Position := 0;

  // upload to a server?

  if ServerName <> ” then

  begin // yes

    ftp := TIdFtp.Create;

    try

      ftp.Host := ServerName;

      ftp.Username := ServerUserID;

      ftp.Password := ServerPassword;

      ftp.OnStatus := FTPStatus;

      ftp.OnWork := FTPWork;

      ftp.Connect();

      ftp.ChangeDir(ServerPath);

      ftp.Put(memfile, BackupName);

    finally

      ftp.Free;

    end;

  end else

  begin // save locally

    infile := &File.OpenWrite(ServerPath + ‘\’ + BackupName);

    memfile.WriteTo(infile);

    infile.Close;

  end;
  memfile.Free;

  zip.Close;

  ProgressState := ‘Backup complete’;

end;

To take advantage of subscriptions, the observer must implement the ISubscriber interface. ISubscriber is defined in the Borland.Eco.Subscription namespace, so add this to the Uses clause of the form. We can then alter our form to implement the interface by changing the first line of the form definition to be:

TWinForm1 = class(System.Windows.Forms.Form, ISubscriber)

The ISubscriber interface requires two methods to be implemented, these are IsAlive and Receive. The IDE can help here, just scroll down to the bottom of the TWinform1 class and, in the public section, hit Ctrl-Space, Delphi will show you a list of overrideable methods with IsAlive and Receive at the top and in red. Highlight both of these (the list allows multi-select) and hit return, then Shift-Ctrl-C to create the implementation stubs.

The IsAlive method needs only one line – set the Result to True to indicate you want the subscription to continue.

Before implementing the Receive method, let’s set up the subscriptions. These will go in the click event of the Backup button, just before the call to Backup:

    p.AsIObject.Properties['ProgressState'].SubscribeToValue(self);

    p.AsIObject.Properties['ProgressPoint'].SubscribeToValue(self);

Underlying our Project (and other) objects, is an ECO object that implements the plumbing ECO needs to do its work for us. The AsIObject property gives us access to that underlying object and the Properties property gives access to the plumbing for our individual properties. The ability to subscribe exists at that level. The above lines set up a subscription for our form (self) on two of the attributes we added. When passing self, we are actually passing the ISubscriber interface we’ve implemented, and so ECO will now be able to call our Receive method whenever either of these Project attributes changes.

We now need to add a couple of items to our user interface to display progress, a label and a progress gauge. Name them ProgressLabel and ProgressBar respectively.

Below is the code for the Receive method. The first line gets the actual attribute that has changed. When the type of the object is a string, it must be ProgressState that has changed, if an integer, then it must be ProgressPoint. If an integer, we check if it is -1, the signal from Project that it is about to start the counting, this gives us an opportunity to initialize our progress gauge.

var o: TObject;

    p: Project;

begin

  o := (ElementChangedEventArgs(e).Element.AsObject);

  if o is string then

  begin

    ProgressLabel.Text := o.ToString;

    ProgressLabel.Refresh;

  end

  else if o is Integer then

  begin

    if Integer(o) = -1 then

    begin

      p := ProjectsCM.CurrentElement(ProjectList).AsObject as Project;

      ProgressBar.Value := 0;

      ProgressBar.Maximum := p.FileEntrys.Count;

    end else

    if Integer(o) <= ProgressBar.Maximum then

    begin

      ProgressBar.Value := Integer(o);

    end;

    ProgressBar.Refresh;

  end;

  Result := True;

end;

You should now be able to compile and run the application and, pressing the backup button on a project, you should see visible feedback.

Doing it better…

unit ECOSubscribe;

interface
uses

  Borland.Eco.Subscription;
type

  TECOSubscriber = class(TObject, ISubscriber)

  private

    FOnReceive: EventHandler;

  published

  public

    function IsAlive: Boolean;

    function Receive(sender: TObject; e: EventArgs): Boolean;

    procedure set_OnReceive(const Value: EventHandler);

    property OnReceive: EventHandler add FOnReceive remove set_OnReceive;

  end;
implementation
{ TECOSubscriber }
function TECOSubscriber.IsAlive: Boolean;

begin

  Result := True;

end;
function TECOSubscriber.Receive(sender: TObject; e: EventArgs): Boolean;

begin

  if Assigned(FOnReceive) then

    FOnReceive(Self, e);

end;
procedure TECOSubscriber.set_OnReceive(const Value: EventHandler);

begin

  FOnReceive := Value;

end;
end.

    FProgressState: TECOSubscriber;

    FProgressPoint: TECOSubscriber;

    procedure ProgressStateChanged(sender: TObject; e: EventArgs);

    procedure ProgressPointChanged(sender: TObject; e: EventArgs);

procedure TWinForm1.ProgressStateChanged(sender: TObject; e: EventArgs);

begin

  ProgressLabel.Text :=

    (ElementChangedEventArgs(e).Element.AsObject).ToString;

end;

procedure TWinForm1.ProgressPointChanged(sender: TObject; e: EventArgs);

var p: Project;

    point: integer;

begin

  point := Integer(ElementChangedEventArgs(e).Element.AsObject);

  if point = -1 then

  begin

    p := ProjectsCM.CurrentElement(ProjectList).AsObject as Project;

    ProgressBar.Value := 0;

    ProgressBar.Maximum := p.FileEntrys.C