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/checkbox.h"
  47     #include "wx/stattext.h"
  48     #include "wx/textctrl.h"
  49     #include "wx/listbox.h"
  50
  51     #include "wx/sizer.h"
  52 #endif
  53
  54 #include "wx/txtstrm.h"
  55 #include "wx/numdlg.h"
  56 #include "wx/textdlg.h"
  57 #include "wx/ffile.h"
  58 #include "wx/scopedptr.h"
  59 #include "wx/stopwatch.h"
  60
  61 #include "wx/process.h"
  62
  63 #include "wx/mimetype.h"
  64
  65 #ifdef __WINDOWS__
  66     #include "wx/dde.h"
  67 #endif // __WINDOWS__
  68
  69 #ifndef wxHAS_IMAGES_IN_RESOURCES
  70     #include "../sample.xpm"
  71 #endif
  72
  73 // ----------------------------------------------------------------------------
  74 // the usual application and main frame classes
  75 // ----------------------------------------------------------------------------
  76
  77 // Define a new application type, each program should derive a class from wxApp
  78 class MyApp : public wxApp
  79 {
  80 public:
  81     // override base class virtuals
  82     // ----------------------------
  83
  84     // this one is called on application startup and is a good place for the app
  85     // initialization (doing it here and not in the ctor allows to have an error
  86     // return: if OnInit() returns false, the application terminates)
  87     virtual bool OnInit();
  88 };
  89
  90 // Define an array of process pointers used by MyFrame
  91 class MyPipedProcess;
  92 WX_DEFINE_ARRAY_PTR(MyPipedProcess *, MyPipedProcessesArray);
  93
  94 class MyProcess;
  95 WX_DEFINE_ARRAY_PTR(MyProcess *, MyProcessesArray);
  96
  97 // Define a new frame type: this is going to be our main frame
  98 class MyFrame : public wxFrame
  99 {
 100 public:
 101     // ctor and dtor
 102     MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size);
 103     virtual ~MyFrame();
 104
 105     // event handlers (these functions should _not_ be virtual)
 106     void OnQuit(wxCommandEvent& event);
 107
 108     void OnKill(wxCommandEvent& event);
 109
 110     void OnClear(wxCommandEvent& event);
 111
 112     void OnBeginBusyCursor(wxCommandEvent& event);
 113     void OnEndBusyCursor(wxCommandEvent& event);
 114
 115     void OnSyncExec(wxCommandEvent& event);
 116     void OnAsyncExec(wxCommandEvent& event);
 117     void OnShell(wxCommandEvent& event);
 118     void OnExecWithRedirect(wxCommandEvent& event);
 119     void OnExecWithPipe(wxCommandEvent& event);
 120
 121     void OnPOpen(wxCommandEvent& event);
 122
 123     void OnFileExec(wxCommandEvent& event);
 124     void OnFileLaunch(wxCommandEvent& event);
 125     void OnOpenURL(wxCommandEvent& event);
 126     void OnShowCommandForExt(wxCommandEvent& event);
 127
 128     void OnAbout(wxCommandEvent& event);
 129
 130     // polling output of async processes
 131     void OnIdleTimer(wxTimerEvent& event);
 132     void OnIdle(wxIdleEvent& event);
 133
 134     // for MyPipedProcess
 135     void OnProcessTerminated(MyPipedProcess *process);
 136     wxListBox *GetLogListBox() const { return m_lbox; }
 137
 138     // for MyProcess
 139     void OnAsyncTermination(MyProcess *process);
 140
 141     // timer updating a counter in the background
 142     void OnBgTimer(wxTimerEvent& event);
 143
 144 private:
 145     void ShowOutput(const wxString& cmd,
 146                     const wxArrayString& output,
 147                     const wxString& title);
 148
 149     int GetExecFlags() const;
 150
 151     void DoAsyncExec(const wxString& cmd);
 152
 153     void AddAsyncProcess(MyProcess *process) { m_allAsync.push_back(process); }
 154
 155     void AddPipedProcess(MyPipedProcess *process);
 156     void RemovePipedProcess(MyPipedProcess *process);
 157
 158
 159     // the PID of the last process we launched asynchronously
 160     long m_pidLast;
 161
 162     // last command we executed
 163     wxString m_cmdLast;
 164
 165 #ifdef __WINDOWS__
 166     void OnDDEExec(wxCommandEvent& event);
 167     void OnDDERequest(wxCommandEvent& event);
 168
 169     bool GetDDEServer();
 170
 171     // last params of a DDE transaction
 172     wxString m_server,
 173              m_topic,
 174              m_cmdDde;
 175 #endif // __WINDOWS__
 176
 177     wxListBox *m_lbox;
 178
 179     // array of running processes with redirected IO
 180     MyPipedProcessesArray m_running;
 181
 182     // array of all asynchrously running processes
 183     MyProcessesArray m_allAsync;
 184
 185     // the idle event wake up timer
 186     wxTimer m_timerIdleWakeUp;
 187
 188     // a background timer allowing to easily check visually whether the
 189     // messages are processed or not
 190     wxTimer m_timerBg;
 191
 192     // any class wishing to process wxWidgets events must use this macro
 193     DECLARE_EVENT_TABLE()
 194 };
 195
 196 // ----------------------------------------------------------------------------
 197 // MyPipeFrame: allows the user to communicate with the child process
 198 // ----------------------------------------------------------------------------
 199
 200 class MyPipeFrame : public wxFrame
 201 {
 202 public:
 203     MyPipeFrame(wxFrame *parent,
 204                 const wxString& cmd,
 205                 wxProcess *process);
 206
 207 protected:
 208     void OnTextEnter(wxCommandEvent& WXUNUSED(event)) { DoSend(); }
 209     void OnBtnSend(wxCommandEvent& WXUNUSED(event)) { DoSend(); }
 210     void OnBtnSendFile(wxCommandEvent& WXUNUSED(event));
 211     void OnBtnGet(wxCommandEvent& WXUNUSED(event)) { DoGet(); }
 212     void OnBtnClose(wxCommandEvent& WXUNUSED(event)) { DoClose(); }
 213
 214     void OnClose(wxCloseEvent& event);
 215
 216     void OnProcessTerm(wxProcessEvent& event);
 217
 218     void DoSend()
 219     {
 220         wxString s(m_textOut->GetValue());
 221         s += wxT('\n');
 222         m_out.Write(s.c_str(), s.length());
 223         m_textOut->Clear();
 224
 225         DoGet();
 226     }
 227
 228     void DoGet();
 229     void DoClose();
 230
 231 private:
 232     void DoGetFromStream(wxTextCtrl *text, wxInputStream& in);
 233     void DisableInput();
 234     void DisableOutput();
 235
 236
 237     wxProcess *m_process;
 238
 239     wxOutputStream &m_out;
 240     wxInputStream &m_in,
 241                   &m_err;
 242
 243     wxTextCtrl *m_textOut,
 244                *m_textIn,
 245                *m_textErr;
 246
 247     DECLARE_EVENT_TABLE()
 248 };
 249
 250 // ----------------------------------------------------------------------------
 251 // wxProcess-derived classes
 252 // ----------------------------------------------------------------------------
 253
 254 // This is the handler for process termination events
 255 class MyProcess : public wxProcess
 256 {
 257 public:
 258     MyProcess(MyFrame *parent, const wxString& cmd)
 259         : wxProcess(parent), m_cmd(cmd)
 260     {
 261         m_parent = parent;
 262     }
 263
 264     // instead of overriding this virtual function we might as well process the
 265     // event from it in the frame class - this might be more convenient in some
 266     // cases
 267     virtual void OnTerminate(int pid, int status);
 268
 269 protected:
 270     MyFrame *m_parent;
 271     wxString m_cmd;
 272 };
 273
 274 // A specialization of MyProcess for redirecting the output
 275 class MyPipedProcess : public MyProcess
 276 {
 277 public:
 278     MyPipedProcess(MyFrame *parent, const wxString& cmd)
 279         : MyProcess(parent, cmd)
 280         {
 281             Redirect();
 282         }
 283
 284     virtual void OnTerminate(int pid, int status);
 285
 286     virtual bool HasInput();
 287 };
 288
 289 // A version of MyPipedProcess which also sends input to the stdin of the
 290 // child process
 291 class MyPipedProcess2 : public MyPipedProcess
 292 {
 293 public:
 294     MyPipedProcess2(MyFrame *parent, const wxString& cmd, const wxString& input)
 295         : MyPipedProcess(parent, cmd), m_input(input)
 296         {
 297         }
 298
 299     virtual bool HasInput();
 300
 301 private:
 302     wxString m_input;
 303 };
 304
 305 // ----------------------------------------------------------------------------
 306 // constants
 307 // ----------------------------------------------------------------------------
 308
 309 // IDs for the controls and the menu commands
 310 enum
 311 {
 312     // timer ids
 313     Exec_TimerIdle = 10,
 314     Exec_TimerBg,
 315
 316     // menu items
 317     Exec_Kill = 100,
 318     Exec_ClearLog,
 319     Exec_BeginBusyCursor,
 320     Exec_EndBusyCursor,
 321     Exec_SyncExec = 200,
 322     Exec_AsyncExec,
 323     Exec_Shell,
 324     Exec_POpen,
 325     Exec_OpenFile,
 326     Exec_ShowCommandForExt,
 327     Exec_LaunchFile,
 328     Exec_OpenURL,
 329     Exec_DDEExec,
 330     Exec_DDERequest,
 331     Exec_Redirect,
 332     Exec_Pipe,
 333     Exec_Flags_HideConsole,
 334     Exec_Flags_ShowConsole,
 335     Exec_Flags_NoEvents,
 336     Exec_About = wxID_ABOUT,
 337     Exec_Quit = wxID_EXIT,
 338
 339     // control ids
 340     Exec_Btn_Send = 1000,
 341     Exec_Btn_SendFile,
 342     Exec_Btn_Get,
 343     Exec_Btn_Close
 344 };
 345
 346 static const wxChar *DIALOG_TITLE = wxT("Exec sample");
 347
 348 // ----------------------------------------------------------------------------
 349 // event tables and other macros for wxWidgets
 350 // ----------------------------------------------------------------------------
 351
 352 // the event tables connect the wxWidgets events with the functions (event
 353 // handlers) which process them. It can be also done at run-time, but for the
 354 // simple menu events like this the static method is much simpler.
 355 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 356     EVT_MENU(Exec_Quit,  MyFrame::OnQuit)
 357     EVT_MENU(Exec_Kill,  MyFrame::OnKill)
 358     EVT_MENU(Exec_ClearLog,  MyFrame::OnClear)
 359     EVT_MENU(Exec_BeginBusyCursor,  MyFrame::OnBeginBusyCursor)
 360     EVT_MENU(Exec_EndBusyCursor,  MyFrame::OnEndBusyCursor)
 361
 362     EVT_MENU(Exec_SyncExec, MyFrame::OnSyncExec)
 363     EVT_MENU(Exec_AsyncExec, MyFrame::OnAsyncExec)
 364     EVT_MENU(Exec_Shell, MyFrame::OnShell)
 365     EVT_MENU(Exec_Redirect, MyFrame::OnExecWithRedirect)
 366     EVT_MENU(Exec_Pipe, MyFrame::OnExecWithPipe)
 367
 368     EVT_MENU(Exec_POpen, MyFrame::OnPOpen)
 369
 370     EVT_MENU(Exec_OpenFile, MyFrame::OnFileExec)
 371     EVT_MENU(Exec_ShowCommandForExt, MyFrame::OnShowCommandForExt)
 372     EVT_MENU(Exec_LaunchFile, MyFrame::OnFileLaunch)
 373     EVT_MENU(Exec_OpenURL, MyFrame::OnOpenURL)
 374
 375 #ifdef __WINDOWS__
 376     EVT_MENU(Exec_DDEExec, MyFrame::OnDDEExec)
 377     EVT_MENU(Exec_DDERequest, MyFrame::OnDDERequest)
 378 #endif // __WINDOWS__
 379
 380     EVT_MENU(Exec_About, MyFrame::OnAbout)
 381
 382     EVT_IDLE(MyFrame::OnIdle)
 383
 384     EVT_TIMER(Exec_TimerIdle, MyFrame::OnIdleTimer)
 385     EVT_TIMER(Exec_TimerBg, MyFrame::OnBgTimer)
 386 END_EVENT_TABLE()
 387
 388 BEGIN_EVENT_TABLE(MyPipeFrame, wxFrame)
 389     EVT_BUTTON(Exec_Btn_Send, MyPipeFrame::OnBtnSend)
 390     EVT_BUTTON(Exec_Btn_SendFile, MyPipeFrame::OnBtnSendFile)
 391     EVT_BUTTON(Exec_Btn_Get, MyPipeFrame::OnBtnGet)
 392     EVT_BUTTON(Exec_Btn_Close, MyPipeFrame::OnBtnClose)
 393
 394     EVT_TEXT_ENTER(wxID_ANY, MyPipeFrame::OnTextEnter)
 395
 396     EVT_CLOSE(MyPipeFrame::OnClose)
 397
 398     EVT_END_PROCESS(wxID_ANY, MyPipeFrame::OnProcessTerm)
 399 END_EVENT_TABLE()
 400
 401 // Create a new application object: this macro will allow wxWidgets to create
 402 // the application object during program execution (it's better than using a
 403 // static object for many reasons) and also declares the accessor function
 404 // wxGetApp() which will return the reference of the right type (i.e. MyApp and
 405 // not wxApp)
 406 IMPLEMENT_APP(MyApp)
 407
 408 // ============================================================================
 409 // implementation
 410 // ============================================================================
 411
 412 // ----------------------------------------------------------------------------
 413 // the application class
 414 // ----------------------------------------------------------------------------
 415
 416 // `Main program' equivalent: the program execution "starts" here
 417 bool MyApp::OnInit()
 418 {
 419     if ( !wxApp::OnInit() )
 420         return false;
 421
 422     // Create the main application window
 423     MyFrame *frame = new MyFrame(wxT("Exec wxWidgets sample"),
 424                                  wxDefaultPosition, wxSize(500, 140));
 425
 426     // Show it
 427     frame->Show(true);
 428
 429     // success: wxApp::OnRun() will be called which will enter the main message
 430     // loop and the application will run. If we returned false here, the
 431     // application would exit immediately.
 432     return true;
 433 }
 434
 435 // ----------------------------------------------------------------------------
 436 // main frame
 437 // ----------------------------------------------------------------------------
 438
 439 #ifdef __VISUALC__
 440 #pragma warning(disable: 4355) // this used in base member initializer list
 441 #endif
 442
 443 // frame constructor
 444 MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
 445        : wxFrame((wxFrame *)NULL, wxID_ANY, title, pos, size),
 446          m_timerIdleWakeUp(this, Exec_TimerIdle),
 447          m_timerBg(this, Exec_TimerBg)
 448 {
 449     SetIcon(wxICON(sample));
 450
 451     m_pidLast = 0;
 452
 453 #ifdef __WXMAC__
 454     // we need this in order to allow the about menu relocation, since ABOUT is
 455     // not the default id of the about menu
 456     wxApp::s_macAboutMenuItemId = Exec_About;
 457 #endif
 458
 459     // create a menu bar
 460     wxMenu *menuFile = new wxMenu(wxEmptyString, wxMENU_TEAROFF);
 461     menuFile->Append(Exec_Kill, wxT("&Kill process...\tCtrl-K"),
 462                      wxT("Kill a process by PID"));
 463     menuFile->AppendSeparator();
 464     menuFile->Append(Exec_OpenFile, wxT("Open &file...\tCtrl-F"),
 465                      wxT("Launch the command to open this kind of files"));
 466     menuFile->Append(Exec_ShowCommandForExt,
 467                      "Show association for extension...\tShift-Ctrl-A",
 468                      "Show the command associated with the given extension");
 469     menuFile->Append(Exec_LaunchFile, wxT("La&unch file...\tShift-Ctrl-F"),
 470                      wxT("Launch the default application associated with the file"));
 471     menuFile->Append(Exec_OpenURL, wxT("Open &URL...\tCtrl-U"),
 472                      wxT("Launch the default browser with the given URL"));
 473     menuFile->AppendSeparator();
 474     menuFile->Append(Exec_BeginBusyCursor, wxT("Show &busy cursor\tCtrl-C"));
 475     menuFile->Append(Exec_EndBusyCursor, wxT("Show &normal cursor\tShift-Ctrl-C"));
 476     menuFile->AppendSeparator();
 477     menuFile->Append(Exec_ClearLog, wxT("&Clear log\tCtrl-L"),
 478                      wxT("Clear the log window"));
 479     menuFile->AppendSeparator();
 480     menuFile->Append(Exec_Quit, wxT("E&xit\tAlt-X"), wxT("Quit this program"));
 481
 482     wxMenu *flagsMenu = new wxMenu;
 483     flagsMenu->AppendCheckItem(Exec_Flags_HideConsole, "Always &hide console");
 484     flagsMenu->AppendCheckItem(Exec_Flags_ShowConsole, "Always &show console");
 485     flagsMenu->AppendCheckItem(Exec_Flags_NoEvents, "Disable &events",
 486                                "This flag is valid for sync execution only");
 487
 488     wxMenu *execMenu = new wxMenu;
 489     execMenu->AppendSubMenu(flagsMenu, "Execution flags");
 490     execMenu->AppendSeparator();
 491     execMenu->Append(Exec_SyncExec, wxT("Sync &execution...\tCtrl-E"),
 492                      wxT("Launch a program and return when it terminates"));
 493     execMenu->Append(Exec_AsyncExec, wxT("&Async execution...\tCtrl-A"),
 494                      wxT("Launch a program and return immediately"));
 495     execMenu->Append(Exec_Shell, wxT("Execute &shell command...\tCtrl-S"),
 496                      wxT("Launch a shell and execute a command in it"));
 497     execMenu->AppendSeparator();
 498     execMenu->Append(Exec_Redirect, wxT("Capture command &output...\tCtrl-O"),
 499                      wxT("Launch a program and capture its output"));
 500     execMenu->Append(Exec_Pipe, wxT("&Pipe through command..."),
 501                      wxT("Pipe a string through a filter"));
 502     execMenu->Append(Exec_POpen, wxT("&Open a pipe to a command...\tCtrl-P"),
 503                      wxT("Open a pipe to and from another program"));
 504
 505 #ifdef __WINDOWS__
 506     execMenu->AppendSeparator();
 507     execMenu->Append(Exec_DDEExec, wxT("Execute command via &DDE...\tCtrl-D"));
 508     execMenu->Append(Exec_DDERequest, wxT("Send DDE &request...\tCtrl-R"));
 509 #endif
 510
 511     wxMenu *helpMenu = new wxMenu(wxEmptyString, wxMENU_TEAROFF);
 512     helpMenu->Append(Exec_About, wxT("&About\tF1"), wxT("Show about dialog"));
 513
 514     // now append the freshly created menu to the menu bar...
 515     wxMenuBar *menuBar = new wxMenuBar();
 516     menuBar->Append(menuFile, wxT("&File"));
 517     menuBar->Append(execMenu, wxT("&Exec"));
 518     menuBar->Append(helpMenu, wxT("&Help"));
 519
 520     // ... and attach this menu bar to the frame
 521     SetMenuBar(menuBar);
 522
 523     // create the listbox in which we will show misc messages as they come
 524     m_lbox = new wxListBox(this, wxID_ANY);
 525     wxFont font(12, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL,
 526                 wxFONTWEIGHT_NORMAL);
 527     if ( font.IsOk() )
 528         m_lbox->SetFont(font);
 529
 530 #if wxUSE_STATUSBAR
 531     // create a status bar just for fun (by default with 1 pane only)
 532     CreateStatusBar(2);
 533     SetStatusText(wxT("Welcome to wxWidgets exec sample!"));
 534 #endif // wxUSE_STATUSBAR
 535
 536     m_timerBg.Start(1000);
 537 }
 538
 539 MyFrame::~MyFrame()
 540 {
 541     // any processes left until now must be deleted manually: normally this is
 542     // done when the associated process terminates but it must be still running
 543     // if this didn't happen until now
 544     for ( size_t n = 0; n < m_allAsync.size(); n++ )
 545     {
 546         delete m_allAsync[n];
 547     }
 548 }
 549
 550 // ----------------------------------------------------------------------------
 551 // event handlers: file and help menu
 552 // ----------------------------------------------------------------------------
 553
 554 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 555 {
 556     // true is to force the frame to close
 557     Close(true);
 558 }
 559
 560 void MyFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 561 {
 562     m_lbox->Clear();
 563 }
 564
 565 void MyFrame::OnBeginBusyCursor(wxCommandEvent& WXUNUSED(event))
 566 {
 567     wxBeginBusyCursor();
 568 }
 569
 570 void MyFrame::OnEndBusyCursor(wxCommandEvent& WXUNUSED(event))
 571 {
 572     wxEndBusyCursor();
 573 }
 574
 575 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 576 {
 577     wxMessageBox(wxT("Exec wxWidgets Sample\n(c) 2000-2002 Vadim Zeitlin"),
 578                  wxT("About Exec"), wxOK | wxICON_INFORMATION, this);
 579 }
 580
 581 void MyFrame::OnKill(wxCommandEvent& WXUNUSED(event))
 582 {
 583     long pid = wxGetNumberFromUser(wxT("Please specify the process to kill"),
 584                                    wxT("Enter PID:"),
 585                                    wxT("Exec question"),
 586                                    m_pidLast,
 587                                    // we need the full unsigned int range
 588                                    -INT_MAX, INT_MAX,
 589                                    this);
 590     if ( pid == -1 )
 591     {
 592         // cancelled
 593         return;
 594     }
 595
 596     m_pidLast = pid;
 597
 598     static const wxString signalNames[] =
 599     {
 600         wxT("Just test (SIGNONE)"),
 601         wxT("Hangup (SIGHUP)"),
 602         wxT("Interrupt (SIGINT)"),
 603         wxT("Quit (SIGQUIT)"),
 604         wxT("Illegal instruction (SIGILL)"),
 605         wxT("Trap (SIGTRAP)"),
 606         wxT("Abort (SIGABRT)"),
 607         wxT("Emulated trap (SIGEMT)"),
 608         wxT("FP exception (SIGFPE)"),
 609         wxT("Kill (SIGKILL)"),
 610         wxT("Bus (SIGBUS)"),
 611         wxT("Segment violation (SIGSEGV)"),
 612         wxT("System (SIGSYS)"),
 613         wxT("Broken pipe (SIGPIPE)"),
 614         wxT("Alarm (SIGALRM)"),
 615         wxT("Terminate (SIGTERM)"),
 616     };
 617
 618     static int s_sigLast = wxSIGNONE;
 619     int sig = wxGetSingleChoiceIndex(wxT("How to kill the process?"),
 620                                      wxT("Exec question"),
 621                                      WXSIZEOF(signalNames), signalNames,
 622                                      s_sigLast,
 623                                      this);
 624     switch ( sig )
 625     {
 626         default:
 627             wxFAIL_MSG( wxT("unexpected return value") );
 628             // fall through
 629
 630         case -1:
 631             // cancelled
 632             return;
 633
 634         case wxSIGNONE:
 635         case wxSIGHUP:
 636         case wxSIGINT:
 637         case wxSIGQUIT:
 638         case wxSIGILL:
 639         case wxSIGTRAP:
 640         case wxSIGABRT:
 641         case wxSIGEMT:
 642         case wxSIGFPE:
 643         case wxSIGKILL:
 644         case wxSIGBUS:
 645         case wxSIGSEGV:
 646         case wxSIGSYS:
 647         case wxSIGPIPE:
 648         case wxSIGALRM:
 649         case wxSIGTERM:
 650             break;
 651     }
 652
 653     s_sigLast = sig;
 654
 655     if ( sig == wxSIGNONE )
 656     {
 657         // This simply calls Kill(wxSIGNONE) but using it is more convenient.
 658         if ( wxProcess::Exists(pid) )
 659         {
 660             wxLogStatus(wxT("Process %ld is running."), pid);
 661         }
 662         else
 663         {
 664             wxLogStatus(wxT("No process with pid = %ld."), pid);
 665         }
 666     }
 667     else // not SIGNONE
 668     {
 669         wxKillError rc = wxProcess::Kill(pid, (wxSignal)sig);
 670         if ( rc == wxKILL_OK )
 671         {
 672             wxLogStatus(wxT("Process %ld killed with signal %d."), pid, sig);
 673         }
 674         else
 675         {
 676             static const wxChar *errorText[] =
 677             {
 678                 wxT(""), // no error
 679                 wxT("signal not supported"),
 680                 wxT("permission denied"),
 681                 wxT("no such process"),
 682                 wxT("unspecified error"),
 683             };
 684
 685             wxLogStatus(wxT("Failed to kill process %ld with signal %d: %s"),
 686                         pid, sig, errorText[rc]);
 687         }
 688     }
 689 }
 690
 691 // ----------------------------------------------------------------------------
 692 // execution options dialog
 693 // ----------------------------------------------------------------------------
 694
 695 enum ExecQueryDialogID
 696 {
 697     TEXT_EXECUTABLE,
 698     TEXT_CWD,
 699     TEXT_ENVIRONMENT
 700 };
 701
 702 class ExecQueryDialog : public wxDialog
 703 {
 704 public:
 705     ExecQueryDialog(const wxString& cmd);
 706
 707     wxString GetExecutable() const
 708     {
 709         return m_executable->GetValue();
 710     }
 711
 712     wxString GetWorkDir() const
 713     {
 714         return m_useCWD->GetValue() ? m_cwdtext->GetValue() : wxString();
 715     }
 716
 717     void GetEnvironment(wxEnvVariableHashMap& env);
 718
 719 private:
 720     void OnUpdateWorkingDirectoryUI(wxUpdateUIEvent& event)
 721     {
 722         event.Enable(m_useCWD->GetValue());
 723     }
 724
 725     void OnUpdateEnvironmentUI(wxUpdateUIEvent& event)
 726     {
 727         event.Enable(m_useEnv->GetValue());
 728     }
 729
 730     wxTextCtrl* m_executable;
 731     wxTextCtrl* m_cwdtext;
 732     wxTextCtrl* m_envtext;
 733     wxCheckBox* m_useCWD;
 734     wxCheckBox* m_useEnv;
 735
 736     DECLARE_EVENT_TABLE()
 737 };
 738
 739 BEGIN_EVENT_TABLE(ExecQueryDialog, wxDialog)
 740     EVT_UPDATE_UI(TEXT_CWD, ExecQueryDialog::OnUpdateWorkingDirectoryUI)
 741     EVT_UPDATE_UI(TEXT_ENVIRONMENT, ExecQueryDialog::OnUpdateEnvironmentUI)
 742 END_EVENT_TABLE()
 743
 744 ExecQueryDialog::ExecQueryDialog(const wxString& cmd)
 745     : wxDialog(NULL, wxID_ANY, DIALOG_TITLE,
 746                wxDefaultPosition, wxDefaultSize,
 747                wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
 748 {
 749     wxSizer* globalSizer = new wxBoxSizer(wxVERTICAL);
 750
 751     m_executable = new wxTextCtrl(this, TEXT_EXECUTABLE, wxString());
 752     m_cwdtext = new wxTextCtrl(this, TEXT_CWD, wxString());
 753     m_envtext = new wxTextCtrl(this, TEXT_ENVIRONMENT, wxString(),
 754                                wxDefaultPosition, wxSize(300, 200),
 755                                wxTE_MULTILINE|wxHSCROLL);
 756
 757     const wxSizerFlags flagsExpand = wxSizerFlags().Expand().Border();
 758     globalSizer->Add(new wxStaticText(this, wxID_ANY, "Enter the command: "),
 759                      flagsExpand);
 760     globalSizer->Add(m_executable, flagsExpand);
 761
 762     m_useCWD = new wxCheckBox(this, wxID_ANY, "Working directory: ");
 763     globalSizer->Add(m_useCWD, flagsExpand);
 764     globalSizer->Add(m_cwdtext, flagsExpand);
 765
 766     m_useEnv = new wxCheckBox(this, wxID_ANY, "Environment: ");
 767     globalSizer->Add(m_useEnv, flagsExpand);
 768     globalSizer->Add(m_envtext, wxSizerFlags(flagsExpand).Proportion(1));
 769
 770     globalSizer->Add(CreateStdDialogButtonSizer(wxOK|wxCANCEL), flagsExpand);
 771     SetSizerAndFit(globalSizer);
 772
 773
 774     m_executable->SetValue(cmd);
 775     m_cwdtext->SetValue(wxGetCwd());
 776     wxEnvVariableHashMap env;
 777     if ( wxGetEnvMap(&env) )
 778     {
 779         for ( wxEnvVariableHashMap::iterator it = env.begin();
 780               it != env.end();
 781               ++it )
 782         {
 783             m_envtext->AppendText(it->first + '=' + it->second + '\n');
 784         }
 785     }
 786     m_useCWD->SetValue(false);
 787     m_useEnv->SetValue(false);
 788 }
 789
 790 void ExecQueryDialog::GetEnvironment(wxEnvVariableHashMap& env)
 791 {
 792     env.clear();
 793     if ( m_useEnv->GetValue() )
 794     {
 795         wxString name,
 796                  value;
 797
 798         const int nb = m_envtext->GetNumberOfLines();
 799         for ( int l = 0; l < nb; l++ )
 800         {
 801             const wxString line = m_envtext->GetLineText(l).Trim();
 802
 803             if ( !line.empty() )
 804             {
 805                 name = line.BeforeFirst('=', &value);
 806                 if ( name.empty() )
 807                 {
 808                     wxLogWarning("Skipping invalid environment line \"%s\".", line);
 809                     continue;
 810                 }
 811
 812                 env[name] = value;
 813             }
 814         }
 815     }
 816 }
 817
 818 static bool QueryExec(wxString& cmd, wxExecuteEnv& env)
 819 {
 820     ExecQueryDialog dialog(cmd);
 821
 822     if ( dialog.ShowModal() != wxID_OK )
 823         return false;
 824
 825     cmd = dialog.GetExecutable();
 826     env.cwd = dialog.GetWorkDir();
 827     dialog.GetEnvironment(env.env);
 828
 829     return true;
 830 }
 831
 832 // ----------------------------------------------------------------------------
 833 // event handlers: exec menu
 834 // ----------------------------------------------------------------------------
 835
 836 int MyFrame::GetExecFlags() const
 837 {
 838     wxMenuBar* const mbar = GetMenuBar();
 839
 840     int flags = 0;
 841
 842     if ( mbar->IsChecked(Exec_Flags_HideConsole) )
 843         flags |= wxEXEC_HIDE_CONSOLE;
 844     if ( mbar->IsChecked(Exec_Flags_ShowConsole) )
 845         flags |= wxEXEC_SHOW_CONSOLE;
 846     if ( mbar->IsChecked(Exec_Flags_NoEvents) )
 847         flags |= wxEXEC_NOEVENTS;
 848
 849     return flags;
 850 }
 851
 852 void MyFrame::DoAsyncExec(const wxString& cmd)
 853 {
 854     MyProcess * const process = new MyProcess(this, cmd);
 855     m_pidLast = wxExecute(cmd, wxEXEC_ASYNC | GetExecFlags(), process);
 856     if ( !m_pidLast )
 857     {
 858         wxLogError(wxT("Execution of '%s' failed."), cmd.c_str());
 859
 860         delete process;
 861     }
 862     else
 863     {
 864         wxLogStatus(wxT("Process %ld (%s) launched."), m_pidLast, cmd.c_str());
 865
 866         m_cmdLast = cmd;
 867
 868         // the parent frame keeps track of all async processes as it needs to
 869         // free them if we exit before the child process terminates
 870         AddAsyncProcess(process);
 871     }
 872 }
 873
 874 void MyFrame::OnSyncExec(wxCommandEvent& WXUNUSED(event))
 875 {
 876     wxString cmd;
 877     wxExecuteEnv env;
 878     if ( !QueryExec(cmd, env) )
 879         return;
 880
 881     wxLogStatus( wxT("'%s' is running please wait..."), cmd.c_str() );
 882
 883     int code = wxExecute(cmd, wxEXEC_SYNC | GetExecFlags(), NULL, &env);
 884
 885     wxLogStatus(wxT("Process '%s' terminated with exit code %d."),
 886         cmd.c_str(), code);
 887
 888     m_cmdLast = cmd;
 889 }
 890
 891 void MyFrame::OnAsyncExec(wxCommandEvent& WXUNUSED(event))
 892 {
 893     wxString cmd = wxGetTextFromUser(wxT("Enter the command: "),
 894                                      DIALOG_TITLE,
 895                                      m_cmdLast);
 896
 897     if ( !cmd )
 898         return;
 899
 900     DoAsyncExec(cmd);
 901 }
 902
 903 void MyFrame::OnShell(wxCommandEvent& WXUNUSED(event))
 904 {
 905     wxString cmd = wxGetTextFromUser(wxT("Enter the command: "),
 906                                      DIALOG_TITLE,
 907                                      m_cmdLast);
 908
 909     if ( !cmd )
 910         return;
 911
 912     int code = wxShell(cmd);
 913     wxLogStatus(wxT("Shell command '%s' terminated with exit code %d."),
 914                 cmd.c_str(), code);
 915     m_cmdLast = cmd;
 916 }
 917
 918 void MyFrame::OnExecWithRedirect(wxCommandEvent& WXUNUSED(event))
 919 {
 920     if ( !m_cmdLast )
 921     {
 922 #ifdef __WXMSW__
 923         m_cmdLast = "type Makefile.in";
 924 #else
 925         m_cmdLast = "cat -n Makefile";
 926 #endif
 927     }
 928
 929     wxString cmd = wxGetTextFromUser(wxT("Enter the command: "),
 930                                      DIALOG_TITLE,
 931                                      m_cmdLast);
 932
 933     if ( !cmd )
 934         return;
 935
 936     bool sync;
 937     switch ( wxMessageBox(wxT("Execute it synchronously?"),
 938                           wxT("Exec question"),
 939                           wxYES_NO | wxCANCEL | wxICON_QUESTION, this) )
 940     {
 941         case wxYES:
 942             sync = true;
 943             break;
 944
 945         case wxNO:
 946             sync = false;
 947             break;
 948
 949         default:
 950             return;
 951     }
 952
 953     if ( sync )
 954     {
 955         wxLogStatus("\"%s\" is running please wait...", cmd);
 956
 957         wxStopWatch sw;
 958
 959         wxArrayString output, errors;
 960         int code = wxExecute(cmd, output, errors);
 961
 962         wxLogStatus("Command \"%s\" terminated after %ldms; exit code %d.",
 963                     cmd, sw.Time(), code);
 964
 965         ShowOutput(cmd, output, wxT("Output"));
 966         ShowOutput(cmd, errors, wxT("Errors"));
 967     }
 968     else // async exec
 969     {
 970         MyPipedProcess *process = new MyPipedProcess(this, cmd);
 971         if ( !wxExecute(cmd, wxEXEC_ASYNC, process) )
 972         {
 973             wxLogError(wxT("Execution of '%s' failed."), cmd.c_str());
 974
 975             delete process;
 976         }
 977         else
 978         {
 979             AddPipedProcess(process);
 980         }
 981     }
 982
 983     m_cmdLast = cmd;
 984 }
 985
 986 void MyFrame::OnExecWithPipe(wxCommandEvent& WXUNUSED(event))
 987 {
 988     if ( !m_cmdLast )
 989         m_cmdLast = wxT("tr [a-z] [A-Z]");
 990
 991     wxString cmd = wxGetTextFromUser(wxT("Enter the command: "),
 992                                      DIALOG_TITLE,
 993                                      m_cmdLast);
 994
 995     if ( !cmd )
 996         return;
 997
 998     wxString input = wxGetTextFromUser(wxT("Enter the string to send to it: "),
 999                                        DIALOG_TITLE);
1000     if ( !input )
1001         return;
1002
1003     // always execute the filter asynchronously
1004     MyPipedProcess2 *process = new MyPipedProcess2(this, cmd, input);
1005     long pid = wxExecute(cmd, wxEXEC_ASYNC, process);
1006     if ( pid )
1007     {
1008         wxLogStatus(wxT("Process %ld (%s) launched."), pid, cmd.c_str());
1009
1010         AddPipedProcess(process);
1011     }
1012     else
1013     {
1014         wxLogError(wxT("Execution of '%s' failed."), cmd.c_str());
1015
1016         delete process;
1017     }
1018
1019     m_cmdLast = cmd;
1020 }
1021
1022 void MyFrame::OnPOpen(wxCommandEvent& WXUNUSED(event))
1023 {
1024     wxString cmd = wxGetTextFromUser(wxT("Enter the command to launch: "),
1025                                      DIALOG_TITLE,
1026                                      m_cmdLast);
1027     if ( cmd.empty() )
1028         return;
1029
1030     wxProcess *process = wxProcess::Open(cmd);
1031     if ( !process )
1032     {
1033         wxLogError(wxT("Failed to launch the command."));
1034         return;
1035     }
1036
1037     wxLogVerbose(wxT("PID of the new process: %ld"), process->GetPid());
1038
1039     wxOutputStream *out = process->GetOutputStream();
1040     if ( !out )
1041     {
1042         wxLogError(wxT("Failed to connect to child stdin"));
1043         return;
1044     }
1045
1046     wxInputStream *in = process->GetInputStream();
1047     if ( !in )
1048     {
1049         wxLogError(wxT("Failed to connect to child stdout"));
1050         return;
1051     }
1052
1053     new MyPipeFrame(this, cmd, process);
1054 }
1055
1056 static wxString gs_lastFile;
1057
1058 static bool AskUserForFileName()
1059 {
1060     wxString filename;
1061
1062 #if wxUSE_FILEDLG
1063     filename = wxLoadFileSelector(wxT("any"), wxEmptyString, gs_lastFile);
1064 #else // !wxUSE_FILEDLG
1065     filename = wxGetTextFromUser(wxT("Enter the file name"), wxT("exec sample"),
1066                                  gs_lastFile);
1067 #endif // wxUSE_FILEDLG/!wxUSE_FILEDLG
1068
1069     if ( filename.empty() )
1070         return false;
1071
1072     gs_lastFile = filename;
1073
1074     return true;
1075 }
1076
1077 void MyFrame::OnFileExec(wxCommandEvent& WXUNUSED(event))
1078 {
1079     if ( !AskUserForFileName() )
1080         return;
1081
1082     wxString ext = gs_lastFile.AfterLast(wxT('.'));
1083     wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
1084     if ( !ft )
1085     {
1086         wxLogError(wxT("Impossible to determine the file type for extension '%s'"),
1087                    ext.c_str());
1088         return;
1089     }
1090
1091     wxString cmd;
1092     bool ok = ft->GetOpenCommand(&cmd,
1093                                  wxFileType::MessageParameters(gs_lastFile));
1094     delete ft;
1095     if ( !ok )
1096     {
1097         wxLogError(wxT("Impossible to find out how to open files of extension '%s'"),
1098                    ext.c_str());
1099         return;
1100     }
1101
1102     DoAsyncExec(cmd);
1103 }
1104
1105 void MyFrame::OnShowCommandForExt(wxCommandEvent& WXUNUSED(event))
1106 {
1107     static wxString s_ext;
1108
1109     wxString ext = wxGetTextFromUser
1110                    (
1111                     "Enter the extension without leading dot",
1112                     "Exec sample",
1113                     s_ext,
1114                     this
1115                    );
1116     if ( ext.empty() )
1117         return;
1118
1119     s_ext = ext;
1120
1121     wxScopedPtr<wxFileType>
1122         ft(wxTheMimeTypesManager->GetFileTypeFromExtension(ext));
1123     if ( !ft )
1124     {
1125         wxLogError("Information for extension \"%s\" not found", ext);
1126         return;
1127     }
1128
1129     const wxString cmd = ft->GetOpenCommand("file." + ext);
1130     if ( cmd.empty() )
1131     {
1132         wxLogWarning("Open command for extension \"%s\" not defined.", ext);
1133         return;
1134     }
1135
1136     wxLogMessage("Open command for files of extension \"%s\" is\n%s",
1137                  ext, cmd);
1138 }
1139
1140 void MyFrame::OnFileLaunch(wxCommandEvent& WXUNUSED(event))
1141 {
1142     if ( !AskUserForFileName() )
1143         return;
1144
1145     if ( !wxLaunchDefaultApplication(gs_lastFile) )
1146     {
1147         wxLogError("Opening \"%s\" in default application failed.", gs_lastFile);
1148     }
1149 }
1150
1151 void MyFrame::OnOpenURL(wxCommandEvent& WXUNUSED(event))
1152 {
1153     static wxString s_url(wxT("http://www.wxwidgets.org/"));
1154
1155     wxString filename = wxGetTextFromUser
1156                         (
1157                             wxT("Enter the URL"),
1158                             wxT("exec sample"),
1159                             s_url,
1160                             this
1161                         );
1162
1163     if ( filename.empty() )
1164         return;
1165
1166     s_url = filename;
1167
1168     if ( !wxLaunchDefaultBrowser(s_url) )
1169     {
1170         wxLogError(wxT("Failed to open URL \"%s\""), s_url.c_str());
1171     }
1172 }
1173
1174 // ----------------------------------------------------------------------------
1175 // DDE stuff
1176 // ----------------------------------------------------------------------------
1177
1178 #ifdef __WINDOWS__
1179
1180 bool MyFrame::GetDDEServer()
1181 {
1182     wxString server = wxGetTextFromUser(wxT("Server to connect to:"),
1183                                         DIALOG_TITLE, m_server);
1184     if ( !server )
1185         return false;
1186
1187     m_server = server;
1188
1189     wxString topic = wxGetTextFromUser(wxT("DDE topic:"), DIALOG_TITLE, m_topic);
1190     if ( !topic )
1191         return false;
1192
1193     m_topic = topic;
1194
1195     wxString cmd = wxGetTextFromUser(wxT("DDE command:"), DIALOG_TITLE, m_cmdDde);
1196     if ( !cmd )
1197         return false;
1198
1199     m_cmdDde = cmd;
1200
1201     return true;
1202 }
1203
1204 void MyFrame::OnDDEExec(wxCommandEvent& WXUNUSED(event))
1205 {
1206     if ( !GetDDEServer() )
1207         return;
1208
1209     wxDDEClient client;
1210     wxConnectionBase *conn = client.MakeConnection(wxEmptyString, m_server, m_topic);
1211     if ( !conn )
1212     {
1213         wxLogError(wxT("Failed to connect to the DDE server '%s'."),
1214                    m_server.c_str());
1215     }
1216     else
1217     {
1218         if ( !conn->Execute(m_cmdDde) )
1219         {
1220             wxLogError(wxT("Failed to execute command '%s' via DDE."),
1221                        m_cmdDde.c_str());
1222         }
1223         else
1224         {
1225             wxLogStatus(wxT("Successfully executed DDE command"));
1226         }
1227     }
1228 }
1229
1230 void MyFrame::OnDDERequest(wxCommandEvent& WXUNUSED(event))
1231 {
1232     if ( !GetDDEServer() )
1233         return;
1234
1235     wxDDEClient client;
1236     wxConnectionBase *conn = client.MakeConnection(wxEmptyString, m_server, m_topic);
1237     if ( !conn )
1238     {
1239         wxLogError(wxT("Failed to connect to the DDE server '%s'."),
1240                    m_server.c_str());
1241     }
1242     else
1243     {
1244         if ( !conn->Request(m_cmdDde) )
1245         {
1246             wxLogError(wxT("Failed to  send request '%s' via DDE."),
1247                        m_cmdDde.c_str());
1248         }
1249         else
1250         {
1251             wxLogStatus(wxT("Successfully sent DDE request."));
1252         }
1253     }
1254 }
1255
1256 #endif // __WINDOWS__
1257
1258 // ----------------------------------------------------------------------------
1259 // various helpers
1260 // ----------------------------------------------------------------------------
1261
1262 // input polling
1263 void MyFrame::OnIdle(wxIdleEvent& event)
1264 {
1265     size_t count = m_running.GetCount();
1266     for ( size_t n = 0; n < count; n++ )
1267     {
1268         if ( m_running[n]->HasInput() )
1269         {
1270             event.RequestMore();
1271         }
1272     }
1273 }
1274
1275 void MyFrame::OnIdleTimer(wxTimerEvent& WXUNUSED(event))
1276 {
1277     wxWakeUpIdle();
1278 }
1279
1280 void MyFrame::OnBgTimer(wxTimerEvent& WXUNUSED(event))
1281 {
1282     static unsigned long s_ticks = 0;
1283     SetStatusText(wxString::Format("%lu ticks", s_ticks++), 1);
1284 }
1285
1286 void MyFrame::OnProcessTerminated(MyPipedProcess *process)
1287 {
1288     RemovePipedProcess(process);
1289 }
1290
1291 void MyFrame::OnAsyncTermination(MyProcess *process)
1292 {
1293     m_allAsync.Remove(process);
1294
1295     delete process;
1296 }
1297
1298 void MyFrame::AddPipedProcess(MyPipedProcess *process)
1299 {
1300     if ( m_running.IsEmpty() )
1301     {
1302         // we want to start getting the timer events to ensure that a
1303         // steady stream of idle events comes in -- otherwise we
1304         // wouldn't be able to poll the child process input
1305         m_timerIdleWakeUp.Start(100);
1306     }
1307     //else: the timer is already running
1308
1309     m_running.Add(process);
1310     m_allAsync.Add(process);
1311 }
1312
1313 void MyFrame::RemovePipedProcess(MyPipedProcess *process)
1314 {
1315     m_running.Remove(process);
1316
1317     if ( m_running.IsEmpty() )
1318     {
1319         // we don't need to get idle events all the time any more
1320         m_timerIdleWakeUp.Stop();
1321     }
1322 }
1323
1324 void MyFrame::ShowOutput(const wxString& cmd,
1325                          const wxArrayString& output,
1326                          const wxString& title)
1327 {
1328     size_t count = output.GetCount();
1329     if ( !count )
1330         return;
1331
1332     m_lbox->Append(wxString::Format(wxT("--- %s of '%s' ---"),
1333                                     title.c_str(), cmd.c_str()));
1334
1335     for ( size_t n = 0; n < count; n++ )
1336     {
1337         m_lbox->Append(output[n]);
1338     }
1339
1340     m_lbox->Append(wxString::Format(wxT("--- End of %s ---"),
1341                                     title.Lower().c_str()));
1342 }
1343
1344 // ----------------------------------------------------------------------------
1345 // MyProcess
1346 // ----------------------------------------------------------------------------
1347
1348 void MyProcess::OnTerminate(int pid, int status)
1349 {
1350     wxLogStatus(m_parent, wxT("Process %u ('%s') terminated with exit code %d."),
1351                 pid, m_cmd.c_str(), status);
1352
1353     m_parent->OnAsyncTermination(this);
1354 }
1355
1356 // ----------------------------------------------------------------------------
1357 // MyPipedProcess
1358 // ----------------------------------------------------------------------------
1359
1360 bool MyPipedProcess::HasInput()
1361 {
1362     bool hasInput = false;
1363
1364     if ( IsInputAvailable() )
1365     {
1366         wxTextInputStream tis(*GetInputStream());
1367
1368         // this assumes that the output is always line buffered
1369         wxString msg;
1370         msg << m_cmd << wxT(" (stdout): ") << tis.ReadLine();
1371
1372         m_parent->GetLogListBox()->Append(msg);
1373
1374         hasInput = true;
1375     }
1376
1377     if ( IsErrorAvailable() )
1378     {
1379         wxTextInputStream tis(*GetErrorStream());
1380
1381         // this assumes that the output is always line buffered
1382         wxString msg;
1383         msg << m_cmd << wxT(" (stderr): ") << tis.ReadLine();
1384
1385         m_parent->GetLogListBox()->Append(msg);
1386
1387         hasInput = true;
1388     }
1389
1390     return hasInput;
1391 }
1392
1393 void MyPipedProcess::OnTerminate(int pid, int status)
1394 {
1395     // show the rest of the output
1396     while ( HasInput() )
1397         ;
1398
1399     m_parent->OnProcessTerminated(this);
1400
1401     MyProcess::OnTerminate(pid, status);
1402 }
1403
1404 // ----------------------------------------------------------------------------
1405 // MyPipedProcess2
1406 // ----------------------------------------------------------------------------
1407
1408 bool MyPipedProcess2::HasInput()
1409 {
1410     if ( !m_input.empty() )
1411     {
1412         wxTextOutputStream os(*GetOutputStream());
1413         os.WriteString(m_input);
1414
1415         CloseOutput();
1416         m_input.clear();
1417
1418         // call us once again - may be we'll have output
1419         return true;
1420     }
1421
1422     return MyPipedProcess::HasInput();
1423 }
1424
1425 // ============================================================================
1426 // MyPipeFrame implementation
1427 // ============================================================================
1428
1429 MyPipeFrame::MyPipeFrame(wxFrame *parent,
1430                          const wxString& cmd,
1431                          wxProcess *process)
1432            : wxFrame(parent, wxID_ANY, cmd),
1433              m_process(process),
1434              // in a real program we'd check that the streams are !NULL here
1435              m_out(*process->GetOutputStream()),
1436              m_in(*process->GetInputStream()),
1437              m_err(*process->GetErrorStream())
1438 {
1439     m_process->SetNextHandler(this);
1440
1441     wxPanel *panel = new wxPanel(this, wxID_ANY);
1442
1443     m_textOut = new wxTextCtrl(panel, wxID_ANY, wxEmptyString,
1444                               wxDefaultPosition, wxDefaultSize,
1445                               wxTE_PROCESS_ENTER);
1446     m_textIn = new wxTextCtrl(panel, wxID_ANY, wxEmptyString,
1447                                wxDefaultPosition, wxDefaultSize,
1448                                wxTE_MULTILINE | wxTE_RICH);
1449     m_textIn->SetEditable(false);
1450     m_textErr = new wxTextCtrl(panel, wxID_ANY, wxEmptyString,
1451                                wxDefaultPosition, wxDefaultSize,
1452                                wxTE_MULTILINE | wxTE_RICH);
1453     m_textErr->SetEditable(false);
1454
1455     wxSizer *sizerTop = new wxBoxSizer(wxVERTICAL);
1456     sizerTop->Add(m_textOut, 0, wxGROW | wxALL, 5);
1457
1458     wxSizer *sizerBtns = new wxBoxSizer(wxHORIZONTAL);
1459     sizerBtns->
1460         Add(new wxButton(panel, Exec_Btn_Send, wxT("&Send")), 0, wxALL, 5);
1461     sizerBtns->
1462         Add(new wxButton(panel, Exec_Btn_SendFile, wxT("&File...")), 0, wxALL, 5);
1463     sizerBtns->
1464         Add(new wxButton(panel, Exec_Btn_Get, wxT("&Get")), 0, wxALL, 5);
1465     sizerBtns->
1466         Add(new wxButton(panel, Exec_Btn_Close, wxT("&Close")), 0, wxALL, 5);
1467
1468     sizerTop->Add(sizerBtns, 0, wxCENTRE | wxALL, 5);
1469     sizerTop->Add(m_textIn, 1, wxGROW | wxALL, 5);
1470     sizerTop->Add(m_textErr, 1, wxGROW | wxALL, 5);
1471
1472     panel->SetSizer(sizerTop);
1473     sizerTop->Fit(this);
1474
1475     Show();
1476 }
1477
1478 void MyPipeFrame::OnBtnSendFile(wxCommandEvent& WXUNUSED(event))
1479 {
1480 #if wxUSE_FILEDLG
1481     wxFileDialog filedlg(this, wxT("Select file to send"));
1482     if ( filedlg.ShowModal() != wxID_OK )
1483         return;
1484
1485     wxFFile file(filedlg.GetFilename(), wxT("r"));
1486     wxString data;
1487     if ( !file.IsOpened() || !file.ReadAll(&data) )
1488         return;
1489
1490     // can't write the entire string at once, this risk overflowing the pipe
1491     // and we would dead lock
1492     size_t len = data.length();
1493     const wxChar *pc = data.c_str();
1494     while ( len )
1495     {
1496         const size_t CHUNK_SIZE = 4096;
1497         m_out.Write(pc, len > CHUNK_SIZE ? CHUNK_SIZE : len);
1498
1499         // note that not all data could have been written as we don't block on
1500         // the write end of the pipe
1501         const size_t lenChunk = m_out.LastWrite();
1502
1503         pc += lenChunk;
1504         len -= lenChunk;
1505
1506         DoGet();
1507     }
1508 #endif // wxUSE_FILEDLG
1509 }
1510
1511 void MyPipeFrame::DoGet()
1512 {
1513     // we don't have any way to be notified when any input appears on the
1514     // stream so we have to poll it :-(
1515     DoGetFromStream(m_textIn, m_in);
1516     DoGetFromStream(m_textErr, m_err);
1517 }
1518
1519 void MyPipeFrame::DoGetFromStream(wxTextCtrl *text, wxInputStream& in)
1520 {
1521     while ( in.CanRead() )
1522     {
1523         char buffer[4096];
1524         buffer[in.Read(buffer, WXSIZEOF(buffer) - 1).LastRead()] = '\0';
1525
1526         text->AppendText(buffer);
1527     }
1528 }
1529
1530 void MyPipeFrame::DoClose()
1531 {
1532     m_process->CloseOutput();
1533
1534     DisableInput();
1535 }
1536
1537 void MyPipeFrame::DisableInput()
1538 {
1539     m_textOut->SetEditable(false);
1540     FindWindow(Exec_Btn_Send)->Disable();
1541     FindWindow(Exec_Btn_SendFile)->Disable();
1542     FindWindow(Exec_Btn_Close)->Disable();
1543 }
1544
1545 void MyPipeFrame::DisableOutput()
1546 {
1547     FindWindow(Exec_Btn_Get)->Disable();
1548 }
1549
1550 void MyPipeFrame::OnClose(wxCloseEvent& event)
1551 {
1552     if ( m_process )
1553     {
1554         // we're not interested in getting the process termination notification
1555         // if we are closing it ourselves
1556         wxProcess *process = m_process;
1557         m_process = NULL;
1558         process->SetNextHandler(NULL);
1559
1560         process->CloseOutput();
1561     }
1562
1563     event.Skip();
1564 }
1565
1566 void MyPipeFrame::OnProcessTerm(wxProcessEvent& WXUNUSED(event))
1567 {
1568     DoGet();
1569
1570     wxDELETE(m_process);
1571
1572     wxLogWarning(wxT("The other process has terminated, closing"));
1573
1574     DisableInput();
1575     DisableOutput();
1576 }