fixed completely broken CheckForTransparency()

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

diff --git a/samples/exec/exec.cpp b/samples/exec/exec.cpp
index d11a4ac917d7ede89eee9dda98262c092ec17f2b..13cfdc28e9a68b353d25ff5f0634f78fe3cc80ad 100644 (file)
--- a/samples/exec/exec.cpp
+++ b/samples/exec/exec.cpp
@@ -17,7 +17,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(__APPLE__)

     #pragma implementation "exec.cpp"
     #pragma interface "exec.cpp"
 #endif
     #pragma implementation "exec.cpp"
     #pragma interface "exec.cpp"
 #endif


@@ -33,14 +33,25 @@
 // need because it includes almost all "standard" wxWindows headers
 #ifndef WX_PRECOMP
     #include "wx/app.h"
 // need because it includes almost all "standard" wxWindows headers
 #ifndef WX_PRECOMP
     #include "wx/app.h"

+    #include "wx/log.h"

     #include "wx/frame.h"
     #include "wx/frame.h"

+    #include "wx/panel.h"
+
+    #include "wx/timer.h"
+

     #include "wx/utils.h"
     #include "wx/menu.h"
     #include "wx/utils.h"
     #include "wx/menu.h"

+

     #include "wx/msgdlg.h"
     #include "wx/textdlg.h"
     #include "wx/msgdlg.h"
     #include "wx/textdlg.h"

-    #include "wx/listbox.h"

     #include "wx/filedlg.h"
     #include "wx/choicdlg.h"
     #include "wx/filedlg.h"
     #include "wx/choicdlg.h"

+
+    #include "wx/button.h"
+    #include "wx/textctrl.h"
+    #include "wx/listbox.h"
+
+    #include "wx/sizer.h"

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


@@ -54,7 +65,7 @@
 #endif // __WINDOWS__
 
 // ----------------------------------------------------------------------------
 #endif // __WINDOWS__
 
 // ----------------------------------------------------------------------------

-// private classes
+// the usual application and main frame classes

 // ----------------------------------------------------------------------------
 
 // Define a new application type, each program should derive a class from wxApp
 // ----------------------------------------------------------------------------
 
 // Define a new application type, each program should derive a class from wxApp


@@ -94,11 +105,14 @@ public:
     void OnExecWithRedirect(wxCommandEvent& event);
     void OnExecWithPipe(wxCommandEvent& event);
 
     void OnExecWithRedirect(wxCommandEvent& event);
     void OnExecWithPipe(wxCommandEvent& event);
 

+    void OnPOpen(wxCommandEvent& event);
+

     void OnFileExec(wxCommandEvent& event);
 
     void OnAbout(wxCommandEvent& event);
 
     // polling output of async processes
     void OnFileExec(wxCommandEvent& event);
 
     void OnAbout(wxCommandEvent& event);
 
     // polling output of async processes

+    void OnTimer(wxTimerEvent& event);

     void OnIdle(wxIdleEvent& event);
 
     // for MyPipedProcess
     void OnIdle(wxIdleEvent& event);
 
     // for MyPipedProcess


@@ -112,8 +126,33 @@ private:
 
     void DoAsyncExec(const wxString& cmd);
 
 
     void DoAsyncExec(const wxString& cmd);
 

+    void AddAsyncProcess(MyPipedProcess *process)
+    {
+        if ( m_running.IsEmpty() )
+        {
+            // we want to start getting the timer events to ensure that a
+            // steady stream of idle events comes in -- otherwise we
+            // wouldn't be able to poll the child process input
+            m_timerIdleWakeUp.Start(100);
+        }
+        //else: the timer is already running
+
+        m_running.Add(process);
+    }
+
+    void RemoveAsyncProcess(MyPipedProcess *process)
+    {
+        m_running.Remove(process);
+
+        if ( m_running.IsEmpty() )
+        {
+            // we don't need to get idle events all the time any more
+            m_timerIdleWakeUp.Stop();
+        }
+    }
+

     // the PID of the last process we launched asynchronously
     // the PID of the last process we launched asynchronously

-    int m_pidLast;
+    long m_pidLast;

 
     // last command we executed
     wxString m_cmdLast;
 
     // last command we executed
     wxString m_cmdLast;


@@ -134,10 +173,59 @@ private:
 
     MyProcessesArray m_running;
 
 
     MyProcessesArray m_running;
 

+    // the idle event wake up timer
+    wxTimer m_timerIdleWakeUp;
+

     // any class wishing to process wxWindows events must use this macro
     DECLARE_EVENT_TABLE()
 };
 
     // any class wishing to process wxWindows events must use this macro
     DECLARE_EVENT_TABLE()
 };
 

