applied patch 430452 (mingw32 compilation fixes)

[wxWidgets.git] / samples / exec / exec.cpp

diff --git a/samples/exec/exec.cpp b/samples/exec/exec.cpp
index 0bc3b509aee8a95e9a3bbd68d9b8c8e980892669..80f4f4335d938ced49c1bab13b28763a98cc3845 100644 (file)
--- a/samples/exec/exec.cpp
+++ b/samples/exec/exec.cpp
@@ -39,12 +39,15 @@
     #include "wx/msgdlg.h"
     #include "wx/textdlg.h"
     #include "wx/listbox.h"
     #include "wx/msgdlg.h"
     #include "wx/textdlg.h"
     #include "wx/listbox.h"

+    #include "wx/filedlg.h"

 #endif
 
 #include "wx/txtstrm.h"
 
 #include "wx/process.h"
 
 #endif
 
 #include "wx/txtstrm.h"
 
 #include "wx/process.h"
 

+#include "wx/mimetype.h"
+

 #ifdef __WINDOWS__
     #include "wx/dde.h"
 #endif // __WINDOWS__
 #ifdef __WINDOWS__
     #include "wx/dde.h"
 #endif // __WINDOWS__


@@ -86,7 +89,9 @@ public:
     void OnAsyncExec(wxCommandEvent& event);
     void OnShell(wxCommandEvent& event);
     void OnExecWithRedirect(wxCommandEvent& event);
     void OnAsyncExec(wxCommandEvent& event);
     void OnShell(wxCommandEvent& event);
     void OnExecWithRedirect(wxCommandEvent& event);

-    void OnDDEExec(wxCommandEvent& event);
+    void OnExecWithPipe(wxCommandEvent& event);
+
+    void OnFileExec(wxCommandEvent& event);

 
     void OnAbout(wxCommandEvent& event);
 
 
     void OnAbout(wxCommandEvent& event);
 


@@ -94,13 +99,31 @@ public:
     void OnIdle(wxIdleEvent& event);
 
     // for MyPipedProcess
     void OnIdle(wxIdleEvent& event);
 
     // for MyPipedProcess

-    void OnProcessTerminated(MyPipedProcess *process)
-        { m_running.Remove(process); }
+    void OnProcessTerminated(MyPipedProcess *process);

     wxListBox *GetLogListBox() const { return m_lbox; }
 
 private:
     wxListBox *GetLogListBox() const { return m_lbox; }
 
 private:

+    void ShowOutput(const wxString& cmd,
+                    const wxArrayString& output,
+                    const wxString& title);
+
+    void DoAsyncExec(const wxString& cmd);
+
+    // last command we executed

     wxString m_cmdLast;
 
     wxString m_cmdLast;
 

+#ifdef __WINDOWS__
+    void OnDDEExec(wxCommandEvent& event);
+    void OnDDERequest(wxCommandEvent& event);
+
+    bool GetDDEServer();
+
+    // last params of a DDE transaction
+    wxString m_server,
+             m_topic,
+             m_cmdDde;
+#endif // __WINDOWS__
+

     wxListBox *m_lbox;
 
     MyProcessesArray m_running;
     wxListBox *m_lbox;
 
     MyProcessesArray m_running;


@@ -141,7 +164,23 @@ public:
 
     virtual void OnTerminate(int pid, int status);
 
 
     virtual void OnTerminate(int pid, int status);
 

-    bool HasInput();
+    virtual bool HasInput();
+};
+
+// A version of MyPipedProcess which also sends input to the stdin of the
+// child process
+class MyPipedProcess2 : public MyPipedProcess
+{
+public:
+    MyPipedProcess2(MyFrame *parent, const wxString& cmd, const wxString& input)
+        : MyPipedProcess(parent, cmd), m_input(input)
+        {
+        }
+
+    virtual bool HasInput();
+
+private:
+    wxString m_input;

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -157,8 +196,11 @@ enum
     Exec_SyncExec = 200,
     Exec_AsyncExec,
     Exec_Shell,
     Exec_SyncExec = 200,
     Exec_AsyncExec,
     Exec_Shell,

+    Exec_OpenFile,

     Exec_DDEExec,
     Exec_DDEExec,

+    Exec_DDERequest,

     Exec_Redirect,
     Exec_Redirect,

+    Exec_Pipe,

     Exec_About = 300
 };
 
     Exec_About = 300
 };
 


