🚀 go-pugleaf

"Robert L. Smith" <bsmithOMIT@cinSPAMele.com> wrote in message
news:3f21a974@newsgroups.borland.com...

> More complicated approaches using threads ... haven't worked.

I don't understand what you mean by this.  Using a thread is the only way I
can see to allow your application to continue execution and to wait for the
hardware call to talk_to_hardware() to return.  Perhaps there were technical
difficulties trying to get a thread to work for you ... if the suggestion I
have below doesn't work in your case then perhaps you can elaborate on why a
thread won't work for you.

> Is there a simple way to meet all these requirements?

This is how I might do it:


//--------------------------------------------------------------------------
-  // thread.h

//--------------------------------------------------------------------------
-
  #include <Classes.hpp>
  #include <SyncObjs.hpp>

  class TalkHardwareThread : public TThread
  {
    typedef TThread inherited;
    private:
      int fCallCount;
      TCriticalSection* fCallCountCS;

    protected:
      virtual void __fastcall Execute();

    public:
      __fastcall TalkHardwareThread(bool CreateSuspended);

      void AddCallToQueue();
      void Abort();
  };


//--------------------------------------------------------------------------
-  // thread.cpp

//--------------------------------------------------------------------------
-
  #include "thread.h"


  //*****
  // dummy routines to simulate the hardware interface
  bool aborting = false;
  void abort_talking()
  {
    aborting = true;
  }

  int talk_to_hardware()
  {
    // dummy routine to allow compile
    for (int count = 0; count < 20 && !aborting; ++count)
      Sleep(100); // sleep short increments to allow for abort

    Beep();
    return 0;
  }
  //*****

  __fastcall TalkHardwareThread::TalkHardwareThread(bool CreateSuspended)
    : inherited(CreateSuspended)
  {
  }

  void TalkHardwareThread::AddCallToQueue()
  {
    fCallCountCS->Enter();
    ++fCallCount;
    fCallCountCS->Leave();

    if (Suspended)
      Resume();
  }

  void TalkHardwareThread::Abort()
  {
    fCallCountCS->Enter();
    fCallCount = 0;
    fCallCountCS->Leave();

    abort_talking();
  }

  void __fastcall TalkHardwareThread::Execute()
  {
    fCallCountCS = new TCriticalSection;

    try
    {
      while (!Terminated)
      {
        fCallCountCS->Enter();
        bool  call = fCallCount > 0;
        fCallCountCS->Leave();

        if (call)
        {
          fCallCountCS->Enter();
          --fCallCount;
          fCallCountCS->Leave();

          talk_to_hardware();
        }
        else
          Suspend();
      }
    }
    catch (...)
    {
    }

    delete fCallCountCS;
  }


//--------------------------------------------------------------------------
-  // main.h

//--------------------------------------------------------------------------
-
  #include "thread.h"

  class TForm1 : public TForm
  {
    __published:
    TButton *TalkBtn;
    TButton *AbortBtn;
    void __fastcall TalkBtnClick(TObject *Sender);
    void __fastcall AbortBtnClick(TObject *Sender);
    private:
      TalkHardwareThread* fTalkHardwareThread;

    public:
      __fastcall TForm1(TComponent* Owner);
      __fastcall ~TForm1();
  };


//--------------------------------------------------------------------------
-  // main.cpp

//--------------------------------------------------------------------------
-
  #include "main.h"

  TForm1 *Form1;

  __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
  {
    fTalkHardwareThread = new TalkHardwareThread(false);
  }

  __fastcall TForm1::~TForm1()
  {
    fTalkHardwareThread->Abort();
    fTalkHardwareThread->Terminate();
    if (fTalkHardwareThread->Suspended)
      fTalkHardwareThread->Resume();
    Application->ProcessMessages();
    fTalkHardwareThread->WaitFor();

    delete fTalkHardwareThread;
  }

  void __fastcall TForm1::TalkBtnClick(TObject *Sender)
  {
    fTalkHardwareThread->AddCallToQueue();
  }

  void __fastcall TForm1::AbortBtnClick(TObject *Sender)
  {
    fTalkHardwareThread->Abort();
  }

HTH,
- Clayton