ProcessCreationFlags Enum, Member of ScriptUtils

Member of  ScriptUtils Use ProcessCreationFlags object | Changes | Purchase | Download

Description

Specifies additional flags that control the priority class and the creation of the process. The following creation flags can be specified in any combination, except as noted

Values

pcfNone = &H0 Default
pcfDEBUG_PROCESS = &H1 If this flag is set, the calling process is treated as a debugger, and the new process is a process being debugged. The system notifies the debugger of all debug events that occur in the process being debugged.
pcfDEBUG_ONLY_THIS_PROCESS = &H2 If not set and the calling process is being debugged, the new process becomes another process being debugged by the calling processís debugger. If the calling process is not a process being debugged, no debugging-related actions occur.
pcfCREATE_SUSPENDED = &H4 The primary thread of the new process is created in a suspended state, and does not run until the ResumeThread function is called.
pcfDETACHED_PROCESS = &H8  For console processes, the new process does not have access to the console of the parent process. The new process can call the AllocConsole function at a later time to create a new console. This flag cannot be used with the CREATE_NEW_CONSOLE flag.
pcfCREATE_NEW_CONSOLE = &H1016  The new process has a new console, instead of inheriting the parentís console. This flag cannot be used with the DETACHED_PROCESS flag.
pcfNORMAL_PRIORITY_CLASS = &H2032  Indicates a normal process with no special scheduling needs.
pcfIDLE_PRIORITY_CLASS = &H4064  Indicates a process whose threads run only when the system is idle and are preempted by the threads of any process running in a higher priority class. An example is a screen saver. The idle priority class is inherited by child processes.
pcfHIGH_PRIORITY_CLASS = &H80128  Indicates a process that performs time-critical tasks that must be executed immediately for it to run correctly. The threads of a high-priority class process preempt the threads of normal-priority or idle-priority class processes. An example is Windows Task List, which must respond quickly when called by the user, regardless of the load on the operating system. Use extreme care when using the high-priority class, because a high-priority class CPU-bound application can use nearly all available cycles.
pcfREALTIME_PRIORITY_CLASS = &H100256  Indicates a process that has the highest possible priority. The threads of a real-time priority class process preempt the threads of all other processes, including operating system processes performing important tasks. For example, a real-time process that executes for more than a very brief interval can cause disk caches not to flush or cause the mouse to be unresponsive.
pcfCREATE_NEW_PROCESS_GROUP = &H200512  The new process is the root process of a new process group. The process group includes all processes that are descendants of this root process. The process identifier of the new process group is the same as the process identifier, which is returned in the ProcessInformation parameter.
pcfCREATE_UNICODE_ENVIRONMENT = &H4001 024  If set, the environment block pointed to by lpEnvironment uses Unicode characters. If clear, the environment block uses ANSI characters. This flag is set by default.
pcfCREATE_SEPARATE_WOW_VDM = &H8002 048  This flag is valid only when starting a 16-bit Windows-based application. If set, the new process is run in a private Virtual DOS Machine (VDM). By default, all 16-bit Windows-based applications are run as threads in a single, shared VDM. The advantage of running separately is that a crash only kills the single VDM; any other programs running in distinct VDMs continue to function normally. Also, 16-bit Windows-based applications that are run in separate VDMs have separate input queues. That means that if one application hangs momentarily, applications in separate VDMs continue to receive input.
pcfCREATE_SHARED_WOW_VDM = &H10004 096  The flag is valid only when starting a 16-bit Windows-based application. If the DefaultSeparateVDM switch in the Windows section of WIN.INI is TRUE, this flag causes the CreateProcess function to override the switch and run the new process in the shared Virtual DOS Machine.
pcfCREATE_FORCEDOS = &H20008 192  
pcfCREATE_DEFAULT_ERROR_MODE = &H400000067 108 864  The new process does not inherit the error mode of the calling process. Instead, CreateProcess gives the new process the current default error mode.
pcfCREATE_NO_WINDOW = &H8000000134 217 728  

Includes

VBS include

