Check if a Shell Process Ends 
Author Message
 Check if a Shell Process Ends

Hi Everybody,

Badly need help on this:

My VB app needs to install 3 softwares one after another. These 3
softwares are installation packages packaged using InstallShield.

My SHELL for the 3 softwares works in a similar fashion like this:

    strProg = "d:\gricdial.exe"
    If Dir(strProg) <> "" Then
        Screen.MousePointer = vbHourglass
        Shell strProg, vbNormalFocus
        ExecCmd (strProg)
        Screen.MousePointer = vbDefault
    Else
        MsgBox "Cannot execute installation program for Global Roaming",
vbExclamation
    End If

To ensure that the first software completes installation before
installing the next, I used the source code provided by VB (see attached
file) : 96.htm (without the Sub Form_Click())

The problem was:

Once InstallShield for the first app starts, it hangs my VB app. I have
to end task my VB app before the installation software can continue.


Thanks,
Candice

[ 96.htm 12K ]

HOWTO: 32-Bit App Can Determine When a Shelled Process Ends

The information in this article applies to:
  • Microsoft Visual Basic Learning, Professional, and Enterprise Editions for Windows, version 6.0
  • Microsoft Visual Basic Standard, Professional, and Enterprise Editions, 32-bit only, for Windows, version 4.0

SUMMARY

Executing the Shell() function in a Visual Basic for Windows program starts another executable program asynchronously and returns control to the Visual Basic application. This shelled program continues to run independently of your application until the user closes it.

However, if your Visual Basic application needs to wait for the shelled process to terminate, you could use the Windows API to poll the status of the application, but this is not a very efficient technique. The example in this article demonstrates a better way.

A 16-bit application would use a completely different technique to accomplish the same effect. For additional information on the 16-bit process, please refer the following Knowledge Base article:

   Q96844 : HOWTO: Determine When a Shelled Process Has Terminated

MORE INFORMATION

The Win32 API has integrated functionality that enables an application to wait until a shelled process has completed. To use these functions, you need a handle to the shelled process. The easiest way to achieve this is to use the CreateProcess() API function to launch your shelled program rather than Visual Basic[ASCII 146]s Shell() function.

Creating the Shelled Process

In a 32-bit application, you need to create an addressable process. To do this, use the CreateProcess() function to start your shelled application. The CreateProcess() function gives your program the process handle of the shelled process via one of its passed parameters.

Waiting for the Shelled Process to Terminate

Having used CreateProcess() to get a process handle, pass that handle to the WaitForSingleObject() function. This causes your Visual Basic application to suspend execution until the shelled process terminates.

Getting the Exit Code from the Shelled Application

It was common for a DOS application to return an exit code indicating the status of the completed application. While Windows provides other ways to convey the same information, some applications only provide exit codes. Passing the process handle to the GetExitCodeProcess() API allows you to retrieve this information.

Below are the steps necessary to build a Visual Basic for Windows program that uses the CreateProcess() function to execute the Windows Notepad (NOTEPAD.EXE) application. This code demonstrates how to use the Windows API CreateProcess() and WaitForSingleObject() functions to wait until a shelled process terminates before resuming execution. It also uses the GetExitCodeProcess() function to retrieve the exit code of the shelled process, if any.

The syntax of the CreateProcess() function is extremely complicated, so in the example code, it is encapsulated into a function called ExecCmd(). ExecCmd() takes one parameter, the command line of the application to execute.

Step-by-Step Example

1. Start a new project in Visual Basic. Form1 is created by default.

