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