'ProcessCreationFlags - begin
Public Const pcfNone = &H0 'Default
Public Const pcfDEBUG_PROCESS = &H1 'If this flag is set, the calling process is treated as a debugger, and the new process is a process being debugged. The system notifies the debugger of all debug events that occur in the process being debugged.
Public Const pcfDEBUG_ONLY_THIS_PROCESS = &H2 'If not set and the calling process is being debugged, the new process becomes another process being debugged by the calling processís debugger. If the calling process is not a process being debugged, no debugging-related actions occur.
Public Const pcfCREATE_SUSPENDED = &H4 'The primary thread of the new process is created in a suspended state, and does not run until the ResumeThread function is called.
Public Const pcfDETACHED_PROCESS = &H8 ' For console processes, the new process does not have access to the console of the parent process. The new process can call the AllocConsole function at a later time to create a new console. This flag cannot be used with the CREATE_NEW_CONSOLE flag.
Public Const pcfCREATE_NEW_CONSOLE = &H10 'The new process has a new console, instead of inheriting the parentís console. This flag cannot be used with the DETACHED_PROCESS flag.
Public Const pcfNORMAL_PRIORITY_CLASS = &H20 'Indicates a normal process with no special scheduling needs.
Public Const pcfIDLE_PRIORITY_CLASS = &H40 'Indicates a process whose threads run only when the system is idle and are preempted by the threads of any process running in a higher priority class. An example is a screen saver. The idle priority class is inherited by child processes.
Public Const pcfHIGH_PRIORITY_CLASS = &H80 'Indicates a process that performs time-critical tasks that must be executed immediately for it to run correctly. The threads of a high-priority class process preempt the threads of normal-priority or idle-priority class processes. An example is Windows Task List, which must respond quickly when called by the user, regardless of the load on the operating system. Use extreme care when using the high-priority class, because a high-priority class CPU-bound application can use nearly all available cycles.
Public Const pcfREALTIME_PRIORITY_CLASS = &H100 'Indicates a process that has the highest possible priority. The threads of a real-time priority class process preempt the threads of all other processes, including operating system processes performing important tasks. For example, a real-time process that executes for more than a very brief interval can cause disk caches not to flush or cause the mouse to be unresponsive.
Public Const pcfCREATE_NEW_PROCESS_GROUP = &H200 'The new process is the root process of a new process group. The process group includes all processes that are descendants of this root process. The process identifier of the new process group is the same as the process identifier, which is returned in the ProcessInformation parameter.
Public Const pcfCREATE_UNICODE_ENVIRONMENT = &H400 'If set, the environment block pointed to by lpEnvironment uses Unicode characters. If clear, the environment block uses ANSI characters. This flag is set by default.
Public Const pcfCREATE_SEPARATE_WOW_VDM = &H800 'This flag is valid only when starting a 16-bit Windows-based application. If set, the new process is run in a private Virtual DOS Machine (VDM). By default, all 16-bit Windows-based applications are run as threads in a single, shared VDM. The advantage of running separately is that a crash only kills the single VDM; any other programs running in distinct VDMs continue to function normally. Also, 16-bit Windows-based applications that are run in separate VDMs have separate input queues. That means that if one application hangs momentarily, applications in separate VDMs continue to receive input.
Public Const pcfCREATE_SHARED_WOW_VDM = &H1000 'The flag is valid only when starting a 16-bit Windows-based application. If the DefaultSeparateVDM switch in the Windows section of WIN.INI is TRUE, this flag causes the CreateProcess function to override the switch and run the new process in the shared Virtual DOS Machine.
Public Const pcfCREATE_FORCEDOS = &H2000
Public Const pcfCREATE_DEFAULT_ERROR_MODE = &H4000000 'The new process does not inherit the error mode of the calling process. Instead, CreateProcess gives the new process the current default error mode.
Public Const pcfCREATE_NO_WINDOW = &H8000000
'ProcessCreationFlags - end

VB4 include