2. Add the following code to the General Declarations section of Form1:

   	Private Type STARTUPINFO
            cb As Long
            lpReserved As String
            lpDesktop As String
            lpTitle As String
            dwX As Long
            dwY As Long
            dwXSize As Long
            dwYSize As Long
            dwXCountChars As Long
            dwYCountChars As Long
            dwFillAttribute As Long
            dwFlags As Long
            wShowWindow As Integer
            cbReserved2 As Integer
            lpReserved2 As Long
            hStdInput As Long
            hStdOutput As Long
            hStdError As Long
         End Type

         Private Type PROCESS_INFORMATION
            hProcess As Long
            hThread As Long
            dwProcessID As Long
            dwThreadID As Long
         End Type

         Private Declare Function WaitForSingleObject Lib "kernel32" (ByVal _
            hHandle As Long, ByVal dwMilliseconds As Long) As Long

         Private Declare Function CreateProcessA Lib "kernel32" (ByVal _
            lpApplicationName As Long, ByVal lpCommandLine As String, ByVal _
            lpProcessAttributes As Long, ByVal lpThreadAttributes As Long, _
            ByVal bInheritHandles As Long, ByVal dwCreationFlags As Long, _
            ByVal lpEnvironment As Long, ByVal lpCurrentDirectory As Long, _
            lpStartupInfo As STARTUPINFO, lpProcessInformation As _
            PROCESS_INFORMATION) As Long

         Private Declare Function CloseHandle Lib "kernel32" _
            (ByVal hObject As Long) As Long

         Private Declare Function GetExitCodeProcess Lib "kernel32" _
            (ByVal hProcess As Long, lpExitCode As Long) As Long

         Private Const NORMAL_PRIORITY_CLASS = &H20&
         Private Const INFINITE = -1&

         Public Function ExecCmd(cmdline$)
            Dim proc As PROCESS_INFORMATION
            Dim start As STARTUPINFO

            ' Initialize the STARTUPINFO structure:
            start.cb = Len(start)

            ' Start the shelled application:
            ret& = CreateProcessA(0&, cmdline$, 0&, 0&, 1&, _
               NORMAL_PRIORITY_CLASS, 0&, 0&, start, proc)

            ' Wait for the shelled application to finish:
            ret& = WaitForSingleObject(proc.hProcess, INFINITE)
            Call GetExitCodeProcess(proc.hProcess, ret&)
            Call CloseHandle(proc.hProcess)
            ExecCmd = ret&
         End Function

         Sub Form_Click()
            Dim retval As Long
            retval = ExecCmd("notepad.exe")
            MsgBox "Process Finished, Exit Code " & retval
         End Sub

3. Press the F5 key to run the application.

4. Using the mouse, click the Form1 window. At this point the NotePad

   application is started.

5. Terminate NotePad. A MsgBox will appear indicating termination of the NotePad
   application and an exit code of 0. To test this sample with an application
   that returns an exit code, implement Knowledge Base article Q178357 and
   change the parameter passed to ExecCmd to "project1.exe." NOTE: The MsgBox
   statement following the ExecCmd() function is not executed because the
   WaitForSingleObject() function prevents it. The message box does not appear
   until Notepad is closed when the user chooses Exit from Notepad's File menu
   (ALT, F, X).

REFERENCES

   Q178357 : HOWTO: Set an Error Level from a Visual Basic Application

Additional query words: GetModuleUsage kbVBp400 kbVBp600 kbVBp kbdsd kbDSupport

Keywords          :  
Version           : WINDOWS:4.0,6.0
Platform          : WINDOWS
Issue type        : kbhowto


Last Reviewed: May 7, 1999
© 1999 Microsoft Corporation. All rights reserved. Terms of Use.
...

read more »



Sun, 25 Nov 2001 03:00:00 GMT  
 Check if a Shell Process Ends

HOWTO: 32-Bit App Can Determine When a Shelled Process EndsHi!

Normally, it's possible to use the WaitForSingleObject API to determine when a process ends. However, with Installshield, this is not possible. The reason for this is that the main InstallShield process only unpacks the installation files, then starts a second process named "_ins0432._mp" - or something like that - that runs the actual installation. The main process then exits, way before the installation is completed.

What you need to do is wait for the second process to complete. To do that, you must enumerate all the processes until you find the installation program, retrieve it's handle and then wait for it to end (using WaitForSingleObject).

A simple workaround is to use the FindWindow API to wait for the installation program to start and end. All you need to know then is the title of the installation program's main window. The following example will wait for a window to appear and then disappear before continuing:

Private Declare Function FindWindow Lib "user32" Alias "FindWindowA" (ByVal lpClassName As String, ByVal lpWindowName As String) As Long