+// ----------------------------------------------------------------------------
+// MyPipeFrame: allows the user to communicate with the child process
+// ----------------------------------------------------------------------------
+
+class MyPipeFrame : public wxFrame
+{
+public:
+    MyPipeFrame(wxFrame *parent,
+                const wxString& cmd,
+                wxProcess *process);
+
+protected:
+    void OnTextEnter(wxCommandEvent& event) { DoSend(); }
+    void OnBtnSend(wxCommandEvent& event) { DoSend(); }
+    void OnBtnGet(wxCommandEvent& event) { DoGet(); }
+
+    void OnClose(wxCloseEvent& event);
+
+    void OnProcessTerm(wxProcessEvent& event);
+
+    void DoSend()
+    {
+        m_out.WriteString(m_textIn->GetValue() + _T('\n'));
+        m_textIn->Clear();
+
+        DoGet();
+    }
+
+    void DoGet();
+
+private:
+    wxProcess *m_process;
+
+    wxTextInputStream m_in;
+    wxTextOutputStream m_out;
+
+    wxTextCtrl *m_textIn,
+               *m_textOut;
+
+    DECLARE_EVENT_TABLE()
+};
+
+// ----------------------------------------------------------------------------
+// wxProcess-derived classes
+// ----------------------------------------------------------------------------
+

 // This is the handler for process termination events
 class MyProcess : public wxProcess
 {
 // This is the handler for process termination events
 class MyProcess : public wxProcess
 {


@@ -203,12 +291,17 @@ enum
     Exec_SyncExec = 200,
     Exec_AsyncExec,
     Exec_Shell,
     Exec_SyncExec = 200,
     Exec_AsyncExec,
     Exec_Shell,

+    Exec_POpen,

     Exec_OpenFile,
     Exec_DDEExec,
     Exec_DDERequest,
     Exec_Redirect,
     Exec_Pipe,
     Exec_OpenFile,
     Exec_DDEExec,
     Exec_DDERequest,
     Exec_Redirect,
     Exec_Pipe,

-    Exec_About = 300
+    Exec_About = 300,
+
+    // control ids
+    Exec_Btn_Send = 1000,
+    Exec_Btn_Get

 };
 
 static const wxChar *DIALOG_TITLE = _T("Exec sample");
 };
 
 static const wxChar *DIALOG_TITLE = _T("Exec sample");


@@ -231,16 +324,31 @@ BEGIN_EVENT_TABLE(MyFrame, wxFrame)
     EVT_MENU(Exec_Redirect, MyFrame::OnExecWithRedirect)
     EVT_MENU(Exec_Pipe, MyFrame::OnExecWithPipe)
 
     EVT_MENU(Exec_Redirect, MyFrame::OnExecWithRedirect)
     EVT_MENU(Exec_Pipe, MyFrame::OnExecWithPipe)
 

+    EVT_MENU(Exec_POpen, MyFrame::OnPOpen)
+

     EVT_MENU(Exec_OpenFile, MyFrame::OnFileExec)
 
 #ifdef __WINDOWS__
     EVT_MENU(Exec_DDEExec, MyFrame::OnDDEExec)
     EVT_MENU(Exec_DDERequest, MyFrame::OnDDERequest)
 #endif // __WINDOWS__
     EVT_MENU(Exec_OpenFile, MyFrame::OnFileExec)
 
 #ifdef __WINDOWS__
     EVT_MENU(Exec_DDEExec, MyFrame::OnDDEExec)
     EVT_MENU(Exec_DDERequest, MyFrame::OnDDERequest)
 #endif // __WINDOWS__

-    
+

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

+
+    EVT_TIMER(-1, MyFrame::OnTimer)
+END_EVENT_TABLE()
+
+BEGIN_EVENT_TABLE(MyPipeFrame, wxFrame)
+    EVT_BUTTON(Exec_Btn_Send, MyPipeFrame::OnBtnSend)
+    EVT_BUTTON(Exec_Btn_Get, MyPipeFrame::OnBtnGet)
+
+    EVT_TEXT_ENTER(-1, MyPipeFrame::OnTextEnter)
+
+    EVT_CLOSE(MyPipeFrame::OnClose)
+
+    EVT_END_PROCESS(-1, MyPipeFrame::OnProcessTerm)

 END_EVENT_TABLE()
 
 // Create a new application object: this macro will allow wxWindows to create
 END_EVENT_TABLE()
 
 // Create a new application object: this macro will allow wxWindows to create