'ProcessCreationFlags - begin
Public Const pcfNone As Long = &H0 'Default
Public Const pcfDEBUG_PROCESS As Long = &H1 'If this flag is set, the calling process is treated as a debugger, and the new process is a process being debugged. The system notifies the debugger of all debug events that occur in the process being debugged.
Public Const pcfDEBUG_ONLY_THIS_PROCESS As Long = &H2 'If not set and the calling process is being debugged, the new process becomes another process being debugged by the calling processís debugger. If the calling process is not a process being debugged, no debugging-related actions occur.
Public Const pcfCREATE_SUSPENDED As Long = &H4 'The primary thread of the new process is created in a suspended state, and does not run until the ResumeThread function is called.
Public Const pcfDETACHED_PROCESS As Long = &H8 ' For console processes, the new process does not have access to the console of the parent process. The new process can call the AllocConsole function at a later time to create a new console. This flag cannot be used with the CREATE_NEW_CONSOLE flag.
Public Const pcfCREATE_NEW_CONSOLE As Long = &H10 'The new process has a new console, instead of inheriting the parentís console. This flag cannot be used with the DETACHED_PROCESS flag.
Public Const pcfNORMAL_PRIORITY_CLASS As Long = &H20 'Indicates a normal process with no special scheduling needs.
Public Const pcfIDLE_PRIORITY_CLASS As Long = &H40 'Indicates a process whose threads run only when the system is idle and are preempted by the threads of any process running in a higher priority class. An example is a screen saver. The idle priority class is inherited by child processes.
Public Const pcfHIGH_PRIORITY_CLASS As Long = &H80 'Indicates a process that performs time-critical tasks that must be executed immediately for it to run correctly. The threads of a high-priority class process preempt the threads of normal-priority or idle-priority class processes. An example is Windows Task List, which must respond quickly when called by the user, regardless of the load on the operating system. Use extreme care when using the high-priority class, because a high-priority class CPU-bound application can use nearly all available cycles.
Public Const pcfREALTIME_PRIORITY_CLASS As Long = &H100 'Indicates a process that has the highest possible priority. The threads of a real-time priority class process preempt the threads of all other processes, including operating system processes performing important tasks. For example, a real-time process that executes for more than a very brief interval can cause disk caches not to flush or cause the mouse to be unresponsive.
Public Const pcfCREATE_NEW_PROCESS_GROUP As Long = &H200 'The new process is the root process of a new process group. The process group includes all processes that are descendants of this root process. The process identifier of the new process group is the same as the process identifier, which is returned in the ProcessInformation parameter.
Public Const pcfCREATE_UNICODE_ENVIRONMENT As Long = &H400 'If set, the environment block pointed to by lpEnvironment uses Unicode characters. If clear, the environment block uses ANSI characters. This flag is set by default.
Public Const pcfCREATE_SEPARATE_WOW_VDM As Long = &H800 'This flag is valid only when starting a 16-bit Windows-based application. If set, the new process is run in a private Virtual DOS Machine (VDM). By default, all 16-bit Windows-based applications are run as threads in a single, shared VDM. The advantage of running separately is that a crash only kills the single VDM; any other programs running in distinct VDMs continue to function normally. Also, 16-bit Windows-based applications that are run in separate VDMs have separate input queues. That means that if one application hangs momentarily, applications in separate VDMs continue to receive input.
Public Const pcfCREATE_SHARED_WOW_VDM As Long = &H1000 'The flag is valid only when starting a 16-bit Windows-based application. If the DefaultSeparateVDM switch in the Windows section of WIN.INI is TRUE, this flag causes the CreateProcess function to override the switch and run the new process in the shared Virtual DOS Machine.
Public Const pcfCREATE_FORCEDOS As Long = &H2000
Public Const pcfCREATE_DEFAULT_ERROR_MODE As Long = &H4000000 'The new process does not inherit the error mode of the calling process. Instead, CreateProcess gives the new process the current default error mode.
Public Const pcfCREATE_NO_WINDOW As Long = &H8000000
'ProcessCreationFlags - end

VB5 include

