mirror of
https://gitee.com/csharpui/CPF.git
synced 2025-04-05 17:37:51 +08:00
482 lines
13 KiB
C#
482 lines
13 KiB
C#
using CPF.Mac.ObjCRuntime;
|
|
using System;
|
|
using System.ComponentModel;
|
|
|
|
namespace CPF.Mac.Foundation
|
|
{
|
|
[Register("NSTask", true)]
|
|
public class NSTask : NSObject
|
|
{
|
|
private static readonly IntPtr selLaunchPathHandle = Selector.GetHandle("launchPath");
|
|
|
|
private static readonly IntPtr selSetLaunchPath_Handle = Selector.GetHandle("setLaunchPath:");
|
|
|
|
private static readonly IntPtr selArgumentsHandle = Selector.GetHandle("arguments");
|
|
|
|
private static readonly IntPtr selSetArguments_Handle = Selector.GetHandle("setArguments:");
|
|
|
|
private static readonly IntPtr selEnvironmentHandle = Selector.GetHandle("environment");
|
|
|
|
private static readonly IntPtr selSetEnvironment_Handle = Selector.GetHandle("setEnvironment:");
|
|
|
|
private static readonly IntPtr selCurrentDirectoryPathHandle = Selector.GetHandle("currentDirectoryPath");
|
|
|
|
private static readonly IntPtr selSetCurrentDirectoryPath_Handle = Selector.GetHandle("setCurrentDirectoryPath:");
|
|
|
|
private static readonly IntPtr selStandardInputHandle = Selector.GetHandle("standardInput");
|
|
|
|
private static readonly IntPtr selSetStandardInput_Handle = Selector.GetHandle("setStandardInput:");
|
|
|
|
private static readonly IntPtr selStandardOutputHandle = Selector.GetHandle("standardOutput");
|
|
|
|
private static readonly IntPtr selSetStandardOutput_Handle = Selector.GetHandle("setStandardOutput:");
|
|
|
|
private static readonly IntPtr selStandardErrorHandle = Selector.GetHandle("standardError");
|
|
|
|
private static readonly IntPtr selSetStandardError_Handle = Selector.GetHandle("setStandardError:");
|
|
|
|
private static readonly IntPtr selIsRunningHandle = Selector.GetHandle("isRunning");
|
|
|
|
private static readonly IntPtr selProcessIdentifierHandle = Selector.GetHandle("processIdentifier");
|
|
|
|
private static readonly IntPtr selTerminationStatusHandle = Selector.GetHandle("terminationStatus");
|
|
|
|
private static readonly IntPtr selTerminationReasonHandle = Selector.GetHandle("terminationReason");
|
|
|
|
private static readonly IntPtr selLaunchHandle = Selector.GetHandle("launch");
|
|
|
|
private static readonly IntPtr selInterruptHandle = Selector.GetHandle("interrupt");
|
|
|
|
private static readonly IntPtr selTerminateHandle = Selector.GetHandle("terminate");
|
|
|
|
private static readonly IntPtr selSuspendHandle = Selector.GetHandle("suspend");
|
|
|
|
private static readonly IntPtr selResumeHandle = Selector.GetHandle("resume");
|
|
|
|
private static readonly IntPtr selWaitUntilExitHandle = Selector.GetHandle("waitUntilExit");
|
|
|
|
private static readonly IntPtr selLaunchedTaskWithLaunchPathArguments_Handle = Selector.GetHandle("launchedTaskWithLaunchPath:arguments:");
|
|
|
|
private static readonly IntPtr class_ptr = Class.GetHandle("NSTask");
|
|
|
|
private object __mt_Environment_var;
|
|
|
|
private object __mt_StandardInput_var;
|
|
|
|
private object __mt_StandardOutput_var;
|
|
|
|
private object __mt_StandardError_var;
|
|
|
|
private static NSString _NSTaskDidTerminateNotification;
|
|
|
|
public override IntPtr ClassHandle => class_ptr;
|
|
|
|
public virtual string LaunchPath
|
|
{
|
|
[Export("launchPath")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selLaunchPathHandle));
|
|
}
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selLaunchPathHandle));
|
|
}
|
|
[Export("setLaunchPath:")]
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(value);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetLaunchPath_Handle, intPtr);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetLaunchPath_Handle, intPtr);
|
|
}
|
|
NSString.ReleaseNative(intPtr);
|
|
}
|
|
}
|
|
|
|
public virtual string[] Arguments
|
|
{
|
|
[Export("arguments")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSArray.StringArrayFromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selArgumentsHandle));
|
|
}
|
|
return NSArray.StringArrayFromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selArgumentsHandle));
|
|
}
|
|
[Export("setArguments:")]
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
NSArray nSArray = NSArray.FromStrings(value);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetArguments_Handle, nSArray.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetArguments_Handle, nSArray.Handle);
|
|
}
|
|
nSArray.Dispose();
|
|
}
|
|
}
|
|
|
|
public virtual NSDictionary Environment
|
|
{
|
|
[Export("environment")]
|
|
get
|
|
{
|
|
return (NSDictionary)(__mt_Environment_var = ((!IsDirectBinding) ? ((NSDictionary)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selEnvironmentHandle))) : ((NSDictionary)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selEnvironmentHandle)))));
|
|
}
|
|
[Export("setEnvironment:")]
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetEnvironment_Handle, value.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetEnvironment_Handle, value.Handle);
|
|
}
|
|
__mt_Environment_var = value;
|
|
}
|
|
}
|
|
|
|
public virtual string CurrentDirectoryPath
|
|
{
|
|
[Export("currentDirectoryPath")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selCurrentDirectoryPathHandle));
|
|
}
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selCurrentDirectoryPathHandle));
|
|
}
|
|
[Export("setCurrentDirectoryPath:")]
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(value);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetCurrentDirectoryPath_Handle, intPtr);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetCurrentDirectoryPath_Handle, intPtr);
|
|
}
|
|
NSString.ReleaseNative(intPtr);
|
|
}
|
|
}
|
|
|
|
public virtual NSObject StandardInput
|
|
{
|
|
[Export("standardInput")]
|
|
get
|
|
{
|
|
return (NSObject)(__mt_StandardInput_var = ((!IsDirectBinding) ? Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selStandardInputHandle)) : Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selStandardInputHandle))));
|
|
}
|
|
[Export("setStandardInput:")]
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetStandardInput_Handle, value.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetStandardInput_Handle, value.Handle);
|
|
}
|
|
__mt_StandardInput_var = value;
|
|
}
|
|
}
|
|
|
|
public virtual NSObject StandardOutput
|
|
{
|
|
[Export("standardOutput")]
|
|
get
|
|
{
|
|
return (NSObject)(__mt_StandardOutput_var = ((!IsDirectBinding) ? Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selStandardOutputHandle)) : Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selStandardOutputHandle))));
|
|
}
|
|
[Export("setStandardOutput:")]
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetStandardOutput_Handle, value.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetStandardOutput_Handle, value.Handle);
|
|
}
|
|
__mt_StandardOutput_var = value;
|
|
}
|
|
}
|
|
|
|
public virtual NSObject StandardError
|
|
{
|
|
[Export("standardError")]
|
|
get
|
|
{
|
|
return (NSObject)(__mt_StandardError_var = ((!IsDirectBinding) ? Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selStandardErrorHandle)) : Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selStandardErrorHandle))));
|
|
}
|
|
[Export("setStandardError:")]
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetStandardError_Handle, value.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetStandardError_Handle, value.Handle);
|
|
}
|
|
__mt_StandardError_var = value;
|
|
}
|
|
}
|
|
|
|
public virtual bool IsRunning
|
|
{
|
|
[Export("isRunning")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selIsRunningHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selIsRunningHandle);
|
|
}
|
|
}
|
|
|
|
public virtual int ProcessIdentifier
|
|
{
|
|
[Export("processIdentifier")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.int_objc_msgSend(base.Handle, selProcessIdentifierHandle);
|
|
}
|
|
return Messaging.int_objc_msgSendSuper(base.SuperHandle, selProcessIdentifierHandle);
|
|
}
|
|
}
|
|
|
|
public virtual int TerminationStatus
|
|
{
|
|
[Export("terminationStatus")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.int_objc_msgSend(base.Handle, selTerminationStatusHandle);
|
|
}
|
|
return Messaging.int_objc_msgSendSuper(base.SuperHandle, selTerminationStatusHandle);
|
|
}
|
|
}
|
|
|
|
public virtual NSTaskTerminationReason TerminationReason
|
|
{
|
|
[Export("terminationReason")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return (NSTaskTerminationReason)Messaging.int_objc_msgSend(base.Handle, selTerminationReasonHandle);
|
|
}
|
|
return (NSTaskTerminationReason)Messaging.int_objc_msgSendSuper(base.SuperHandle, selTerminationReasonHandle);
|
|
}
|
|
}
|
|
|
|
[Field("NSTaskDidTerminateNotification", "Foundation")]
|
|
public static NSString NSTaskDidTerminateNotification
|
|
{
|
|
get
|
|
{
|
|
if (_NSTaskDidTerminateNotification == null)
|
|
{
|
|
_NSTaskDidTerminateNotification = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSTaskDidTerminateNotification");
|
|
}
|
|
return _NSTaskDidTerminateNotification;
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
[Export("init")]
|
|
public NSTask()
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend(base.Handle, Selector.Init);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, Selector.Init);
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
[Export("initWithCoder:")]
|
|
public NSTask(NSCoder coder)
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, Selector.InitWithCoder, coder.Handle);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, Selector.InitWithCoder, coder.Handle);
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public NSTask(NSObjectFlag t)
|
|
: base(t)
|
|
{
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public NSTask(IntPtr handle)
|
|
: base(handle)
|
|
{
|
|
}
|
|
|
|
[Export("launch")]
|
|
public virtual void Launch()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selLaunchHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selLaunchHandle);
|
|
}
|
|
}
|
|
|
|
[Export("interrupt")]
|
|
public virtual void Interrupt()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selInterruptHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selInterruptHandle);
|
|
}
|
|
}
|
|
|
|
[Export("terminate")]
|
|
public virtual void Terminate()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selTerminateHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selTerminateHandle);
|
|
}
|
|
}
|
|
|
|
[Export("suspend")]
|
|
public virtual bool Suspend()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selSuspendHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selSuspendHandle);
|
|
}
|
|
|
|
[Export("resume")]
|
|
public virtual bool Resume()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selResumeHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selResumeHandle);
|
|
}
|
|
|
|
[Export("waitUntilExit")]
|
|
public virtual void WaitUntilExit()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selWaitUntilExitHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selWaitUntilExitHandle);
|
|
}
|
|
}
|
|
|
|
[Export("launchedTaskWithLaunchPath:arguments:")]
|
|
public static NSTask LaunchFromPath(string path, string[] arguments)
|
|
{
|
|
if (path == null)
|
|
{
|
|
throw new ArgumentNullException("path");
|
|
}
|
|
if (arguments == null)
|
|
{
|
|
throw new ArgumentNullException("arguments");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(path);
|
|
NSArray nSArray = NSArray.FromStrings(arguments);
|
|
NSTask result = (NSTask)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr_IntPtr(class_ptr, selLaunchedTaskWithLaunchPathArguments_Handle, intPtr, nSArray.Handle));
|
|
NSString.ReleaseNative(intPtr);
|
|
nSArray.Dispose();
|
|
return result;
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
base.Dispose(disposing);
|
|
if (base.Handle == IntPtr.Zero)
|
|
{
|
|
__mt_Environment_var = null;
|
|
__mt_StandardInput_var = null;
|
|
__mt_StandardOutput_var = null;
|
|
__mt_StandardError_var = null;
|
|
}
|
|
}
|
|
}
|
|
}
|