{************************************************}
{                                                }
{   Turbo Vision File Manager Demo               }
{   Copyright (c) 1992 by Borland International  }
{                                                }
{   For Virtual Pascal v2.1 (c) 2000 vpascal.com }
{                                                }
{************************************************}

{$V-}
{&Use32+,Delphi-}

unit Assoc;  { Association list manager }

interface

uses Objects, Dos;

type
  PAssociation = ^TAssociation;
  TAssociation = object(TObject)
    Ext: ExtStr;
    Cmd: PString;
    Prompt: Boolean;
    constructor Init(AExt: ExtStr; const ACmd: String; APrompt: Boolean);
    constructor Load(var S: TStream);
    destructor Done; virtual;
    procedure Store(var S: TStream);
  end;

procedure InitAssociations;
procedure DoneAssociations;

procedure Associate(DefExt: ExtStr);
function GetAssociatedCommand(Ext: ExtStr): PAssociation;
procedure WriteAssociationList(var S: TStream);
procedure ReadAssociationList(var S: TStream);

procedure RegisterAssociations;

implementation

uses Drivers, Views, Dialogs, App, MsgBox, Validate, Tools;

const
  cmAddAssoc   = 100;
  cmEditAssoc  = cmAddAssoc + 1;
  cmDelAssoc   = cmEditAssoc + 1;

type
  { transfer record for a list box }
  TListBoxRec = record
    List: PCollection;
    Selection: Word;
  end;

  TAssocRec = record
    Extension: ExtStr;
    Command: String;
    Prompt: Word;
  end;

  PAssociateList = ^TAssociateList;
  TAssociateList = object(TCollection)
    procedure FillCloneList(P: PCollection);
    procedure UseCloneList(P: PCollection);
  end;

  PAssocBox = ^TAssocBox;
  TAssocBox = object(TListBox)
    function GetText(Item: Integer; MaxLen: Integer): String; virtual;
  end;

  PAssocDialog = ^TAssocDialog;
  TAssocDialog = object(TDialog)
    DefExt: ExtStr;
    ListBox: PAssocBox;
    constructor Init(ADefExt: ExtStr);
    procedure HandleEvent(var Event: TEvent); virtual;
  end;

  PExtValidator = ^TExtValidator;
  TExtValidator = object(TValidator)
    function IsValid(const S: string): Boolean; virtual;
    procedure Error; virtual;
  end;

  PNonBlankValidator = ^TNonBlankValidator;
  TNonBlankValidator = object(TPXPictureValidator)
    procedure Error; virtual;
  end;

const
  RAssociation : TStreamRec = (
    ObjType : 1001;
    VmtLink : Ofs(TypeOf(TAssociation)^);
    Load    : @TAssociation.Load;
    Store   : @TAssociation.Store
  );
  RAssociateList : TStreamRec = (
    ObjType : 1002;
    VmtLink : Ofs(TypeOf(TAssociateList)^);
    Load    : @TAssociateList.Load;
    Store   : @TAssociateList.Store
  );

const
  AssociateList: PAssociateList = nil;

{ TAssociateList }
procedure TAssociateList.FillCloneList(P: PCollection);

  procedure AddCloneItem(Item: PAssociation); far;
  begin
    P^.Insert(New(PAssociation, Init(Item^.Ext, Item^.Cmd^, Item^.Prompt)));
  end;

begin
  ForEach(@AddCloneItem);
end;

procedure TAssociateList.UseCloneList(P: PCollection);

  procedure UseCloneItem(Item: PAssociation); far;
  begin
    Insert(New(PAssociation, Init(Item^.Ext, Item^.Cmd^, Item^.Prompt)));
  end;

begin
  FreeAll;
  P^.ForEach(@UseCloneItem);
end;


{ TAssociation }
constructor TAssociation.Init(AExt: ExtStr; const ACmd: String;
  APrompt: Boolean);
begin
  inherited Init;
  Ext := AExt;
  Cmd := NewStr(ACmd);
  Prompt := APrompt;
end;

constructor TAssociation.Load(var S: TStream);
begin
  inherited Init;
  S.Read(Ext, SizeOf(Ext));
  Cmd := S.ReadStr;
  S.Read(Prompt, SizeOf(Prompt));
end;

destructor TAssociation.Done;
begin
  DisposeStr(Cmd);
  inherited Done;
end;

procedure TAssociation.Store(var S: TStream);
begin
  S.Write(Ext, SizeOf(Ext));
  S.WriteStr(Cmd);
  S.Write(Prompt, SizeOf(Prompt));
