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 // 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
  70 class MyApp : public wxApp
  71 {
  72 public:
  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
  83 class MyPipedProcess;
  84 WX_DEFINE_ARRAY_PTR(MyPipedProcess *, MyProcessesArray);
  85
  86 // Define a new frame type: this is going to be our main frame
  87 class MyFrame : public wxFrame
  88 {
  89 public:
  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
 121 private:
 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
 186 class MyPipeFrame : public wxFrame
 187 {
 188 public:
 189     MyPipeFrame(wxFrame *parent,
 190                 const wxString& cmd,
 191                 wxProcess *process);
 192
 193 protected:
 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
 217 private:
 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
 241 class MyProcess : public wxProcess
 242 {
 243 public:
 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
 255 protected:
 256     MyFrame *m_parent;
 257     wxString m_cmd;
 258 };
 259
 260 // A specialization of MyProcess for redirecting the output
 261 class MyPipedProcess : public MyProcess
 262 {
 263 public:
 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
 277 class MyPipedProcess2 : public MyPipedProcess
 278 {
 279 public:
 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
 287 private:
 288     wxString m_input;
 289 };
 290
 291 // ----------------------------------------------------------------------------
 292 // constants
 293 // ----------------------------------------------------------------------------
 294
 295 // IDs for the controls and the menu commands
 296 enum
 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
 321 static 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.
 330 BEGIN_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)
 356 END_EVENT_TABLE()
 357
 358 BEGIN_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)
 369 END_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)
 376 IMPLEMENT_APP(MyApp)
 377
 378 // ============================================================================
 379 // implementation
 380 // ============================================================================
 381
 382 // ----------------------------------------------------------------------------
 383 // the application class
 384 // ----------------------------------------------------------------------------
 385
 386 // `Main program' equivalent: the program execution "starts" here
 387 bool MyApp::OnInit()
 388 {
 389     if ( !wxApp::OnInit() )
 390         return false;
 391
 392     // Create the main application window
 393     MyFrame *frame = new MyFrame(_T("Exec wxWidgets sample"),
 394                                  wxDefaultPosition, wxSize(500, 140));
 395
 396     // Show it and tell the application that it's our main window
 397     frame->Show(true);
 398     SetTopWindow(frame);
 399
 400     // success: wxApp::OnRun() will be called which will enter the main message
 401     // loop and the application will run. If we returned false here, the
 402     // application would exit immediately.
 403     return true;
 404 }
 405
 406 // ----------------------------------------------------------------------------
 407 // main frame
 408 // ----------------------------------------------------------------------------
 409
 410 #ifdef __VISUALC__
 411 #pragma warning(disable: 4355) // this used in base member initializer list
 412 #endif
 413
 414 // frame constructor
 415 MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
 416        : wxFrame((wxFrame *)NULL, wxID_ANY, title, pos, size),
 417          m_timerIdleWakeUp(this)
 418 {
 419     m_pidLast = 0;
 420
 421 #ifdef __WXMAC__
 422     // we need this in order to allow the about menu relocation, since ABOUT is
 423     // not the default id of the about menu
 424     wxApp::s_macAboutMenuItemId = Exec_About;
 425 #endif
 426
 427     // create a menu bar
 428     wxMenu *menuFile = new wxMenu(wxEmptyString, wxMENU_TEAROFF);
 429     menuFile->Append(Exec_Kill, _T("&Kill process...\tCtrl-K"),
 430                      _T("Kill a process by PID"));
 431     menuFile->AppendSeparator();
 432     menuFile->Append(Exec_ClearLog, _T("&Clear log\tCtrl-C"),
 433                      _T("Clear the log window"));
 434     menuFile->AppendSeparator();
 435     menuFile->Append(Exec_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));
 436
 437     wxMenu *execMenu = new wxMenu;
 438     execMenu->Append(Exec_SyncExec, _T("Sync &execution...\tCtrl-E"),
 439                      _T("Launch a program and return when it terminates"));
 440     execMenu->Append(Exec_AsyncExec, _T("&Async execution...\tCtrl-A"),
 441                      _T("Launch a program and return immediately"));
 442     execMenu->Append(Exec_Shell, _T("Execute &shell command...\tCtrl-S"),
 443                      _T("Launch a shell and execute a command in it"));
 444     execMenu->AppendSeparator();
 445     execMenu->Append(Exec_Redirect, _T("Capture command &output...\tCtrl-O"),
 446                      _T("Launch a program and capture its output"));
 447     execMenu->Append(Exec_Pipe, _T("&Pipe through command..."),
 448                      _T("Pipe a string through a filter"));
 449     execMenu->Append(Exec_POpen, _T("&Open a pipe to a command...\tCtrl-P"),
 450                      _T("Open a pipe to and from another program"));
 451
 452     execMenu->AppendSeparator();
 453     execMenu->Append(Exec_OpenFile, _T("Open &file...\tCtrl-F"),
 454                      _T("Launch the command to open this kind of files"));
 455     execMenu->Append(Exec_OpenURL, _T("Open &URL...\tCtrl-U"),
 456                      _T("Launch the default browser with the given URL"));
 457 #ifdef __WINDOWS__
 458     execMenu->AppendSeparator();
 459     execMenu->Append(Exec_DDEExec, _T("Execute command via &DDE...\tCtrl-D"));
 460     execMenu->Append(Exec_DDERequest, _T("Send DDE &request...\tCtrl-R"));
 461 #endif
 462
 463     wxMenu *helpMenu = new wxMenu(wxEmptyString, wxMENU_TEAROFF);
 464     helpMenu->Append(Exec_About, _T("&About...\tF1"), _T("Show about dialog"));
 465
 466     // now append the freshly created menu to the menu bar...
 467     wxMenuBar *menuBar = new wxMenuBar();
 468     menuBar->Append(menuFile, _T("&File"));
 469     menuBar->Append(execMenu, _T("&Exec"));
 470     menuBar->Append(helpMenu, _T("&Help"));
 471
 472     // ... and attach this menu bar to the frame
 473     SetMenuBar(menuBar);
 474
 475     // create the listbox in which we will show misc messages as they come
 476     m_lbox = new wxListBox(this, wxID_ANY);
 477     wxFont font(12, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL,
 478                 wxFONTWEIGHT_NORMAL);
 479     if ( font.Ok() )
 480         m_lbox->SetFont(font);
 481
 482 #if wxUSE_STATUSBAR
 483     // create a status bar just for fun (by default with 1 pane only)
 484     CreateStatusBar();
 485     SetStatusText(_T("Welcome to wxWidgets exec sample!"));
 486 #endif // wxUSE_STATUSBAR
 487 }
 488
 489 // ----------------------------------------------------------------------------
 490 // event handlers: file and help menu
 491 // ----------------------------------------------------------------------------
 492
 493 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 494 {
 495     // true is to force the frame to close
 496     Close(true);
 497 }
 498
 499 void MyFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 500 {
 501     m_lbox->Clear();
 502 }
 503
 504 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 505 {
 506     wxMessageBox(_T("Exec wxWidgets Sample\n(c) 2000-2002 Vadim Zeitlin"),
 507                  _T("About Exec"), wxOK | wxICON_INFORMATION, this);
 508 }
 509
 510 void MyFrame::OnKill(wxCommandEvent& WXUNUSED(event))
 511 {
 512     long pid = wxGetNumberFromUser(_T("Please specify the process to kill"),
 513                                    _T("Enter PID:"),
 514                                    _T("Exec question"),
 515                                    m_pidLast,
 516                                    // we need the full unsigned int range
 517                                    -INT_MAX, INT_MAX,
 518                                    this);
 519     if ( pid == -1 )
 520     {
 521         // cancelled
 522         return;
 523     }
 524
 525     static const wxString signalNames[] =
 526     {
 527         _T("Just test (SIGNONE)"),
 528         _T("Hangup (SIGHUP)"),
 529         _T("Interrupt (SIGINT)"),
 530         _T("Quit (SIGQUIT)"),
 531         _T("Illegal instruction (SIGILL)"),
 532         _T("Trap (SIGTRAP)"),
 533         _T("Abort (SIGABRT)"),
 534         _T("Emulated trap (SIGEMT)"),
 535         _T("FP exception (SIGFPE)"),
 536         _T("Kill (SIGKILL)"),
 537         _T("Bus (SIGBUS)"),
 538         _T("Segment violation (SIGSEGV)"),
 539         _T("System (SIGSYS)"),
 540         _T("Broken pipe (SIGPIPE)"),
 541         _T("Alarm (SIGALRM)"),
 542         _T("Terminate (SIGTERM)"),
 543     };
 544
 545     int sig = wxGetSingleChoiceIndex(_T("How to kill the process?"),
 546                                      _T("Exec question"),
 547                                      WXSIZEOF(signalNames), signalNames,
 548                                      this);
 549     switch ( sig )
 550     {
 551         default:
 552             wxFAIL_MSG( _T("unexpected return value") );
 553             // fall through
 554
 555         case -1:
 556             // cancelled
 557             return;
 558
 559         case wxSIGNONE:
 560         case wxSIGHUP:
 561         case wxSIGINT:
 562         case wxSIGQUIT:
 563         case wxSIGILL:
 564         case wxSIGTRAP:
 565         case wxSIGABRT:
 566         case wxSIGEMT:
 567         case wxSIGFPE:
 568         case wxSIGKILL:
 569         case wxSIGBUS:
 570         case wxSIGSEGV:
 571         case wxSIGSYS:
 572         case wxSIGPIPE:
 573         case wxSIGALRM:
 574         case wxSIGTERM:
 575             break;
 576     }
 577
 578     if ( sig == 0 )
 579     {
 580         if ( wxProcess::Exists(pid) )
 581             wxLogStatus(_T("Process %ld is running."), pid);
 582         else
 583             wxLogStatus(_T("No process with pid = %ld."), pid);
 584     }
 585     else // not SIGNONE
 586     {
 587         wxKillError rc = wxProcess::Kill(pid, (wxSignal)sig);
 588         if ( rc == wxKILL_OK )
 589         {
 590             wxLogStatus(_T("Process %ld killed with signal %d."), pid, sig);
 591         }
 592         else
 593         {
 594             static const wxChar *errorText[] =
 595             {
 596                 _T(""), // no error
 597                 _T("signal not supported"),
 598                 _T("permission denied"),
 599                 _T("no such process"),
 600                 _T("unspecified error"),
 601             };
 602
 603             wxLogStatus(_T("Failed to kill process %ld with signal %d: %s"),
 604                         pid, sig, errorText[rc]);
 605         }
 606     }
 607 }
 608
 609 // ----------------------------------------------------------------------------
 610 // event handlers: exec menu
 611 // ----------------------------------------------------------------------------
 612
 613 void MyFrame::DoAsyncExec(const wxString& cmd)
 614 {
 615     wxProcess *process = new MyProcess(this, cmd);
 616     m_pidLast = wxExecute(cmd, wxEXEC_ASYNC, process);
 617     if ( !m_pidLast )
 618     {
 619         wxLogError( _T("Execution of '%s' failed."), cmd.c_str() );
 620
 621         delete process;
 622     }
 623     else
 624     {
 625         wxLogStatus( _T("Process %ld (%s) launched."),
 626             m_pidLast, cmd.c_str() );
 627
 628         m_cmdLast = cmd;
 629     }
 630 }
 631
 632 void MyFrame::OnSyncExec(wxCommandEvent& WXUNUSED(event))
 633 {
 634     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 635                                      DIALOG_TITLE,
 636                                      m_cmdLast);
 637
 638     if ( !cmd )
 639         return;
 640
 641     wxLogStatus( _T("'%s' is running please wait..."), cmd.c_str() );
 642
 643     int code = wxExecute(cmd, wxEXEC_SYNC);
 644
 645     wxLogStatus(_T("Process '%s' terminated with exit code %d."),
 646         cmd.c_str(), code);
 647
 648     m_cmdLast = cmd;
 649 }
 650
 651 void MyFrame::OnAsyncExec(wxCommandEvent& WXUNUSED(event))
 652 {
 653     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 654                                      DIALOG_TITLE,
 655                                      m_cmdLast);
 656
 657     if ( !cmd )
 658         return;
 659
 660     DoAsyncExec(cmd);
 661 }
 662
 663 void MyFrame::OnShell(wxCommandEvent& WXUNUSED(event))
 664 {
 665     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 666                                      DIALOG_TITLE,
 667                                      m_cmdLast);
 668
 669     if ( !cmd )
 670         return;
 671
 672     int code = wxShell(cmd);
 673     wxLogStatus(_T("Shell command '%s' terminated with exit code %d."),
 674                 cmd.c_str(), code);
 675     m_cmdLast = cmd;
 676 }
 677
 678 void MyFrame::OnExecWithRedirect(wxCommandEvent& WXUNUSED(event))
 679 {
 680     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 681                                      DIALOG_TITLE,
 682                                      m_cmdLast);
 683
 684     if ( !cmd )
 685         return;
 686
 687     bool sync;
 688     switch ( wxMessageBox(_T("Execute it synchronously?"),
 689                           _T("Exec question"),
 690                           wxYES_NO | wxCANCEL | wxICON_QUESTION, this) )
 691     {
 692         case wxYES:
 693             sync = true;
 694             break;
 695
 696         case wxNO:
 697             sync = false;
 698             break;
 699
 700         default:
 701             return;
 702     }
 703
 704     if ( sync )
 705     {
 706         wxArrayString output, errors;
 707         int code = wxExecute(cmd, output, errors);
 708         wxLogStatus(_T("command '%s' terminated with exit code %d."),
 709                     cmd.c_str(), code);
 710
 711         if ( code != -1 )
 712         {
 713             ShowOutput(cmd, output, _T("Output"));
 714             ShowOutput(cmd, errors, _T("Errors"));
 715         }
 716     }
 717     else // async exec
 718     {
 719         MyPipedProcess *process = new MyPipedProcess(this, cmd);
 720         if ( !wxExecute(cmd, wxEXEC_ASYNC, process) )
 721         {
 722             wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
 723
 724             delete process;
 725         }
 726         else
 727         {
 728             AddAsyncProcess(process);
 729         }
 730     }
 731
 732     m_cmdLast = cmd;
 733 }
 734
 735 void MyFrame::OnExecWithPipe(wxCommandEvent& WXUNUSED(event))
 736 {
 737     if ( !m_cmdLast )
 738         m_cmdLast = _T("tr [a-z] [A-Z]");
 739
 740     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 741                                      DIALOG_TITLE,
 742                                      m_cmdLast);
 743
 744     if ( !cmd )
 745         return;
 746
 747     wxString input = wxGetTextFromUser(_T("Enter the string to send to it: "),
 748                                        DIALOG_TITLE);
 749     if ( !input )
 750         return;
 751
 752     // always execute the filter asynchronously
 753     MyPipedProcess2 *process = new MyPipedProcess2(this, cmd, input);
 754     long pid = wxExecute(cmd, wxEXEC_ASYNC, process);
 755     if ( pid )
 756     {
 757         wxLogStatus( _T("Process %ld (%s) launched."), pid, cmd.c_str() );
 758
 759         AddAsyncProcess(process);
 760     }
 761     else
 762     {
 763         wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
 764
 765         delete process;
 766     }
 767
 768     m_cmdLast = cmd;
 769 }
 770
 771 void MyFrame::OnPOpen(wxCommandEvent& WXUNUSED(event))
 772 {
 773     wxString cmd = wxGetTextFromUser(_T("Enter the command to launch: "),
 774                                      DIALOG_TITLE,
 775                                      m_cmdLast);
 776     if ( cmd.empty() )
 777         return;
 778
 779     wxProcess *process = wxProcess::Open(cmd);
 780     if ( !process )
 781     {
 782         wxLogError(_T("Failed to launch the command."));
 783         return;
 784     }
 785
 786     wxLogVerbose(_T("PID of the new process: %ld"), process->GetPid());
 787
 788     wxOutputStream *out = process->GetOutputStream();
 789     if ( !out )
 790     {
 791         wxLogError(_T("Failed to connect to child stdin"));
 792         return;
 793     }
 794
 795     wxInputStream *in = process->GetInputStream();
 796     if ( !in )
 797     {
 798         wxLogError(_T("Failed to connect to child stdout"));
 799         return;
 800     }
 801
 802     new MyPipeFrame(this, cmd, process);
 803 }
 804
 805 void MyFrame::OnFileExec(wxCommandEvent& WXUNUSED(event))
 806 {
 807     static wxString s_filename;
 808
 809     wxString filename;
 810
 811 #if wxUSE_FILEDLG
 812     filename = wxLoadFileSelector(_T("any file"), NULL, s_filename, this);
 813 #else // !wxUSE_FILEDLG
 814     filename = wxGetTextFromUser(_T("Enter the file name"), _T("exec sample"),
 815                                  s_filename, this);
 816 #endif // wxUSE_FILEDLG/!wxUSE_FILEDLG
 817
 818     if ( filename.empty() )
 819         return;
 820
 821     s_filename = filename;
 822
 823     wxString ext = filename.AfterFirst(_T('.'));
 824     wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
 825     if ( !ft )
 826     {
 827         wxLogError(_T("Impossible to determine the file type for extension '%s'"),
 828                    ext.c_str());
 829         return;
 830     }
 831
 832     wxString cmd;
 833     bool ok = ft->GetOpenCommand(&cmd,
 834                                  wxFileType::MessageParameters(filename));
 835     delete ft;
 836     if ( !ok )
 837     {
 838         wxLogError(_T("Impossible to find out how to open files of extension '%s'"),
 839                    ext.c_str());
 840         return;
 841     }
 842
 843     DoAsyncExec(cmd);
 844 }
 845
 846 void MyFrame::OnOpenURL(wxCommandEvent& WXUNUSED(event))
 847 {
 848     static wxString s_filename;
 849
 850     wxString filename = wxGetTextFromUser
 851                         (
 852                             _T("Enter the URL"),
 853                             _T("exec sample"),
 854                             s_filename,
 855                             this
 856                         );
 857
 858     if ( filename.empty() )
 859         return;
 860
 861     s_filename = filename;
 862
 863     if ( !wxLaunchDefaultBrowser(s_filename) )
 864         wxLogError(_T("Failed to open URL \"%s\""), s_filename.c_str());
 865 }
 866
 867 // ----------------------------------------------------------------------------
 868 // DDE stuff
 869 // ----------------------------------------------------------------------------
 870
 871 #ifdef __WINDOWS__
 872
 873 bool MyFrame::GetDDEServer()
 874 {
 875     wxString server = wxGetTextFromUser(_T("Server to connect to:"),
 876                                         DIALOG_TITLE, m_server);
 877     if ( !server )
 878         return false;
 879
 880     m_server = server;
 881
 882     wxString topic = wxGetTextFromUser(_T("DDE topic:"), DIALOG_TITLE, m_topic);
 883     if ( !topic )
 884         return false;
 885
 886     m_topic = topic;
 887
 888     wxString cmd = wxGetTextFromUser(_T("DDE command:"), DIALOG_TITLE, m_cmdDde);
 889     if ( !cmd )
 890         return false;
 891
 892     m_cmdDde = cmd;
 893
 894     return true;
 895 }
 896
 897 void MyFrame::OnDDEExec(wxCommandEvent& WXUNUSED(event))
 898 {
 899     if ( !GetDDEServer() )
 900         return;
 901
 902     wxDDEClient client;
 903     wxConnectionBase *conn = client.MakeConnection(wxEmptyString, m_server, m_topic);
 904     if ( !conn )
 905     {
 906         wxLogError(_T("Failed to connect to the DDE server '%s'."),
 907                    m_server.c_str());
 908     }
 909     else
 910     {
 911         if ( !conn->Execute(m_cmdDde) )
 912         {
 913             wxLogError(_T("Failed to execute command '%s' via DDE."),
 914                        m_cmdDde.c_str());
 915         }
 916         else
 917         {
 918             wxLogStatus(_T("Successfully executed DDE command"));
 919         }
 920     }
 921 }
 922
 923 void MyFrame::OnDDERequest(wxCommandEvent& WXUNUSED(event))
 924 {
 925     if ( !GetDDEServer() )
 926         return;
 927
 928     wxDDEClient client;
 929     wxConnectionBase *conn = client.MakeConnection(wxEmptyString, m_server, m_topic);
 930     if ( !conn )
 931     {
 932         wxLogError(_T("Failed to connect to the DDE server '%s'."),
 933                    m_server.c_str());
 934     }
 935     else
 936     {
 937         if ( !conn->Request(m_cmdDde) )
 938         {
 939             wxLogError(_T("Failed to  send request '%s' via DDE."),
 940                        m_cmdDde.c_str());
 941         }
 942         else
 943         {
 944             wxLogStatus(_T("Successfully sent DDE request."));
 945         }
 946     }
 947 }
 948
 949 #endif // __WINDOWS__
 950
 951 // ----------------------------------------------------------------------------
 952 // various helpers
 953 // ----------------------------------------------------------------------------
 954
 955 // input polling
 956 void MyFrame::OnIdle(wxIdleEvent& event)
 957 {
 958     size_t count = m_running.GetCount();
 959     for ( size_t n = 0; n < count; n++ )
 960     {
 961         if ( m_running[n]->HasInput() )
 962         {
 963             event.RequestMore();
 964         }
 965     }
 966 }
 967
 968 void MyFrame::OnTimer(wxTimerEvent& WXUNUSED(event))
 969 {
 970     wxWakeUpIdle();
 971 }
 972
 973 void MyFrame::OnProcessTerminated(MyPipedProcess *process)
 974 {
 975     RemoveAsyncProcess(process);
 976 }
 977
 978
 979 void MyFrame::ShowOutput(const wxString& cmd,
 980                          const wxArrayString& output,
 981                          const wxString& title)
 982 {
 983     size_t count = output.GetCount();
 984     if ( !count )
 985         return;
 986
 987     m_lbox->Append(wxString::Format(_T("--- %s of '%s' ---"),
 988                                     title.c_str(), cmd.c_str()));
 989
 990     for ( size_t n = 0; n < count; n++ )
 991     {
 992         m_lbox->Append(output[n]);
 993     }
 994
 995     m_lbox->Append(wxString::Format(_T("--- End of %s ---"),
 996                                     title.Lower().c_str()));
 997 }
 998
 999 // ----------------------------------------------------------------------------
