samples/exec/exec.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        exec.cpp
   3 // Purpose:     exec sample demonstrates wxExecute and related functions
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     15.01.00
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Vadim Zeitlin
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "exec.cpp"
  22     #pragma interface "exec.cpp"
  23 #endif
  24
  25 // For compilers that support precompilation, includes "wx/wx.h".
  26 #include "wx/wxprec.h"
  27
  28 #ifdef __BORLANDC__
  29     #pragma hdrstop
  30 #endif
  31
  32 // for all others, include the necessary headers (this file is usually all you
  33 // need because it includes almost all "standard" wxWindows headers
  34 #ifndef WX_PRECOMP
  35     #include "wx/app.h"
  36     #include "wx/frame.h"
  37     #include "wx/utils.h"
  38     #include "wx/menu.h"
  39     #include "wx/msgdlg.h"
  40     #include "wx/textdlg.h"
  41     #include "wx/listbox.h"
  42     #include "wx/filedlg.h"
  43     #include "wx/choicdlg.h"
  44 #endif
  45
  46 #include "wx/txtstrm.h"
  47
  48 #include "wx/process.h"
  49
  50 #include "wx/mimetype.h"
  51
  52 #ifdef __WINDOWS__
  53     #include "wx/dde.h"
  54 #endif // __WINDOWS__
  55
  56 // ----------------------------------------------------------------------------
  57 // private classes
  58 // ----------------------------------------------------------------------------
  59
  60 // Define a new application type, each program should derive a class from wxApp
  61 class MyApp : public wxApp
  62 {
  63 public:
  64     // override base class virtuals
  65     // ----------------------------
  66
  67     // this one is called on application startup and is a good place for the app
  68     // initialization (doing it here and not in the ctor allows to have an error
  69     // return: if OnInit() returns false, the application terminates)
  70     virtual bool OnInit();
  71 };
  72
  73 // Define an array of process pointers used by MyFrame
  74 class MyPipedProcess;
  75 WX_DEFINE_ARRAY(MyPipedProcess *, MyProcessesArray);
  76
  77 // Define a new frame type: this is going to be our main frame
  78 class MyFrame : public wxFrame
  79 {
  80 public:
  81     // ctor(s)
  82     MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size);
  83
  84     // event handlers (these functions should _not_ be virtual)
  85     void OnQuit(wxCommandEvent& event);
  86
  87     void OnKill(wxCommandEvent& event);
  88
  89     void OnClear(wxCommandEvent& event);
  90
  91     void OnSyncExec(wxCommandEvent& event);
  92     void OnAsyncExec(wxCommandEvent& event);
  93     void OnShell(wxCommandEvent& event);
  94     void OnExecWithRedirect(wxCommandEvent& event);
  95     void OnExecWithPipe(wxCommandEvent& event);
  96
  97     void OnFileExec(wxCommandEvent& event);
  98
  99     void OnAbout(wxCommandEvent& event);
 100
 101     // polling output of async processes
 102     void OnIdle(wxIdleEvent& event);
 103
 104     // for MyPipedProcess
 105     void OnProcessTerminated(MyPipedProcess *process);
 106     wxListBox *GetLogListBox() const { return m_lbox; }
 107
 108 private:
 109     void ShowOutput(const wxString& cmd,
 110                     const wxArrayString& output,
 111                     const wxString& title);
 112
 113     void DoAsyncExec(const wxString& cmd);
 114
 115     // the PID of the last process we launched asynchronously
 116     int m_pidLast;
 117
 118     // last command we executed
 119     wxString m_cmdLast;
 120
 121 #ifdef __WINDOWS__
 122     void OnDDEExec(wxCommandEvent& event);
 123     void OnDDERequest(wxCommandEvent& event);
 124
 125     bool GetDDEServer();
 126
 127     // last params of a DDE transaction
 128     wxString m_server,
 129              m_topic,
 130              m_cmdDde;
 131 #endif // __WINDOWS__
 132
 133     wxListBox *m_lbox;
 134
 135     MyProcessesArray m_running;
 136
 137     // any class wishing to process wxWindows events must use this macro
 138     DECLARE_EVENT_TABLE()
 139 };
 140
 141 // This is the handler for process termination events
 142 class MyProcess : public wxProcess
 143 {
 144 public:
 145     MyProcess(MyFrame *parent, const wxString& cmd)
 146         : wxProcess(parent), m_cmd(cmd)
 147     {
 148         m_parent = parent;
 149     }
 150
 151     // instead of overriding this virtual function we might as well process the
 152     // event from it in the frame class - this might be more convenient in some
 153     // cases
 154     virtual void OnTerminate(int pid, int status);
 155
 156 protected:
 157     MyFrame *m_parent;
 158     wxString m_cmd;
 159 };
 160
 161 // A specialization of MyProcess for redirecting the output
 162 class MyPipedProcess : public MyProcess
 163 {
 164 public:
 165     MyPipedProcess(MyFrame *parent, const wxString& cmd)
 166         : MyProcess(parent, cmd)
 167         {
 168             Redirect();
 169         }
 170
 171     virtual void OnTerminate(int pid, int status);
 172
 173     virtual bool HasInput();
 174 };
 175
 176 // A version of MyPipedProcess which also sends input to the stdin of the
 177 // child process
 178 class MyPipedProcess2 : public MyPipedProcess
 179 {
 180 public:
 181     MyPipedProcess2(MyFrame *parent, const wxString& cmd, const wxString& input)
 182         : MyPipedProcess(parent, cmd), m_input(input)
 183         {
 184         }
 185
 186     virtual bool HasInput();
 187
 188 private:
 189     wxString m_input;
 190 };
 191
 192 // ----------------------------------------------------------------------------
 193 // constants
 194 // ----------------------------------------------------------------------------
 195
 196 // IDs for the controls and the menu commands
 197 enum
 198 {
 199     // menu items
 200     Exec_Quit = 100,
 201     Exec_Kill,
 202     Exec_ClearLog,
 203     Exec_SyncExec = 200,
 204     Exec_AsyncExec,
 205     Exec_Shell,
 206     Exec_OpenFile,
 207     Exec_DDEExec,
 208     Exec_DDERequest,
 209     Exec_Redirect,
 210     Exec_Pipe,
 211     Exec_About = 300
 212 };
 213
 214 static const wxChar *DIALOG_TITLE = _T("Exec sample");
 215
 216 // ----------------------------------------------------------------------------
 217 // event tables and other macros for wxWindows
 218 // ----------------------------------------------------------------------------
 219
 220 // the event tables connect the wxWindows events with the functions (event
 221 // handlers) which process them. It can be also done at run-time, but for the
 222 // simple menu events like this the static method is much simpler.
 223 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 224     EVT_MENU(Exec_Quit,  MyFrame::OnQuit)
 225     EVT_MENU(Exec_Kill,  MyFrame::OnKill)
 226     EVT_MENU(Exec_ClearLog,  MyFrame::OnClear)
 227
 228     EVT_MENU(Exec_SyncExec, MyFrame::OnSyncExec)
 229     EVT_MENU(Exec_AsyncExec, MyFrame::OnAsyncExec)
 230     EVT_MENU(Exec_Shell, MyFrame::OnShell)
 231     EVT_MENU(Exec_Redirect, MyFrame::OnExecWithRedirect)
 232     EVT_MENU(Exec_Pipe, MyFrame::OnExecWithPipe)
 233
 234     EVT_MENU(Exec_OpenFile, MyFrame::OnFileExec)
 235
 236 #ifdef __WINDOWS__
 237     EVT_MENU(Exec_DDEExec, MyFrame::OnDDEExec)
 238     EVT_MENU(Exec_DDERequest, MyFrame::OnDDERequest)
 239 #endif // __WINDOWS__
 240
 241     EVT_MENU(Exec_About, MyFrame::OnAbout)
 242
 243     EVT_IDLE(MyFrame::OnIdle)
 244 END_EVENT_TABLE()
 245
 246 // Create a new application object: this macro will allow wxWindows to create
 247 // the application object during program execution (it's better than using a
 248 // static object for many reasons) and also declares the accessor function
 249 // wxGetApp() which will return the reference of the right type (i.e. MyApp and
 250 // not wxApp)
 251 IMPLEMENT_APP(MyApp)
 252
 253 // ============================================================================
 254 // implementation
 255 // ============================================================================
 256
 257 // ----------------------------------------------------------------------------
 258 // the application class
 259 // ----------------------------------------------------------------------------
 260
 261 // `Main program' equivalent: the program execution "starts" here
 262 bool MyApp::OnInit()
 263 {
 264     // Create the main application window
 265     MyFrame *frame = new MyFrame(_T("Exec wxWindows sample"),
 266                                  wxDefaultPosition, wxSize(500, 140));
 267
 268     // Show it and tell the application that it's our main window
 269     frame->Show(TRUE);
 270     SetTopWindow(frame);
 271
 272     // success: wxApp::OnRun() will be called which will enter the main message
 273     // loop and the application will run. If we returned FALSE here, the
 274     // application would exit immediately.
 275     return TRUE;
 276 }
 277
 278 // ----------------------------------------------------------------------------
 279 // main frame
 280 // ----------------------------------------------------------------------------
 281
 282 // frame constructor
 283 MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
 284        : wxFrame((wxFrame *)NULL, -1, title, pos, size)
 285 {
 286     m_pidLast = 0;
 287
 288 #ifdef __WXMAC__
 289     // we need this in order to allow the about menu relocation, since ABOUT is
 290     // not the default id of the about menu
 291     wxApp::s_macAboutMenuItemId = Exec_About;
 292 #endif
 293
 294     // create a menu bar
 295     wxMenu *menuFile = new wxMenu(_T(""), wxMENU_TEAROFF);
 296     menuFile->Append(Exec_Kill, _T("&Kill process...\tCtrl-K"),
 297                      _T("Kill a process by PID"));
 298     menuFile->AppendSeparator();
 299     menuFile->Append(Exec_ClearLog, _T("&Clear log\tCtrl-C"),
 300                      _T("Clear the log window"));
 301     menuFile->AppendSeparator();
 302     menuFile->Append(Exec_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));
 303
 304     wxMenu *execMenu = new wxMenu;
 305     execMenu->Append(Exec_SyncExec, _T("Sync &execution...\tCtrl-E"),
 306                      _T("Launch a program and return when it terminates"));
 307     execMenu->Append(Exec_AsyncExec, _T("&Async execution...\tCtrl-A"),
 308                      _T("Launch a program and return immediately"));
 309     execMenu->Append(Exec_Shell, _T("Execute &shell command...\tCtrl-S"),
 310                      _T("Launch a shell and execute a command in it"));
 311     execMenu->AppendSeparator();
 312     execMenu->Append(Exec_Redirect, _T("Capture command &output...\tCtrl-O"),
 313                      _T("Launch a program and capture its output"));
 314     execMenu->Append(Exec_Pipe, _T("&Pipe through command...\tCtrl-P"),
 315                      _T("Pipe a string through a filter"));
 316
 317     execMenu->AppendSeparator();
 318     execMenu->Append(Exec_OpenFile, _T("Open &file...\tCtrl-F"),
 319                      _T("Launch the command to open this kind of files"));
 320 #ifdef __WINDOWS__
 321     execMenu->AppendSeparator();
 322     execMenu->Append(Exec_DDEExec, _T("Execute command via &DDE...\tCtrl-D"));
 323     execMenu->Append(Exec_DDERequest, _T("Send DDE &request...\tCtrl-R"));
 324 #endif
 325
 326     wxMenu *helpMenu = new wxMenu(_T(""), wxMENU_TEAROFF);
 327     helpMenu->Append(Exec_About, _T("&About...\tF1"), _T("Show about dialog"));
 328
 329     // now append the freshly created menu to the menu bar...
 330     wxMenuBar *menuBar = new wxMenuBar();
 331     menuBar->Append(menuFile, _T("&File"));
 332     menuBar->Append(execMenu, _T("&Exec"));
 333     menuBar->Append(helpMenu, _T("&Help"));
 334
 335     // ... and attach this menu bar to the frame
 336     SetMenuBar(menuBar);
 337
 338     // create the listbox in which we will show misc messages as they come
 339     m_lbox = new wxListBox(this, -1);
 340     wxFont font(12, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL,
 341                 wxFONTWEIGHT_NORMAL);
 342     if ( font.Ok() )
 343         m_lbox->SetFont(font);
 344
 345 #if wxUSE_STATUSBAR
 346     // create a status bar just for fun (by default with 1 pane only)
 347     CreateStatusBar();
 348     SetStatusText(_T("Welcome to wxWindows exec sample!"));
 349 #endif // wxUSE_STATUSBAR
 350 }
 351
 352 // ----------------------------------------------------------------------------
 353 // event handlers: file and help menu
 354 // ----------------------------------------------------------------------------
 355
 356 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 357 {
 358     // TRUE is to force the frame to close
 359     Close(TRUE);
 360 }
 361
 362 void MyFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 363 {
 364     m_lbox->Clear();
 365 }
 366
 367 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 368 {
 369     wxMessageBox(_T("Exec wxWindows Sample\n© 2000-2001 Vadim Zeitlin"),
 370                  _T("About Exec"), wxOK | wxICON_INFORMATION, this);
 371 }
 372
 373 void MyFrame::OnKill(wxCommandEvent& WXUNUSED(event))
 374 {
 375     long pid = wxGetNumberFromUser(_T("Please specify the process to kill"),
 376                                    _T("Enter PID:"),
 377                                    _T("Exec question"),
 378                                    m_pidLast,
 379                                    1, INT_MAX,
 380                                    this);
 381     if ( pid == -1 )
 382     {
 383         // cancelled
 384         return;
 385     }
 386
 387     static const wxString signalNames[] =
 388     {
 389         _T("Just test (SIGNONE)"),
 390         _T("Hangup (SIGHUP)"),
 391         _T("Interrupt (SIGINT)"),
 392         _T("Quit (SIGQUIT)"),
 393         _T("Illegal instruction (SIGILL)"),
 394         _T("Trap (SIGTRAP)"),
 395         _T("Abort (SIGABRT)"),
 396         _T("Emulated trap (SIGEMT)"),
 397         _T("FP exception (SIGFPE)"),
 398         _T("Kill (SIGKILL)"),
 399         _T("Bus (SIGBUS)"),
 400         _T("Segment violation (SIGSEGV)"),
 401         _T("System (SIGSYS)"),
 402         _T("Broken pipe (SIGPIPE)"),
 403         _T("Alarm (SIGALRM)"),
 404         _T("Terminate (SIGTERM)"),
 405     };
 406
 407     int sig = wxGetSingleChoiceIndex(_T("How to kill the process?"),
 408                                      _T("Exec question"),
 409                                      WXSIZEOF(signalNames), signalNames,
 410                                      this);
 411     switch ( sig )
 412     {
 413         default:
 414             wxFAIL_MSG( _T("unexpected return value") );
 415             // fall through
 416
 417         case -1:
 418             // cancelled
 419             return;
 420
 421         case wxSIGNONE:
 422         case wxSIGHUP:
 423         case wxSIGINT:
 424         case wxSIGQUIT:
 425         case wxSIGILL:
 426         case wxSIGTRAP:
 427         case wxSIGABRT:
 428         case wxSIGEMT:
 429         case wxSIGFPE:
 430         case wxSIGKILL:
 431         case wxSIGBUS:
 432         case wxSIGSEGV:
 433         case wxSIGSYS:
 434         case wxSIGPIPE:
 435         case wxSIGALRM:
 436         case wxSIGTERM:
 437             break;
 438     }
 439
 440     if ( sig == 0 )
 441     {
 442         if ( wxProcess::Exists(pid) )
 443             wxLogStatus(_T("Process %d is running."), pid);
 444         else
 445             wxLogStatus(_T("No process with pid = %d."), pid);
 446     }
 447     else // not SIGNONE
 448     {
 449         wxKillError rc = wxProcess::Kill(pid, (wxSignal)sig);
 450         if ( rc == wxKILL_OK )
 451         {
 452             wxLogStatus(_T("Process %d killed with signal %d."), pid, sig);
 453         }
 454         else
 455         {
 456             static const wxChar *errorText[] =
 457             {
 458                 _T(""), // no error
 459                 _T("signal not supported"),
 460                 _T("permission denied"),
 461                 _T("no such process"),
 462                 _T("unspecified error"),
 463             };
 464
 465             wxLogStatus(_T("Failed to kill process %d with signal %d: %s"),
 466                         pid, sig, errorText[rc]);
 467         }
 468     }
 469 }
 470
 471 // ----------------------------------------------------------------------------
 472 // event handlers: exec menu
 473 // ----------------------------------------------------------------------------
 474
 475 void MyFrame::DoAsyncExec(const wxString& cmd)
 476 {
 477     wxProcess *process = new MyProcess(this, cmd);
 478     m_pidLast = wxExecute(cmd, FALSE /* async */, process);
 479     if ( !m_pidLast )
 480     {
 481         wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
 482
 483         delete process;
 484     }
 485     else
 486     {
 487         wxLogStatus(_T("Process %ld (%s) launched."), m_pidLast, cmd.c_str());
 488
 489         m_cmdLast = cmd;
 490     }
 491 }
 492
 493 void MyFrame::OnSyncExec(wxCommandEvent& WXUNUSED(event))
 494 {
 495     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 496                                      DIALOG_TITLE,
 497                                      m_cmdLast);
 498
 499     if ( !cmd )
 500         return;
 501
 502     wxLogStatus(_T("'%s' is running please wait..."), cmd.c_str());
 503
 504     int code = wxExecute(cmd, TRUE /* sync */);
 505
 506     wxLogStatus(_T("Process '%s' terminated with exit code %d."),
 507                 cmd.c_str(), code);
 508     m_cmdLast = cmd;
 509 }
 510
 511 void MyFrame::OnAsyncExec(wxCommandEvent& WXUNUSED(event))
 512 {
 513     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 514                                      DIALOG_TITLE,
 515                                      m_cmdLast);
 516
 517     if ( !cmd )
 518         return;
 519
 520     DoAsyncExec(cmd);
 521 }
 522
 523 void MyFrame::OnShell(wxCommandEvent& WXUNUSED(event))
 524 {
 525     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 526                                      DIALOG_TITLE,
 527                                      m_cmdLast);
 528
 529     if ( !cmd )
 530         return;
 531
 532     int code = wxShell(cmd);
 533     wxLogStatus(_T("Shell command '%s' terminated with exit code %d."),
 534                 cmd.c_str(), code);
 535     m_cmdLast = cmd;
 536 }
 537
 538 void MyFrame::OnExecWithRedirect(wxCommandEvent& WXUNUSED(event))
 539 {
 540     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 541                                      DIALOG_TITLE,
 542                                      m_cmdLast);
 543
 544     if ( !cmd )
 545         return;
 546
 547     bool sync;
 548     switch ( wxMessageBox(_T("Execute it synchronously?"),
 549                           _T("Exec question"),
 550                           wxYES_NO | wxCANCEL | wxICON_QUESTION, this) )
 551     {
 552         case wxYES:
 553             sync = TRUE;
 554             break;
 555
 556         case wxNO:
 557             sync = FALSE;
 558             break;
 559
 560         default:
 561             return;
 562     }
 563
 564     if ( sync )
 565     {
 566         wxArrayString output, errors;
 567         int code = wxExecute(cmd, output, errors);
 568         wxLogStatus(_T("command '%s' terminated with exit code %d."),
 569                     cmd.c_str(), code);
 570
 571         if ( code != -1 )
 572         {
 573             ShowOutput(cmd, output, _T("Output"));
 574             ShowOutput(cmd, errors, _T("Errors"));
 575         }
 576     }
 577     else // async exec
 578     {
 579         MyPipedProcess *process = new MyPipedProcess(this, cmd);
 580         if ( !wxExecute(cmd, FALSE /* async */, process) )
 581         {
 582             wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
 583
 584             delete process;
 585         }
 586         else
 587         {
 588             m_running.Add(process);
 589         }
 590     }
 591
 592     m_cmdLast = cmd;
 593 }
 594
 595 void MyFrame::OnExecWithPipe(wxCommandEvent& WXUNUSED(event))
 596 {
 597     if ( !m_cmdLast )
 598         m_cmdLast = _T("tr [a-z] [A-Z]");
 599
 600     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 601                                      DIALOG_TITLE,
 602                                      m_cmdLast);
 603
 604     if ( !cmd )
 605         return;
 606
 607     wxString input = wxGetTextFromUser(_T("Enter the string to send to it: "),
 608                                        DIALOG_TITLE);
 609     if ( !input )
 610         return;
 611
 612     // always execute the filter asynchronously
 613     MyPipedProcess2 *process = new MyPipedProcess2(this, cmd, input);
 614     int pid = wxExecute(cmd, FALSE /* async */, process);
 615     if ( pid )
 616     {
 617         wxLogStatus(_T("Process %ld (%s) launched."), pid, cmd.c_str());
 618
 619         m_running.Add(process);
 620     }
 621     else
 622     {
 623         wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
 624
 625         delete process;
 626     }
 627
 628     m_cmdLast = cmd;
 629 }
 630
 631 void MyFrame::OnFileExec(wxCommandEvent& event)
 632 {
 633     static wxString s_filename;
 634
 635     wxString filename = wxLoadFileSelector(_T("file"), _T(""), s_filename);
 636     if ( !filename )
 637         return;
 638
 639     s_filename = filename;
 640
 641     wxString ext = filename.AfterFirst(_T('.'));
 642     wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
 643     if ( !ft )
 644     {
 645         wxLogError(_T("Impossible to determine the file type for extension '%s'"),
 646                    ext.c_str());
 647         return;
 648     }
 649
 650     wxString cmd;
 651     bool ok = ft->GetOpenCommand(&cmd,
 652                                  wxFileType::MessageParameters(filename, _T("")));
 653     delete ft;
 654     if ( !ok )
 655     {
 656         wxLogError(_T("Impossible to find out how to open files of extension '%s'"),
 657                    ext.c_str());
 658         return;
 659     }
 660
 661     DoAsyncExec(cmd);
 662 }
 663
 664 // ----------------------------------------------------------------------------
 665 // DDE stuff
 666 // ----------------------------------------------------------------------------
 667
 668 #ifdef __WINDOWS__
 669
 670 bool MyFrame::GetDDEServer()
 671 {
 672     wxString server = wxGetTextFromUser(_T("Server to connect to:"),
 673                                         DIALOG_TITLE, m_server);
 674     if ( !server )
 675         return FALSE;
 676
 677     m_server = server;
 678
 679     wxString topic = wxGetTextFromUser(_T("DDE topic:"), DIALOG_TITLE, m_topic);
 680     if ( !topic )
 681         return FALSE;
 682
 683     m_topic = topic;
 684
 685     wxString cmd = wxGetTextFromUser(_T("DDE command:"), DIALOG_TITLE, m_cmdDde);
 686     if ( !cmd )
 687         return FALSE;
 688
 689     m_cmdDde = cmd;
 690
 691     return TRUE;
 692 }
 693
 694 void MyFrame::OnDDEExec(wxCommandEvent& WXUNUSED(event))
 695 {
 696     if ( !GetDDEServer() )
 697         return;
 698
 699     wxDDEClient client;
 700     wxConnectionBase *conn = client.MakeConnection("", m_server, m_topic);
 701     if ( !conn )
 702     {
 703         wxLogError(_T("Failed to connect to the DDE server '%s'."),
 704                    m_server.c_str());
 705     }
 706     else
 707     {
 708         if ( !conn->Execute(m_cmdDde) )
 709         {
 710             wxLogError(_T("Failed to execute command '%s' via DDE."),
 711                        m_cmdDde.c_str());
 712         }
 713         else
 714         {
 715             wxLogStatus(_T("Successfully executed DDE command"));
 716         }
 717     }
 718 }
 719
 720 void MyFrame::OnDDERequest(wxCommandEvent& WXUNUSED(event))
 721 {
 722     if ( !GetDDEServer() )
 723         return;
 724
 725     wxDDEClient client;
 726     wxConnectionBase *conn = client.MakeConnection("", m_server, m_topic);
 727     if ( !conn )
 728     {
 729         wxLogError(_T("Failed to connect to the DDE server '%s'."),
 730                    m_server.c_str());
 731     }
 732     else
 733     {
 734         if ( !conn->Request(m_cmdDde) )
 735         {
 736             wxLogError(_T("Failed to  send request '%s' via DDE."),
 737                        m_cmdDde.c_str());
 738         }
 739         else
 740         {
 741             wxLogStatus(_T("Successfully sent DDE request."));
 742         }
 743     }
 744 }
 745
 746 #endif // __WINDOWS__
 747
 748 // ----------------------------------------------------------------------------
 749 // various helpers
 750 // ----------------------------------------------------------------------------
 751
 752 // input polling
 753 void MyFrame::OnIdle(wxIdleEvent& event)
 754 {
 755     size_t count = m_running.GetCount();
 756     for ( size_t n = 0; n < count; n++ )
 757     {
 758         if ( m_running[n]->HasInput() )
 759         {
 760             event.RequestMore();
 761         }
 762     }
 763 }
 764
 765 void MyFrame::OnProcessTerminated(MyPipedProcess *process)
 766 {
 767     m_running.Remove(process);
 768 }
 769
 770
 771 void MyFrame::ShowOutput(const wxString& cmd,
 772                          const wxArrayString& output,
 773                          const wxString& title)
 774 {
 775     size_t count = output.GetCount();
 776     if ( !count )
 777         return;
 778
 779     m_lbox->Append(wxString::Format(_T("--- %s of '%s' ---"),
 780                                     title.c_str(), cmd.c_str()));
 781
 782     for ( size_t n = 0; n < count; n++ )
 783     {
 784         m_lbox->Append(output[n]);
 785     }
 786
 787     m_lbox->Append(_T("--- End of output ---"));
 788 }
 789
 790 // ----------------------------------------------------------------------------
 791 // MyProcess
 792 // ----------------------------------------------------------------------------
 793
 794 void MyProcess::OnTerminate(int pid, int status)
 795 {
 796     wxLogStatus(m_parent, _T("Process %u ('%s') terminated with exit code %d."),
 797                 pid, m_cmd.c_str(), status);
 798
 799     // we're not needed any more
 800     delete this;
 801 }
 802
 803 // ----------------------------------------------------------------------------
 804 // MyPipedProcess
 805 // ----------------------------------------------------------------------------
 806
 807 bool MyPipedProcess::HasInput()
 808 {
 809     bool hasInput = FALSE;
 810
 811     wxInputStream& is = *GetInputStream();
 812     if ( !is.Eof() )
 813     {
 814         wxTextInputStream tis(is);
 815
 816         // this assumes that the output is always line buffered
 817         wxString msg;
 818         msg << m_cmd << _T(" (stdout): ") << tis.ReadLine();
 819
 820         m_parent->GetLogListBox()->Append(msg);
 821
 822         hasInput = TRUE;
 823     }
 824
 825     wxInputStream& es = *GetErrorStream();
 826     if ( !es.Eof() )
 827     {
 828         wxTextInputStream tis(es);
 829
 830         // this assumes that the output is always line buffered
 831         wxString msg;
 832         msg << m_cmd << _T(" (stderr): ") << tis.ReadLine();
 833
 834         m_parent->GetLogListBox()->Append(msg);
 835
 836         hasInput = TRUE;
 837     }
 838
 839     return hasInput;
 840 }
 841
 842 void MyPipedProcess::OnTerminate(int pid, int status)
 843 {
 844     // show the rest of the output
 845     while ( HasInput() )
 846         ;
 847
 848     m_parent->OnProcessTerminated(this);
 849
 850     MyProcess::OnTerminate(pid, status);
 851 }
 852
 853 // ----------------------------------------------------------------------------
 854 // MyPipedProcess2
 855 // ----------------------------------------------------------------------------
 856
 857 bool MyPipedProcess2::HasInput()
 858 {
 859     if ( !!m_input )
 860     {
 861         wxTextOutputStream os(*GetOutputStream());
 862         os.WriteString(m_input);
 863
 864         CloseOutput();
 865         m_input.clear();
 866
 867         // call us once again - may be we'll have output
 868         return TRUE;
 869     }
 870
 871     return MyPipedProcess::HasInput();
 872 }