addial.pas

测试用例

  end;

  procedure TApdCustomModemDialer.Dial;
  begin
    if Dialing then
      raise EAlreadyDialing.Create(ecAlreadyDialing, False);
    if not Assigned(FModem) then
      raise EModemNotAssigned.Create(ecModemNotAssigned, False);
    if (Modem.ComPort = nil) then
      raise EPortNotAssigned.Create(ecPortNotAssigned, False);

    ComPort := Modem.ComPort;

    {let the user know what we're up to...}
    FDialResult := drDialing;
    SinkHooks;

    DialTry  := 0;
    FDialing := True;
    PrepareDialing;
  end;

  procedure TApdCustomModemDialer.Cycle;
  begin
    if not Dialing then
      raise ENotDialing.Create(ecNotDialing, False);

    {prevent reentrancy}
    if Cycling then
      Exit;
    Cycling := True;

    {if we're retrying, stop}
    if Retrying then begin
      RetryDone;
      Cycling := False;
    end else begin
      {cancel the dial attempt in progress}
      Modem.CancelDialAnswer;

      Inc(DialTry);
      if (DialTry > MaxDialTries) then begin
        FDialResult := drAborted;
        DialingFinished;
        TooManyTries;
        Exit;
      end;

      {let the user know what we're up to}
      CycleDial;

      {delay a bit so as to avoid freaking the modem out}
      DelayTicks(4, False);

      PrepareDialing;
      Cycling := False;
    end;
  end;

  procedure TApdCustomModemDialer.Extend(const ByHowMuch : Cardinal);
  begin
    if not Dialing then
      raise ENotDialing.Create(ecNotDialing, False);

    try
      Modem.ExtendConnectAttempt(ByHowMuch);
    except
      on EModemNotDialing do begin
      end else
        raise;
    end;
  end;

  procedure TApdCustomModemDialer.Abort;
  begin
    if not Dialing then
      raise ENotDialing.Create(ecNotDialing, False);

    if Modem.IsAttemptingConnect then begin
      Modem.CancelDialAnswer;
      FDialResult := drAborted;
    end else if Retrying then begin
      ComPort.RemoveTrigger(RetryIdx);
      RetryIdx := 0;
    end;                                                          

    DialingFinished;
  end;

{TDialerForm}

  constructor TDialerForm.Create(AOwner : TComponent);
  begin
    inherited Create(AOwner);

    Labels[1]  := Label1;
    Labels[2]  := Label2;
    Labels[3]  := Label3;
    Labels[4]  := Label4;
    Labels[5]  := Label5;
    Labels[6]  := Label6;
    Labels[7]  := Label7;
    Labels[8]  := Label8;
    Labels[9]  := Label9;
    Labels[10] := Label10;
    Labels[11] := Label11;
    Labels[12] := Label12;
    Labels[13] := Label13;

    SaveTrig := nil;
    DialTrig := 0;
    Dialer   := nil;
  end;

  procedure TDialerForm.CycleBtnClick(Sender: TObject);
  begin
    if not Dialer.Retrying then
      AddResString(ddCycling);

    try
      Dialer.Cycle;
    finally
    end;
  end;

  procedure TDialerForm.ExtendBtnClick(Sender: TObject);
  begin
    try
      Dialer.Extend(5);
    finally
    end;
  end;

  procedure TDialerForm.AbortBtnClick(Sender: TObject);
  begin
    try
      Dialer.Abort;
    finally
      ModalResult := mrAbort;
    end;
  end;

  procedure TDialerForm.AddStatusString(const St : String);
    {-Put a status string in the display}
  var
    I : Integer;

  begin
    Inc(OnLabel);
    if (OnLabel > NumStatusLines) then begin
      for I := 2 to NumStatusLines do
        Labels[I-1].Caption := Labels[I].Caption;
      Dec(OnLabel);
    end;

    Labels[OnLabel].Caption := St;
  end;

  procedure TDialerForm.AddResString(const ResID : Cardinal);
    {-Load a status string from a resource and display it}
  begin
    AddStatusString(AproLoadStr(ResID)); 
  end;

  procedure TDialerForm.DoDial(const ADialer : TApdCustomModemDialer);
    {-Begin dialing}
  var
    I : Cardinal;

  begin
    OnLabel := 0;
    for I := 1 to NumStatusLines do
      Labels[I].Caption := '';

    Dialer := ADialer;

    {set up a timer trigger to start the dial}
    SaveTrig := Dialer.Modem.ComPort.OnTriggerTimer;
    DialTrig := Dialer.Modem.ComPort.AddTimerTrigger;
    Dialer.Modem.ComPort.OnTriggerTimer := FrmTriggerTimer;
    Dialer.Modem.ComPort.SetTimerTrigger(DialTrig, 4, True);

    with Dialer do begin
      OnRetryStart            := FrmRetryStart;
      OnRetryCount            := FrmRetryCount;
      OnRetryEnd              := FrmRetryEnd;
      OnDialStart             := FrmDialStart;
      OnConnect               := FrmConnect;
      OnDialCount             := FrmDialCount;
      OnGotLineSpeed          := FrmGotLineSpeed;
      OnBusy                  := FrmBusy;
      OnVoice                 := FrmVoice;
      OnError                 := FrmError;
      OnNoCarrier             := FrmNoCarrier;
      OnNoDialTone            := FrmNoDialTone;
      OnDialTimedOut          := FrmDialTimedOut;
      OnTooManyTries          := FrmTooManyTries;
      OnConnectionEstablished := FrmConnectionEstablished;

      ShowModal;

      OnRetryStart            := nil;
      OnRetryCount            := nil;
      OnRetryEnd              := nil;
      OnDialStart             := nil;
      OnConnect               := nil;
      OnDialCount             := nil;
      OnGotLineSpeed          := nil;
      OnBusy                  := nil;
      OnVoice                 := nil;
      OnError                 := nil;
      OnNoCarrier             := nil;
      OnNoDialTone            := nil;
      OnConnectionEstablished := nil;
      OnTooManyTries          := nil;
    end;
  end;

  procedure TDialerForm.FrmRetryStart(Sender : TObject);
  begin
    AddStatusString(AproLoadStr(ddRetryWaiting) + ' ' +
      IntToStr(Dialer.RetrySecs));
  end;

  procedure TDialerForm.FrmRetryCount(M : TObject; Remaining : Word);
  begin
    Labels[OnLabel].Caption := AproLoadStr(ddRetryWaiting) + ' ' +
      IntToStr(Remaining);
  end;

  procedure TDialerForm.FrmRetryEnd(Sender : TObject);
  begin
    Labels[OnLabel].Caption := AproLoadStr(ddRetryWaitOver);         
  end;

  procedure TDialerForm.FrmDialStart(Sender : TObject);
  begin
    AddStatusString(AproLoadStr(ddDialing) + ' ' +                   
      IntToStr(Dialer.Modem.DialTimeout));
  end;

  procedure TDialerForm.FrmConnect(Sender : TObject);
  begin
    AddResString(ddModemConnect);
  end;

  procedure TDialerForm.FrmDialCount(M : TObject; Remaining : Word);
  begin
    Labels[OnLabel].Caption := AproLoadStr(ddDialing) + ' ' +        
      IntToStr(Remaining);
  end;

  procedure TDialerForm.FrmGotLineSpeed(M : TObject; Speed : LongInt);
  begin
    AddStatusString(format(AproLoadStr(ddModemConnectAt),
      [Speed]));                       
  end;

  procedure TDialerForm.FrmBusy(Sender : TObject);
  begin
    if (Dialer.DialResult = drAborted) then
      ModalResult := mrAbort
    else
      AddResString(ddModemBusy);
  end;

  procedure TDialerForm.FrmVoice(Sender : TObject);
  begin
    if (Dialer.DialResult = drAborted) then
      ModalResult := mrAbort
    else
      AddResString(ddModemVoice);
  end;

  procedure TDialerForm.FrmError(Sender : TObject);
  begin
    if (Dialer.DialResult = drAborted) then
      ModalResult := mrAbort
    else
      AddResString(ddModemError);
  end;

  procedure TDialerForm.FrmNoCarrier(Sender : TObject);
  begin
    if (Dialer.DialResult = drAborted) then
      ModalResult := mrAbort
    else
      AddResString(ddModemNoCarrier);
  end;

  procedure TDialerForm.FrmNoDialTone(Sender : TObject);
  begin
    if (Dialer.DialResult = drAborted) then
      ModalResult := mrAbort
    else
      AddResString(ddModemNoDialTone);
  end;

  procedure TDialerForm.FrmDialTimedOut(Sender : Tobject);
  begin
    Labels[OnLabel].Caption := AproLoadStr(ddDialTimedOut);         
  end;

  procedure TDialerForm.FrmTooManyTries(Sender : TObject);
  begin
    ModalResult := mrAbort;
  end;

  procedure TDialerForm.FrmConnectionEstablished(Sender : TObject);
  begin
    ModalResult := mrOK;
    PostMessage(Handle,wm_Close,0,0);
  end;

  procedure TDialerForm.FrmTriggerTimer(CP : TObject; TriggerHandle : Word);
  begin
    if (TriggerHandle = DialTrig) then begin
      Dialer.Modem.ComPort.OnTriggerTimer := SaveTrig;
      Dialer.Modem.ComPort.RemoveTrigger(DialTrig);
      SaveTrig := nil;
      DialTrig := 0;
      Dialer.Dial;
    end else if Assigned(SaveTrig) then
      SaveTrig(CP, TriggerHandle);
  end;

{TApdDialerDialog}

  procedure TApdDialerDialog.Notification(AComponent : TComponent; Operation : TOperation);
  begin
    inherited Notification(AComponent, Operation);

    if (Operation = opRemove) then begin
      {see if our modem is going away}
      if (AComponent = FModem) then
        FModem  := nil;
    end else if (Operation = opInsert) then begin
      {check for modem being installed}
      if not Assigned(FModem) and (AComponent is TApdCustomModem) then
        Modem := TApdCustomModem(AComponent);
    end;
  end;

  constructor TApdDialerDialog.Create(AOwner : TComponent);
  var
    I : Integer;

  begin
    inherited Create(AOwner);

    {set default property values}
    FModem         := nil;
    FPhoneNumber   := '';
    FMaxDialTries  := addDefMaxDialTries;
    FRetrySecs     := addDefRetrySecs;
    FDialerOptions := addDefDialerOptions;
    FCaption       := 'Dial Progress';

    {search our owner for a modem}
    if Assigned(AOwner) and (AOwner.ComponentCount > 0) then
      for I := 0 to Pred(AOwner.ComponentCount) do
        if AOwner.Components[I] is TApdCustomModem then begin
          FModem := TApdCustomModem(AOwner.Components[I]);
          Break;
        end;
  end;

  function TApdDialerDialog.Execute : Boolean;
  var
    Dialer : TApdCustomModemDialer;
    Frm    : TDialerForm;

  begin
    {check for valid property values}
    if not Assigned(FModem) then
      raise EModemNotAssigned.Create(ecModemNotAssigned, False);
    if (Modem.ComPort = nil) then
      raise EPortNotAssigned.Create(ecPortNotAssigned, False);

    {create form}
    Frm       := TDialerForm.Create(Self);
    Frm.Ctl3D := Ctl3D;
    Frm.Caption := FCaption;                                       

    try
      {create the dialer}
      Dialer               := TApdCustomModemDialer.Create(Self);
      Dialer.Modem         := Modem;
      Dialer.PhoneNumber   := PhoneNumber;
      Dialer.MaxDialTries  := MaxDialTries;
      Dialer.RetrySecs     := RetrySecs;
      Dialer.DialerOptions := DialerOptions;
    except
      Frm.Free;
      raise;
    end;

    {dial the modem}
    Frm.DoDial(Dialer);
    Frm.Free;

    Result := (Dialer.DialResult = drConnected);

    Dialer.Free;
  end;

  function TApdDialerDialog.GetVersion : string;
  begin
    Result := ApVersionStr;
  end;

  procedure TApdDialerDialog.SetVersion(const Value : string);
  begin
  end;

end.