Public Enum ProcessCreationFlags
  pcfNone = &H0 'Default
  pcfDEBUG_PROCESS = &H1 'If this flag is set, the calling process is treated as a debugger, and the new process is a process being debugged. The system notifies the debugger of all debug events that occur in the process being debugged.
  pcfDEBUG_ONLY_THIS_PROCESS = &H2 'If not set and the calling process is being debugged, the new process becomes another process being debugged by the calling processís debugger. If the calling process is not a process being debugged, no debugging-related actions occur.
  pcfCREATE_SUSPENDED = &H4 'The primary thread of the new process is created in a suspended state, and does not run until the ResumeThread function is called.
  pcfDETACHED_PROCESS = &H8 ' For console processes, the new process does not have access to the console of the parent process. The new process can call the AllocConsole function at a later time to create a new console. This flag cannot be used with the CREATE_NEW_CONSOLE flag.
  pcfCREATE_NEW_CONSOLE = &H10 'The new process has a new console, instead of inheriting the parentís console. This flag cannot be used with the DETACHED_PROCESS flag.
  pcfNORMAL_PRIORITY_CLASS = &H20 'Indicates a normal process with no special scheduling needs.
  pcfIDLE_PRIORITY_CLASS = &H40 'Indicates a process whose threads run only when the system is idle and are preempted by the threads of any process running in a higher priority class. An example is a screen saver. The idle priority class is inherited by child processes.
  pcfHIGH_PRIORITY_CLASS = &H80 'Indicates a process that performs time-critical tasks that must be executed immediately for it to run correctly. The threads of a high-priority class process preempt the threads of normal-priority or idle-priority class processes. An example is Windows Task List, which must respond quickly when called by the user, regardless of the load on the operating system. Use extreme care when using the high-priority class, because a high-priority class CPU-bound application can use nearly all available cycles.
  pcfREALTIME_PRIORITY_CLASS = &H100 'Indicates a process that has the highest possible priority. The threads of a real-time priority class process preempt the threads of all other processes, including operating system processes performing important tasks. For example, a real-time process that executes for more than a very brief interval can cause disk caches not to flush or cause the mouse to be unresponsive.
  pcfCREATE_NEW_PROCESS_GROUP = &H200 'The new process is the root process of a new process group. The process group includes all processes that are descendants of this root process. The process identifier of the new process group is the same as the process identifier, which is returned in the ProcessInformation parameter.
  pcfCREATE_UNICODE_ENVIRONMENT = &H400 'If set, the environment block pointed to by lpEnvironment uses Unicode characters. If clear, the environment block uses ANSI characters. This flag is set by default.
  pcfCREATE_SEPARATE_WOW_VDM = &H800 'This flag is valid only when starting a 16-bit Windows-based application. If set, the new process is run in a private Virtual DOS Machine (VDM). By default, all 16-bit Windows-based applications are run as threads in a single, shared VDM. The advantage of running separately is that a crash only kills the single VDM; any other programs running in distinct VDMs continue to function normally. Also, 16-bit Windows-based applications that are run in separate VDMs have separate input queues. That means that if one application hangs momentarily, applications in separate VDMs continue to receive input.
  pcfCREATE_SHARED_WOW_VDM = &H1000 'The flag is valid only when starting a 16-bit Windows-based application. If the DefaultSeparateVDM switch in the Windows section of WIN.INI is TRUE, this flag causes the CreateProcess function to override the switch and run the new process in the shared Virtual DOS Machine.
  pcfCREATE_FORCEDOS = &H2000
  pcfCREATE_DEFAULT_ERROR_MODE = &H4000000 'The new process does not inherit the error mode of the calling process. Instead, CreateProcess gives the new process the current default error mode.
  pcfCREATE_NO_WINDOW = &H8000000
End Enum 'ProcessCreationFlags

JScript include

