tpsystools_4.04/source/StSpawn.pas

// Upgraded to Delphi 2009: Sebastian Zierer

(* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is TurboPower SysTools
 *
 * The Initial Developer of the Original Code is
 * TurboPower Software
 *
 * Portions created by the Initial Developer are Copyright (C) 1996-2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * ***** END LICENSE BLOCK ***** *)

{*********************************************************}
{* SysTools: StSpawn.pas 4.04                            *}
{*********************************************************}
{* SysTools: Component to spawn another application      *}
{*********************************************************}

{$I StDefine.inc}

unit StSpawn;

interface

uses
  SysUtils, Windows, ExtCtrls, Messages, Classes, ShellAPI,

  StBase, StConst;

type

  TStWaitThread = class(TThread)
    protected
      FTimeOut  : Longint;
      procedure Execute; override;
    public
      CancelWaitEvent : THandle;
      WaitResult  : DWORD;
      WaitFors    : PWOHandleArray;                                      {!!.01}

      constructor Create(aInst, CancelIt : THandle; ATimeOut : Longint);
      destructor Destroy; override;                                      {!!.01}
  end;

  TStSpawnCommand = (scOpen, scPrint, scOther);
  TStShowState = (ssMinimized, ssMaximized, ssNormal, ssMinNotActive);

  TStSpawnErrorEvent = procedure (Sender : TObject; Error : Word) of object;
  TStSpawnCompletedEvent = procedure (Sender : TObject) of object;
  TStSpawnTimeOutEvent = procedure (Sender : TObject) of object;

  TStSpawnApplication = class(TStComponent)
  protected {private}
    { Private declarations }

    FAllowChange    : Boolean;
    FCancelEvent    : THandle;
    FDefaultDir     : String;
    FFileName       : String;
    FInstance       : THandle;
    FNotifyWhenDone : Boolean;
    FOnCompleted    : TStSpawnCompletedEvent;
    FOnSpawnError   : TStSpawnErrorEvent;
    FOnSpawnTimeOut : TStSpawnTimeOutEvent;
    FRunParameters  : String;
    FShowState      : TStShowState;
    FSpawnCommand   : TStSpawnCommand;
    FTimer          : TTimer;
    FTimeOut        : Longint;
    FWaitResult     : DWORD;
    FWaitThread     : TStWaitThread;
    FSpawnCommandStr     : String;

  protected
    { Protected declarations }

    CountDownValue : Longint;
    procedure DoOnThreadEnd(Sender : TObject);
    procedure SetDefaultDir(const Value : String);                 {!!.02}
    procedure SetFileName(const Value : String);                   {!!.02}
    procedure SetOnCompleted(Value : TStSpawnCompletedEvent);
    procedure SetOnSpawnError(Value : TStSpawnErrorEvent);
    procedure SetNotifyWhenDone(Value : Boolean);
    procedure SetRunParameters(const Value : String);              {!!.02}
    procedure SetShowState(Value : TStShowState);
    procedure SetSpawnCommand(Value : TStSpawnCommand);
    procedure SetSpawnTimeOut(Value : TStSpawnTimeOutEvent);
    procedure SetTimeOut(Value : Longint);
  public
    { Public declarations }

    constructor Create(AOwner : TComponent); override;
    destructor Destroy; override;

    procedure CancelWait;
    function Execute : THandle;
  published
    { Published declarations }

    property DefaultDir : String
      read FDefaultDir write SetDefaultDir;

    property FileName : String
      read FFileName write SetFileName;

    property NotifyWhenDone : Boolean
      read FNotifyWhenDone write SetNotifyWhenDone default True;

    property OnCompleted : TStSpawnCompletedEvent
      read FOnCompleted write SetOnCompleted;

    property OnSpawnError : TStSpawnErrorEvent
      read FOnSpawnError write SetOnSpawnError;

    property OnTimeOut : TStSpawnTimeOutEvent
      read FOnSpawnTimeOut write SetSpawnTimeOut;

    property RunParameters : String
      read FRunParameters write SetRunParameters;

    property ShowState : TStShowState
      read FShowState write SetShowState default ssNormal;

    property SpawnCommand : TStSpawnCommand
      read FSpawnCommand write SetSpawnCommand default scOpen;

    property TimeOut : Longint
      read FTimeOut write SetTimeOut default 0;

    property SpawnCommandStr : String
      read FSpawnCommandStr write FSpawnCommandStr;

  end;

