#pas
unit hiThread;

interface

{$I share.inc}

uses Kol,Share,Windows,Debug, NSThreads;

type
  THIThread = class(TDebug)
    private
      th:TThread;

      function Execute(Sender:TThread): Integer;
      procedure SyncExec(Sender: TThread; Param: Pointer);
    public
      _prop_Delay:cardinal;
      _prop_FastStop:boolean;
      _prop_BusyEvent:byte;

      _event_onSyncExec:THI_Event;
      _event_onExec:THI_Event;

      destructor Destroy; override;
      procedure _work_doStart(var _Data:TData; Index:word);
      procedure _work_doStop(var _Data:TData; Index:word);
      procedure _work_doStopFlag(var _Data:TData; Index:word);
      procedure _work_doDelay(var _Data:TData; Index:word);
      procedure _var_Busy(var _Data:TData; Index:word);
  end;

implementation

destructor THIThread.Destroy;
var dt:TData;
begin
  _work_doStop(dt,0);
  inherited Destroy;
end;

function THIThread.Execute(Sender:TThread): Integer;
begin
  repeat
    Sleep(_prop_delay);
    _hi_OnEvent(_event_onExec);
    if Assigned(_event_onSyncExec.Event) then Sender.Synchronize(SyncExec);
  until Sender.Stopped or _prop_FastStop;
  Result := 0;
end;

procedure THIThread.SyncExec(Sender: TThread; Param: Pointer);
begin
  _hi_OnEvent(_event_onSyncExec);
end;

procedure THIThread._work_doStart;
begin
  if Assigned(th) then
  begin
    if (_prop_BusyEvent = 0) and (not th.Terminated) then exit;
    th.Free;
  end;

  th := TThread.Create;
  th.OnExecute := Execute;
  th.Resume;
end;

procedure THIThread._work_doStop;
begin
  if th <> nil then
  begin
    th.Free;
    th := nil;
  end;
end;

procedure THIThread._work_doStopFlag;
begin
  if Assigned(th) then th.Stop;
end;

procedure THIThread._work_doDelay;
begin
  _prop_Delay := ToInteger(_Data);
end;

procedure THIThread._var_Busy;
begin
   dtInteger(_Data,integer(Assigned(th) and (not th.Terminated)));
end;

end.