//ProcessCreationFlags - begin
var pcfNone = 0x0; //Default
var pcfDEBUG_PROCESS = 0x1; //If this flag is set, the calling process is treated as a debugger, and the new process is a process being debugged. The system notifies the debugger of all debug events that occur in the process being debugged.
var pcfDEBUG_ONLY_THIS_PROCESS = 0x2; //If not set and the calling process is being debugged, the new process becomes another process being debugged by the calling processís debugger. If the calling process is not a process being debugged, no debugging-related actions occur.
var pcfCREATE_SUSPENDED = 0x4; //The primary thread of the new process is created in a suspended state, and does not run until the ResumeThread function is called.
var pcfDETACHED_PROCESS = 0x8; // For console processes, the new process does not have access to the console of the parent process. The new process can call the AllocConsole function at a later time to create a new console. This flag cannot be used with the CREATE_NEW_CONSOLE flag.
var pcfCREATE_NEW_CONSOLE = 0x10; //The new process has a new console, instead of inheriting the parentís console. This flag cannot be used with the DETACHED_PROCESS flag.
var pcfNORMAL_PRIORITY_CLASS = 0x20; //Indicates a normal process with no special scheduling needs.
var pcfIDLE_PRIORITY_CLASS = 0x40; //Indicates a process whose threads run only when the system is idle and are preempted by the threads of any process running in a higher priority class. An example is a screen saver. The idle priority class is inherited by child processes.
var pcfHIGH_PRIORITY_CLASS = 0x80; //Indicates a process that performs time-critical tasks that must be executed immediately for it to run correctly. The threads of a high-priority class process preempt the threads of normal-priority or idle-priority class processes. An example is Windows Task List, which must respond quickly when called by the user, regardless of the load on the operating system. Use extreme care when using the high-priority class, because a high-priority class CPU-bound application can use nearly all available cycles.
var pcfREALTIME_PRIORITY_CLASS = 0x100; //Indicates a process that has the highest possible priority. The threads of a real-time priority class process preempt the threads of all other processes, including operating system processes performing important tasks. For example, a real-time process that executes for more than a very brief interval can cause disk caches not to flush or cause the mouse to be unresponsive.
var pcfCREATE_NEW_PROCESS_GROUP = 0x200; //The new process is the root process of a new process group. The process group includes all processes that are descendants of this root process. The process identifier of the new process group is the same as the process identifier, which is returned in the ProcessInformation parameter.
var pcfCREATE_UNICODE_ENVIRONMENT = 0x400; //If set, the environment block pointed to by lpEnvironment uses Unicode characters. If clear, the environment block uses ANSI characters. This flag is set by default.
var pcfCREATE_SEPARATE_WOW_VDM = 0x800; //This flag is valid only when starting a 16-bit Windows-based application. If set, the new process is run in a private Virtual DOS Machine (VDM). By default, all 16-bit Windows-based applications are run as threads in a single, shared VDM. The advantage of running separately is that a crash only kills the single VDM; any other programs running in distinct VDMs continue to function normally. Also, 16-bit Windows-based applications that are run in separate VDMs have separate input queues. That means that if one application hangs momentarily, applications in separate VDMs continue to receive input.
var pcfCREATE_SHARED_WOW_VDM = 0x1000; //The flag is valid only when starting a 16-bit Windows-based application. If the DefaultSeparateVDM switch in the Windows section of WIN.INI is TRUE, this flag causes the CreateProcess function to override the switch and run the new process in the shared Virtual DOS Machine.
var pcfCREATE_FORCEDOS = 0x2000;
var pcfCREATE_DEFAULT_ERROR_MODE = 0x4000000; //The new process does not inherit the error mode of the calling process. Instead, CreateProcess gives the new process the current default error mode.
var pcfCREATE_NO_WINDOW = 0x8000000;
//ProcessCreationFlags - end

IDL include