@@ -179,7 +221,12 @@ BEGIN_EVENT_TABLE(MyFrame, wxFrame)
     EVT_MENU(Exec_AsyncExec, MyFrame::OnAsyncExec)
     EVT_MENU(Exec_Shell, MyFrame::OnShell)
     EVT_MENU(Exec_Redirect, MyFrame::OnExecWithRedirect)
     EVT_MENU(Exec_AsyncExec, MyFrame::OnAsyncExec)
     EVT_MENU(Exec_Shell, MyFrame::OnShell)
     EVT_MENU(Exec_Redirect, MyFrame::OnExecWithRedirect)

+    EVT_MENU(Exec_Pipe, MyFrame::OnExecWithPipe)
+
+    EVT_MENU(Exec_OpenFile, MyFrame::OnFileExec)
+

     EVT_MENU(Exec_DDEExec, MyFrame::OnDDEExec)
     EVT_MENU(Exec_DDEExec, MyFrame::OnDDEExec)

+    EVT_MENU(Exec_DDERequest, MyFrame::OnDDERequest)

 
     EVT_MENU(Exec_About, MyFrame::OnAbout)
 
 
     EVT_MENU(Exec_About, MyFrame::OnAbout)
 


@@ -232,11 +279,6 @@ MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
     wxApp::s_macAboutMenuItemId = Exec_About;
 #endif
 
     wxApp::s_macAboutMenuItemId = Exec_About;
 #endif
 

-    // set the frame icon
-#ifndef __WXGTK__
-    SetIcon(wxICON(mondrian));
-#endif
-

     // create a menu bar
     wxMenu *menuFile = new wxMenu(_T(""), wxMENU_TEAROFF);
     menuFile->Append(Exec_ClearLog, _T("&Clear log\tCtrl-C"),
     // create a menu bar
     wxMenu *menuFile = new wxMenu(_T(""), wxMENU_TEAROFF);
     menuFile->Append(Exec_ClearLog, _T("&Clear log\tCtrl-C"),


@@ -251,12 +293,19 @@ MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
                      _T("Launch a program and return immediately"));
     execMenu->Append(Exec_Shell, _T("Execute &shell command...\tCtrl-S"),
                      _T("Launch a shell and execute a command in it"));
                      _T("Launch a program and return immediately"));
     execMenu->Append(Exec_Shell, _T("Execute &shell command...\tCtrl-S"),
                      _T("Launch a shell and execute a command in it"));

+    execMenu->AppendSeparator();

     execMenu->Append(Exec_Redirect, _T("Capture command &output...\tCtrl-O"),
                      _T("Launch a program and capture its output"));
     execMenu->Append(Exec_Redirect, _T("Capture command &output...\tCtrl-O"),
                      _T("Launch a program and capture its output"));

+    execMenu->Append(Exec_Pipe, _T("&Pipe through command...\tCtrl-P"),
+                     _T("Pipe a string through a filter"));

 
 

+    execMenu->AppendSeparator();
+    execMenu->Append(Exec_OpenFile, _T("Open &file...\tCtrl-F"),
+                     _T("Launch the command to open this kind of files"));

 #ifdef __WINDOWS__
     execMenu->AppendSeparator();
     execMenu->Append(Exec_DDEExec, _T("Execute command via &DDE...\tCtrl-D"));
 #ifdef __WINDOWS__
     execMenu->AppendSeparator();
     execMenu->Append(Exec_DDEExec, _T("Execute command via &DDE...\tCtrl-D"));

+    execMenu->Append(Exec_DDERequest, _T("Send DDE &request...\tCtrl-R"));

 #endif
 
     wxMenu *helpMenu = new wxMenu(_T(""), wxMENU_TEAROFF);
 #endif
 
     wxMenu *helpMenu = new wxMenu(_T(""), wxMENU_TEAROFF);


@@ -273,6 +322,10 @@ MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
 
     // create the listbox in which we will show misc messages as they come
     m_lbox = new wxListBox(this, -1);
 
     // create the listbox in which we will show misc messages as they come
     m_lbox = new wxListBox(this, -1);

+    wxFont font(12, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL,
+                wxFONTWEIGHT_NORMAL);
+    if ( font.Ok() )
+        m_lbox->SetFont(font);

 
 #if wxUSE_STATUSBAR
     // create a status bar just for fun (by default with 1 pane only)
 
 #if wxUSE_STATUSBAR
     // create a status bar just for fun (by default with 1 pane only)


