adlibmdm.pas

Async Professional 4.04

  FModemList := TList.Create;
  FModemList.Clear;

  FModem := TList.Create;
  FModem.Clear;
end;

destructor TApdLibModem.Destroy;
begin
  FreeModemList;
  FModemList.Free;

  FreeModem;
  FModem.Free;

  inherited Destroy;
end;

procedure TApdLibModem.SetLibModemPath (v : string);
begin
  if v <> FLibModemPath then
    FLibModemPath := v;
end;

procedure TApdLibModem.FreeModemList;
var
  i : Integer;
begin
  for i := 0 to FModemList.Count - 1 do
    if assigned (FModemList[i]) then
      FreeMem (FModemList[i]);
  FModemList.Clear;
end;

procedure TApdLibModem.LoadModemListAttribute (oOwner     : TObject;
                                               sName,
                                               sValue     : DOMString;
                                               bSpecified : Boolean);
begin
  if not FReadingAttributes then
    Exit;
  if sName = 'ModemName' then
    PLmModemName (FModemList [FCurIndex]).ModemName := sValue
  else if sName = 'Manufacturer' then
    PLmModemName (FModemList [FCurIndex]).Manufacturer := sValue
  else if sName = 'Model' then
    PLmModemName (FModemList [FCurIndex]).Model := sValue
  else if sName = 'ModemFile' then
    PLmModemName (FModemList [FCurIndex]).ModemFile := sValue;
end;

procedure TApdLibModem.LoadModemListElementStart (oOwner : TObject;
                                                  sValue : DOMString);
var
  CanLoad : Boolean;
begin
  if (sValue = 'ModemRecord') or (sValue = 'ModemCap') then begin

    // Create new record

    FModemList.Add (AllocMem (SizeOf (TLmModemName)));
    FCurIndex := FModemList.Count - 1;

    // There are some strange things that go on in the parsing of the file.
    // It appears that all the attributes are read, THEN the OnStartElement
    // event will fire (for example, all the <ModemCap xxx="yyy"> attributes
    // will fire, when they are done, then OnStartElement will fire with
    // ModemCap.  To get around this, we will look for a ModemCap entry
    // to start the first record.  On each ModemRecord value that we get here,
    // fire the OnLoadModemRecord event (since it happens after the record
    // was loaded.

    // The CurIndex will always point to the record that is the next one to
    // be filled out.  The record that was just loaded will be in CurIndex - 1.

    // One annoying side effect of this is that an additional blank record
    // is added at the end of the list.  TODO - fix this.

    if sValue = 'ModemRecord' then begin
      CanLoad := True;
      if (Assigned (FOnLoadModemRecord)) and
         (Assigned (FModemList [FCurIndex])) and
         (FCurIndex >= 1) then
        FOnLoadModemRecord (PLmModemName (FModemList [FCurIndex - 1]).ModemName,
                            PLmModemName (FModemList [FCurIndex - 1]).Manufacturer,
                            PLmModemName (FModemList [FCurIndex - 1]).Model,
                            PLmModemName (FModemList [FCurIndex - 1]).ModemFile,
                            CanLoad);
      if (not CanLoad) and (FCurIndex >= 1) then begin
        FreeMem (FModemList[FCurIndex - 1]);
        FModemList.Delete (FCurIndex - 1);
        FCurIndex := FModemList.Count - 1;
        FCompleteDbs := False;
      end;
    end;

    FReadingAttributes := True
  end else
    FReadingAttributes := False;
end;

procedure TApdLibModem.LoadModemListElementEnd (oOwner : TObject;
                                                sValue : DOMString);
begin
  { nothing to do here }
end;

procedure TApdLibModem.LoadModemListElementBegin (oOwner : TObject;
                                                  sValue : DOMString);
begin
  { nothing to do here }
end;

procedure TApdLibModem.LoadModemList;
var
  Parser : TApdParser;