1000 // MyProcess
1001 // ----------------------------------------------------------------------------
1002
1003 void MyProcess::OnTerminate(int pid, int status)
1004 {
1005     wxLogStatus(m_parent, _T("Process %u ('%s') terminated with exit code %d."),
1006                 pid, m_cmd.c_str(), status);
1007
1008     // we're not needed any more
1009     delete this;
1010 }
1011
1012 // ----------------------------------------------------------------------------
1013 // MyPipedProcess
1014 // ----------------------------------------------------------------------------
1015
1016 bool MyPipedProcess::HasInput()
1017 {
1018     bool hasInput = false;
1019
1020     if ( IsInputAvailable() )
1021     {
1022         wxTextInputStream tis(*GetInputStream());
1023
1024         // this assumes that the output is always line buffered
1025         wxString msg;
1026         msg << m_cmd << _T(" (stdout): ") << tis.ReadLine();
1027
1028         m_parent->GetLogListBox()->Append(msg);
1029
1030         hasInput = true;
1031     }
1032
1033     if ( IsErrorAvailable() )
1034     {
1035         wxTextInputStream tis(*GetErrorStream());
1036
1037         // this assumes that the output is always line buffered
1038         wxString msg;
1039         msg << m_cmd << _T(" (stderr): ") << tis.ReadLine();
1040
1041         m_parent->GetLogListBox()->Append(msg);
1042
1043         hasInput = true;
1044     }
1045
1046     return hasInput;
1047 }
1048
1049 void MyPipedProcess::OnTerminate(int pid, int status)
1050 {
1051     // show the rest of the output
1052     while ( HasInput() )
1053         ;
1054
1055     m_parent->OnProcessTerminated(this);
1056
1057     MyProcess::OnTerminate(pid, status);
1058 }
1059
1060 // ----------------------------------------------------------------------------
1061 // MyPipedProcess2
1062 // ----------------------------------------------------------------------------
1063
1064 bool MyPipedProcess2::HasInput()
1065 {
1066     if ( !m_input.empty() )
1067     {
1068         wxTextOutputStream os(*GetOutputStream());
1069         os.WriteString(m_input);
1070
1071         CloseOutput();
1072         m_input.clear();
1073
1074         // call us once again - may be we'll have output
1075         return true;
1076     }
1077
1078     return MyPipedProcess::HasInput();
1079 }
1080
1081 // ============================================================================
1082 // MyPipeFrame implementation
1083 // ============================================================================
1084
1085 MyPipeFrame::MyPipeFrame(wxFrame *parent,
1086                          const wxString& cmd,
1087                          wxProcess *process)
1088            : wxFrame(parent, wxID_ANY, cmd),
1089              m_process(process),
1090              // in a real program we'd check that the streams are !NULL here
1091              m_out(*process->GetOutputStream()),
1092              m_in(*process->GetInputStream()),
1093              m_err(*process->GetErrorStream())
1094 {
1095     m_process->SetNextHandler(this);
1096
1097     wxPanel *panel = new wxPanel(this, wxID_ANY);
1098
1099     m_textOut = new wxTextCtrl(panel, wxID_ANY, wxEmptyString,
1100                               wxDefaultPosition, wxDefaultSize,
1101                               wxTE_PROCESS_ENTER);
1102     m_textIn = new wxTextCtrl(panel, wxID_ANY, wxEmptyString,
1103                                wxDefaultPosition, wxDefaultSize,
1104                                wxTE_MULTILINE | wxTE_RICH);
1105     m_textIn->SetEditable(false);
1106     m_textErr = new wxTextCtrl(panel, wxID_ANY, wxEmptyString,
1107                                wxDefaultPosition, wxDefaultSize,
1108                                wxTE_MULTILINE | wxTE_RICH);
1109     m_textErr->SetEditable(false);
1110
1111     wxSizer *sizerTop = new wxBoxSizer(wxVERTICAL);
1112     sizerTop->Add(m_textOut, 0, wxGROW | wxALL, 5);
1113
1114     wxSizer *sizerBtns = new wxBoxSizer(wxHORIZONTAL);
1115     sizerBtns->
1116         Add(new wxButton(panel, Exec_Btn_Send, _T("&Send")), 0, wxALL, 5);
1117     sizerBtns->
1118         Add(new wxButton(panel, Exec_Btn_SendFile, _T("&File...")), 0, wxALL, 5);
1119     sizerBtns->
1120         Add(new wxButton(panel, Exec_Btn_Get, _T("&Get")), 0, wxALL, 5);
1121     sizerBtns->
1122         Add(new wxButton(panel, Exec_Btn_Close, _T("&Close")), 0, wxALL, 5);
1123
1124     sizerTop->Add(sizerBtns, 0, wxCENTRE | wxALL, 5);
1125     sizerTop->Add(m_textIn, 1, wxGROW | wxALL, 5);
1126     sizerTop->Add(m_textErr, 1, wxGROW | wxALL, 5);
1127
1128     panel->SetSizer(sizerTop);
1129     sizerTop->Fit(this);
1130
1131     Show();
1132 }
1133
1134 void MyPipeFrame::OnBtnSendFile(wxCommandEvent& WXUNUSED(event))
1135 {
1136 #if wxUSE_FILEDLG
1137     wxFileDialog filedlg(this, _T("Select file to send"));
1138     if ( filedlg.ShowModal() != wxID_OK )
1139         return;
1140
1141     wxFFile file(filedlg.GetFilename(), _T("r"));
1142     wxString data;
1143     if ( !file.IsOpened() || !file.ReadAll(&data) )
1144         return;
1145
1146     // can't write the entire string at once, this risk overflowing the pipe
1147     // and we would dead lock
1148     size_t len = data.length();
1149     const wxChar *pc = data.c_str();
1150     while ( len )
1151     {
1152         const size_t CHUNK_SIZE = 4096;
1153         m_out.Write(pc, len > CHUNK_SIZE ? CHUNK_SIZE : len);
1154
1155         // note that not all data could have been written as we don't block on
1156         // the write end of the pipe
1157         const size_t lenChunk = m_out.LastWrite();
1158
1159         pc += lenChunk;
1160         len -= lenChunk;
1161
1162         DoGet();
1163     }
1164 #endif // wxUSE_FILEDLG
1165 }
1166
1167 void MyPipeFrame::DoGet()
1168 {
1169     // we don't have any way to be notified when any input appears on the
1170     // stream so we have to poll it :-(
1171     DoGetFromStream(m_textIn, m_in);
1172     DoGetFromStream(m_textErr, m_err);
1173 }
1174
1175 void MyPipeFrame::DoGetFromStream(wxTextCtrl *text, wxInputStream& in)
1176 {
1177     while ( in.CanRead() )
1178     {
1179         wxChar buffer[4096];
1180         buffer[in.Read(buffer, WXSIZEOF(buffer) - 1).LastRead()] = _T('\0');
1181
1182         text->AppendText(buffer);
1183     }
1184 }
1185
1186 void MyPipeFrame::DoClose()
1187 {
1188     m_process->CloseOutput();
1189
1190     DisableInput();
1191 }
1192
1193 void MyPipeFrame::DisableInput()
1194 {
1195     m_textOut->SetEditable(false);
1196     FindWindow(Exec_Btn_Send)->Disable();
1197     FindWindow(Exec_Btn_SendFile)->Disable();
1198     FindWindow(Exec_Btn_Close)->Disable();
1199 }
1200
1201 void MyPipeFrame::DisableOutput()
1202 {
1203     FindWindow(Exec_Btn_Get)->Disable();
1204 }
1205
1206 void MyPipeFrame::OnClose(wxCloseEvent& event)
1207 {
1208     if ( m_process )
1209     {
1210         // we're not interested in getting the process termination notification
1211         // if we are closing it ourselves
1212         wxProcess *process = m_process;
1213         m_process = NULL;
1214         process->SetNextHandler(NULL);
1215
1216         process->CloseOutput();
1217     }
1218
1219     event.Skip();
1220 }
1221
1222 void MyPipeFrame::OnProcessTerm(wxProcessEvent& WXUNUSED(event))
1223 {
1224     DoGet();
1225
1226     delete m_process;
1227     m_process = NULL;
1228
1229     wxLogWarning(_T("The other process has terminated, closing"));
1230
1231     DisableInput();
1232     DisableOutput();
1233 }