Private Sub WaitForWindow(WindowClass As String, WindowTitle As String)
    Dim WindowHandle As Long
    While WindowHandle = 0
        WindowHandle = FindWindow(ByVal WindowClass, ByVal WindowTitle)
        DoEvents
    Wend
    While WindowHandle <> 0
        WindowHandle = FindWindow(ByVal WindowClass, ByVal WindowTitle)
        DoEvents
    Wend
End Sub

To use the WaitForWindow sub use the following syntax:

    WaitForWindow vbNullString, "Title of window"

The first parameter is the name of the window class. Normally you won't need to specify this, but if you have more than one window with the same title, the class name can help you select the correct window. Of course, you will then need some sort of utility to determine the class name.
  Hi Everybody,

  Badly need help on this:

  My VB app needs to install 3 softwares one after another. These 3
  softwares are installation packages packaged using InstallShield.

  My SHELL for the 3 softwares works in a similar fashion like this:

      strProg = "d:\gricdial.exe"
      If Dir(strProg) <> "" Then
          Screen.MousePointer = vbHourglass
          Shell strProg, vbNormalFocus
          ExecCmd (strProg)
          Screen.MousePointer = vbDefault
      Else
          MsgBox "Cannot execute installation program for Global Roaming",
  vbExclamation
      End If

  To ensure that the first software completes installation before
  installing the next, I used the source code provided by VB (see attached
  file) : 96.htm (without the Sub Form_Click())

  The problem was:

  Once InstallShield for the first app starts, it hangs my VB app. I have
  to end task my VB app before the installation software can continue.


  Thanks,
  Candice