@@ -301,6 +354,24 @@ void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
                  _T("About Exec"), wxOK | wxICON_INFORMATION, this);
 }
 
                  _T("About Exec"), wxOK | wxICON_INFORMATION, this);
 }
 

+void MyFrame::DoAsyncExec(const wxString& cmd)
+{
+    wxProcess *process = new MyProcess(this, cmd);
+    long pid = wxExecute(cmd, FALSE /* async */, process);
+    if ( !pid )
+    {
+        wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
+
+        delete process;
+    }
+    else
+    {
+        wxLogStatus(_T("Process %ld (%s) launched."), pid, cmd.c_str());
+
+        m_cmdLast = cmd;
+    }
+}
+

 void MyFrame::OnSyncExec(wxCommandEvent& WXUNUSED(event))
 {
     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
 void MyFrame::OnSyncExec(wxCommandEvent& WXUNUSED(event))
 {
     wxString cmd = wxGetTextFromUser(_T("Enter the command: "),


@@ -310,7 +381,10 @@ void MyFrame::OnSyncExec(wxCommandEvent& WXUNUSED(event))
     if ( !cmd )
         return;
 
     if ( !cmd )
         return;
 

+    wxLogStatus(_T("'%s' is running please wait..."), cmd.c_str());
+

     int code = wxExecute(cmd, TRUE /* sync */);
     int code = wxExecute(cmd, TRUE /* sync */);

+

     wxLogStatus(_T("Process '%s' terminated with exit code %d."),
                 cmd.c_str(), code);
     m_cmdLast = cmd;
     wxLogStatus(_T("Process '%s' terminated with exit code %d."),
                 cmd.c_str(), code);
     m_cmdLast = cmd;


@@ -325,17 +399,7 @@ void MyFrame::OnAsyncExec(wxCommandEvent& WXUNUSED(event))
     if ( !cmd )
         return;
 
     if ( !cmd )
         return;
 

-    wxProcess *process = new MyProcess(this, cmd);
-    if ( !wxExecute(cmd, FALSE /* async */, process) )
-    {
-        wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
-
-        delete process;
-    }
-    else
-    {
-        m_cmdLast = cmd;
-    }
+    DoAsyncExec(cmd);

 }
 
 void MyFrame::OnShell(wxCommandEvent& WXUNUSED(event))
 }
 
 void MyFrame::OnShell(wxCommandEvent& WXUNUSED(event))


@@ -381,21 +445,15 @@ void MyFrame::OnExecWithRedirect(wxCommandEvent& WXUNUSED(event))
 
     if ( sync )
     {
 
     if ( sync )
     {

-        wxArrayString output;
-        int code = wxExecute(cmd, output);
+        wxArrayString output, errors;
+        int code = wxExecute(cmd, output, errors);

         wxLogStatus(_T("command '%s' terminated with exit code %d."),
                     cmd.c_str(), code);
 
         if ( code != -1 )
         {
         wxLogStatus(_T("command '%s' terminated with exit code %d."),
                     cmd.c_str(), code);
 
         if ( code != -1 )
         {

-            m_lbox->Append(wxString::Format(_T("--- Output of '%s' ---"),
-                                            cmd.c_str()));
-
-            size_t count = output.GetCount();
-            for ( size_t n = 0; n < count; n++ )
-            {
-                m_lbox->Append(output[n]);
-            }
+            ShowOutput(cmd, output, _T("Output"));
+            ShowOutput(cmd, errors, _T("Errors"));

         }
     }
     else // async exec
         }
     }
     else // async exec


@@ -416,48 +474,155 @@ void MyFrame::OnExecWithRedirect(wxCommandEvent& WXUNUSED(event))
     m_cmdLast = cmd;
 }
 
     m_cmdLast = cmd;
 }
 