implementation

{-----------------------------------------------------------------------------}
{                               WIN32  WAIT THREAD                            }
{-----------------------------------------------------------------------------}

const                                                                    {!!.01}
  WAIT_HANDLE_COUNT = 2;                                                 {!!.01}

constructor TStWaitThread.Create(aInst, CancelIt : THandle; ATimeOut : Longint);
begin
  GetMem(WaitFors, WAIT_HANDLE_COUNT * SizeOf(THandle));                 {!!.01}
  WaitFors^[0] := aInst;                                                 {!!.01}
  WaitFors^[1] := CancelIt;                                              {!!.01}
  FTimeOut := ATimeOut * 1000;
  CancelWaitEvent := CancelIt;

  inherited Create(True);
end;

{!!.01 - Added}
destructor TStWaitThread.Destroy;
begin
  FreeMem(WaitFors, WAIT_HANDLE_COUNT * SizeOf(THandle));
  inherited Destroy;
end;
{!!.01 - End Added}

procedure TStWaitThread.Execute;
begin
  if (FTimeOut > 0) then
    WaitResult := WaitForMultipleObjects(WAIT_HANDLE_COUNT, WaitFors,    {!!.01}
      False, FTimeOut)                                                   {!!.01}
  else
    WaitResult := WaitForMultipleObjects(WAIT_HANDLE_COUNT, WaitFors,    {!!.01}
      False, INFINITE);                                                  {!!.01}
end;


{-----------------------------------------------------------------------------}
{                               TStSpawnApplication                           }
{-----------------------------------------------------------------------------}

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

  FAllowChange     := True;
  FDefaultDir      := '';
  FFileName        := '';
  FNotifyWhenDone  := True;
  FShowState       := ssNormal;
  FSpawnCommand    := scOpen;
  FSpawnCommandStr := '';
  FTimer           := nil;
  FTimeOut         := 0;

end;

destructor TStSpawnApplication.Destroy;
begin
  FTimer.Free;
  FTimer := nil;

  inherited Destroy;
end;


procedure TStSpawnApplication.CancelWait;
begin
  if (FCancelEvent <> 0) then
    SetEvent(FWaitThread.CancelWaitEvent);
end;


procedure TStSpawnApplication.DoOnThreadEnd(Sender : TObject);
begin
  FWaitResult := FWaitThread.WaitResult;

  case FWaitResult of
    WAIT_FAILED :
      begin
        if (Assigned(FOnSpawnError)) then
          FOnSpawnError(Self, GetLastError);
      end;

    WAIT_TIMEOUT :
      begin
        if Assigned(FOnSpawnTimeOut) then
          FOnSpawnTimeOut(Self);
      end;

    WAIT_OBJECT_0,
    WAIT_OBJECT_0 + 1 :
      begin
        if (FNotifyWhenDone) and (Assigned(FOnCompleted)) then
          FOnCompleted(Self);
      end;
  end;

  if (FCancelEvent <> 0) then begin
    SetEvent(FCancelEvent);
    CloseHandle(FCancelEvent);
    FCancelEvent := 0;
  end;
end;


function TStSpawnApplication.Execute : THandle;
var
  Cmd         : String;
  HowShow     : integer;
  Res         : Bool;
  Startup     : TShellExecuteInfo;

begin
  if (FileName = '') and (RunParameters > '') then
    RaiseStError(EStSpawnError, stscInsufficientData);

  case FSpawnCommand of
    scOpen : Cmd := 'open';
    scPrint: Cmd := 'print';
    scOther: Cmd := FSpawnCommandStr;
  end;

  case FShowState of
    ssNormal       : HowShow := SW_NORMAL;
    ssMinimized    : HowShow := SW_MINIMIZE;
    ssMaximized    : HowShow := SW_SHOWMAXIMIZED;
    ssMinNotActive : HowShow := SW_SHOWMINNOACTIVE;
  else
    HowShow := SW_NORMAL;
  end;
  FInstance := 0;

  with Startup do begin
    cbSize       := SizeOf(Startup);
    fMask        := SEE_MASK_NOCLOSEPROCESS or SEE_MASK_FLAG_NO_UI;
    Wnd          := 0;
    lpVerb       := Pointer(Cmd);
    if (FFileName > '') then
      lpFile       := PChar(FFileName)
    else
      lpFile       := nil;
    if (FRunParameters > '') then
      lpParameters := PChar(FRunParameters)
    else
      lpParameters := nil;
    if (FDefaultDir > '') then
      lpDirectory  := PChar(FDefaultDir)
    else
      lpDirectory  := nil;
    nShow        := HowShow;
    hInstApp     := 0;
  end;

  Res := ShellExecuteEx(@Startup);
  FInstance := Startup.hProcess;

  if (not Res) then begin
    Result := 0;
    if (Assigned(FOnSpawnError)) then begin
      FOnSpawnError(Self, GetLastError);
    end;
  end else
    Result := FInstance;

  if (NotifyWhenDone) then begin
    FTimer := nil;
    FCancelEvent := CreateEvent(nil, False, False, PChar(FloatToStr(Now)));

    FWaitThread := TStWaitThread.Create(FInstance, FCancelEvent, FTimeOut);
    FWaitThread.OnTerminate := DoOnThreadEnd;
    FWaitThread.FreeOnTerminate := True;
    FWaitThread.Resume;
  end;
