1/////////////////////////////////////////////////////////////////////////////
2// Name:        exec.cpp
3// Purpose:     exec sample demonstrates wxExecute and related functions
4// Author:      Vadim Zeitlin
5// Modified by:
6// Created:     15.01.00
7// RCS-ID:      $Id: exec.cpp 54352 2008-06-25 07:51:09Z JS $
8// Copyright:   (c) Vadim Zeitlin
9// Licence:     wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20// For compilers that support precompilation, includes "wx/wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
24    #pragma hdrstop
25#endif
26
27// for all others, include the necessary headers (this file is usually all you
28// need because it includes almost all "standard" wxWidgets headers
29#ifndef WX_PRECOMP
30    #include "wx/app.h"
31    #include "wx/log.h"
32    #include "wx/frame.h"
33    #include "wx/panel.h"
34
35    #include "wx/timer.h"
36
37    #include "wx/utils.h"
38    #include "wx/menu.h"
39
40    #include "wx/msgdlg.h"
41    #include "wx/textdlg.h"
42    #include "wx/filedlg.h"
43    #include "wx/choicdlg.h"
44
45    #include "wx/button.h"
46    #include "wx/textctrl.h"
47    #include "wx/listbox.h"
48
49    #include "wx/sizer.h"
50#endif
51
52#include "wx/txtstrm.h"
53#include "wx/numdlg.h"
54#include "wx/textdlg.h"
55#include "wx/ffile.h"
56
57#include "wx/process.h"
58
59#include "wx/mimetype.h"
60
61#ifdef __WINDOWS__
62    #include "wx/dde.h"
63#endif // __WINDOWS__
64
65// ----------------------------------------------------------------------------
66// the usual application and main frame classes
67// ----------------------------------------------------------------------------
68
69// Define a new application type, each program should derive a class from wxApp
70class MyApp : public wxApp
71{
72public:
73    // override base class virtuals
74    // ----------------------------
75
76    // this one is called on application startup and is a good place for the app
77    // initialization (doing it here and not in the ctor allows to have an error
78    // return: if OnInit() returns false, the application terminates)
79    virtual bool OnInit();
80};
81
82// Define an array of process pointers used by MyFrame
83class MyPipedProcess;
84WX_DEFINE_ARRAY_PTR(MyPipedProcess *, MyProcessesArray);
85
86// Define a new frame type: this is going to be our main frame
87class MyFrame : public wxFrame
88{
89public:
90    // ctor(s)
91    MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size);
92
93    // event handlers (these functions should _not_ be virtual)
94    void OnQuit(wxCommandEvent& event);
95
96    void OnKill(wxCommandEvent& event);
97
98    void OnClear(wxCommandEvent& event);
99
100    void OnSyncExec(wxCommandEvent& event);
101    void OnAsyncExec(wxCommandEvent& event);
102    void OnShell(wxCommandEvent& event);
103    void OnExecWithRedirect(wxCommandEvent& event);
104    void OnExecWithPipe(wxCommandEvent& event);
105
106    void OnPOpen(wxCommandEvent& event);
107
108    void OnFileExec(wxCommandEvent& event);
109    void OnOpenURL(wxCommandEvent& event);
110
111    void OnAbout(wxCommandEvent& event);
112
113    // polling output of async processes
114    void OnTimer(wxTimerEvent& event);
115    void OnIdle(wxIdleEvent& event);
116
117    // for MyPipedProcess
118    void OnProcessTerminated(MyPipedProcess *process);
119    wxListBox *GetLogListBox() const { return m_lbox; }
120
121private:
122    void ShowOutput(const wxString& cmd,
123                    const wxArrayString& output,
124                    const wxString& title);
125
126    void DoAsyncExec(const wxString& cmd);
127
128    void AddAsyncProcess(MyPipedProcess *process)
129    {
130        if ( m_running.IsEmpty() )
131        {
132            // we want to start getting the timer events to ensure that a
133            // steady stream of idle events comes in -- otherwise we
134            // wouldn't be able to poll the child process input
135            m_timerIdleWakeUp.Start(100);
136        }
137        //else: the timer is already running
138
139        m_running.Add(process);
140    }
141
142    void RemoveAsyncProcess(MyPipedProcess *process)
143    {
144        m_running.Remove(process);
145
146        if ( m_running.IsEmpty() )
147        {
148            // we don't need to get idle events all the time any more
149            m_timerIdleWakeUp.Stop();
150        }
151    }
152
153    // the PID of the last process we launched asynchronously
154    long m_pidLast;
155
156    // last command we executed
157    wxString m_cmdLast;
158
159#ifdef __WINDOWS__
160    void OnDDEExec(wxCommandEvent& event);
161    void OnDDERequest(wxCommandEvent& event);
162
163    bool GetDDEServer();
164
165    // last params of a DDE transaction
166    wxString m_server,
167             m_topic,
168             m_cmdDde;
169#endif // __WINDOWS__
170
171    wxListBox *m_lbox;
172
173    MyProcessesArray m_running;
174
175    // the idle event wake up timer
176    wxTimer m_timerIdleWakeUp;
177
178    // any class wishing to process wxWidgets events must use this macro
179    DECLARE_EVENT_TABLE()
180};
181
182// ----------------------------------------------------------------------------
183// MyPipeFrame: allows the user to communicate with the child process
184// ----------------------------------------------------------------------------
185
186class MyPipeFrame : public wxFrame
187{
188public:
189    MyPipeFrame(wxFrame *parent,
190                const wxString& cmd,
191                wxProcess *process);
192
193protected:
194    void OnTextEnter(wxCommandEvent& WXUNUSED(event)) { DoSend(); }
195    void OnBtnSend(wxCommandEvent& WXUNUSED(event)) { DoSend(); }
196    void OnBtnSendFile(wxCommandEvent& WXUNUSED(event));
197    void OnBtnGet(wxCommandEvent& WXUNUSED(event)) { DoGet(); }
198    void OnBtnClose(wxCommandEvent& WXUNUSED(event)) { DoClose(); }
199
200    void OnClose(wxCloseEvent& event);
201
202    void OnProcessTerm(wxProcessEvent& event);
203
204    void DoSend()
205    {
206        wxString s(m_textOut->GetValue());
207        s += _T('\n');
208        m_out.Write(s.c_str(), s.length());
209        m_textOut->Clear();
210
211        DoGet();
212    }
213
214    void DoGet();
215    void DoClose();
216
217private:
218    void DoGetFromStream(wxTextCtrl *text, wxInputStream& in);
219    void DisableInput();
220    void DisableOutput();
221
222
223    wxProcess *m_process;
224
225    wxOutputStream &m_out;
226    wxInputStream &m_in,
227                  &m_err;
228
229    wxTextCtrl *m_textOut,
230               *m_textIn,
231               *m_textErr;
232
233    DECLARE_EVENT_TABLE()
234};
235
236// ----------------------------------------------------------------------------
237// wxProcess-derived classes
238// ----------------------------------------------------------------------------
239
240// This is the handler for process termination events
241class MyProcess : public wxProcess
242{
243public:
244    MyProcess(MyFrame *parent, const wxString& cmd)
245        : wxProcess(parent), m_cmd(cmd)
246    {
247        m_parent = parent;
248    }
249
250    // instead of overriding this virtual function we might as well process the
251    // event from it in the frame class - this might be more convenient in some
252    // cases
253    virtual void OnTerminate(int pid, int status);
254
255protected:
256    MyFrame *m_parent;
257    wxString m_cmd;
258};
259
260// A specialization of MyProcess for redirecting the output
261class MyPipedProcess : public MyProcess
262{
263public:
264    MyPipedProcess(MyFrame *parent, const wxString& cmd)
265        : MyProcess(parent, cmd)
266        {
267            Redirect();
268        }
269
270    virtual void OnTerminate(int pid, int status);
271
272    virtual bool HasInput();
273};
274
275// A version of MyPipedProcess which also sends input to the stdin of the
276// child process
277class MyPipedProcess2 : public MyPipedProcess
278{
279public:
280    MyPipedProcess2(MyFrame *parent, const wxString& cmd, const wxString& input)
281        : MyPipedProcess(parent, cmd), m_input(input)
282        {
283        }
284
285    virtual bool HasInput();
286
287private:
288    wxString m_input;
289};
290
291// ----------------------------------------------------------------------------
292// constants
293// ----------------------------------------------------------------------------
294
295// IDs for the controls and the menu commands
296enum
297{
298    // menu items
299    Exec_Quit = 100,
300    Exec_Kill,
301    Exec_ClearLog,
302    Exec_SyncExec = 200,
303    Exec_AsyncExec,
304    Exec_Shell,
305    Exec_POpen,
306    Exec_OpenFile,
307    Exec_OpenURL,
308    Exec_DDEExec,
309    Exec_DDERequest,
310    Exec_Redirect,
311    Exec_Pipe,
312    Exec_About = 300,
313
314    // control ids
315    Exec_Btn_Send = 1000,
316    Exec_Btn_SendFile,
317    Exec_Btn_Get,
318    Exec_Btn_Close
319};
320
321static const wxChar *DIALOG_TITLE = _T("Exec sample");
322
323// ----------------------------------------------------------------------------
324// event tables and other macros for wxWidgets
325// ----------------------------------------------------------------------------
326
327// the event tables connect the wxWidgets events with the functions (event
328// handlers) which process them. It can be also done at run-time, but for the
329// simple menu events like this the static method is much simpler.
330BEGIN_EVENT_TABLE(MyFrame, wxFrame)
331    EVT_MENU(Exec_Quit,  MyFrame::OnQuit)
332    EVT_MENU(Exec_Kill,  MyFrame::OnKill)
333    EVT_MENU(Exec_ClearLog,  MyFrame::OnClear)
334
335    EVT_MENU(Exec_SyncExec, MyFrame::OnSyncExec)
336    EVT_MENU(Exec_AsyncExec, MyFrame::OnAsyncExec)
337    EVT_MENU(Exec_Shell, MyFrame::OnShell)
338    EVT_MENU(Exec_Redirect, MyFrame::OnExecWithRedirect)
339    EVT_MENU(Exec_Pipe, MyFrame::OnExecWithPipe)
340
341    EVT_MENU(Exec_POpen, MyFrame::OnPOpen)
342
343    EVT_MENU(Exec_OpenFile, MyFrame::OnFileExec)
344    EVT_MENU(Exec_OpenURL, MyFrame::OnOpenURL)
345
346#ifdef __WINDOWS__
347    EVT_MENU(Exec_DDEExec, MyFrame::OnDDEExec)
348    EVT_MENU(Exec_DDERequest, MyFrame::OnDDERequest)
349#endif // __WINDOWS__
350
351    EVT_MENU(Exec_About, MyFrame::OnAbout)
352
353    EVT_IDLE(MyFrame::OnIdle)
354
355    EVT_TIMER(wxID_ANY, MyFrame::OnTimer)
356END_EVENT_TABLE()
357
358BEGIN_EVENT_TABLE(MyPipeFrame, wxFrame)
359    EVT_BUTTON(Exec_Btn_Send, MyPipeFrame::OnBtnSend)
360    EVT_BUTTON(Exec_Btn_SendFile, MyPipeFrame::OnBtnSendFile)
361    EVT_BUTTON(Exec_Btn_Get, MyPipeFrame::OnBtnGet)
362    EVT_BUTTON(Exec_Btn_Close, MyPipeFrame::OnBtnClose)
363
364    EVT_TEXT_ENTER(wxID_ANY, MyPipeFrame::OnTextEnter)
365
366    EVT_CLOSE(MyPipeFrame::OnClose)
367
368    EVT_END_PROCESS(wxID_ANY, MyPipeFrame::OnProcessTerm)
369END_EVENT_TABLE()
370
371// Create a new application object: this macro will allow wxWidgets to create
372// the application object during program execution (it's better than using a
373// static object for many reasons) and also declares the accessor function
374// wxGetApp() which will return the reference of the right type (i.e. MyApp and
375// not wxApp)
376IMPLEMENT_APP(MyApp)
377
378// ============================================================================
379// implementation
380// ============================================================================
381
382// ----------------------------------------------------------------------------
383// the application class
384// ----------------------------------------------------------------------------
385
386// `Main program' equivalent: the program execution "starts" here
387bool MyApp::OnInit()
388{
389    // Create the main application window
390    MyFrame *frame = new MyFrame(_T("Exec wxWidgets sample"),
391                                 wxDefaultPosition, wxSize(500, 140));
392
393    // Show it and tell the application that it's our main window
394    frame->Show(true);
395    SetTopWindow(frame);
396
397    // success: wxApp::OnRun() will be called which will enter the main message
398    // loop and the application will run. If we returned false here, the
399    // application would exit immediately.
400    return true;
401}
402
403// ----------------------------------------------------------------------------
404// main frame
405// ----------------------------------------------------------------------------
406
407#ifdef __VISUALC__
408#pragma warning(disable: 4355) // this used in base member initializer list
409#endif
410
411// frame constructor
412MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
413       : wxFrame((wxFrame *)NULL, wxID_ANY, title, pos, size),
414         m_timerIdleWakeUp(this)
415{
416    m_pidLast = 0;
417
418#ifdef __WXMAC__
419    // we need this in order to allow the about menu relocation, since ABOUT is
420    // not the default id of the about menu
421    wxApp::s_macAboutMenuItemId = Exec_About;
422#endif
423
424    // create a menu bar
425    wxMenu *menuFile = new wxMenu(wxEmptyString, wxMENU_TEAROFF);
426    menuFile->Append(Exec_Kill, _T("&Kill process...\tCtrl-K"),
427                     _T("Kill a process by PID"));
428    menuFile->AppendSeparator();
429    menuFile->Append(Exec_ClearLog, _T("&Clear log\tCtrl-C"),
430                     _T("Clear the log window"));
431    menuFile->AppendSeparator();
432    menuFile->Append(Exec_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));
433
434    wxMenu *execMenu = new wxMenu;
435    execMenu->Append(Exec_SyncExec, _T("Sync &execution...\tCtrl-E"),
436                     _T("Launch a program and return when it terminates"));
437    execMenu->Append(Exec_AsyncExec, _T("&Async execution...\tCtrl-A"),
438                     _T("Launch a program and return immediately"));
439    execMenu->Append(Exec_Shell, _T("Execute &shell command...\tCtrl-S"),
440                     _T("Launch a shell and execute a command in it"));
441    execMenu->AppendSeparator();
442    execMenu->Append(Exec_Redirect, _T("Capture command &output...\tCtrl-O"),
443                     _T("Launch a program and capture its output"));
444    execMenu->Append(Exec_Pipe, _T("&Pipe through command..."),
445                     _T("Pipe a string through a filter"));
446    execMenu->Append(Exec_POpen, _T("&Open a pipe to a command...\tCtrl-P"),
447                     _T("Open a pipe to and from another program"));
448
449    execMenu->AppendSeparator();
450    execMenu->Append(Exec_OpenFile, _T("Open &file...\tCtrl-F"),
451                     _T("Launch the command to open this kind of files"));
452    execMenu->Append(Exec_OpenURL, _T("Open &URL...\tCtrl-U"),
453                     _T("Launch the default browser with the given URL"));
454#ifdef __WINDOWS__
455    execMenu->AppendSeparator();
456    execMenu->Append(Exec_DDEExec, _T("Execute command via &DDE...\tCtrl-D"));
457    execMenu->Append(Exec_DDERequest, _T("Send DDE &request...\tCtrl-R"));
458#endif
459
460    wxMenu *helpMenu = new wxMenu(wxEmptyString, wxMENU_TEAROFF);
461    helpMenu->Append(Exec_About, _T("&About...\tF1"), _T("Show about dialog"));
462
463    // now append the freshly created menu to the menu bar...
464    wxMenuBar *menuBar = new wxMenuBar();
465    menuBar->Append(menuFile, _T("&File"));
466    menuBar->Append(execMenu, _T("&Exec"));
467    menuBar->Append(helpMenu, _T("&Help"));
468
469    // ... and attach this menu bar to the frame
470    SetMenuBar(menuBar);
471
472    // create the listbox in which we will show misc messages as they come
473    m_lbox = new wxListBox(this, wxID_ANY);
474    wxFont font(12, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL,
475                wxFONTWEIGHT_NORMAL);
476    if ( font.Ok() )
477        m_lbox->SetFont(font);
478
479#if wxUSE_STATUSBAR
480    // create a status bar just for fun (by default with 1 pane only)
481    CreateStatusBar();
482    SetStatusText(_T("Welcome to wxWidgets exec sample!"));
483#endif // wxUSE_STATUSBAR
484}
485
486// ----------------------------------------------------------------------------
487// event handlers: file and help menu
488// ----------------------------------------------------------------------------
489
490void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
491{
492    // true is to force the frame to close
493    Close(true);
494}
495
496void MyFrame::OnClear(wxCommandEvent& WXUNUSED(event))
497{
498    m_lbox->Clear();
499}
500
501void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
502{
503    wxMessageBox(_T("Exec wxWidgets Sample\n(c) 2000-2002 Vadim Zeitlin"),
504                 _T("About Exec"), wxOK | wxICON_INFORMATION, this);
505}
506
507void MyFrame::OnKill(wxCommandEvent& WXUNUSED(event))
508{
509    long pid = wxGetNumberFromUser(_T("Please specify the process to kill"),
510                                   _T("Enter PID:"),
511                                   _T("Exec question"),
512                                   m_pidLast,
513                                   // we need the full unsigned int range
514                                   -INT_MAX, INT_MAX,
515                                   this);
516    if ( pid == -1 )
517    {
518        // cancelled
519        return;
520    }
521
522    static const wxString signalNames[] =
523    {
524        _T("Just test (SIGNONE)"),
525        _T("Hangup (SIGHUP)"),
526        _T("Interrupt (SIGINT)"),
527        _T("Quit (SIGQUIT)"),
528        _T("Illegal instruction (SIGILL)"),
529        _T("Trap (SIGTRAP)"),
530        _T("Abort (SIGABRT)"),
531        _T("Emulated trap (SIGEMT)"),
532        _T("FP exception (SIGFPE)"),
533        _T("Kill (SIGKILL)"),
534        _T("Bus (SIGBUS)"),
535        _T("Segment violation (SIGSEGV)"),
536        _T("System (SIGSYS)"),
537        _T("Broken pipe (SIGPIPE)"),
538        _T("Alarm (SIGALRM)"),
539        _T("Terminate (SIGTERM)"),
540    };
541
542    int sig = wxGetSingleChoiceIndex(_T("How to kill the process?"),
543                                     _T("Exec question"),
544                                     WXSIZEOF(signalNames), signalNames,
545                                     this);
546    switch ( sig )
547    {
548        default:
549            wxFAIL_MSG( _T("unexpected return value") );
550            // fall through
551
552        case -1:
553            // cancelled
554            return;
555
556        case wxSIGNONE:
557        case wxSIGHUP:
558        case wxSIGINT:
559        case wxSIGQUIT:
560        case wxSIGILL:
561        case wxSIGTRAP:
562        case wxSIGABRT:
563        case wxSIGEMT:
564        case wxSIGFPE:
565        case wxSIGKILL:
566        case wxSIGBUS:
567        case wxSIGSEGV:
568        case wxSIGSYS:
569        case wxSIGPIPE:
570        case wxSIGALRM:
571        case wxSIGTERM:
572            break;
573    }
574
575    if ( sig == 0 )
576    {
577        if ( wxProcess::Exists(pid) )
578            wxLogStatus(_T("Process %ld is running."), pid);
579        else
580            wxLogStatus(_T("No process with pid = %ld."), pid);
581    }
582    else // not SIGNONE
583    {
584        wxKillError rc = wxProcess::Kill(pid, (wxSignal)sig);
585        if ( rc == wxKILL_OK )
586        {
587            wxLogStatus(_T("Process %ld killed with signal %d."), pid, sig);
588        }
589        else
590        {
591            static const wxChar *errorText[] =
592            {
593                _T(""), // no error
594                _T("signal not supported"),
595                _T("permission denied"),
596                _T("no such process"),
597                _T("unspecified error"),
598            };
599
600            wxLogStatus(_T("Failed to kill process %ld with signal %d: %s"),
601                        pid, sig, errorText[rc]);
602        }
603    }
604}
605
606// ----------------------------------------------------------------------------
607// event handlers: exec menu
608// ----------------------------------------------------------------------------
609
610void MyFrame::DoAsyncExec(const wxString& cmd)
611{
612    wxProcess *process = new MyProcess(this, cmd);
613    m_pidLast = wxExecute(cmd, wxEXEC_ASYNC, process);
614    if ( !m_pidLast )
615    {
616        wxLogError( _T("Execution of '%s' failed."), cmd.c_str() );
617
618        delete process;
619    }
620    else
621    {
622        wxLogStatus( _T("Process %ld (%s) launched."),
623            m_pidLast, cmd.c_str() );
624
625        m_cmdLast = cmd;
626    }
627}
628
629void MyFrame::OnSyncExec(wxCommandEvent& WXUNUSED(event))
630{
631    wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
632                                     DIALOG_TITLE,
633                                     m_cmdLast);
634
635    if ( !cmd )
636        return;
637
638    wxLogStatus( _T("'%s' is running please wait..."), cmd.c_str() );
639
640    int code = wxExecute(cmd, wxEXEC_SYNC);
641
642    wxLogStatus(_T("Process '%s' terminated with exit code %d."),
643        cmd.c_str(), code);
644
645    m_cmdLast = cmd;
646}
647
648void MyFrame::OnAsyncExec(wxCommandEvent& WXUNUSED(event))
649{
650    wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
651                                     DIALOG_TITLE,
652                                     m_cmdLast);
653
654    if ( !cmd )
655        return;
656
657    DoAsyncExec(cmd);
658}
659
660void MyFrame::OnShell(wxCommandEvent& WXUNUSED(event))
661{
662    wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
663                                     DIALOG_TITLE,
664                                     m_cmdLast);
665
666    if ( !cmd )
667        return;
668
669    int code = wxShell(cmd);
670    wxLogStatus(_T("Shell command '%s' terminated with exit code %d."),
671                cmd.c_str(), code);
672    m_cmdLast = cmd;
673}
674
675void MyFrame::OnExecWithRedirect(wxCommandEvent& WXUNUSED(event))
676{
677    wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
678                                     DIALOG_TITLE,
679                                     m_cmdLast);
680
681    if ( !cmd )
682        return;
683
684    bool sync;
685    switch ( wxMessageBox(_T("Execute it synchronously?"),
686                          _T("Exec question"),
687                          wxYES_NO | wxCANCEL | wxICON_QUESTION, this) )
688    {
689        case wxYES:
690            sync = true;
691            break;
692
693        case wxNO:
694            sync = false;
695            break;
696
697        default:
698            return;
699    }
700
701    if ( sync )
702    {
703        wxArrayString output, errors;
704        int code = wxExecute(cmd, output, errors);
705        wxLogStatus(_T("command '%s' terminated with exit code %d."),
706                    cmd.c_str(), code);
707
708        if ( code != -1 )
709        {
710            ShowOutput(cmd, output, _T("Output"));
711            ShowOutput(cmd, errors, _T("Errors"));
712        }
713    }
714    else // async exec
715    {
716        MyPipedProcess *process = new MyPipedProcess(this, cmd);
717        if ( !wxExecute(cmd, wxEXEC_ASYNC, process) )
718        {
719            wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
720
721            delete process;
722        }
723        else
724        {
725            AddAsyncProcess(process);
726        }
727    }
728
729    m_cmdLast = cmd;
730}
731
732void MyFrame::OnExecWithPipe(wxCommandEvent& WXUNUSED(event))
733{
734    if ( !m_cmdLast )
735        m_cmdLast = _T("tr [a-z] [A-Z]");
736
737    wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
738                                     DIALOG_TITLE,
739                                     m_cmdLast);
740
741    if ( !cmd )
742        return;
743
744    wxString input = wxGetTextFromUser(_T("Enter the string to send to it: "),
745                                       DIALOG_TITLE);
746    if ( !input )
747        return;
748
749    // always execute the filter asynchronously
750    MyPipedProcess2 *process = new MyPipedProcess2(this, cmd, input);
751    long pid = wxExecute(cmd, wxEXEC_ASYNC, process);
752    if ( pid )
753    {
754        wxLogStatus( _T("Process %ld (%s) launched."), pid, cmd.c_str() );
755
756        AddAsyncProcess(process);
757    }
758    else
759    {
760        wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
761
762        delete process;
763    }
764
765    m_cmdLast = cmd;
766}
767
768void MyFrame::OnPOpen(wxCommandEvent& WXUNUSED(event))
769{
770    wxString cmd = wxGetTextFromUser(_T("Enter the command to launch: "),
771                                     DIALOG_TITLE,
772                                     m_cmdLast);
773    if ( cmd.empty() )
774        return;
775
776    wxProcess *process = wxProcess::Open(cmd);
777    if ( !process )
778    {
779        wxLogError(_T("Failed to launch the command."));
780        return;
781    }
782
783    wxLogVerbose(_T("PID of the new process: %ld"), process->GetPid());
784
785    wxOutputStream *out = process->GetOutputStream();
786    if ( !out )
787    {
788        wxLogError(_T("Failed to connect to child stdin"));
789        return;
790    }
791
792    wxInputStream *in = process->GetInputStream();
793    if ( !in )
794    {
795        wxLogError(_T("Failed to connect to child stdout"));
796        return;
797    }
798
799    new MyPipeFrame(this, cmd, process);
800}
801
802void MyFrame::OnFileExec(wxCommandEvent& WXUNUSED(event))
803{
804    static wxString s_filename;
805
806    wxString filename;
807
808#if wxUSE_FILEDLG
809    filename = wxLoadFileSelector(_T("any file"), NULL, s_filename, this);
810#else // !wxUSE_FILEDLG
811    filename = wxGetTextFromUser(_T("Enter the file name"), _T("exec sample"),
812                                 s_filename, this);
813#endif // wxUSE_FILEDLG/!wxUSE_FILEDLG
814
815    if ( filename.empty() )
816        return;
817
818    s_filename = filename;
819
820    wxString ext = filename.AfterLast(_T('.'));
821    wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
822    if ( !ft )
823    {
824        wxLogError(_T("Impossible to determine the file type for extension '%s'"),
825                   ext.c_str());
826        return;
827    }
828
829    wxString cmd;
830    bool ok = ft->GetOpenCommand(&cmd,
831                                 wxFileType::MessageParameters(filename));
832    delete ft;
833    if ( !ok )
834    {
835        wxLogError(_T("Impossible to find out how to open files of extension '%s'"),
836                   ext.c_str());
837        return;
838    }
839
840    DoAsyncExec(cmd);
841}
842
843void MyFrame::OnOpenURL(wxCommandEvent& WXUNUSED(event))
844{
845    static wxString s_filename;
846
847    wxString filename = wxGetTextFromUser
848                        (
849                            _T("Enter the URL"),
850                            _T("exec sample"),
851                            s_filename,
852                            this
853                        );
854
855    if ( filename.empty() )
856        return;
857
858    s_filename = filename;
859
860    if ( !wxLaunchDefaultBrowser(s_filename) )
861        wxLogError(_T("Failed to open URL \"%s\""), s_filename.c_str());
862}
863
864// ----------------------------------------------------------------------------
865// DDE stuff
866// ----------------------------------------------------------------------------
867
868#ifdef __WINDOWS__
869
870bool MyFrame::GetDDEServer()
871{
872    wxString server = wxGetTextFromUser(_T("Server to connect to:"),
873                                        DIALOG_TITLE, m_server);
874    if ( !server )
875        return false;
876
877    m_server = server;
878
879    wxString topic = wxGetTextFromUser(_T("DDE topic:"), DIALOG_TITLE, m_topic);
880    if ( !topic )
881        return false;
882
883    m_topic = topic;
884
885    wxString cmd = wxGetTextFromUser(_T("DDE command:"), DIALOG_TITLE, m_cmdDde);
886    if ( !cmd )
887        return false;
888
889    m_cmdDde = cmd;
890
891    return true;
892}
893
894void MyFrame::OnDDEExec(wxCommandEvent& WXUNUSED(event))
895{
896    if ( !GetDDEServer() )
897        return;
898
899    wxDDEClient client;
900    wxConnectionBase *conn = client.MakeConnection(wxEmptyString, m_server, m_topic);
901    if ( !conn )
902    {
903        wxLogError(_T("Failed to connect to the DDE server '%s'."),
904                   m_server.c_str());
905    }
906    else
907    {
908        if ( !conn->Execute(m_cmdDde) )
909        {
910            wxLogError(_T("Failed to execute command '%s' via DDE."),
911                       m_cmdDde.c_str());
912        }
913        else
914        {
915            wxLogStatus(_T("Successfully executed DDE command"));
916        }
917    }
918}
919
920void MyFrame::OnDDERequest(wxCommandEvent& WXUNUSED(event))
921{
922    if ( !GetDDEServer() )
923        return;
924
925    wxDDEClient client;
926    wxConnectionBase *conn = client.MakeConnection(wxEmptyString, m_server, m_topic);
927    if ( !conn )
928    {
929        wxLogError(_T("Failed to connect to the DDE server '%s'."),
930                   m_server.c_str());
931    }
932    else
933    {
934        if ( !conn->Request(m_cmdDde) )
935        {
936            wxLogError(_T("Failed to  send request '%s' via DDE."),
937                       m_cmdDde.c_str());
938        }
939        else
940        {
941            wxLogStatus(_T("Successfully sent DDE request."));
942        }
943    }
944}
945
946#endif // __WINDOWS__
947
948// ----------------------------------------------------------------------------
949// various helpers
950// ----------------------------------------------------------------------------
951
952// input polling
953void MyFrame::OnIdle(wxIdleEvent& event)
954{
955    size_t count = m_running.GetCount();
956    for ( size_t n = 0; n < count; n++ )
957    {
958        if ( m_running[n]->HasInput() )
959        {
960            event.RequestMore();
961        }
962    }
963}
964
965void MyFrame::OnTimer(wxTimerEvent& WXUNUSED(event))
966{
967    wxWakeUpIdle();
968}
969
970void MyFrame::OnProcessTerminated(MyPipedProcess *process)
971{
972    RemoveAsyncProcess(process);
973}
974
975
976void MyFrame::ShowOutput(const wxString& cmd,
977                         const wxArrayString& output,
978                         const wxString& title)
979{
980    size_t count = output.GetCount();
981    if ( !count )
982        return;
983
984    m_lbox->Append(wxString::Format(_T("--- %s of '%s' ---"),
985                                    title.c_str(), cmd.c_str()));
986
987    for ( size_t n = 0; n < count; n++ )
988    {
989        m_lbox->Append(output[n]);
990    }
991
992    m_lbox->Append(wxString::Format(_T("--- End of %s ---"),
993                                    title.Lower().c_str()));
994}
995
996// ----------------------------------------------------------------------------
997// MyProcess
998// ----------------------------------------------------------------------------
999
1000void MyProcess::OnTerminate(int pid, int status)
1001{
1002    wxLogStatus(m_parent, _T("Process %u ('%s') terminated with exit code %d."),
1003                pid, m_cmd.c_str(), status);
1004
1005    // we're not needed any more
1006    delete this;
1007}
1008
1009// ----------------------------------------------------------------------------
1010// MyPipedProcess
1011// ----------------------------------------------------------------------------
1012
1013bool MyPipedProcess::HasInput()
1014{
1015    bool hasInput = false;
1016
1017    if ( IsInputAvailable() )
1018    {
1019        wxTextInputStream tis(*GetInputStream());
1020
1021        // this assumes that the output is always line buffered
1022        wxString msg;
1023        msg << m_cmd << _T(" (stdout): ") << tis.ReadLine();
1024
1025        m_parent->GetLogListBox()->Append(msg);
1026
1027        hasInput = true;
1028    }
1029
1030    if ( IsErrorAvailable() )
1031    {
1032        wxTextInputStream tis(*GetErrorStream());
1033
1034        // this assumes that the output is always line buffered
1035        wxString msg;
1036        msg << m_cmd << _T(" (stderr): ") << tis.ReadLine();
1037
1038        m_parent->GetLogListBox()->Append(msg);
1039
1040        hasInput = true;
1041    }
1042
1043    return hasInput;
1044}
1045
1046void MyPipedProcess::OnTerminate(int pid, int status)
1047{
1048    // show the rest of the output
1049    while ( HasInput() )
1050        ;
1051
1052    m_parent->OnProcessTerminated(this);
1053
1054    MyProcess::OnTerminate(pid, status);
1055}
1056
1057// ----------------------------------------------------------------------------
1058// MyPipedProcess2
1059// ----------------------------------------------------------------------------
1060
1061bool MyPipedProcess2::HasInput()
1062{
1063    if ( !m_input.empty() )
1064    {
1065        wxTextOutputStream os(*GetOutputStream());
1066        os.WriteString(m_input);
1067
1068        CloseOutput();
1069        m_input.clear();
1070
1071        // call us once again - may be we'll have output
1072        return true;
1073    }
1074
1075    return MyPipedProcess::HasInput();
1076}
1077
1078// ============================================================================
1079// MyPipeFrame implementation
1080// ============================================================================
1081
1082MyPipeFrame::MyPipeFrame(wxFrame *parent,
1083                         const wxString& cmd,
1084                         wxProcess *process)
1085           : wxFrame(parent, wxID_ANY, cmd),
1086             m_process(process),
1087             // in a real program we'd check that the streams are !NULL here
1088             m_out(*process->GetOutputStream()),
1089             m_in(*process->GetInputStream()),
1090             m_err(*process->GetErrorStream())
1091{
1092    m_process->SetNextHandler(this);
1093
1094    wxPanel *panel = new wxPanel(this, wxID_ANY);
1095
1096    m_textOut = new wxTextCtrl(panel, wxID_ANY, wxEmptyString,
1097                              wxDefaultPosition, wxDefaultSize,
1098                              wxTE_PROCESS_ENTER);
1099    m_textIn = new wxTextCtrl(panel, wxID_ANY, wxEmptyString,
1100                               wxDefaultPosition, wxDefaultSize,
1101                               wxTE_MULTILINE | wxTE_RICH);
1102    m_textIn->SetEditable(false);
1103    m_textErr = new wxTextCtrl(panel, wxID_ANY, wxEmptyString,
1104                               wxDefaultPosition, wxDefaultSize,
1105                               wxTE_MULTILINE | wxTE_RICH);
1106    m_textErr->SetEditable(false);
1107
1108    wxSizer *sizerTop = new wxBoxSizer(wxVERTICAL);
1109    sizerTop->Add(m_textOut, 0, wxGROW | wxALL, 5);
1110
1111    wxSizer *sizerBtns = new wxBoxSizer(wxHORIZONTAL);
1112    sizerBtns->
1113        Add(new wxButton(panel, Exec_Btn_Send, _T("&Send")), 0, wxALL, 5);
1114    sizerBtns->
1115        Add(new wxButton(panel, Exec_Btn_SendFile, _T("&File...")), 0, wxALL, 5);
1116    sizerBtns->
1117        Add(new wxButton(panel, Exec_Btn_Get, _T("&Get")), 0, wxALL, 5);
1118    sizerBtns->
1119        Add(new wxButton(panel, Exec_Btn_Close, _T("&Close")), 0, wxALL, 5);
1120
1121    sizerTop->Add(sizerBtns, 0, wxCENTRE | wxALL, 5);
1122    sizerTop->Add(m_textIn, 1, wxGROW | wxALL, 5);
1123    sizerTop->Add(m_textErr, 1, wxGROW | wxALL, 5);
1124
1125    panel->SetSizer(sizerTop);
1126    sizerTop->Fit(this);
1127
1128    Show();
1129}
1130
1131void MyPipeFrame::OnBtnSendFile(wxCommandEvent& WXUNUSED(event))
1132{
1133#if wxUSE_FILEDLG
1134    wxFileDialog filedlg(this, _T("Select file to send"));
1135    if ( filedlg.ShowModal() != wxID_OK )
1136        return;
1137
1138    wxFFile file(filedlg.GetFilename(), _T("r"));
1139    wxString data;
1140    if ( !file.IsOpened() || !file.ReadAll(&data) )
1141        return;
1142
1143    // can't write the entire string at once, this risk overflowing the pipe
1144    // and we would dead lock
1145    size_t len = data.length();
1146    const wxChar *pc = data.c_str();
1147    while ( len )
1148    {
1149        const size_t CHUNK_SIZE = 4096;
1150        m_out.Write(pc, len > CHUNK_SIZE ? CHUNK_SIZE : len);
1151
1152        // note that not all data could have been written as we don't block on
1153        // the write end of the pipe
1154        const size_t lenChunk = m_out.LastWrite();
1155
1156        pc += lenChunk;
1157        len -= lenChunk;
1158
1159        DoGet();
1160    }
1161#endif // wxUSE_FILEDLG
1162}
1163
1164void MyPipeFrame::DoGet()
1165{
1166    // we don't have any way to be notified when any input appears on the
1167    // stream so we have to poll it :-(
1168    DoGetFromStream(m_textIn, m_in);
1169    DoGetFromStream(m_textErr, m_err);
1170}
1171
1172void MyPipeFrame::DoGetFromStream(wxTextCtrl *text, wxInputStream& in)
1173{
1174    while ( in.CanRead() )
1175    {
1176        wxChar buffer[4096];
1177        buffer[in.Read(buffer, WXSIZEOF(buffer) - 1).LastRead()] = _T('\0');
1178
1179        text->AppendText(buffer);
1180    }
1181}
1182
1183void MyPipeFrame::DoClose()
1184{
1185    m_process->CloseOutput();
1186
1187    DisableInput();
1188}
1189
1190void MyPipeFrame::DisableInput()
1191{
1192    m_textOut->SetEditable(false);
1193    FindWindow(Exec_Btn_Send)->Disable();
1194    FindWindow(Exec_Btn_SendFile)->Disable();
1195    FindWindow(Exec_Btn_Close)->Disable();
1196}
1197
1198void MyPipeFrame::DisableOutput()
1199{
1200    FindWindow(Exec_Btn_Get)->Disable();
1201}
1202
1203void MyPipeFrame::OnClose(wxCloseEvent& event)
1204{
1205    if ( m_process )
1206    {
1207        // we're not interested in getting the process termination notification
1208        // if we are closing it ourselves
1209        wxProcess *process = m_process;
1210        m_process = NULL;
1211        process->SetNextHandler(NULL);
1212
1213        process->CloseOutput();
1214    }
1215
1216    event.Skip();
1217}
1218
1219void MyPipeFrame::OnProcessTerm(wxProcessEvent& WXUNUSED(event))
1220{
1221    DoGet();
1222
1223    delete m_process;
1224    m_process = NULL;
1225
1226    wxLogWarning(_T("The other process has terminated, closing"));
1227
1228    DisableInput();
1229    DisableOutput();
1230}
1231