]> git.saurik.com Git - wxWidgets.git/blame - src/msw/utilsexc.cpp
don't disable top level children in parents Enable()
[wxWidgets.git] / src / msw / utilsexc.cpp
CommitLineData
32592631 1/////////////////////////////////////////////////////////////////////////////
b568d04f 2// Name: msw/utilsexec.cpp
79066131 3// Purpose: wxExecute implementation for MSW
32592631
GL
4// Author: Julian Smart
5// Modified by:
6// Created: 04/01/98
7// RCS-ID: $Id$
79066131 8// Copyright: (c) 1998-2002 wxWindows dev team
3f4a0c5b 9// Licence: wxWindows license
32592631
GL
10/////////////////////////////////////////////////////////////////////////////
11
b568d04f
VZ
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
32592631 20#ifdef __GNUG__
b568d04f 21 #pragma implementation
32592631
GL
22#endif
23
24// For compilers that support precompilation, includes "wx.h".
25#include "wx/wxprec.h"
26
27#ifdef __BORLANDC__
b568d04f 28 #pragma hdrstop
32592631
GL
29#endif
30
31#ifndef WX_PRECOMP
b568d04f
VZ
32 #include "wx/utils.h"
33 #include "wx/app.h"
34 #include "wx/intl.h"
32592631
GL
35#endif
36
3e64d4e1 37#include "wx/log.h"
1044a386
JS
38
39#ifdef __WIN32__
8b33ae2d 40 #include "wx/stream.h"
b568d04f 41 #include "wx/process.h"
1044a386 42#endif
dbeac4bd 43
32592631 44#include "wx/msw/private.h"
dbeac4bd 45
32592631
GL
46#include <ctype.h>
47
04ef50df 48#if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__)
b568d04f 49 #include <direct.h>
17dff81c 50#ifndef __MWERKS__
b568d04f 51 #include <dos.h>
32592631 52#endif
17dff81c 53#endif
32592631 54
b568d04f
VZ
55#if defined(__GNUWIN32__) && !defined(__TWIN32__)
56 #include <sys/unistd.h>
57 #include <sys/stat.h>
57c208c5 58#endif
32592631 59
04ef50df 60#if defined(__WIN32__) && !defined(__WXWINE__) && !defined(__WXMICROWIN__)
32592631
GL
61#include <io.h>
62
63#ifndef __GNUWIN32__
64#include <shellapi.h>
65#endif
66#endif
67
68#include <stdio.h>
69#include <stdlib.h>
70#include <string.h>
71#ifndef __WATCOMC__
3f4a0c5b
VZ
72 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
73 #include <errno.h>
74 #endif
32592631
GL
75#endif
76#include <stdarg.h>
77
731dd422
VZ
78#if wxUSE_IPC
79 #include "wx/dde.h" // for WX_DDE hack in wxExecute
80#endif // wxUSE_IPC
5bd3a2da 81
b568d04f
VZ
82// ----------------------------------------------------------------------------
83// constants
84// ----------------------------------------------------------------------------
85
cb6827a8
VZ
86// this message is sent when the process we're waiting for terminates
87#define wxWM_PROC_TERMINATED (WM_USER + 10000)
32592631 88
b568d04f
VZ
89// ----------------------------------------------------------------------------
90// this module globals
91// ----------------------------------------------------------------------------
92
93// we need to create a hidden window to receive the process termination
94// notifications and for this we need a (Win) class name for it which we will
95// register the first time it's needed
96static const wxChar *gs_classForHiddenWindow = NULL;
97
98// ----------------------------------------------------------------------------
99// private types
100// ----------------------------------------------------------------------------
101
cb6827a8
VZ
102// structure describing the process we're being waiting for
103struct wxExecuteData
104{
105public:
106 ~wxExecuteData()
107 {
750b78ba 108#ifndef __WIN16__
cb6827a8
VZ
109 if ( !::CloseHandle(hProcess) )
110 {
f6bcfd97 111 wxLogLastError(wxT("CloseHandle(hProcess)"));
cb6827a8 112 }
750b78ba 113#endif
cb6827a8
VZ
114 }
115
116 HWND hWnd; // window to send wxWM_PROC_TERMINATED to
117 HANDLE hProcess; // handle of the process
118 DWORD dwProcessId; // pid of the process
119 wxProcess *handler;
120 DWORD dwExitCode; // the exit code of the process
121 bool state; // set to FALSE when the process finishes
32592631
GL
122};
123
f6bcfd97 124#if defined(__WIN32__) && wxUSE_STREAMS
8b33ae2d 125
8b33ae2d
GL
126// ----------------------------------------------------------------------------
127// wxPipeStreams
128// ----------------------------------------------------------------------------
129
f6bcfd97
BP
130class wxPipeInputStream: public wxInputStream
131{
8b33ae2d
GL
132public:
133 wxPipeInputStream(HANDLE hInput);
79066131 134 virtual ~wxPipeInputStream();
8b33ae2d 135
79066131
VZ
136 // returns TRUE if the pipe is still opened
137 bool IsOpened() const { return m_hInput != INVALID_HANDLE_VALUE; }
138
139 // returns TRUE if there is any data to be read from the pipe
140 bool IsAvailable() const;
f6bcfd97 141
8b33ae2d
GL
142protected:
143 size_t OnSysRead(void *buffer, size_t len);
144
145protected:
146 HANDLE m_hInput;
147};
148
f6bcfd97
BP
149class wxPipeOutputStream: public wxOutputStream
150{
8b33ae2d
GL
151public:
152 wxPipeOutputStream(HANDLE hOutput);
79066131 153 virtual ~wxPipeOutputStream();
8b33ae2d
GL
154
155protected:
156 size_t OnSysWrite(const void *buffer, size_t len);
157
158protected:
159 HANDLE m_hOutput;
160};
161
79066131
VZ
162// define this to let wxexec.cpp know that we know what we're doing
163#define _WX_USED_BY_WXEXECUTE_
164#include "../common/execcmn.cpp"
165
166// ----------------------------------------------------------------------------
167// wxPipe represents a Win32 anonymous pipe
168// ----------------------------------------------------------------------------
169
170class wxPipe
171{
172public:
173 // the symbolic names for the pipe ends
174 enum Direction
175 {
176 Read,
177 Write
178 };
179
180 // default ctor doesn't do anything
181 wxPipe() { m_handles[Read] = m_handles[Write] = INVALID_HANDLE_VALUE; }
182
183 // create the pipe, return TRUE if ok, FALSE on error
184 bool Create()
185 {
186 // default secutiry attributes
187 SECURITY_ATTRIBUTES security;
188
189 security.nLength = sizeof(security);
190 security.lpSecurityDescriptor = NULL;
191 security.bInheritHandle = TRUE; // to pass it to the child
192
193 if ( !::CreatePipe(&m_handles[0], &m_handles[1], &security, 0) )
194 {
195 wxLogSysError(_("Failed to create an anonymous pipe"));
196
197 return FALSE;
198 }
199
200 return TRUE;
201 }
202
203 // return TRUE if we were created successfully
204 bool IsOk() const { return m_handles[Read] != INVALID_HANDLE_VALUE; }
205
206 // return the descriptor for one of the pipe ends
207 HANDLE operator[](Direction which) const
208 {
209 wxASSERT_MSG( which >= 0 && (size_t)which < WXSIZEOF(m_handles),
210 _T("invalid pipe index") );
211
212 return m_handles[which];
213 }
214
215 // detach a descriptor, meaning that the pipe dtor won't close it, and
216 // return it
217 HANDLE Detach(Direction which)
218 {
219 wxASSERT_MSG( which >= 0 && (size_t)which < WXSIZEOF(m_handles),
220 _T("invalid pipe index") );
221
222 HANDLE handle = m_handles[which];
223 m_handles[which] = INVALID_HANDLE_VALUE;
224
225 return handle;
226 }
227
228 // close the pipe descriptors
229 void Close()
230 {
231 for ( size_t n = 0; n < WXSIZEOF(m_handles); n++ )
232 {
233 if ( m_handles[n] != INVALID_HANDLE_VALUE )
234 {
235 ::CloseHandle(m_handles[n]);
236 m_handles[n] = INVALID_HANDLE_VALUE;
237 }
238 }
239 }
240
241 // dtor closes the pipe descriptors
242 ~wxPipe() { Close(); }
243
244private:
245 HANDLE m_handles[2];
246};
247
248#endif // wxUSE_STREAMS
249
250// ============================================================================
251// implementation
252// ============================================================================
253
254#ifdef __WIN32__
255
256// ----------------------------------------------------------------------------
257// process termination detecting support
258// ----------------------------------------------------------------------------
259
260// thread function for the thread monitoring the process termination
261static DWORD __stdcall wxExecuteThread(void *arg)
262{
263 wxExecuteData *data = (wxExecuteData*)arg;
264
265 if ( ::WaitForSingleObject(data->hProcess, INFINITE) != WAIT_OBJECT_0 )
266 {
267 wxLogDebug(_T("Waiting for the process termination failed!"));
268 }
269
270 // get the exit code
271 if ( !::GetExitCodeProcess(data->hProcess, &data->dwExitCode) )
272 {
273 wxLogLastError(wxT("GetExitCodeProcess"));
274 }
275
276 wxASSERT_MSG( data->dwExitCode != STILL_ACTIVE,
277 wxT("process should have terminated") );
278
279 // send a message indicating process termination to the window
280 ::SendMessage(data->hWnd, wxWM_PROC_TERMINATED, 0, (LPARAM)data);
281
282 return 0;
283}
284
285// window procedure of a hidden window which is created just to receive
286// the notification message when a process exits
287LRESULT APIENTRY _EXPORT wxExecuteWindowCbk(HWND hWnd, UINT message,
288 WPARAM wParam, LPARAM lParam)
289{
290 if ( message == wxWM_PROC_TERMINATED )
291 {
292 DestroyWindow(hWnd); // we don't need it any more
293
294 wxExecuteData *data = (wxExecuteData *)lParam;
295 if ( data->handler )
296 {
297 data->handler->OnTerminate((int)data->dwProcessId,
298 (int)data->dwExitCode);
299 }
300
301 if ( data->state )
302 {
303 // we're executing synchronously, tell the waiting thread
304 // that the process finished
305 data->state = 0;
306 }
307 else
308 {
309 // asynchronous execution - we should do the clean up
310 delete data;
311 }
312
313 return 0;
314 }
315 else
316 {
317 return DefWindowProc(hWnd, message, wParam, lParam);
318 }
319}
320
321// ============================================================================
322// implementation of IO redirection support classes
323// ============================================================================
324
325#if wxUSE_STREAMS
326
327// ----------------------------------------------------------------------------
328// wxPipeInputStreams
329// ----------------------------------------------------------------------------
8b33ae2d
GL
330
331wxPipeInputStream::wxPipeInputStream(HANDLE hInput)
332{
333 m_hInput = hInput;
cd6ce4a9 334}
8b33ae2d
GL
335
336wxPipeInputStream::~wxPipeInputStream()
337{
79066131
VZ
338 if ( m_hInput != INVALID_HANDLE_VALUE )
339 ::CloseHandle(m_hInput);
8b33ae2d
GL
340}
341
79066131 342bool wxPipeInputStream::IsAvailable() const
8b33ae2d 343{
79066131
VZ
344 if ( !IsOpened() )
345 return FALSE;
346
f6bcfd97
BP
347 DWORD nAvailable;
348
349 // function name is misleading, it works with anon pipes as well
350 DWORD rc = ::PeekNamedPipe
351 (
352 m_hInput, // handle
353 NULL, 0, // ptr to buffer and its size
354 NULL, // [out] bytes read
355 &nAvailable, // [out] bytes available
356 NULL // [out] bytes left
357 );
358
359 if ( !rc )
360 {
361 if ( ::GetLastError() != ERROR_BROKEN_PIPE )
362 {
363 // unexpected error
364 wxLogLastError(_T("PeekNamedPipe"));
365 }
8b33ae2d 366
f6bcfd97
BP
367 // don't try to continue reading from a pipe if an error occured or if
368 // it had been closed
79066131
VZ
369 ::CloseHandle(m_hInput);
370
371 wxConstCast(this, wxPipeInputStream)->m_hInput = INVALID_HANDLE_VALUE;
372
373 return FALSE;
f6bcfd97 374 }
79066131
VZ
375
376 return nAvailable != 0;
f6bcfd97
BP
377}
378
379size_t wxPipeInputStream::OnSysRead(void *buffer, size_t len)
380{
381 // reading from a pipe may block if there is no more data, always check for
382 // EOF first
79066131
VZ
383 if ( !IsAvailable() )
384 {
385 m_lasterror = wxSTREAM_EOF;
386
f6bcfd97 387 return 0;
79066131
VZ
388 }
389
390 m_lasterror = wxSTREAM_NOERROR;
f6bcfd97
BP
391
392 DWORD bytesRead;
393 if ( !::ReadFile(m_hInput, buffer, len, &bytesRead, NULL) )
394 {
395 if ( ::GetLastError() == ERROR_BROKEN_PIPE )
8b33ae2d
GL
396 m_lasterror = wxSTREAM_EOF;
397 else
398 m_lasterror = wxSTREAM_READ_ERROR;
399 }
f6bcfd97 400
8b33ae2d
GL
401 return bytesRead;
402}
403
79066131 404// ----------------------------------------------------------------------------
8b33ae2d 405// wxPipeOutputStream
79066131 406// ----------------------------------------------------------------------------
8b33ae2d
GL
407
408wxPipeOutputStream::wxPipeOutputStream(HANDLE hOutput)
409{
410 m_hOutput = hOutput;
cd6ce4a9 411}
8b33ae2d
GL
412
413wxPipeOutputStream::~wxPipeOutputStream()
414{
415 ::CloseHandle(m_hOutput);
416}
417
418size_t wxPipeOutputStream::OnSysWrite(const void *buffer, size_t len)
419{
420 DWORD bytesRead;
421
422 m_lasterror = wxSTREAM_NOERROR;
f6bcfd97
BP
423 if ( !::WriteFile(m_hOutput, buffer, len, &bytesRead, NULL) )
424 {
425 if ( ::GetLastError() == ERROR_BROKEN_PIPE )
8b33ae2d
GL
426 m_lasterror = wxSTREAM_EOF;
427 else
428 m_lasterror = wxSTREAM_READ_ERROR;
429 }
f6bcfd97 430
8b33ae2d
GL
431 return bytesRead;
432}
433
79066131
VZ
434#endif // wxUSE_STREAMS
435
436#endif // Win32
8b33ae2d 437
b568d04f 438// ============================================================================
79066131 439// wxExecute functions family
b568d04f 440// ============================================================================
5260b1c5 441
ca289436
VZ
442#if wxUSE_IPC
443
444// connect to the given server via DDE and ask it to execute the command
445static bool wxExecuteDDE(const wxString& ddeServer,
446 const wxString& ddeTopic,
447 const wxString& ddeCommand)
448{
449 bool ok;
450
451 wxDDEClient client;
452 wxConnectionBase *conn = client.MakeConnection(_T(""),
453 ddeServer,
454 ddeTopic);
455 if ( !conn )
456 {
457 ok = FALSE;
458 }
459 else // connected to DDE server
460 {
461 // the added complication here is that although most
462 // programs use XTYP_EXECUTE for their DDE API, some
463 // important ones - like IE and other MS stuff - use
464 // XTYP_REQUEST!
465 //
466 // so we try it first and then the other one if it
467 // failed
468 {
469 wxLogNull noErrors;
470 ok = conn->Request(ddeCommand) != NULL;
471 }
472
473 if ( !ok )
474 {
475 // now try execute - but show the errors
476 ok = conn->Execute(ddeCommand);
477 }
478 }
479
480 return ok;
481}
482
483#endif // wxUSE_IPC
484
fbf456aa 485long wxExecute(const wxString& cmd, int flags, wxProcess *handler)
32592631 486{
5bd3a2da
VZ
487 wxCHECK_MSG( !!cmd, 0, wxT("empty command in wxExecute") );
488
039f62f4 489 wxString command;
6ba63600 490
731dd422 491#if wxUSE_IPC
5bd3a2da
VZ
492 // DDE hack: this is really not pretty, but we need to allow this for
493 // transparent handling of DDE servers in wxMimeTypesManager. Usually it
494 // returns the command which should be run to view/open/... a file of the
495 // given type. Sometimes, however, this command just launches the server
496 // and an additional DDE request must be made to really open the file. To
497 // keep all this well hidden from the application, we allow a special form
6ba63600 498 // of command: WX_DDE#<command>#DDE_SERVER#DDE_TOPIC#DDE_COMMAND in which
5bd3a2da 499 // case we execute just <command> and process the rest below
039f62f4 500 wxString ddeServer, ddeTopic, ddeCommand;
5bd3a2da
VZ
501 static const size_t lenDdePrefix = 7; // strlen("WX_DDE:")
502 if ( cmd.Left(lenDdePrefix) == _T("WX_DDE#") )
503 {
ca289436
VZ
504 // speed up the concatenations below
505 ddeServer.reserve(256);
506 ddeTopic.reserve(256);
507 ddeCommand.reserve(256);
508
5bd3a2da
VZ
509 const wxChar *p = cmd.c_str() + 7;
510 while ( *p && *p != _T('#') )
511 {
512 command += *p++;
513 }
514
515 if ( *p )
516 {
517 // skip '#'
518 p++;
519 }
520 else
521 {
522 wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
523 }
524
525 while ( *p && *p != _T('#') )
526 {
527 ddeServer += *p++;
528 }
529
530 if ( *p )
531 {
532 // skip '#'
533 p++;
534 }
535 else
536 {
537 wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
538 }
539
540 while ( *p && *p != _T('#') )
541 {
542 ddeTopic += *p++;
543 }
544
545 if ( *p )
546 {
547 // skip '#'
548 p++;
549 }
550 else
551 {
552 wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
553 }
554
555 while ( *p )
556 {
557 ddeCommand += *p++;
558 }
6ba63600 559
ca289436
VZ
560 // if we want to just launch the program and not wait for its
561 // termination, try to execute DDE command right now, it can succeed if
562 // the process is already running - but as it fails if it's not
563 // running, suppress any errors it might generate
fbf456aa 564 if ( !(flags & wxEXEC_SYNC) )
6ba63600 565 {
ca289436
VZ
566 wxLogNull noErrors;
567 if ( wxExecuteDDE(ddeServer, ddeTopic, ddeCommand) )
568 {
569 // a dummy PID - this is a hack, of course, but it's well worth
570 // it as we don't open a new server each time we're called
571 // which would be quite bad
572 return -1;
573 }
6ba63600 574 }
5bd3a2da
VZ
575 }
576 else
731dd422 577#endif // wxUSE_IPC
5bd3a2da
VZ
578 {
579 // no DDE
580 command = cmd;
581 }
32592631 582
57c208c5 583#if defined(__WIN32__) && !defined(__TWIN32__)
cb6827a8 584
f6bcfd97
BP
585 // the IO redirection is only supported with wxUSE_STREAMS
586 BOOL redirect = FALSE;
79066131 587
f6bcfd97 588#if wxUSE_STREAMS
79066131
VZ
589 wxPipe pipeIn, pipeOut, pipeErr;
590
591 // we'll save here the copy of pipeIn[Write]
33ac7e6f 592 HANDLE hpipeStdinWrite = INVALID_HANDLE_VALUE;
8b33ae2d 593
cd6ce4a9 594 // open the pipes to which child process IO will be redirected if needed
cd6ce4a9
VZ
595 if ( handler && handler->IsRedirected() )
596 {
79066131
VZ
597 // create pipes for redirecting stdin, stdout and stderr
598 if ( !pipeIn.Create() || !pipeOut.Create() || !pipeErr.Create() )
cd6ce4a9 599 {
79066131 600 wxLogSysError(_("Failed to redirect the child process IO"));
8b33ae2d 601
fbf456aa
VZ
602 // indicate failure: we need to return different error code
603 // depending on the sync flag
604 return flags & wxEXEC_SYNC ? -1 : 0;
8b33ae2d
GL
605 }
606
f6bcfd97 607 redirect = TRUE;
8b33ae2d 608 }
f6bcfd97 609#endif // wxUSE_STREAMS
5bd3a2da 610
cb6827a8
VZ
611 // create the process
612 STARTUPINFO si;
11c7d5b6 613 wxZeroMemory(si);
cb6827a8
VZ
614 si.cb = sizeof(si);
615
f6bcfd97
BP
616#if wxUSE_STREAMS
617 if ( redirect )
cb6827a8 618 {
fbf456aa 619 si.dwFlags = STARTF_USESTDHANDLES;
f6bcfd97 620
79066131
VZ
621 si.hStdInput = pipeIn[wxPipe::Read];
622 si.hStdOutput = pipeOut[wxPipe::Write];
623 si.hStdError = pipeErr[wxPipe::Write];
f6bcfd97 624
fbf456aa
VZ
625 // when the std IO is redirected, we don't show the (console) process
626 // window by default, but this can be overridden by the caller by
627 // specifying wxEXEC_NOHIDE flag
628 if ( !(flags & wxEXEC_NOHIDE) )
629 {
630 si.dwFlags |= STARTF_USESHOWWINDOW;
631 si.wShowWindow = SW_HIDE;
632 }
f6bcfd97
BP
633
634 // we must duplicate the handle to the write side of stdin pipe to make
79066131
VZ
635 // it non inheritable: indeed, we must close the writing end of pipeIn
636 // before launching the child process as otherwise this handle will be
f6bcfd97
BP
637 // inherited by the child which will never close it and so the pipe
638 // will never be closed and the child will be left stuck in ReadFile()
79066131 639 HANDLE pipeInWrite = pipeIn.Detach(wxPipe::Write);
f6bcfd97
BP
640 if ( !::DuplicateHandle
641 (
79066131
VZ
642 ::GetCurrentProcess(),
643 pipeInWrite,
644 ::GetCurrentProcess(),
f6bcfd97
BP
645 &hpipeStdinWrite,
646 0, // desired access: unused here
647 FALSE, // not inherited
648 DUPLICATE_SAME_ACCESS // same access as for src handle
649 ) )
cd6ce4a9 650 {
f6bcfd97 651 wxLogLastError(_T("DuplicateHandle"));
8b33ae2d 652 }
cd6ce4a9 653
79066131 654 ::CloseHandle(pipeInWrite);
f6bcfd97
BP
655 }
656#endif // wxUSE_STREAMS
cb6827a8 657
f6bcfd97
BP
658 PROCESS_INFORMATION pi;
659 DWORD dwFlags = CREATE_DEFAULT_ERROR_MODE | CREATE_SUSPENDED;
660
661 bool ok = ::CreateProcess
662 (
663 NULL, // application name (use only cmd line)
664 (wxChar *)
665 command.c_str(), // full command line
666 NULL, // security attributes: defaults for both
667 NULL, // the process and its main thread
668 redirect, // inherit handles if we use pipes
669 dwFlags, // process creation flags
670 NULL, // environment (use the same)
671 NULL, // current directory (use the same)
672 &si, // startup info (unused here)
673 &pi // process info
674 ) != 0;
675
676#if wxUSE_STREAMS
677 // we can close the pipe ends used by child anyhow
678 if ( redirect )
679 {
79066131
VZ
680 ::CloseHandle(pipeIn.Detach(wxPipe::Read));
681 ::CloseHandle(pipeOut.Detach(wxPipe::Write));
682 ::CloseHandle(pipeErr.Detach(wxPipe::Write));
cb6827a8 683 }
f6bcfd97 684#endif // wxUSE_STREAMS
cb6827a8 685
f6bcfd97 686 if ( !ok )
5e1febfa 687 {
f6bcfd97
BP
688#if wxUSE_STREAMS
689 // close the other handles too
690 if ( redirect )
5e1febfa 691 {
79066131
VZ
692 ::CloseHandle(pipeOut.Detach(wxPipe::Read));
693 ::CloseHandle(pipeErr.Detach(wxPipe::Read));
5e1febfa 694 }
f6bcfd97 695#endif // wxUSE_STREAMS
5e1febfa 696
f6bcfd97
BP
697 wxLogSysError(_("Execution of command '%s' failed"), command.c_str());
698
fbf456aa 699 return flags & wxEXEC_SYNC ? -1 : 0;
f6bcfd97 700 }
8b33ae2d 701
f6bcfd97 702#if wxUSE_STREAMS
79066131
VZ
703 // the input buffer bufOut is connected to stdout, this is why it is
704 // called bufOut and not bufIn
705 wxStreamTempInputBuffer bufOut,
706 bufErr;
707
f6bcfd97
BP
708 if ( redirect )
709 {
8b33ae2d 710 // We can now initialize the wxStreams
79066131
VZ
711 wxPipeInputStream *
712 outStream = new wxPipeInputStream(pipeOut.Detach(wxPipe::Read));
713 wxPipeInputStream *
714 errStream = new wxPipeInputStream(pipeErr.Detach(wxPipe::Read));
715 wxPipeOutputStream *
716 inStream = new wxPipeOutputStream(hpipeStdinWrite);
717
718 handler->SetPipeStreams(outStream, inStream, errStream);
8b33ae2d 719
79066131
VZ
720 bufOut.Init(outStream);
721 bufErr.Init(errStream);
8b33ae2d 722 }
f6bcfd97 723#endif // wxUSE_STREAMS
8b33ae2d 724
0d7ea902 725 // register the class for the hidden window used for the notifications
b568d04f
VZ
726 if ( !gs_classForHiddenWindow )
727 {
728 gs_classForHiddenWindow = _T("wxHiddenWindow");
729
730 WNDCLASS wndclass;
731 wxZeroMemory(wndclass);
732 wndclass.lpfnWndProc = (WNDPROC)wxExecuteWindowCbk;
733 wndclass.hInstance = wxGetInstance();
734 wndclass.lpszClassName = gs_classForHiddenWindow;
735
736 if ( !::RegisterClass(&wndclass) )
737 {
f6bcfd97 738 wxLogLastError(wxT("RegisterClass(hidden window)"));
b568d04f
VZ
739 }
740 }
741
cb6827a8
VZ
742 // create a hidden window to receive notification about process
743 // termination
b568d04f 744 HWND hwnd = ::CreateWindow(gs_classForHiddenWindow, NULL,
0d7ea902
VZ
745 WS_OVERLAPPEDWINDOW,
746 0, 0, 0, 0, NULL,
cb6827a8 747 (HMENU)NULL, wxGetInstance(), 0);
223d09f6 748 wxASSERT_MSG( hwnd, wxT("can't create a hidden window for wxExecute") );
e6045e08 749
cb6827a8
VZ
750 // Alloc data
751 wxExecuteData *data = new wxExecuteData;
752 data->hProcess = pi.hProcess;
753 data->dwProcessId = pi.dwProcessId;
754 data->hWnd = hwnd;
fbf456aa
VZ
755 data->state = (flags & wxEXEC_SYNC) != 0;
756 if ( flags & wxEXEC_SYNC )
e6045e08 757 {
5e1febfa
VZ
758 // handler may be !NULL for capturing program output, but we don't use
759 // it wxExecuteData struct in this case
e6045e08
VZ
760 data->handler = NULL;
761 }
762 else
763 {
764 // may be NULL or not
765 data->handler = handler;
766 }
cb6827a8
VZ
767
768 DWORD tid;
769 HANDLE hThread = ::CreateThread(NULL,
770 0,
19193a2c 771 wxExecuteThread,
cb6827a8
VZ
772 (void *)data,
773 0,
774 &tid);
775
0d7ea902
VZ
776 // resume process we created now - whether the thread creation succeeded or
777 // not
778 if ( ::ResumeThread(pi.hThread) == (DWORD)-1 )
779 {
780 // ignore it - what can we do?
f6bcfd97 781 wxLogLastError(wxT("ResumeThread in wxExecute"));
0d7ea902
VZ
782 }
783
784 // close unneeded handle
785 if ( !::CloseHandle(pi.hThread) )
f6bcfd97 786 wxLogLastError(wxT("CloseHandle(hThread)"));
0d7ea902 787
cb6827a8
VZ
788 if ( !hThread )
789 {
f6bcfd97 790 wxLogLastError(wxT("CreateThread in wxExecute"));
cb6827a8
VZ
791
792 DestroyWindow(hwnd);
793 delete data;
794
795 // the process still started up successfully...
796 return pi.dwProcessId;
797 }
e6045e08 798
f6bcfd97
BP
799 ::CloseHandle(hThread);
800
731dd422 801#if wxUSE_IPC
5bd3a2da
VZ
802 // second part of DDE hack: now establish the DDE conversation with the
803 // just launched process
ca289436 804 if ( !ddeServer.empty() )
5bd3a2da 805 {
ca289436
VZ
806 bool ok;
807
808 // give the process the time to init itself
809 //
810 // we use a very big timeout hoping that WaitForInputIdle() will return
811 // much sooner, but not INFINITE just in case the process hangs
812 // completely - like this we will regain control sooner or later
813 switch ( ::WaitForInputIdle(pi.hProcess, 10000 /* 10 seconds */) )
6ba63600 814 {
ca289436
VZ
815 default:
816 wxFAIL_MSG( _T("unexpected WaitForInputIdle() return code") );
817 // fall through
6ba63600 818
ca289436
VZ
819 case -1:
820 wxLogLastError(_T("WaitForInputIdle() in wxExecute"));
6ba63600 821
ca289436
VZ
822 case WAIT_TIMEOUT:
823 wxLogDebug(_T("Timeout too small in WaitForInputIdle"));
824
825 ok = FALSE;
826 break;
827
828 case 0:
829 // ok, process ready to accept DDE requests
830 ok = wxExecuteDDE(ddeServer, ddeTopic, ddeCommand);
6ba63600 831 }
5bd3a2da 832 }
731dd422 833#endif // wxUSE_IPC
5bd3a2da 834
fbf456aa 835 if ( !(flags & wxEXEC_SYNC) )
cb6827a8
VZ
836 {
837 // clean up will be done when the process terminates
e6045e08
VZ
838
839 // return the pid
cb6827a8
VZ
840 return pi.dwProcessId;
841 }
e6045e08 842
0d7ea902
VZ
843 // waiting until command executed (disable everything while doing it)
844#if wxUSE_GUI
cd6ce4a9
VZ
845 {
846 wxBusyCursor bc;
847
848 wxWindowDisabler wd;
0d7ea902
VZ
849#endif // wxUSE_GUI
850
79066131
VZ
851 // wait until the child process terminates
852 while ( data->state )
853 {
854#if wxUSE_STREAMS
855 bufOut.Update();
856 bufErr.Update();
857#endif // wxUSE_STREAMS
858
859 // don't eat 100% of the CPU -- ugly but anything else requires
860 // real async IO which we don't have for the moment
861 ::Sleep(50);
862
863 // repaint the GUI
864 wxYield();
865 }
e6045e08 866
0d7ea902 867#if wxUSE_GUI
cd6ce4a9 868 }
0d7ea902
VZ
869#endif // wxUSE_GUI
870
e6045e08 871 DWORD dwExitCode = data->dwExitCode;
cb6827a8
VZ
872 delete data;
873
e6045e08
VZ
874 // return the exit code
875 return dwExitCode;
cb6827a8
VZ
876#else // Win16
877 long instanceID = WinExec((LPCSTR) WXSTRINGCAST command, SW_SHOW);
fbf456aa
VZ
878 if (instanceID < 32)
879 return flags & wxEXEC_SYNC ? -1 : 0;
e6045e08 880
fbf456aa
VZ
881 if ( flags & wxEXEC_SYNC )
882 {
cb6827a8 883 int running;
fbf456aa
VZ
884 do
885 {
cb6827a8 886 wxYield();
27a9bd48 887 running = GetModuleUsage((HINSTANCE)instanceID);
cb6827a8
VZ
888 } while (running);
889 }
890
fbf456aa 891 return instanceID;
cb6827a8 892#endif // Win16/32
32592631 893}
c740f496 894
0493ba13 895long wxExecute(wxChar **argv, int flags, wxProcess *handler)
c740f496 896{
cb6827a8 897 wxString command;
e6045e08 898
0493ba13 899 for ( ;; )
cb6827a8 900 {
0493ba13
VZ
901 command += *argv++;
902 if ( !*argv )
903 break;
cb6827a8 904
0493ba13
VZ
905 command += _T(' ');
906 }
cb6827a8 907
fbf456aa 908 return wxExecute(command, flags, handler);
c740f496 909}
006162a9 910