end;

procedure TStSpawnApplication.SetDefaultDir(const Value : String); {!!.02}
begin
  if (FAllowChange) or (csDesigning in ComponentState) then begin
    if (Value <> FDefaultDir) then
      FDefaultDir := Value;
  end;
end;


procedure TStSpawnApplication.SetFileName(const Value : String);   {!!.02}
begin
  if (FAllowChange) or (csDesigning in ComponentState) then begin
    if (Value <> FileName) then
      FFileName := Value;
  end;
end;


procedure TStSpawnApplication.SetNotifyWhenDone(Value : Boolean);
begin
  if (FAllowChange) or (csDesigning in ComponentState) then begin
    if (Value <> FNotifyWhenDone) then
      FNotifyWhenDone := Value;
  end;
end;


procedure TStSpawnApplication.SetRunParameters(const Value : String);  {!!.02}
begin
  if (FAllowChange) or (csDesigning in ComponentState) then begin
    if (Value <> FRunParameters) then
      FRunParameters := Value;
  end;
end;


procedure TStSpawnApplication.SetOnCompleted(Value : TStSpawnCompletedEvent);
begin
  if (FAllowChange) or (csDesigning in ComponentState) then
    FOnCompleted := Value;
end;


procedure TStSpawnApplication.SetOnSpawnError(Value : TStSpawnErrorEvent);
begin
  if (FAllowChange) or (csDesigning in ComponentState) then
    FOnSpawnError := Value;
end;


procedure TStSpawnApplication.SetShowState(Value : TStShowState);
begin
  if (FAllowChange) or (csDesigning in ComponentState) then begin
    if (Value <> FShowState) then
      FShowState := Value;
  end;
end;


procedure TStSpawnApplication.SetSpawnCommand(Value : TStSpawnCommand);
begin
  if (FAllowChange) or (csDesigning in ComponentState) then begin
    if (Value <> FSpawnCommand) then
      FSpawnCommand := Value;
  end;
end;


procedure TStSpawnApplication.SetSpawnTimeOut(Value : TStSpawnTimeOutEvent);
begin
  if (FAllowChange) or (csDesigning in ComponentState) then
    FOnSpawnTimeOut := Value;
end;


procedure TStSpawnApplication.SetTimeOut(Value : Longint);
begin
  if (FAllowChange) or (csDesigning in ComponentState) then begin
    if (Value <> FTimeOut) and (Value >= 0) then
      FTimeOut := Value;
  end;
end;