begin
  Parser := TApdParser.Create (Self);
  try
    FCompleteDbs := True;
    Parser.OnStartElement := LoadModemListElementStart;
    Parser.OnEndElement := LoadModemListElementEnd;
    Parser.OnAttribute := LoadModemListAttribute;
    Parser.OnBeginElement := LoadModemListElementBegin;
    try
      Parser.ParseDataSource (AddBackSlash (FLibModemPath) +
                              'modemcap.xml');

      { Delete the last record.  The last record will always be a dummy. }
      if FCurIndex > 0 then
        FModemList.Delete (FCurIndex);
    except
      FCompleteDbs := False;
    end;
  finally
    Parser.Free;
  end;
end;

procedure TApdLibModem.FreeModemEntry (Value : Integer);
var
  i : Integer;
begin
  { Release all the responses }

  if Assigned (PLmModem (FModem[Value]).Responses.OK) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.OK.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.OK[i]);
    PLmModem (FModem[Value]).Responses.Ok.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.NegotiationProgress) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.NegotiationProgress.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.NegotiationProgress[i]);
    PLmModem (FModem[Value]).Responses.NegotiationProgress.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.Connect) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.Connect.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.Connect[i]);
    PLmModem (FModem[Value]).Responses.Connect.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.Error) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.Error.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.Error[i]);
    PLmModem (FModem[Value]).Responses.Error.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.NoCarrier) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.NoCarrier.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.NoCarrier[i]);
    PLmModem (FModem[Value]).Responses.NoCarrier.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.NoDialTone) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.NoDialTone.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.NoDialTone[i]);
    PLmModem (FModem[Value]).Responses.NoDialTone.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.Busy) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.Busy.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.Busy[i]);
    PLmModem (FModem[Value]).Responses.Busy.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.NoAnswer) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.NoAnswer.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.NoAnswer[i]);
    PLmModem (FModem[Value]).Responses.NoAnswer.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.Ring) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.Ring.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.Ring[i]);
    PLmModem (FModem[Value]).Responses.Ring.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.VoiceView1) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.VoiceView1.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.VoiceView1[i]);
    PLmModem (FModem[Value]).Responses.VoiceView1.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.VoiceView2) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.VoiceView2.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.VoiceView2[i]);
    PLmModem (FModem[Value]).Responses.VoiceView2.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.VoiceView3) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.VoiceView3.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.VoiceView3[i]);
    PLmModem (FModem[Value]).Responses.VoiceView3.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.VoiceView4) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.VoiceView4.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.VoiceView4[i]);
    PLmModem (FModem[Value]).Responses.VoiceView4.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.VoiceView5) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.VoiceView5.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.VoiceView5[i]);
    PLmModem (FModem[Value]).Responses.VoiceView5.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.VoiceView6) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.VoiceView6.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.VoiceView6[i]);
    PLmModem (FModem[Value]).Responses.VoiceView6.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.VoiceView7) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.VoiceView7.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.VoiceView7[i]);
    PLmModem (FModem[Value]).Responses.VoiceView7.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.VoiceView8) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.VoiceView8.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.VoiceView8[i]);
    PLmModem (FModem[Value]).Responses.VoiceView8.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.RingDuration) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.RingDuration.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.RingDuration[i]);
    PLmModem (FModem[Value]).Responses.RingDuration.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.RingBreak) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.RingBreak.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.RingBreak[i]);
    PLmModem (FModem[Value]).Responses.RingBreak.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.Date) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.Date.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.Date[i]);
    PLmModem (FModem[Value]).Responses.Date.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.Time) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.Time.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.Time[i]);
    PLmModem (FModem[Value]).Responses.Time.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.Number) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.Number.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.Number[i]);
    PLmModem (FModem[Value]).Responses.Number.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.Name) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.Name.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.Name[i]);
    PLmModem (FModem[Value]).Responses.Name.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.Msg) then begin
    for i := 0 to PLmModem (FModem[Value]).Responses.Msg.Count - 1 do
      FreeMem (PLmModem (FModem[Value]).Responses.Msg[i]);
    PLmModem (FModem[Value]).Responses.Msg.Free;
  end;

  if Assigned (PLmModem (FModem[Value]).Responses.SingleRing) then begin