]> git.saurik.com Git - wxWidgets.git/blob - samples/exec/exec.cpp
This is how wxPlotWindow would look like with the
[wxWidgets.git] / samples / exec / exec.cpp
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 #ifdef __GNUG__
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" wxWindows headers
34 #ifndef WX_PRECOMP
35 #include "wx/app.h"
36 #include "wx/frame.h"
37 #include "wx/utils.h"
38 #include "wx/menu.h"
39 #include "wx/msgdlg.h"
40 #include "wx/textdlg.h"
41 #include "wx/listbox.h"
42 #include "wx/filedlg.h"
43 #endif
44
45 #include "wx/txtstrm.h"
46
47 #include "wx/process.h"
48
49 #include "wx/mimetype.h"
50
51 #ifdef __WINDOWS__
52 #include "wx/dde.h"
53 #endif // __WINDOWS__
54
55 // ----------------------------------------------------------------------------
56 // private classes
57 // ----------------------------------------------------------------------------
58
59 // Define a new application type, each program should derive a class from wxApp
60 class MyApp : public wxApp
61 {
62 public:
63 // override base class virtuals
64 // ----------------------------
65
66 // this one is called on application startup and is a good place for the app
67 // initialization (doing it here and not in the ctor allows to have an error
68 // return: if OnInit() returns false, the application terminates)
69 virtual bool OnInit();
70 };
71
72 // Define an array of process pointers used by MyFrame
73 class MyPipedProcess;
74 WX_DEFINE_ARRAY(MyPipedProcess *, MyProcessesArray);
75
76 // Define a new frame type: this is going to be our main frame
77 class MyFrame : public wxFrame
78 {
79 public:
80 // ctor(s)
81 MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size);
82
83 // event handlers (these functions should _not_ be virtual)
84 void OnQuit(wxCommandEvent& event);
85
86 void OnClear(wxCommandEvent& event);
87
88 void OnSyncExec(wxCommandEvent& event);
89 void OnAsyncExec(wxCommandEvent& event);
90 void OnShell(wxCommandEvent& event);
91 void OnExecWithRedirect(wxCommandEvent& event);
92 void OnExecWithPipe(wxCommandEvent& event);
93
94 void OnFileExec(wxCommandEvent& event);
95
96 void OnDDEExec(wxCommandEvent& event);
97
98 void OnAbout(wxCommandEvent& event);
99
100 // polling output of async processes
101 void OnIdle(wxIdleEvent& event);
102
103 // for MyPipedProcess
104 void OnProcessTerminated(MyPipedProcess *process);
105 wxListBox *GetLogListBox() const { return m_lbox; }
106
107 private:
108 void ShowOutput(const wxString& cmd,
109 const wxArrayString& output,
110 const wxString& title);
111
112 void DoAsyncExec(const wxString& cmd);
113
114 wxString m_cmdLast;
115
116 wxListBox *m_lbox;
117
118 MyProcessesArray m_running;
119
120 // any class wishing to process wxWindows events must use this macro
121 DECLARE_EVENT_TABLE()
122 };
123
124 // This is the handler for process termination events
125 class MyProcess : public wxProcess
126 {
127 public:
128 MyProcess(MyFrame *parent, const wxString& cmd)
129 : wxProcess(parent), m_cmd(cmd)
130 {
131 m_parent = parent;
132 }
133
134 // instead of overriding this virtual function we might as well process the
135 // event from it in the frame class - this might be more convenient in some
136 // cases
137 virtual void OnTerminate(int pid, int status);
138
139 protected:
140 MyFrame *m_parent;
141 wxString m_cmd;
142 };
143
144 // A specialization of MyProcess for redirecting the output
145 class MyPipedProcess : public MyProcess
146 {
147 public:
148 MyPipedProcess(MyFrame *parent, const wxString& cmd)
149 : MyProcess(parent, cmd)
150 {
151 Redirect();
152 }
153
154 virtual void OnTerminate(int pid, int status);
155
156 virtual bool HasInput();
157 };
158
159 // A version of MyPipedProcess which also sends input to the stdin of the
160 // child process
161 class MyPipedProcess2 : public MyPipedProcess
162 {
163 public:
164 MyPipedProcess2(MyFrame *parent, const wxString& cmd, const wxString& input)
165 : MyPipedProcess(parent, cmd), m_input(input)
166 {
167 }
168
169 virtual bool HasInput();
170
171 private:
172 wxString m_input;
173 };
174
175 // ----------------------------------------------------------------------------
176 // constants
177 // ----------------------------------------------------------------------------
178
179 // IDs for the controls and the menu commands
180 enum
181 {
182 // menu items
183 Exec_Quit = 100,
184 Exec_ClearLog,
185 Exec_SyncExec = 200,
186 Exec_AsyncExec,
187 Exec_Shell,
188 Exec_OpenFile,
189 Exec_DDEExec,
190 Exec_Redirect,
191 Exec_Pipe,
192 Exec_About = 300
193 };
194
195 static const wxChar *DIALOG_TITLE = _T("Exec sample");
196
197 // ----------------------------------------------------------------------------
198 // event tables and other macros for wxWindows
199 // ----------------------------------------------------------------------------
200
201 // the event tables connect the wxWindows events with the functions (event
202 // handlers) which process them. It can be also done at run-time, but for the
203 // simple menu events like this the static method is much simpler.
204 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
205 EVT_MENU(Exec_Quit, MyFrame::OnQuit)
206 EVT_MENU(Exec_ClearLog, MyFrame::OnClear)
207
208 EVT_MENU(Exec_SyncExec, MyFrame::OnSyncExec)
209 EVT_MENU(Exec_AsyncExec, MyFrame::OnAsyncExec)
210 EVT_MENU(Exec_Shell, MyFrame::OnShell)
211 EVT_MENU(Exec_Redirect, MyFrame::OnExecWithRedirect)
212 EVT_MENU(Exec_Pipe, MyFrame::OnExecWithPipe)
213
214 EVT_MENU(Exec_OpenFile, MyFrame::OnFileExec)
215
216 EVT_MENU(Exec_DDEExec, MyFrame::OnDDEExec)
217
218 EVT_MENU(Exec_About, MyFrame::OnAbout)
219
220 EVT_IDLE(MyFrame::OnIdle)
221 END_EVENT_TABLE()
222
223 // Create a new application object: this macro will allow wxWindows to create
224 // the application object during program execution (it's better than using a
225 // static object for many reasons) and also declares the accessor function
226 // wxGetApp() which will return the reference of the right type (i.e. MyApp and
227 // not wxApp)
228 IMPLEMENT_APP(MyApp)
229
230 // ============================================================================
231 // implementation
232 // ============================================================================
233
234 // ----------------------------------------------------------------------------
235 // the application class
236 // ----------------------------------------------------------------------------
237
238 // `Main program' equivalent: the program execution "starts" here
239 bool MyApp::OnInit()
240 {
241 // Create the main application window
242 MyFrame *frame = new MyFrame(_T("Exec wxWindows sample"),
243 wxDefaultPosition, wxSize(500, 140));
244
245 // Show it and tell the application that it's our main window
246 frame->Show(TRUE);
247 SetTopWindow(frame);
248
249 // success: wxApp::OnRun() will be called which will enter the main message
250 // loop and the application will run. If we returned FALSE here, the
251 // application would exit immediately.
252 return TRUE;
253 }
254
255 // ----------------------------------------------------------------------------
256 // main frame
257 // ----------------------------------------------------------------------------
258
259 // frame constructor
260 MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
261 : wxFrame((wxFrame *)NULL, -1, title, pos, size)
262 {
263 #ifdef __WXMAC__
264 // we need this in order to allow the about menu relocation, since ABOUT is
265 // not the default id of the about menu
266 wxApp::s_macAboutMenuItemId = Exec_About;
267 #endif
268
269 // create a menu bar
270 wxMenu *menuFile = new wxMenu(_T(""), wxMENU_TEAROFF);
271 menuFile->Append(Exec_ClearLog, _T("&Clear log\tCtrl-C"),
272 _T("Clear the log window"));
273 menuFile->AppendSeparator();
274 menuFile->Append(Exec_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));
275
276 wxMenu *execMenu = new wxMenu;
277 execMenu->Append(Exec_SyncExec, _T("Sync &execution...\tCtrl-E"),
278 _T("Launch a program and return when it terminates"));
279 execMenu->Append(Exec_AsyncExec, _T("&Async execution...\tCtrl-A"),
280 _T("Launch a program and return immediately"));
281 execMenu->Append(Exec_Shell, _T("Execute &shell command...\tCtrl-S"),
282 _T("Launch a shell and execute a command in it"));
283 execMenu->AppendSeparator();
284 execMenu->Append(Exec_Redirect, _T("Capture command &output...\tCtrl-O"),
285 _T("Launch a program and capture its output"));
286 execMenu->Append(Exec_Pipe, _T("&Pipe through command...\tCtrl-P"),
287 _T("Pipe a string through a filter"));
288
289 execMenu->AppendSeparator();
290 execMenu->Append(Exec_OpenFile, _T("Open &file...\tCtrl-F"),
291 _T("Launch the command to open this kind of files"));
292 #ifdef __WINDOWS__
293 execMenu->AppendSeparator();
294 execMenu->Append(Exec_DDEExec, _T("Execute command via &DDE...\tCtrl-D"));
295 #endif
296
297 wxMenu *helpMenu = new wxMenu(_T(""), wxMENU_TEAROFF);
298 helpMenu->Append(Exec_About, _T("&About...\tF1"), _T("Show about dialog"));
299
300 // now append the freshly created menu to the menu bar...
301 wxMenuBar *menuBar = new wxMenuBar();
302 menuBar->Append(menuFile, _T("&File"));
303 menuBar->Append(execMenu, _T("&Exec"));
304 menuBar->Append(helpMenu, _T("&Help"));
305
306 // ... and attach this menu bar to the frame
307 SetMenuBar(menuBar);
308
309 // create the listbox in which we will show misc messages as they come
310 m_lbox = new wxListBox(this, -1);
311 wxFont font(12, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL,
312 wxFONTWEIGHT_NORMAL);
313 if ( font.Ok() )
314 m_lbox->SetFont(font);
315
316 #if wxUSE_STATUSBAR
317 // create a status bar just for fun (by default with 1 pane only)
318 CreateStatusBar();
319 SetStatusText(_T("Welcome to wxWindows exec sample!"));
320 #endif // wxUSE_STATUSBAR
321 }
322
323
324 // event handlers
325
326 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
327 {
328 // TRUE is to force the frame to close
329 Close(TRUE);
330 }
331
332 void MyFrame::OnClear(wxCommandEvent& WXUNUSED(event))
333 {
334 m_lbox->Clear();
335 }
336
337 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
338 {
339 wxMessageBox(_T("Exec sample\n© 2000 Vadim Zeitlin"),
340 _T("About Exec"), wxOK | wxICON_INFORMATION, this);
341 }
342
343 void MyFrame::DoAsyncExec(const wxString& cmd)
344 {
345 wxProcess *process = new MyProcess(this, cmd);
346 long pid = wxExecute(cmd, FALSE /* async */, process);
347 if ( !pid )
348 {
349 wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
350
351 delete process;
352 }
353 else
354 {
355 wxLogStatus(_T("Process %ld (%s) launched."), pid, cmd.c_str());
356
357 m_cmdLast = cmd;
358 }
359 }
360
361 void MyFrame::OnSyncExec(wxCommandEvent& WXUNUSED(event))
362 {
363 wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
364 DIALOG_TITLE,
365 m_cmdLast);
366
367 if ( !cmd )
368 return;
369
370 wxLogStatus(_T("'%s' is running please wait..."), cmd.c_str());
371
372 int code = wxExecute(cmd, TRUE /* sync */);
373
374 wxLogStatus(_T("Process '%s' terminated with exit code %d."),
375 cmd.c_str(), code);
376 m_cmdLast = cmd;
377 }
378
379 void MyFrame::OnAsyncExec(wxCommandEvent& WXUNUSED(event))
380 {
381 wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
382 DIALOG_TITLE,
383 m_cmdLast);
384
385 if ( !cmd )
386 return;
387
388 DoAsyncExec(cmd);
389 }
390
391 void MyFrame::OnShell(wxCommandEvent& WXUNUSED(event))
392 {
393 wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
394 DIALOG_TITLE,
395 m_cmdLast);
396
397 if ( !cmd )
398 return;
399
400 int code = wxShell(cmd);
401 wxLogStatus(_T("Shell command '%s' terminated with exit code %d."),
402 cmd.c_str(), code);
403 m_cmdLast = cmd;
404 }
405
406 void MyFrame::OnExecWithRedirect(wxCommandEvent& WXUNUSED(event))
407 {
408 wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
409 DIALOG_TITLE,
410 m_cmdLast);
411
412 if ( !cmd )
413 return;
414
415 bool sync;
416 switch ( wxMessageBox(_T("Execute it synchronously?"),
417 _T("Exec question"),
418 wxYES_NO | wxCANCEL | wxICON_QUESTION, this) )
419 {
420 case wxYES:
421 sync = TRUE;
422 break;
423
424 case wxNO:
425 sync = FALSE;
426 break;
427
428 default:
429 return;
430 }
431
432 if ( sync )
433 {
434 wxArrayString output, errors;
435 int code = wxExecute(cmd, output, errors);
436 wxLogStatus(_T("command '%s' terminated with exit code %d."),
437 cmd.c_str(), code);
438
439 if ( code != -1 )
440 {
441 ShowOutput(cmd, output, _T("Output"));
442 ShowOutput(cmd, errors, _T("Errors"));
443 }
444 }
445 else // async exec
446 {
447 MyPipedProcess *process = new MyPipedProcess(this, cmd);
448 if ( !wxExecute(cmd, FALSE /* async */, process) )
449 {
450 wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
451
452 delete process;
453 }
454 else
455 {
456 m_running.Add(process);
457 }
458 }
459
460 m_cmdLast = cmd;
461 }
462
463 void MyFrame::OnExecWithPipe(wxCommandEvent& WXUNUSED(event))
464 {
465 if ( !m_cmdLast )
466 m_cmdLast = _T("tr [a-z] [A-Z]");
467
468 wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
469 DIALOG_TITLE,
470 m_cmdLast);
471
472 if ( !cmd )
473 return;
474
475 wxString input = wxGetTextFromUser(_T("Enter the string to send to it: "),
476 DIALOG_TITLE);
477 if ( !input )
478 return;
479
480 // always execute the filter asynchronously
481 MyPipedProcess2 *process = new MyPipedProcess2(this, cmd, input);
482 int pid = wxExecute(cmd, FALSE /* async */, process);
483 if ( pid )
484 {
485 wxLogStatus(_T("Process %ld (%s) launched."), pid, cmd.c_str());
486
487 m_running.Add(process);
488 }
489 else
490 {
491 wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
492
493 delete process;
494 }
495
496 m_cmdLast = cmd;
497 }
498
499 void MyFrame::OnFileExec(wxCommandEvent& event)
500 {
501 static wxString s_filename;
502
503 wxString filename = wxLoadFileSelector(_T("file"), _T(""), s_filename);
504 if ( !filename )
505 return;
506
507 s_filename = filename;
508
509 wxString ext = filename.AfterFirst(_T('.'));
510 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
511 if ( !ft )
512 {
513 wxLogError(_T("Impossible to determine the file type for extension '%s'"),
514 ext.c_str());
515 return;
516 }
517
518 wxString cmd;
519 bool ok = ft->GetOpenCommand(&cmd,
520 wxFileType::MessageParameters(filename, _T("")));
521 delete ft;
522 if ( !ok )
523 {
524 wxLogError(_T("Impossible to find out how to open files of extension '%s'"),
525 ext.c_str());
526 return;
527 }
528
529 DoAsyncExec(cmd);
530 }
531
532 void MyFrame::OnDDEExec(wxCommandEvent& WXUNUSED(event))
533 {
534 #ifdef __WINDOWS__
535 wxString server = wxGetTextFromUser(_T("Server to connect to:"),
536 DIALOG_TITLE, _T("IExplore"));
537 if ( !server )
538 return;
539
540 wxString topic = wxGetTextFromUser(_T("DDE topic:"),
541 DIALOG_TITLE, _T("WWW_OpenURL"));
542 if ( !topic )
543 return;
544
545 wxString cmd = wxGetTextFromUser(_T("DDE command:"),
546 DIALOG_TITLE,
547 _T("\"file:F:\\wxWindows\\samples\\"
548 "image\\horse.gif\",,-1,,,,,"));
549 if ( !cmd )
550 return;
551
552 wxDDEClient client;
553 wxConnectionBase *conn = client.MakeConnection("", server, topic);
554 if ( !conn )
555 {
556 wxLogError(_T("Failed to connect to the DDE server '%s'."),
557 server.c_str());
558 }
559 else
560 {
561 if ( !conn->Execute(cmd) )
562 {
563 wxLogError(_T("Failed to execute command '%s' via DDE."),
564 cmd.c_str());
565 }
566 else
567 {
568 wxLogStatus(_T("Successfully executed DDE command"));
569 }
570 }
571 #endif // __WINDOWS__
572 }
573
574 // input polling
575 void MyFrame::OnIdle(wxIdleEvent& event)
576 {
577 size_t count = m_running.GetCount();
578 for ( size_t n = 0; n < count; n++ )
579 {
580 if ( m_running[n]->HasInput() )
581 {
582 event.RequestMore();
583 }
584 }
585 }
586
587 void MyFrame::OnProcessTerminated(MyPipedProcess *process)
588 {
589 m_running.Remove(process);
590 }
591
592
593 void MyFrame::ShowOutput(const wxString& cmd,
594 const wxArrayString& output,
595 const wxString& title)
596 {
597 size_t count = output.GetCount();
598 if ( !count )
599 return;
600
601 m_lbox->Append(wxString::Format(_T("--- %s of '%s' ---"),
602 title.c_str(), cmd.c_str()));
603
604 for ( size_t n = 0; n < count; n++ )
605 {
606 m_lbox->Append(output[n]);
607 }
608
609 m_lbox->Append(_T("--- End of output ---"));
610 }
611
612 // ----------------------------------------------------------------------------
613 // MyProcess
614 // ----------------------------------------------------------------------------
615
616 void MyProcess::OnTerminate(int pid, int status)
617 {
618 wxLogStatus(m_parent, _T("Process %u ('%s') terminated with exit code %d."),
619 pid, m_cmd.c_str(), status);
620
621 // we're not needed any more
622 delete this;
623 }
624
625 // ----------------------------------------------------------------------------
626 // MyPipedProcess
627 // ----------------------------------------------------------------------------
628
629 bool MyPipedProcess::HasInput()
630 {
631 bool hasInput = FALSE;
632
633 wxInputStream& is = *GetInputStream();
634 if ( !is.Eof() )
635 {
636 wxTextInputStream tis(is);
637
638 // this assumes that the output is always line buffered
639 wxString msg;
640 msg << m_cmd << _T(" (stdout): ") << tis.ReadLine();
641
642 m_parent->GetLogListBox()->Append(msg);
643
644 hasInput = TRUE;
645 }
646
647 wxInputStream& es = *GetErrorStream();
648 if ( !es.Eof() )
649 {
650 wxTextInputStream tis(es);
651
652 // this assumes that the output is always line buffered
653 wxString msg;
654 msg << m_cmd << _T(" (stderr): ") << tis.ReadLine();
655
656 m_parent->GetLogListBox()->Append(msg);
657
658 hasInput = TRUE;
659 }
660
661 return hasInput;
662 }
663
664 void MyPipedProcess::OnTerminate(int pid, int status)
665 {
666 // show the rest of the output
667 while ( HasInput() )
668 ;
669
670 m_parent->OnProcessTerminated(this);
671
672 MyProcess::OnTerminate(pid, status);
673 }
674
675 // ----------------------------------------------------------------------------
676 // MyPipedProcess2
677 // ----------------------------------------------------------------------------
678
679 bool MyPipedProcess2::HasInput()
680 {
681 if ( !!m_input )
682 {
683 wxTextOutputStream os(*GetOutputStream());
684 os.WriteString(m_input);
685
686 CloseOutput();
687 m_input.clear();
688
689 // call us once again - may be we'll have output
690 return TRUE;
691 }
692
693 return MyPipedProcess::HasInput();
694 }