end.
1	// Upgraded to Delphi 2009: Sebastian Zierer
2
3	(* *** BEGIN LICENSE BLOCK ***
4	* Version: MPL 1.1
5	*
6	* The contents of this file are subject to the Mozilla Public License Version
7	* 1.1 (the "License"); you may not use this file except in compliance with
8	* the License. You may obtain a copy of the License at
9	* http://www.mozilla.org/MPL/
10	*
11	* Software distributed under the License is distributed on an "AS IS" basis,
12	* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13	* for the specific language governing rights and limitations under the
14	* License.
15	*
16	* The Original Code is TurboPower SysTools
17	*
18	* The Initial Developer of the Original Code is
19	* TurboPower Software
20	*
21	* Portions created by the Initial Developer are Copyright (C) 1996-2002
22	* the Initial Developer. All Rights Reserved.
23	*
24	* Contributor(s):
25	*
26	* *** END LICENSE BLOCK *** *)
27
28	{*********************************************************}
29	{* SysTools: StSpawn.pas 4.04 *}
30	{*********************************************************}
31	{* SysTools: Component to spawn another application *}
32	{*********************************************************}
33
34	{$I StDefine.inc}
35
36	unit StSpawn;
37
38	interface
39
40	uses
41	SysUtils, Windows, ExtCtrls, Messages, Classes, ShellAPI,
42
43	StBase, StConst;
44
45	type
46
47	TStWaitThread = class(TThread)
48	protected
49	FTimeOut : Longint;
50	procedure Execute; override;
51	public
52	CancelWaitEvent : THandle;
53	WaitResult : DWORD;
54	WaitFors : PWOHandleArray; {!!.01}
55
56	constructor Create(aInst, CancelIt : THandle; ATimeOut : Longint);
57	destructor Destroy; override; {!!.01}
58	end;
59
60	TStSpawnCommand = (scOpen, scPrint, scOther);
61	TStShowState = (ssMinimized, ssMaximized, ssNormal, ssMinNotActive);
62
63	TStSpawnErrorEvent = procedure (Sender : TObject; Error : Word) of object;
64	TStSpawnCompletedEvent = procedure (Sender : TObject) of object;
65	TStSpawnTimeOutEvent = procedure (Sender : TObject) of object;
66
67	TStSpawnApplication = class(TStComponent)
68	protected {private}
69	{ Private declarations }
70
71	FAllowChange : Boolean;
72	FCancelEvent : THandle;
73	FDefaultDir : String;
74	FFileName : String;
75	FInstance : THandle;
76	FNotifyWhenDone : Boolean;
77	FOnCompleted : TStSpawnCompletedEvent;
78	FOnSpawnError : TStSpawnErrorEvent;
79	FOnSpawnTimeOut : TStSpawnTimeOutEvent;
80	FRunParameters : String;
81	FShowState : TStShowState;
82	FSpawnCommand : TStSpawnCommand;
83	FTimer : TTimer;
84	FTimeOut : Longint;
85	FWaitResult : DWORD;
86	FWaitThread : TStWaitThread;
87	FSpawnCommandStr : String;
88
89	protected
90	{ Protected declarations }
91
92	CountDownValue : Longint;
93	procedure DoOnThreadEnd(Sender : TObject);
94	procedure SetDefaultDir(const Value : String); {!!.02}
95	procedure SetFileName(const Value : String); {!!.02}
96	procedure SetOnCompleted(Value : TStSpawnCompletedEvent);
97	procedure SetOnSpawnError(Value : TStSpawnErrorEvent);
98	procedure SetNotifyWhenDone(Value : Boolean);
99	procedure SetRunParameters(const Value : String); {!!.02}
100	procedure SetShowState(Value : TStShowState);
101	procedure SetSpawnCommand(Value : TStSpawnCommand);
102	procedure SetSpawnTimeOut(Value : TStSpawnTimeOutEvent);
103	procedure SetTimeOut(Value : Longint);
104	public
105	{ Public declarations }
106
107	constructor Create(AOwner : TComponent); override;
108	destructor Destroy; override;
109
110	procedure CancelWait;
111	function Execute : THandle;
112	published
113	{ Published declarations }
114
115	property DefaultDir : String
116	read FDefaultDir write SetDefaultDir;
117
118	property FileName : String
119	read FFileName write SetFileName;
120
121	property NotifyWhenDone : Boolean
122	read FNotifyWhenDone write SetNotifyWhenDone default True;
123
124	property OnCompleted : TStSpawnCompletedEvent
125	read FOnCompleted write SetOnCompleted;
126
127	property OnSpawnError : TStSpawnErrorEvent
128	read FOnSpawnError write SetOnSpawnError;
129
130	property OnTimeOut : TStSpawnTimeOutEvent
131	read FOnSpawnTimeOut write SetSpawnTimeOut;
132
133	property RunParameters : String
134	read FRunParameters write SetRunParameters;
135
136	property ShowState : TStShowState
137	read FShowState write SetShowState default ssNormal;
138
139	property SpawnCommand : TStSpawnCommand
140	read FSpawnCommand write SetSpawnCommand default scOpen;
141
142	property TimeOut : Longint
143	read FTimeOut write SetTimeOut default 0;
144
145	property SpawnCommandStr : String
146	read FSpawnCommandStr write FSpawnCommandStr;
147
148	end;
149
150	implementation
151
152	{-----------------------------------------------------------------------------}
153	{ WIN32 WAIT THREAD }
154	{-----------------------------------------------------------------------------}
155
156	const {!!.01}
157	WAIT_HANDLE_COUNT = 2; {!!.01}
158
159	constructor TStWaitThread.Create(aInst, CancelIt : THandle; ATimeOut : Longint);
160	begin
161	GetMem(WaitFors, WAIT_HANDLE_COUNT * SizeOf(THandle)); {!!.01}
162	WaitFors^[0] := aInst; {!!.01}
163	WaitFors^[1] := CancelIt; {!!.01}
164	FTimeOut := ATimeOut * 1000;
165	CancelWaitEvent := CancelIt;
166
167	inherited Create(True);
168	end;
169
170	{!!.01 - Added}
171	destructor TStWaitThread.Destroy;
172	begin
173	FreeMem(WaitFors, WAIT_HANDLE_COUNT * SizeOf(THandle));
174	inherited Destroy;
175	end;
176	{!!.01 - End Added}
177
178	procedure TStWaitThread.Execute;
179	begin
180	if (FTimeOut > 0) then
181	WaitResult := WaitForMultipleObjects(WAIT_HANDLE_COUNT, WaitFors, {!!.01}
182	False, FTimeOut) {!!.01}
183	else
184	WaitResult := WaitForMultipleObjects(WAIT_HANDLE_COUNT, WaitFors, {!!.01}
185	False, INFINITE); {!!.01}
186	end;
187
188
189
190	{-----------------------------------------------------------------------------}
191	{ TStSpawnApplication }
192	{-----------------------------------------------------------------------------}
193
194	constructor TStSpawnApplication.Create(AOwner : TComponent);
195	begin
196	inherited Create(AOwner);
197
198	FAllowChange := True;
199	FDefaultDir := '';
200	FFileName := '';
201	FNotifyWhenDone := True;
202	FShowState := ssNormal;
203	FSpawnCommand := scOpen;
204	FSpawnCommandStr := '';
205	FTimer := nil;
206	FTimeOut := 0;
207
208	end;
209
210	destructor TStSpawnApplication.Destroy;
211	begin
212	FTimer.Free;
213	FTimer := nil;
214
215	inherited Destroy;
216	end;
217
218
219	procedure TStSpawnApplication.CancelWait;
220	begin
221	if (FCancelEvent <> 0) then
222	SetEvent(FWaitThread.CancelWaitEvent);
223	end;
224
225
226	procedure TStSpawnApplication.DoOnThreadEnd(Sender : TObject);
227	begin
228	FWaitResult := FWaitThread.WaitResult;
229
230	case FWaitResult of
231	WAIT_FAILED :
232	begin
233	if (Assigned(FOnSpawnError)) then
234	FOnSpawnError(Self, GetLastError);
235	end;
236
237	WAIT_TIMEOUT :
238	begin
239	if Assigned(FOnSpawnTimeOut) then
240	FOnSpawnTimeOut(Self);
241	end;
242
243	WAIT_OBJECT_0,
244	WAIT_OBJECT_0 + 1 :
245	begin
246	if (FNotifyWhenDone) and (Assigned(FOnCompleted)) then
247	FOnCompleted(Self);
248	end;
249	end;
250
251	if (FCancelEvent <> 0) then begin
252	SetEvent(FCancelEvent);
253	CloseHandle(FCancelEvent);
254	FCancelEvent := 0;
255	end;
256	end;
257
258
259	function TStSpawnApplication.Execute : THandle;
260	var
261	Cmd : String;
262	HowShow : integer;
263	Res : Bool;
264	Startup : TShellExecuteInfo;
265
266	begin
267	if (FileName = '') and (RunParameters > '') then
268	RaiseStError(EStSpawnError, stscInsufficientData);
269
270	case FSpawnCommand of
271	scOpen : Cmd := 'open';
272	scPrint: Cmd := 'print';
273	scOther: Cmd := FSpawnCommandStr;
274	end;
275
276	case FShowState of
277	ssNormal : HowShow := SW_NORMAL;
278	ssMinimized : HowShow := SW_MINIMIZE;
279	ssMaximized : HowShow := SW_SHOWMAXIMIZED;
280	ssMinNotActive : HowShow := SW_SHOWMINNOACTIVE;
281	else
282	HowShow := SW_NORMAL;
283	end;
284	FInstance := 0;
285
286	with Startup do begin
287	cbSize := SizeOf(Startup);
288	fMask := SEE_MASK_NOCLOSEPROCESS or SEE_MASK_FLAG_NO_UI;
289	Wnd := 0;
290	lpVerb := Pointer(Cmd);
291	if (FFileName > '') then
292	lpFile := PChar(FFileName)
293	else
294	lpFile := nil;
295	if (FRunParameters > '') then
296	lpParameters := PChar(FRunParameters)
297	else
298	lpParameters := nil;
299	if (FDefaultDir > '') then
300	lpDirectory := PChar(FDefaultDir)
301	else
302	lpDirectory := nil;
303	nShow := HowShow;
304	hInstApp := 0;
305	end;
306
307	Res := ShellExecuteEx(@Startup);
308	FInstance := Startup.hProcess;
309
310	if (not Res) then begin
311	Result := 0;
312	if (Assigned(FOnSpawnError)) then begin
313	FOnSpawnError(Self, GetLastError);
314	end;
315	end else
316	Result := FInstance;
317
318	if (NotifyWhenDone) then begin
319	FTimer := nil;
320	FCancelEvent := CreateEvent(nil, False, False, PChar(FloatToStr(Now)));
321
322	FWaitThread := TStWaitThread.Create(FInstance, FCancelEvent, FTimeOut);
323	FWaitThread.OnTerminate := DoOnThreadEnd;
324	FWaitThread.FreeOnTerminate := True;
325	FWaitThread.Resume;
326	end;
327	end;
328
329	procedure TStSpawnApplication.SetDefaultDir(const Value : String); {!!.02}
330	begin
331	if (FAllowChange) or (csDesigning in ComponentState) then begin
332	if (Value <> FDefaultDir) then
333	FDefaultDir := Value;
334	end;
335	end;
336
337
338	procedure TStSpawnApplication.SetFileName(const Value : String); {!!.02}
339	begin
340	if (FAllowChange) or (csDesigning in ComponentState) then begin
341	if (Value <> FileName) then
342	FFileName := Value;
343	end;
344	end;
345
346
347	procedure TStSpawnApplication.SetNotifyWhenDone(Value : Boolean);
348	begin
349	if (FAllowChange) or (csDesigning in ComponentState) then begin
350	if (Value <> FNotifyWhenDone) then
351	FNotifyWhenDone := Value;
352	end;
353	end;
354
355
356	procedure TStSpawnApplication.SetRunParameters(const Value : String); {!!.02}
357	begin
358	if (FAllowChange) or (csDesigning in ComponentState) then begin
359	if (Value <> FRunParameters) then
360	FRunParameters := Value;
361	end;
362	end;
363
364
365	procedure TStSpawnApplication.SetOnCompleted(Value : TStSpawnCompletedEvent);
366	begin
367	if (FAllowChange) or (csDesigning in ComponentState) then
368	FOnCompleted := Value;
369	end;
370
371
372	procedure TStSpawnApplication.SetOnSpawnError(Value : TStSpawnErrorEvent);
373	begin
374	if (FAllowChange) or (csDesigning in ComponentState) then
375	FOnSpawnError := Value;
376	end;
377
378
379	procedure TStSpawnApplication.SetShowState(Value : TStShowState);
380	begin
381	if (FAllowChange) or (csDesigning in ComponentState) then begin
382	if (Value <> FShowState) then
383	FShowState := Value;
384	end;
385	end;
386
387
388	procedure TStSpawnApplication.SetSpawnCommand(Value : TStSpawnCommand);
389	begin
390	if (FAllowChange) or (csDesigning in ComponentState) then begin
391	if (Value <> FSpawnCommand) then
392	FSpawnCommand := Value;
393	end;
394	end;
395
396
397	procedure TStSpawnApplication.SetSpawnTimeOut(Value : TStSpawnTimeOutEvent);
398	begin
399	if (FAllowChange) or (csDesigning in ComponentState) then
400	FOnSpawnTimeOut := Value;
401	end;
402
403
404	procedure TStSpawnApplication.SetTimeOut(Value : Longint);
405	begin
406	if (FAllowChange) or (csDesigning in ComponentState) then begin
407	if (Value <> FTimeOut) and (Value >= 0) then
408	FTimeOut := Value;
409	end;
410	end;
411
412
413	end.