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