------------------------------------------------------------------------------

              HOWTO: 32-Bit App Can Determine When a Shelled Process Ends
              The information in this article applies to:
                a.. Microsoft Visual Basic Learning, Professional, and Enterprise Editions for Windows, version 6.0
                b.. Microsoft Visual Basic Standard, Professional, and Enterprise Editions, 32-bit only, for Windows, version 4.0

              SUMMARY
              Executing the Shell() function in a Visual Basic for Windows program starts another executable program asynchronously and returns control to the Visual Basic application. This shelled program continues to run independently of your application until the user closes it.

              However, if your Visual Basic application needs to wait for the shelled process to terminate, you could use the Windows API to poll the status of the application, but this is not a very efficient technique. The example in this article demonstrates a better way.

              A 16-bit application would use a completely different technique to accomplish the same effect. For additional information on the 16-bit process, please refer the following Knowledge Base article:

   Q96844 : HOWTO: Determine When a Shelled Process Has Terminated

              MORE INFORMATION
              The Win32 API has integrated functionality that enables an application to wait until a shelled process has completed. To use these functions, you need a handle to the shelled process. The easiest way to achieve this is to use the CreateProcess() API function to launch your shelled program rather than Visual Basic[ASCII 146]s Shell() function.

              Creating the Shelled Process
              In a 32-bit application, you need to create an addressable process. To do this, use the CreateProcess() function to start your shelled application. The CreateProcess() function gives your program the process handle of the shelled process via one of its passed parameters.

              Waiting for the Shelled Process to Terminate
              Having used CreateProcess() to get a process handle, pass that handle to the WaitForSingleObject() function. This causes your Visual Basic application to suspend execution until the shelled process terminates.

              Getting the Exit Code from the Shelled Application
              It was common for a DOS application to return an exit code indicating the status of the completed application. While Windows provides other ways to convey the same information, some applications only provide exit codes. Passing the process handle to the GetExitCodeProcess() API allows you to retrieve this information.

              Below are the steps necessary to build a Visual Basic for Windows program that uses the CreateProcess() function to execute the Windows Notepad (NOTEPAD.EXE) application. This code demonstrates how to use the Windows API CreateProcess() and WaitForSingleObject() functions to wait until a shelled process terminates before resuming execution. It also uses the GetExitCodeProcess() function to retrieve the exit code of the shelled process, if any.

              The syntax of the CreateProcess() function is extremely complicated, so in the example code, it is encapsulated into a function called ExecCmd(). ExecCmd() takes one parameter, the command line of the application to execute.

              Step-by-Step Example
              1. Start a new project in Visual Basic. Form1 is created by default.

              2. Add the following code to the General Declarations section of Form1:

        Private Type STARTUPINFO
            cb As Long
            lpReserved As String
            lpDesktop As String
            lpTitle As String
            dwX As Long
            dwY As Long
            dwXSize As Long
            dwYSize As Long
            dwXCountChars As Long
            dwYCountChars As Long
            dwFillAttribute As Long
            dwFlags As Long
            wShowWindow As Integer
            cbReserved2 As Integer
            lpReserved2 As Long
            hStdInput As Long
            hStdOutput As Long
            hStdError As Long
         End Type

         Private Type PROCESS_INFORMATION
            hProcess As Long
            hThread As Long
            dwProcessID As Long
            dwThreadID As Long
         End Type

         Private Declare Function WaitForSingleObject Lib "kernel32" (ByVal _
            hHandle As Long, ByVal dwMilliseconds As Long) As Long

         Private Declare Function CreateProcessA Lib "kernel32" (ByVal _
            lpApplicationName As Long, ByVal lpCommandLine As String, ByVal _
            lpProcessAttributes As Long, ByVal lpThreadAttributes As Long, _
            ByVal bInheritHandles As Long, ByVal dwCreationFlags As Long, _
            ByVal lpEnvironment As Long, ByVal lpCurrentDirectory As Long, _
            lpStartupInfo As STARTUPINFO, lpProcessInformation As _
            PROCESS_INFORMATION) As Long

         Private Declare Function CloseHandle Lib "kernel32" _
            (ByVal hObject As Long) As Long

         Private Declare Function GetExitCodeProcess Lib "kernel32" _
            (ByVal hProcess As Long, lpExitCode As Long) As Long

         Private Const NORMAL_PRIORITY_CLASS = &H20&
         Private Const INFINITE = -1&

         Public Function ExecCmd(cmdline$)
            Dim proc As PROCESS_INFORMATION
            Dim start As STARTUPINFO

            ' Initialize the STARTUPINFO structure:
            start.cb = Len(start)

            ' Start the shelled application:
            ret& = CreateProcessA(0&, cmdline$, 0&, 0&, 1&, _
               NORMAL_PRIORITY_CLASS, 0&, 0&, start, proc)

            ' Wait for the shelled application to finish:
            ret& = WaitForSingleObject(proc.hProcess, INFINITE)
            Call GetExitCodeProcess(proc.hProcess, ret&)
            Call CloseHandle(proc.hProcess)
            ExecCmd = ret&
         End Function

         Sub Form_Click()
            Dim retval As Long
            retval = ExecCmd("notepad.exe")
            MsgBox "Process Finished, Exit Code " & retval
         End Sub

              3. Press the F5 key to run the application.
              4. Using the mouse, click the Form1 window. At this point the NotePad

   application is started.

              5. Terminate NotePad. A MsgBox will appear indicating termination of the NotePad
   application and an exit code of 0. To test this sample with an application
   that returns an exit code, implement Knowledge Base article Q178357 and
   change the parameter passed to ExecCmd to "project1.exe." NOTE: The MsgBox
   statement following the ExecCmd() function is not executed because the
   WaitForSingleObject() function prevents it. The message box does not appear
   until Notepad is closed when the user chooses Exit from Notepad's File menu
...

read more »



Sun, 25 Nov 2001 03:00:00 GMT  
 Check if a Shell Process Ends

HOWTO: 32-Bit App Can Determine When a Shelled Process EndsYou're supposed to be able to use the AppActivate function for that purpose.  Otherwise, you may want to use a .BAT file to launch one after the other.

Dim MyAppID
Dim strProg as String    
strProg = "d:\gricdial.exe"
If Dir(strProg) <> "" Then
    Screen.MousePointer = vbHourglass
    MyAppID = Shell (strProg, vbNormalFocus)
    AppActivate MyAppID
    ExecCmd (strProg)
    Screen.MousePointer = vbDefault
Else
    MsgBox "Cannot execute installation program for Global Roaming", vbExclamation)
End If

--