@@ -279,9 +387,14 @@ bool MyApp::OnInit()
 // main frame
 // ----------------------------------------------------------------------------
 
 // main frame
 // ----------------------------------------------------------------------------
 

+#ifdef __VISUALC__
+#pragma warning(disable: 4355) // this used in base member initializer list
+#endif
+

 // frame constructor
 MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
 // frame constructor
 MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)

-       : wxFrame((wxFrame *)NULL, -1, title, pos, size)
+       : wxFrame((wxFrame *)NULL, -1, title, pos, size),
+         m_timerIdleWakeUp(this)

 {
     m_pidLast = 0;
 
 {
     m_pidLast = 0;
 


@@ -311,8 +424,10 @@ MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
     execMenu->AppendSeparator();
     execMenu->Append(Exec_Redirect, _T("Capture command &output...\tCtrl-O"),
                      _T("Launch a program and capture its output"));
     execMenu->AppendSeparator();
     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"),
+    execMenu->Append(Exec_Pipe, _T("&Pipe through command..."),

                      _T("Pipe a string through a filter"));
                      _T("Pipe a string through a filter"));

+    execMenu->Append(Exec_POpen, _T("&Open a pipe to a command...\tCtrl-P"),
+                     _T("Open a pipe to and from another program"));

 
     execMenu->AppendSeparator();
     execMenu->Append(Exec_OpenFile, _T("Open &file...\tCtrl-F"),
 
     execMenu->AppendSeparator();
     execMenu->Append(Exec_OpenFile, _T("Open &file...\tCtrl-F"),


@@ -366,7 +481,7 @@ void MyFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 
 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 {
 
 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 {

-    wxMessageBox(_T("Exec wxWindows Sample\n© 2000-2001 Vadim Zeitlin"),
+    wxMessageBox(_T("Exec wxWindows Sample\n© 2000-2002 Vadim Zeitlin"),

                  _T("About Exec"), wxOK | wxICON_INFORMATION, this);
 }
 
                  _T("About Exec"), wxOK | wxICON_INFORMATION, this);
 }
 


@@ -441,16 +556,16 @@ void MyFrame::OnKill(wxCommandEvent& WXUNUSED(event))
     if ( sig == 0 )
     {
         if ( wxProcess::Exists(pid) )
     if ( sig == 0 )
     {
         if ( wxProcess::Exists(pid) )

-            wxLogStatus(_T("Process %d is running."), pid);
+            wxLogStatus(_T("Process %ld is running."), pid);

         else
         else

-            wxLogStatus(_T("No process with pid = %d."), pid);
+            wxLogStatus(_T("No process with pid = %ld."), pid);

     }
     else // not SIGNONE
     {
         wxKillError rc = wxProcess::Kill(pid, (wxSignal)sig);
         if ( rc == wxKILL_OK )
         {
     }
     else // not SIGNONE
     {
         wxKillError rc = wxProcess::Kill(pid, (wxSignal)sig);
         if ( rc == wxKILL_OK )
         {

-            wxLogStatus(_T("Process %d killed with signal %d."), pid, sig);
+            wxLogStatus(_T("Process %ld killed with signal %d."), pid, sig);

         }
         else
         {
         }
         else
         {


@@ -463,7 +578,7 @@ void MyFrame::OnKill(wxCommandEvent& WXUNUSED(event))
                 _T("unspecified error"),
             };
 
                 _T("unspecified error"),
             };
 

-            wxLogStatus(_T("Failed to kill process %d with signal %d: %s"),
+            wxLogStatus(_T("Failed to kill process %ld with signal %d: %s"),

                         pid, sig, errorText[rc]);
         }
     }
                         pid, sig, errorText[rc]);
         }
     }


@@ -479,13 +594,14 @@ void MyFrame::DoAsyncExec(const wxString& cmd)
     m_pidLast = wxExecute(cmd, wxEXEC_ASYNC, process);
     if ( !m_pidLast )
     {
     m_pidLast = wxExecute(cmd, wxEXEC_ASYNC, process);
     if ( !m_pidLast )
     {

-        wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
+        wxLogError( _T("Execution of '%s' failed."), cmd.c_str() );

 
         delete process;
     }
     else
     {
 
         delete process;
     }
     else
     {

-        wxLogStatus(_T("Process %ld (%s) launched."), m_pidLast, cmd.c_str());
+        wxLogStatus( _T("Process %ld (%s) launched."),
+            m_pidLast, cmd.c_str() );

 
         m_cmdLast = cmd;
     }
 
         m_cmdLast = cmd;
     }


@@ -500,12 +616,13 @@ void MyFrame::OnSyncExec(wxCommandEvent& WXUNUSED(event))
     if ( !cmd )
         return;
 
     if ( !cmd )
         return;
 

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

 
     int code = wxExecute(cmd, wxEXEC_SYNC);
 
     wxLogStatus(_T("Process '%s' terminated with exit code %d."),
 
     int code = wxExecute(cmd, wxEXEC_SYNC);
 
     wxLogStatus(_T("Process '%s' terminated with exit code %d."),

-                cmd.c_str(), code);
+        cmd.c_str(), code);
+

     m_cmdLast = cmd;
 }
 
     m_cmdLast = cmd;
 }
 