end;

{ TAssocBox }
function TAssocBox.GetText(Item: Integer; MaxLen: Integer): String;
var
  T: PAssociation;
  Params: array[0..1] of Longint;
  S: String;
begin
  T := List^.At(Item);
  Params[0] := Longint(@T^.Ext);
  Params[1] := Longint(T^.Cmd);
  FormatStr(S, '%-13s %s', Params);
  if Length(S) > MaxLen then
  begin
    S[0] := Char(MaxLen);
    { Fill the last three characters with an ellipses }
    FillChar(S[MaxLen - 4], 3, '.');
  end;
  GetText := S;
end;

function CreateEditDialog: PDialog;
var
  R: TRect;
  D: PDialog;
  P: PView;
begin
  R.Assign(0,0,60,9);
  D := New(PDialog, Init(R, 'Edit Association'));
  with D^ do
  begin
    Options := Options or ofCentered;
    R.Assign(17,2,58,3);
    P := New(PInputLine, Init(R, SizeOf(ExtStr) - 1));
    Insert(P);
    PInputLine(P)^.SetValidator(New(PExtValidator, Init));
    P^.Options := P^.Options or ofValidate;
    R.Assign(2,2,17,3);
    Insert(New(PLabel, Init(R, '~E~xtension', P)));

    R.Assign(17,3,58,4);
    P := New(PInputLine, Init(R, SizeOf(String) - 1));
    PInputLine(P)^.SetValidator(New(PNonBlankValidator, Init('@*[@]',False)));
    P^.Options := P^.Options or ofValidate;
    Insert(P);

    R.Assign(2,3,17,4);
    Insert(New(PLabel, Init(R, 'Co~m~mmand', P)));

    R.Assign(17,4,58,5);
    Insert(New(PCheckBoxes, Init(R, NewSItem('~P~rompt for parameters',
      nil))));

    R.Assign(2,6,12,8);
    Insert(New(PButton, Init(R, '~O~K', cmOK, bfDefault)));
    R.Move(12,0);
    Insert(New(PButton, Init(R, '~C~ancel', cmCancel, bfNormal)));

    SelectNext(False);
  end;
  CreateEditDialog := D;
end;

function AddAssociation(var ListBoxRec: TListBoxRec; DefExt: ExtStr): Word;
var
  D: PDialog;
  XFer: TAssocRec;
  Result: Word;
begin
  XFer.Extension := DefExt;
  XFer.Command := '';
  D := CreateEditDialog;
  Result := Application^.ExecuteDialog(D, @XFer);
  if Result = cmOK then with XFer do
  begin
    UpperCase(Extension);
    ListBoxRec.List^.Insert(New(PAssociation, Init(Extension, Command,
      Prompt > 0)));
  end;
  AddAssociation := Result;
end;

function EditAssociation(var ListBoxRec: TListBoxRec): Word;
var
  D: PDialog;
  XFer: TAssocRec;
  Assoc: PAssociation;
  Result: Integer;
begin
  Result := cmCancel;
  if ListBoxRec.List^.Count = 0 then Exit;
  Assoc := ListBoxRec.List^.At(ListBoxRec.Selection);
  XFer.Extension := Assoc^.Ext;
  XFer.Command := Assoc^.Cmd^;
  if Assoc^.Prompt then XFer.Prompt := 1
  else XFer.Prompt := 0;
  D := CreateEditDialog;
  Result := Application^.ExecuteDialog(D, @XFer);
  if Result = cmOK then
  begin
    UpperCase(XFer.Extension);
    Assoc^.Ext := XFer.Extension;
    DisposeStr(Assoc^.Cmd);
    Assoc^.Cmd := NewStr(XFer.Command);
    Assoc^.Prompt := XFer.Prompt > 0;
  end;
  EditAssociation := Result;
end;

function DeleteAssociation(var ListBoxRec: TListBoxRec): Word;
var
  Assoc: PAssociation;
  Result: Integer;
  P: PString;
begin
  Result := cmCancel;
  if ListBoxRec.List^.Count = 0 then Exit;
  Assoc := ListBoxRec.List^.At(ListBoxRec.Selection);
  P := @Assoc^.Ext;
  Result := MessageBox('Delete association for %s?', @P,
    mfConfirmation + mfOKButton + mfCancelButton);
  if Result = cmOK then
    ListBoxRec.List^.AtFree(ListBoxRec.Selection);
  DeleteAssociation := Result;
end;

{ TAssocDialog }
constructor TAssocDialog.Init(ADefExt: ExtStr);
var
  R: TRect;
  SB: PScrollBar;
