PString New_Job ="";
HWND h_Job = 0;

LRESULT CALLBACK WndProc( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam )
{
  switch( message )
  {
    case WM_COPYDATA:
      COPYDATASTRUCT* pcds;
      pcds = (COPYDATASTRUCT*)lparam;
      } else if (pcds->dwData == 71) {//new job
          h_Job = (HWND)wparam;
          New_Job = PString((LPCTSTR)(pcds->lpData));
          return 1;
...
    case WM_TIMER:
      if (New_Job.GetLength() > 0) {
...
          PString f = New_Job;
...
          'код запуска задания
...
          SendMessage(h_Job, WM_COPYDATA, 0, (LPARAM) &cds); 'сообщение что задание запущено(и можно повторять процесс)

          New_Job = "";
          h_Job = 0;
        }
      }

void OpalConnection::SetPhase(Phases phaseToSet)
{
  //cout << "\nOpalCon\tSetPhase from " << phase << " to " << phaseToSet << " for " << *this << "\n";
  //PTRACE(3, "OpalCon\tSetPhase from " << phase << " to " << phaseToSet << " for " << *this);

  try
  {
  PWaitAndSignal m(phaseMutex);
  }
  catch (int i){}

  // With next few lines we will prevent phase to ever go down when it
  // reaches ReleasingPhase - end result - once you call Release you never
  // go back.
  try
  {
  if (phase < ReleasingPhase || (phase == ReleasingPhase && phaseToSet == ReleasedPhase))
    phase = phaseToSet;
  }
  catch (int i){}
}

PWaitAndSignal m(phaseMutex);

On Error resume Next

void OpalConnection::OnReleased(){
...
  SetPhase(ReleasedPhase);
}


void OpalConnection::SetPhase(Phases phaseToSet)
{
  PTRACE(3, "OpalCon\tSetPhase from " << phase << " to " << phaseToSet << " for " << *this);

  PWaitAndSignal m(phaseMutex);

  // With next few lines we will prevent phase to ever go down when it
  // reaches ReleasingPhase - end result - once you call Release you never
  // go back.
  if (phase < ReleasingPhase || (phase == ReleasingPhase && phaseToSet == ReleasedPhase))
    phase = phaseToSet;
}

Sleep (INFINITE);

void OpalConnection::SetPhase(Phases phaseToSet)
{
  try
  {
  cout << "OpalCon\tSetPhase from " << phase << " to " << phaseToSet << " for " << *this << "\n";
  }
  catch (...)
  {
    PTRACE(3, "Problem in SetPhase!");
    Sleep (INFINITE);
  }
  PTRACE(3, "OpalCon\tSetPhase from " << phase << " to " << phaseToSet << " for " << *this);

  PWaitAndSignal m(phaseMutex);

  // With next few lines we will prevent phase to ever go down when it
  // reaches ReleasingPhase - end result - once you call Release you never
  // go back.
  if (phase < ReleasingPhase || (phase == ReleasingPhase && phaseToSet == ReleasedPhase))
    phase = phaseToSet;
}

void OpalConnection::Release(CallEndReason reason)
{
  {
    PWaitAndSignal m(phaseMutex);
    if (phase >= ReleasingPhase) {
      PTRACE(2, "OpalCon\tAlready released " << *this);
      return;
    }
    SetPhase(ReleasingPhase);
  }

  if (synchronousOnRelease) {
    if (!LockReadWrite()) {
      PTRACE(2, "OpalCon\tAlready released " << *this);
      return;
    }

    PTRACE(3, "OpalCon\tReleasing " << *this);

    // Now set reason for the connection close
    SetCallEndReason(reason);

    UnlockReadWrite();

    OnReleased();
    return;
  }

  PTRACE(3, "OpalCon\tReleasing asynchronously " << *this);

  // Add a reference for the thread we are about to start
  SafeReference();
  PThread::Create(PCREATE_NOTIFIER(OnReleaseThreadMain), reason.AsInteger(),
                  PThread::AutoDeleteThread,
                  PThread::NormalPriority,
                  "OnRelease");
}


void OpalConnection::OnReleaseThreadMain(PThread &, INT reason)
{
  if (LockReadWrite()) {
    // Now set reason for the connection close
    SetCallEndReason(CallEndReason(reason));
	UnlockReadWrite();
  }

  OnReleased();

  PTRACE(4, "OpalCon\tOnRelease thread completed for " << *this);

  // Dereference on the way out of the thread
  SafeDereference();
}