@@ -586,7 +703,7 @@ void MyFrame::OnExecWithRedirect(wxCommandEvent& WXUNUSED(event))
         }
         else
         {
         }
         else
         {

-            m_running.Add(process);
+            AddAsyncProcess(process);

         }
     }
 
         }
     }
 


@@ -612,12 +729,12 @@ void MyFrame::OnExecWithPipe(wxCommandEvent& WXUNUSED(event))
 
     // always execute the filter asynchronously
     MyPipedProcess2 *process = new MyPipedProcess2(this, cmd, input);
 
     // always execute the filter asynchronously
     MyPipedProcess2 *process = new MyPipedProcess2(this, cmd, input);

-    int pid = wxExecute(cmd, wxEXEC_ASYNC, process);
+    long pid = wxExecute(cmd, wxEXEC_ASYNC, process);

     if ( pid )
     {
     if ( pid )
     {

-        wxLogStatus(_T("Process %ld (%s) launched."), pid, cmd.c_str());
+        wxLogStatus( _T("Process %ld (%s) launched."), pid, cmd.c_str() );

 
 

-        m_running.Add(process);
+        AddAsyncProcess(process);

     }
     else
     {
     }
     else
     {


@@ -629,11 +746,43 @@ void MyFrame::OnExecWithPipe(wxCommandEvent& WXUNUSED(event))
     m_cmdLast = cmd;
 }
 
     m_cmdLast = cmd;
 }
 

+void MyFrame::OnPOpen(wxCommandEvent& event)
+{
+    wxString cmd = wxGetTextFromUser(_T("Enter the command to launch: "),
+                                     DIALOG_TITLE,
+                                     m_cmdLast);
+    if ( cmd.empty() )
+        return;
+
+    wxProcess *process = wxProcess::Open(cmd);
+    if ( !process )
+    {
+        wxLogError(_T("Failed to launch the command."));
+        return;
+    }
+
+    wxOutputStream *out = process->GetOutputStream();
+    if ( !out )
+    {
+        wxLogError(_T("Failed to connect to child stdin"));
+        return;
+    }
+
+    wxInputStream *in = process->GetInputStream();
+    if ( !in )
+    {
+        wxLogError(_T("Failed to connect to child stdout"));
+        return;
+    }
+
+    new MyPipeFrame(this, cmd, process);
+}
+

 void MyFrame::OnFileExec(wxCommandEvent& event)
 {
     static wxString s_filename;
 
 void MyFrame::OnFileExec(wxCommandEvent& event)
 {
     static wxString s_filename;
 

-    wxString filename = wxLoadFileSelector(_T("file"), _T(""), s_filename);
+    wxString filename = wxLoadFileSelector(_T(""), _T(""), s_filename);

     if ( !filename )
         return;
 
     if ( !filename )
         return;
 


@@ -698,7 +847,7 @@ void MyFrame::OnDDEExec(wxCommandEvent& WXUNUSED(event))
         return;
 
     wxDDEClient client;
         return;
 
     wxDDEClient client;

-    wxConnectionBase *conn = client.MakeConnection("", m_server, m_topic);
+    wxConnectionBase *conn = client.MakeConnection(_T(""), 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'."),


@@ -724,7 +873,7 @@ void MyFrame::OnDDERequest(wxCommandEvent& WXUNUSED(event))
         return;
 
     wxDDEClient client;
         return;
 
     wxDDEClient client;

-    wxConnectionBase *conn = client.MakeConnection("", m_server, m_topic);
+    wxConnectionBase *conn = client.MakeConnection(_T(""), 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'."),


@@ -763,9 +912,14 @@ void MyFrame::OnIdle(wxIdleEvent& event)
     }
 }
 
     }
 }
 

+void MyFrame::OnTimer(wxTimerEvent& WXUNUSED(event))
+{
+    wxWakeUpIdle();
+}
+

 void MyFrame::OnProcessTerminated(MyPipedProcess *process)
 {
 void MyFrame::OnProcessTerminated(MyPipedProcess *process)
 {

-    m_running.Remove(process);
+    RemoveAsyncProcess(process);

 }
 
 
 }
 
 