-void MyFrame::OnDDEExec(wxCommandEvent& WXUNUSED(event))
+void MyFrame::OnExecWithPipe(wxCommandEvent& WXUNUSED(event))
+{
+    if ( !m_cmdLast )
+        m_cmdLast = _T("tr [a-z] [A-Z]");
+
+    wxString cmd = wxGetTextFromUser(_T("Enter the command: "),
+                                     DIALOG_TITLE,
+                                     m_cmdLast);
+
+    if ( !cmd )
+        return;
+
+    wxString input = wxGetTextFromUser(_T("Enter the string to send to it: "),
+                                       DIALOG_TITLE);
+    if ( !input )
+        return;
+
+    // always execute the filter asynchronously
+    MyPipedProcess2 *process = new MyPipedProcess2(this, cmd, input);
+    int pid = wxExecute(cmd, FALSE /* async */, process);
+    if ( pid )
+    {
+        wxLogStatus(_T("Process %ld (%s) launched."), pid, cmd.c_str());
+
+        m_running.Add(process);
+    }
+    else
+    {
+        wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
+
+        delete process;
+    }
+
+    m_cmdLast = cmd;
+}
+
+void MyFrame::OnFileExec(wxCommandEvent& event)

 {
 {

+    static wxString s_filename;
+
+    wxString filename = wxLoadFileSelector(_T("file"), _T(""), s_filename);
+    if ( !filename )
+        return;
+
+    s_filename = filename;
+
+    wxString ext = filename.AfterFirst(_T('.'));
+    wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
+    if ( !ft )
+    {
+        wxLogError(_T("Impossible to determine the file type for extension '%s'"),
+                   ext.c_str());
+        return;
+    }
+
+    wxString cmd;
+    bool ok = ft->GetOpenCommand(&cmd,
+                                 wxFileType::MessageParameters(filename, _T("")));
+    delete ft;
+    if ( !ok )
+    {
+        wxLogError(_T("Impossible to find out how to open files of extension '%s'"),
+                   ext.c_str());
+        return;
+    }
+
+    DoAsyncExec(cmd);
+}
+

 #ifdef __WINDOWS__
 #ifdef __WINDOWS__

+
+bool MyFrame::GetDDEServer()
+{

     wxString server = wxGetTextFromUser(_T("Server to connect to:"),
     wxString server = wxGetTextFromUser(_T("Server to connect to:"),

-                                        DIALOG_TITLE, _T("IExplore"));
+                                        DIALOG_TITLE, m_server);

     if ( !server )
     if ( !server )

-        return;
+        return FALSE;

 
 

-    wxString topic = wxGetTextFromUser(_T("DDE topic:"),
-                                       DIALOG_TITLE, _T("WWW_OpenURL"));
+    m_server = server;
+
+    wxString topic = wxGetTextFromUser(_T("DDE topic:"), DIALOG_TITLE, m_topic);

     if ( !topic )
     if ( !topic )

-        return;
+        return FALSE;

 
 

-    wxString cmd = wxGetTextFromUser(_T("DDE command:"),
-                                     DIALOG_TITLE,
-                                     _T("\"file:F:\\wxWindows\\samples\\"
-                                        "image\\horse.gif\",,-1,,,,,"));
+    m_topic = topic;
+
+    wxString cmd = wxGetTextFromUser(_T("DDE command:"), DIALOG_TITLE, m_cmdDde);

     if ( !cmd )
     if ( !cmd )

+        return FALSE;
+
+    m_cmdDde = cmd;
+
+    return TRUE;
+}
+
+void MyFrame::OnDDEExec(wxCommandEvent& WXUNUSED(event))
+{
+    if ( !GetDDEServer() )

         return;
 
     wxDDEClient client;
         return;
 
     wxDDEClient client;

-    wxConnectionBase *conn = client.MakeConnection("", server, topic);
+    wxConnectionBase *conn = client.MakeConnection("", m_server, m_topic);

     if ( !conn )
     {
         wxLogError(_T("Failed to connect to the DDE server '%s'."),
     if ( !conn )
     {
         wxLogError(_T("Failed to connect to the DDE server '%s'."),

-                   server.c_str());
+                   m_server.c_str());

     }
     else
     {
     }
     else
     {

-        if ( !conn->Execute(cmd) )
+        if ( !conn->Execute(m_cmdDde) )

         {
             wxLogError(_T("Failed to execute command '%s' via DDE."),
         {
             wxLogError(_T("Failed to execute command '%s' via DDE."),

-                       cmd.c_str());
+                       m_cmdDde.c_str());

         }
         else
         {
             wxLogStatus(_T("Successfully executed DDE command"));
         }
     }
         }
         else
         {
             wxLogStatus(_T("Successfully executed DDE command"));
         }
     }

-#endif // __WINDOWS__

 }
 
 }
 