Paul Mather
University of Cincinnati

  Hi Everybody,

  Badly need help on this:

  My VB app needs to install 3 softwares one after another. These 3
  softwares are installation packages packaged using InstallShield.

  My SHELL for the 3 softwares works in a similar fashion like this:

      strProg = "d:\gricdial.exe"
      If Dir(strProg) <> "" Then
          Screen.MousePointer = vbHourglass
          Shell strProg, vbNormalFocus
          ExecCmd (strProg)
          Screen.MousePointer = vbDefault
      Else
          MsgBox "Cannot execute installation program for Global Roaming",
  vbExclamation
      End If

  To ensure that the first software completes installation before
  installing the next, I used the source code provided by VB (see attached
  file) : 96.htm (without the Sub Form_Click())

  The problem was:

  Once InstallShield for the first app starts, it hangs my VB app. I have
  to end task my VB app before the installation software can continue.


  Thanks,
  Candice

------------------------------------------------------------------------------

              HOWTO: 32-Bit App Can Determine When a Shelled Process Ends
              The information in this article applies to:
                a.. Microsoft Visual Basic Learning, Professional, and Enterprise Editions for Windows, version 6.0
                b.. Microsoft Visual Basic Standard, Professional, and Enterprise Editions, 32-bit only, for Windows, version 4.0

              SUMMARY
              Executing the Shell() function in a Visual Basic for Windows program starts another executable program asynchronously and returns control to the Visual Basic application. This shelled program continues to run independently of your application until the user closes it.

              However, if your Visual Basic application needs to wait for the shelled process to terminate, you could use the Windows API to poll the status of the application, but this is not a very efficient technique. The example in this article demonstrates a better way.

              A 16-bit application would use a completely different technique to accomplish the same effect. For additional information on the 16-bit process, please refer the following Knowledge Base article:

   Q96844 : HOWTO: Determine When a Shelled Process Has Terminated

              MORE INFORMATION
              The Win32 API has integrated functionality that enables an application to wait until a shelled process has completed. To use these functions, you need a handle to the shelled process. The easiest way to achieve this is to use the CreateProcess() API function to launch your shelled program rather than Visual Basic[ASCII 146]s Shell() function.

              Creating the Shelled Process
              In a 32-bit application, you need to create an addressable process. To do this, use the CreateProcess() function to start your shelled application. The CreateProcess() function gives your program the process handle of the shelled process via one of its passed parameters.

              Waiting for the Shelled Process to Terminate
              Having used CreateProcess() to get a process handle, pass that handle to the WaitForSingleObject() function. This causes your Visual Basic application to suspend execution until the shelled process terminates.

              Getting the Exit Code from the Shelled Application
              It was common for a DOS application to return an exit code indicating the status of the completed application. While Windows provides other ways to convey the same information, some applications only provide exit codes. Passing the process handle to the GetExitCodeProcess() API allows you to retrieve this information.

              Below are the steps necessary to build a Visual Basic for Windows program that uses the CreateProcess() function to execute the Windows Notepad (NOTEPAD.EXE) application. This code demonstrates how to use the Windows API CreateProcess() and WaitForSingleObject() functions to wait until a shelled process terminates before resuming execution. It also uses the GetExitCodeProcess() function to retrieve the exit code of the shelled process, if any.

              The syntax of the CreateProcess() function is extremely complicated, so in the example code, it is encapsulated into a function called ExecCmd(). ExecCmd() takes one parameter, the command line of the application to execute.

              Step-by-Step Example
              1. Start a new project in Visual Basic. Form1 is created by default.

              2. Add the following code to the General Declarations section of Form1:

        Private Type STARTUPINFO
            cb As Long
            lpReserved As String
            lpDesktop As String
            lpTitle As String
            dwX As Long
            dwY As Long
            dwXSize As Long
            dwYSize As Long
            dwXCountChars As Long
            dwYCountChars As Long
            dwFillAttribute As Long
            dwFlags As Long
            wShowWindow As Integer
            cbReserved2 As Integer
            lpReserved2 As Long
            hStdInput As Long
            hStdOutput As Long
            hStdError As Long
         End Type

         Private Type PROCESS_INFORMATION
            hProcess As Long
            hThread As Long
            dwProcessID As Long
            dwThreadID As Long
         End Type

         Private Declare Function WaitForSingleObject Lib "kernel32" (ByVal _
            hHandle As Long, ByVal dwMilliseconds As Long) As Long

         Private Declare Function CreateProcessA Lib "kernel32" (ByVal _
            lpApplicationName As Long, ByVal lpCommandLine As String, ByVal _
            lpProcessAttributes As Long, ByVal lpThreadAttributes As Long, _
            ByVal bInheritHandles As Long, ByVal dwCreationFlags As Long, _
            ByVal lpEnvironment As Long, ByVal lpCurrentDirectory As Long, _
            lpStartupInfo As STARTUPINFO, lpProcessInformation As _
            PROCESS_INFORMATION) As Long

         Private Declare Function CloseHandle Lib "kernel32" _
            (ByVal hObject As Long) As Long

         Private Declare Function GetExitCodeProcess Lib "kernel32" _
            (ByVal hProcess As Long, lpExitCode As Long) As Long

         Private Const NORMAL_PRIORITY_CLASS = &H20&
         Private Const INFINITE = -1&

         Public Function ExecCmd(cmdline$)
            Dim proc As PROCESS_INFORMATION
            Dim start As STARTUPINFO

            ' Initialize the STARTUPINFO structure:
            start.cb = Len(start)

            ' Start the shelled application:
            ret& = CreateProcessA(0&, cmdline$, 0&, 0&, 1&, _
               NORMAL_PRIORITY_CLASS, 0&, 0&, start, proc)

            ' Wait for the shelled application to finish:
            ret& = WaitForSingleObject(proc.hProcess, INFINITE)
            Call GetExitCodeProcess(proc.hProcess, ret&)
            Call CloseHandle(proc.hProcess)
            ExecCmd = ret&
         End Function

         Sub Form_Click()
            Dim retval As Long
            retval = ExecCmd("notepad.exe")
            MsgBox "Process Finished, Exit Code " & retval
         End Sub

              3. Press the F5 key to run the application.
              4. Using the mouse, click the Form1 window. At this point the NotePad

   application is started.

              5. Terminate NotePad. A MsgBox will appear indicating termination of the NotePad
   application and an exit code of 0. To test this sample with an application
   that returns an exit code, implement Knowledge Base article Q178357 and
   change the parameter passed to ExecCmd to "project1.exe." NOTE: The MsgBox
   statement following the ExecCmd() function is not executed because the
   WaitForSingleObject() function prevents it. The message box does not appear
   until Notepad is closed when the user chooses Exit from Notepad's File menu
   (ALT, F, X).

              REFERENCES

   Q178357 : HOWTO: Set an Error Level from a Visual Basic Application

              Additional query words: GetModuleUsage kbVBp400 kbVBp600 kbVBp kbdsd kbDSupport

