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