// ProcessCreationFlags
typedef [helpcontext(0x20025), helpstring("Specifies additional flags that control the priority class and the creation of the process. The following creation flags can be specified in any combination, except as noted")]
enum ProcessCreationFlags{
	[helpcontext(0x20025), helpstring("Default")]
		pcfNone = 0x0,
	[helpcontext(0x20025), helpstring("If this flag is set, the calling process is treated as a debugger, and the new process is a process being debugged. The system notifies the debugger of all debug events that occur in the process being debugged.")]
		pcfDEBUG_PROCESS = 0x1,
	[helpcontext(0x20025), helpstring("If not set and the calling process is being debugged, the new process becomes another process being debugged by the calling processís debugger. If the calling process is not a process being debugged, no debugging-related actions occur.")]
		pcfDEBUG_ONLY_THIS_PROCESS = 0x2,
	[helpcontext(0x20025), helpstring("The primary thread of the new process is created in a suspended state, and does not run until the ResumeThread function is called.")]
		pcfCREATE_SUSPENDED = 0x4,
	[helpcontext(0x20025), helpstring(" For console processes, the new process does not have access to the console of the parent process. The new process can call the AllocConsole function at a later time to create a new console. This flag cannot be used with the CREATE_NEW_CONSOLE flag.")]
		pcfDETACHED_PROCESS = 0x8,
	[helpcontext(0x20025), helpstring("The new process has a new console, instead of inheriting the parentís console. This flag cannot be used with the DETACHED_PROCESS flag.")]
		pcfCREATE_NEW_CONSOLE = 0x10,
	[helpcontext(0x20025), helpstring("Indicates a normal process with no special scheduling needs.")]
		pcfNORMAL_PRIORITY_CLASS = 0x20,
	[helpcontext(0x20025), helpstring("Indicates a process whose threads run only when the system is idle and are preempted by the threads of any process running in a higher priority class. An example is a screen saver. The idle priority class is inherited by child processes.")]
		pcfIDLE_PRIORITY_CLASS = 0x40,
	[helpcontext(0x20025), helpstring("Indicates a process that performs time-critical tasks that must be executed immediately for it to run correctly. The threads of a high-priority class process preempt the threads of normal-priority or idle-priority class processes. An example is Windows Ta")]
		pcfHIGH_PRIORITY_CLASS = 0x80,
	[helpcontext(0x20025), helpstring("Indicates a process that has the highest possible priority. The threads of a real-time priority class process preempt the threads of all other processes, including operating system processes performing important tasks. For example, a real-time process tha")]
		pcfREALTIME_PRIORITY_CLASS = 0x100,
	[helpcontext(0x20025), helpstring("The new process is the root process of a new process group. The process group includes all processes that are descendants of this root process. The process identifier of the new process group is the same as the process identifier, which is returned in the")]
		pcfCREATE_NEW_PROCESS_GROUP = 0x200,
	[helpcontext(0x20025), helpstring("If set, the environment block pointed to by lpEnvironment uses Unicode characters. If clear, the environment block uses ANSI characters. This flag is set by default.")]
		pcfCREATE_UNICODE_ENVIRONMENT = 0x400,
	[helpcontext(0x20025), helpstring("This flag is valid only when starting a 16-bit Windows-based application. If set, the new process is run in a private Virtual DOS Machine (VDM). By default, all 16-bit Windows-based applications are run as threads in a single, shared VDM. The advantage of")]
		pcfCREATE_SEPARATE_WOW_VDM = 0x800,
	[helpcontext(0x20025), helpstring("The flag is valid only when starting a 16-bit Windows-based application. If the DefaultSeparateVDM switch in the Windows section of WIN.INI is TRUE, this flag causes the CreateProcess function to override the switch and run the new process in the shared V")]
		pcfCREATE_SHARED_WOW_VDM = 0x1000,
	[helpcontext(0x20025)]
		pcfCREATE_FORCEDOS = 0x2000,
	[helpcontext(0x20025), helpstring("The new process does not inherit the error mode of the calling process. Instead, CreateProcess gives the new process the current default error mode.")]
		pcfCREATE_DEFAULT_ERROR_MODE = 0x4000000,
	[helpcontext(0x20025)]
		pcfCREATE_NO_WINDOW = 0x8000000
} ProcessCreationFlags;

Used in

Kernel.CreateProcess

Other links for ProcessCreationFlags class

ASP file upload and ScriptUtilities classes

Kernel, ByteArray, Process, Thread, Advapi, INIFile, ZLib, LogFile, ASPForm, FormFields, FormField, FormParser, ProgressInfo

ASP file upload and ScriptUtilities enums

ProcessCreationFlags, ThreadPriorities, PriorityClasses, LogonTypes, ConvertCodePages, OutputTypes, ZLibCompressLevels, ConvertTypes, LogLineEncodes, LogLineBeginTypes, FormStates, eFormType

ScriptUtils

Huge ASP upload is easy to use, hi-performance ASP file upload component with progress bar indicator. This component lets you upload multiple files with size up to 4GB to a disk or a database along with another form fields. Huge ASP file upload is a most featured upload component on a market with competitive price and a great performance . The software has also a free version of asp upload with progress, called Pure asp upload , written in plain VBS, without components (so you do not need to install anything on server). This installation package contains also ScriptUtilities library. Script Utilities lets you create hi-performance log files , works with binary data , you can download multiple files with zip/arj compression, work with INI files and much more with the ASP utility.

© 1996 - 2014 Antonin Foller, Motobit Software | About, Contacts | (Find us on Google+)


Other Motobit links:   IISTracer, real-time IIS monitor   ASP file upload - upload files to ASP. 
ActiveX/VBSScript registry editor  ActiveX NT User account manager  Export MDB/DBF from ASP Active LogFile  Email export  ActiveX/ASP Scripting Dictionary object

Motobit.com