begin
  R.Assign(0,0,65,15);
  inherited Init(R, 'File Associations');
  DefExt := ADefExt;
  Options := Options or ofCentered;

  R.Assign(62,3,63,11);
  SB := New(PScrollBar, Init(R));
  Insert(SB);
  R.Assign(2,3,62,11);
  ListBox := New(PAssocBox, Init(R, 1, SB));
  Insert(ListBox);
  R.Assign(2,2,32,3);
  Insert(New(PStaticText, Init(R, 'Extension      Command line')));

  R.Assign(2,12,12,14);
  Insert(New(PButton, Init(R, '~A~dd', cmAddAssoc, bfNormal)));
  R.Move(11, 0);
  Insert(New(PButton, Init(R, '~E~dit', cmEditAssoc, bfNormal)));
  R.Move(11, 0);
  Insert(New(PButton, Init(R, '~D~elete', cmDelAssoc, bfNormal)));

  R.Move(16, 0);
  Insert(New(PButton, Init(R, '~O~K', cmOK, bfDefault)));
  R.Move(11, 0);
  Insert(New(PButton, Init(R, '~C~ancel', cmCancel, bfNormal)));
  SelectNext(False);
end;

procedure TAssocDialog.HandleEvent(var Event: TEvent);
var
  ListBoxRec: TListBoxRec;
begin
  if ListBox^.List^.Count = 0 then
    DisableCommands([cmEditAssoc,cmDelAssoc])
  else
    EnableCommands([cmEditAssoc,cmDelAssoc]);

  inherited HandleEvent(Event);
  if Event.What = evCommand then
  begin
    ListBoxRec.List := ListBox^.List;
    ListBoxRec.Selection := ListBox^.Focused;
    case Event.Command of
      cmAddAssoc :
        if AddAssociation(ListBoxRec, DefExt) <> cmOK then Exit;
      cmEditAssoc :
        if EditAssociation(ListBoxRec) <> cmOK then Exit;
      cmDelAssoc :
        if DeleteAssociation(ListBoxRec) <> cmOK then Exit;
    end;
    ListBox^.SetRange(ListBox^.List^.Count);
    ListBox^.DrawView;
    ClearEvent(Event);
  end;
end;

{ TExtValidator }
function TExtValidator.IsValid(const S: string): Boolean;
begin
  IsValid := False;
  IsValid := (Length(S) > 0) and (S[1] = '.');
end;

procedure TExtValidator.Error;
begin
  MessageBox('Enter an valid file extension in the form ".xxx"', nil,
    mfInformation + mfOKButton);
end;

{ TNonBlankValidator }
procedure TNonBlankValidator.Error;
begin
  MessageBox('Field can not be blank.', nil,
    mfInformation + mfOKButton);
end;


procedure InitAssociations;
begin
  AssociateList := New(PAssociateList, Init(10, 5));
end;

procedure DoneAssociations;
begin
  if AssociateList <> nil then Dispose(AssociateList, Done);
end;

procedure Associate(DefExt: ExtStr);
var
  D: PDialog;
  XFer: TListBoxRec;
  Result: Word;
begin
  if AssociateList = nil then Exit;

  XFer.List := New(PAssociateList, Init(20,5));
  AssociateList^.FillCloneList(XFer.List);
  XFer.Selection := 0;

  D := New(PAssocDialog, Init(DefExt));
  if Application^.ExecuteDialog(D, @XFer) = cmOK then
    AssociateList^.UseCloneList(XFer.List);
  Dispose(XFer.List, Done);
end;

function GetAssociatedCommand(Ext: ExtStr): PAssociation;
var
  Association: PAssociation;

  function MatchExtension(P: PAssociation): Boolean; far;
  begin
    MatchExtension := (P^.Ext = Ext) or ((P^.Ext = '.') and (Ext = ''));
  end;

begin
  GetAssociatedCommand := nil;
  if AssociateList = nil then Exit;
  Association := AssociateList^.FirstThat(@MatchExtension);
  GetAssociatedCommand := Association;
end;

procedure WriteAssociationList(var S: TStream);
begin
  if AssociateList = nil then Exit;
  AssociateList^.Store(S);
end;

procedure ReadAssociationList(var S: TStream);
begin
  if AssociateList <> nil then
    Dispose(AssociateList, Done);
  AssociateList := New(PAssociateList, Load(S));
end;

procedure RegisterAssociations;
begin
  RegisterType(RAssociation);
  RegisterType(RAssociateList);
end;

end.