+void MyFrame::OnDDERequest(wxCommandEvent& WXUNUSED(event))
+{
+    if ( !GetDDEServer() )
+        return;
+
+    wxDDEClient client;
+    wxConnectionBase *conn = client.MakeConnection("", m_server, m_topic);
+    if ( !conn )
+    {
+        wxLogError(_T("Failed to connect to the DDE server '%s'."),
+                   m_server.c_str());
+    }
+    else
+    {
+        if ( !conn->Request(m_cmdDde) )
+        {
+            wxLogError(_T("Failed to  send request '%s' via DDE."),
+                       m_cmdDde.c_str());
+        }
+        else
+        {
+            wxLogStatus(_T("Successfully sent DDE request."));
+        }
+    }
+}
+
+#endif // __WINDOWS__
+

 // input polling
 void MyFrame::OnIdle(wxIdleEvent& event)
 {
 // input polling
 void MyFrame::OnIdle(wxIdleEvent& event)
 {


@@ -471,6 +636,31 @@ void MyFrame::OnIdle(wxIdleEvent& event)
     }
 }
 
     }
 }
 

+void MyFrame::OnProcessTerminated(MyPipedProcess *process)
+{
+    m_running.Remove(process);
+}
+
+
+void MyFrame::ShowOutput(const wxString& cmd,
+                         const wxArrayString& output,
+                         const wxString& title)
+{
+    size_t count = output.GetCount();
+    if ( !count )
+        return;
+
+    m_lbox->Append(wxString::Format(_T("--- %s of '%s' ---"),
+                                    title.c_str(), cmd.c_str()));
+
+    for ( size_t n = 0; n < count; n++ )
+    {
+        m_lbox->Append(output[n]);
+    }
+
+    m_lbox->Append(_T("--- End of output ---"));
+}
+

 // ----------------------------------------------------------------------------
 // MyProcess
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // MyProcess
 // ----------------------------------------------------------------------------


@@ -490,6 +680,8 @@ void MyProcess::OnTerminate(int pid, int status)
 
 bool MyPipedProcess::HasInput()
 {
 
 bool MyPipedProcess::HasInput()
 {

+    bool hasInput = FALSE;
+

     wxInputStream& is = *GetInputStream();
     if ( !is.Eof() )
     {
     wxInputStream& is = *GetInputStream();
     if ( !is.Eof() )
     {


@@ -497,16 +689,28 @@ bool MyPipedProcess::HasInput()
 
         // this assumes that the output is always line buffered
         wxString msg;
 
         // this assumes that the output is always line buffered
         wxString msg;

-        msg << m_cmd << _T(": ") << tis.ReadLine();
+        msg << m_cmd << _T(" (stdout): ") << tis.ReadLine();

 
         m_parent->GetLogListBox()->Append(msg);
 
 
         m_parent->GetLogListBox()->Append(msg);
 

-        return TRUE;
+        hasInput = TRUE;

     }
     }

-    else
+
+    wxInputStream& es = *GetErrorStream();
+    if ( !es.Eof() )

     {
     {

-        return FALSE;
+        wxTextInputStream tis(es);
+
+        // this assumes that the output is always line buffered
+        wxString msg;
+        msg << m_cmd << _T(" (stderr): ") << tis.ReadLine();
+
+        m_parent->GetLogListBox()->Append(msg);
+
+        hasInput = TRUE;

     }
     }

+
+    return hasInput;

 }
 
 void MyPipedProcess::OnTerminate(int pid, int status)
 }
 
 void MyPipedProcess::OnTerminate(int pid, int status)


@@ -519,3 +723,24 @@ void MyPipedProcess::OnTerminate(int pid, int status)
 
     MyProcess::OnTerminate(pid, status);
 }
 
     MyProcess::OnTerminate(pid, status);
 }

+
+// ----------------------------------------------------------------------------
+// MyPipedProcess2
+// ----------------------------------------------------------------------------
+
+bool MyPipedProcess2::HasInput()
+{
+    if ( !!m_input )
+    {
+        wxTextOutputStream os(*GetOutputStream());
+        os.WriteString(m_input);
+
+        CloseOutput();
+        m_input.clear();
+
+        // call us once again - may be we'll have output
+        return TRUE;
+    }
+
+    return MyPipedProcess::HasInput();
+}