@@ -785,7 +939,8 @@ void MyFrame::ShowOutput(const wxString& cmd,
         m_lbox->Append(output[n]);
     }
 
         m_lbox->Append(output[n]);
     }
 

-    m_lbox->Append(_T("--- End of output ---"));
+    m_lbox->Append(wxString::Format(_T("--- End of %s ---"),
+                                    title.Lower().c_str()));

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -809,10 +964,9 @@ bool MyPipedProcess::HasInput()
 {
     bool hasInput = FALSE;
 
 {
     bool hasInput = FALSE;
 

-    wxInputStream& is = *GetInputStream();
-    if ( !is.Eof() )
+    if ( IsInputAvailable() )

     {
     {

-        wxTextInputStream tis(is);
+        wxTextInputStream tis(*GetInputStream());

 
         // this assumes that the output is always line buffered
         wxString msg;
 
         // this assumes that the output is always line buffered
         wxString msg;


@@ -823,10 +977,9 @@ bool MyPipedProcess::HasInput()
         hasInput = TRUE;
     }
 
         hasInput = TRUE;
     }
 

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

     {
     {

-        wxTextInputStream tis(es);
+        wxTextInputStream tis(*GetErrorStream());

 
         // this assumes that the output is always line buffered
         wxString msg;
 
         // this assumes that the output is always line buffered
         wxString msg;


@@ -871,3 +1024,84 @@ bool MyPipedProcess2::HasInput()
 
     return MyPipedProcess::HasInput();
 }
 
     return MyPipedProcess::HasInput();
 }

+
+// ============================================================================
+// MyPipeFrame implementation
+// ============================================================================
+
+MyPipeFrame::MyPipeFrame(wxFrame *parent,
+                         const wxString& cmd,
+                         wxProcess *process)
+           : wxFrame(parent, -1, cmd),
+             m_process(process),
+             // in a real program we'd check that the streams are !NULL here
+             m_in(*process->GetInputStream()),
+             m_out(*process->GetOutputStream())
+{
+    m_process->SetNextHandler(this);
+
+    wxPanel *panel = new wxPanel(this, -1);
+
+    m_textIn = new wxTextCtrl(panel, -1, _T(""),
+                              wxDefaultPosition, wxDefaultSize,
+                              wxTE_PROCESS_ENTER);
+    m_textOut = new wxTextCtrl(panel, -1, _T(""));
+    m_textOut->SetEditable(FALSE);
+
+    wxSizer *sizerTop = new wxBoxSizer(wxVERTICAL);
+    sizerTop->Add(m_textIn, 0, wxGROW | wxALL, 5);
+
+    wxSizer *sizerBtns = new wxBoxSizer(wxHORIZONTAL);
+    sizerBtns->Add(new wxButton(panel, Exec_Btn_Send, _T("&Send")), 0,
+                   wxALL, 10);
+    sizerBtns->Add(new wxButton(panel, Exec_Btn_Get, _T("&Get")), 0,
+                   wxALL, 10);
+
+    sizerTop->Add(sizerBtns, 0, wxCENTRE | wxALL, 5);
+    sizerTop->Add(m_textOut, 0, wxGROW | wxALL, 5);
+
+    panel->SetSizer(sizerTop);
+    sizerTop->Fit(this);
+
+    Show();
+}
+
+void MyPipeFrame::DoGet()
+{
+    // we don't have any way to be notified when any input appears on the
+    // stream so we have to poll it :-(
+    //
+    // NB: this really must be done because otherwise the other program might
+    //     not have enough time to receive or process our data and we'd read
+    //     an empty string
+    while ( !m_process->IsInputAvailable() && m_process->IsInputOpened() )
+        ;
+
+    m_textOut->SetValue(m_in.ReadLine());
+}
+
+void MyPipeFrame::OnClose(wxCloseEvent& event)
+{
+    if ( m_process )
+    {
+        // we're not interested in getting the process termination notification
+        // if we are closing it ourselves
+        wxProcess *process = m_process;
+        m_process = NULL;
+        process->SetNextHandler(NULL);
+
+        process->CloseOutput();
+    }
+
+    event.Skip();
+}
+
+void MyPipeFrame::OnProcessTerm(wxProcessEvent& event)
+{
+    delete m_process;
+    m_process = NULL;
+
+    wxLogWarning(_T("The other process has terminated, closing"));
+
+    Close();
+}