Keywords          :  
Version           : WINDOWS:4.0,6.0
Platform          : WINDOWS
Issue type        : kbhowto

              Last Reviewed: May 7, 1999
              ? 1999 Microsoft Corporation. All rights reserved. Terms of Use.

              Article ID: Q129796

              Last Reviewed:
              May 7, 1999

              Provided by Support Online from Microsoft Product Support Services.

------------------------------------------------------------------

                    Did the information in this article help answer your question?
              Yes
              No
              Did not apply

              Please provide additional comments about this information. If you require a response or technical support, please click Contact Us.
              (255 character max)



Fri, 30 Nov 2001 03:00:00 GMT  
 
 [ 3 post ] 

 Relevant Pages 

1. Why wait the end of a Shell process ?

2. How to determe when a SHELLed process ends.

3. End a shell process ???

4. How a 32-Bit App Can Determine When a Shelled Process Ends, Article ID: Q129796

5. Help with Determining Shell Process Ends

6. Shell launch / Process End

7. How a 32-Bit App Can Determine When a Shelled Process Ends

8. Determine When shelled process end

9. Determining when a shelled process ends

10. Shelled Process does not end

11. How a 32-Bit APP can Determine When a Shelled Process Ends - Q129796

12. Help: Wait for shelled process to end

 

 
Powered by phpBB® Forum Software