mirror of
https://gitee.com/csharpui/CPF.git
synced 2025-04-05 17:37:51 +08:00
674 lines
22 KiB
C#
674 lines
22 KiB
C#
using CPF.Mac.ObjCRuntime;
|
|
using System;
|
|
using System.ComponentModel;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace CPF.Mac.Foundation
|
|
{
|
|
[Register("NSFileHandle", true)]
|
|
public class NSFileHandle : NSObject
|
|
{
|
|
public static class Notifications
|
|
{
|
|
public static NSObject ObserveReadCompletion(EventHandler<NSFileHandleReadEventArgs> handler)
|
|
{
|
|
return NSNotificationCenter.DefaultCenter.AddObserver(ReadCompletionNotification, delegate(NSNotification notification)
|
|
{
|
|
handler(null, new NSFileHandleReadEventArgs(notification));
|
|
});
|
|
}
|
|
|
|
public static NSObject ObserveReadToEndOfFileCompletion(EventHandler<NSFileHandleReadEventArgs> handler)
|
|
{
|
|
return NSNotificationCenter.DefaultCenter.AddObserver(ReadToEndOfFileCompletionNotification, delegate(NSNotification notification)
|
|
{
|
|
handler(null, new NSFileHandleReadEventArgs(notification));
|
|
});
|
|
}
|
|
|
|
public static NSObject ObserveConnectionAccepted(EventHandler<NSFileHandleConnectionAcceptedEventArgs> handler)
|
|
{
|
|
return NSNotificationCenter.DefaultCenter.AddObserver(ConnectionAcceptedNotification, delegate(NSNotification notification)
|
|
{
|
|
handler(null, new NSFileHandleConnectionAcceptedEventArgs(notification));
|
|
});
|
|
}
|
|
|
|
public static NSObject ObserveDataAvailable(EventHandler<NSNotificationEventArgs> handler)
|
|
{
|
|
return NSNotificationCenter.DefaultCenter.AddObserver(DataAvailableNotification, delegate(NSNotification notification)
|
|
{
|
|
handler(null, new NSNotificationEventArgs(notification));
|
|
});
|
|
}
|
|
}
|
|
|
|
private static readonly IntPtr selFileDescriptorHandle = Selector.GetHandle("fileDescriptor");
|
|
|
|
private static readonly IntPtr selAvailableDataHandle = Selector.GetHandle("availableData");
|
|
|
|
private static readonly IntPtr selReadDataToEndOfFileHandle = Selector.GetHandle("readDataToEndOfFile");
|
|
|
|
private static readonly IntPtr selReadDataOfLength_Handle = Selector.GetHandle("readDataOfLength:");
|
|
|
|
private static readonly IntPtr selWriteData_Handle = Selector.GetHandle("writeData:");
|
|
|
|
private static readonly IntPtr selOffsetInFileHandle = Selector.GetHandle("offsetInFile");
|
|
|
|
private static readonly IntPtr selSeekToEndOfFileHandle = Selector.GetHandle("seekToEndOfFile");
|
|
|
|
private static readonly IntPtr selSeekToFileOffset_Handle = Selector.GetHandle("seekToFileOffset:");
|
|
|
|
private static readonly IntPtr selTruncateFileAtOffset_Handle = Selector.GetHandle("truncateFileAtOffset:");
|
|
|
|
private static readonly IntPtr selSynchronizeFileHandle = Selector.GetHandle("synchronizeFile");
|
|
|
|
private static readonly IntPtr selCloseFileHandle = Selector.GetHandle("closeFile");
|
|
|
|
private static readonly IntPtr selFileHandleWithStandardInputHandle = Selector.GetHandle("fileHandleWithStandardInput");
|
|
|
|
private static readonly IntPtr selFileHandleWithStandardOutputHandle = Selector.GetHandle("fileHandleWithStandardOutput");
|
|
|
|
private static readonly IntPtr selFileHandleWithStandardErrorHandle = Selector.GetHandle("fileHandleWithStandardError");
|
|
|
|
private static readonly IntPtr selFileHandleWithNullDeviceHandle = Selector.GetHandle("fileHandleWithNullDevice");
|
|
|
|
private static readonly IntPtr selFileHandleForReadingAtPath_Handle = Selector.GetHandle("fileHandleForReadingAtPath:");
|
|
|
|
private static readonly IntPtr selFileHandleForWritingAtPath_Handle = Selector.GetHandle("fileHandleForWritingAtPath:");
|
|
|
|
private static readonly IntPtr selFileHandleForUpdatingAtPath_Handle = Selector.GetHandle("fileHandleForUpdatingAtPath:");
|
|
|
|
private static readonly IntPtr selFileHandleForReadingFromURLError_Handle = Selector.GetHandle("fileHandleForReadingFromURL:error:");
|
|
|
|
private static readonly IntPtr selFileHandleForWritingToURLError_Handle = Selector.GetHandle("fileHandleForWritingToURL:error:");
|
|
|
|
private static readonly IntPtr selFileHandleForUpdatingURLError_Handle = Selector.GetHandle("fileHandleForUpdatingURL:error:");
|
|
|
|
private static readonly IntPtr selReadInBackgroundAndNotifyForModes_Handle = Selector.GetHandle("readInBackgroundAndNotifyForModes:");
|
|
|
|
private static readonly IntPtr selReadInBackgroundAndNotifyHandle = Selector.GetHandle("readInBackgroundAndNotify");
|
|
|
|
private static readonly IntPtr selReadToEndOfFileInBackgroundAndNotifyForModes_Handle = Selector.GetHandle("readToEndOfFileInBackgroundAndNotifyForModes:");
|
|
|
|
private static readonly IntPtr selReadToEndOfFileInBackgroundAndNotifyHandle = Selector.GetHandle("readToEndOfFileInBackgroundAndNotify");
|
|
|
|
private static readonly IntPtr selAcceptConnectionInBackgroundAndNotifyForModes_Handle = Selector.GetHandle("acceptConnectionInBackgroundAndNotifyForModes:");
|
|
|
|
private static readonly IntPtr selAcceptConnectionInBackgroundAndNotifyHandle = Selector.GetHandle("acceptConnectionInBackgroundAndNotify");
|
|
|
|
private static readonly IntPtr selWaitForDataInBackgroundAndNotifyForModes_Handle = Selector.GetHandle("waitForDataInBackgroundAndNotifyForModes:");
|
|
|
|
private static readonly IntPtr selWaitForDataInBackgroundAndNotifyHandle = Selector.GetHandle("waitForDataInBackgroundAndNotify");
|
|
|
|
private static readonly IntPtr selInitWithFileDescriptorCloseOnDealloc_Handle = Selector.GetHandle("initWithFileDescriptor:closeOnDealloc:");
|
|
|
|
private static readonly IntPtr selInitWithFileDescriptor_Handle = Selector.GetHandle("initWithFileDescriptor:");
|
|
|
|
private static readonly IntPtr selSetReadabilityHandler_Handle = Selector.GetHandle("setReadabilityHandler:");
|
|
|
|
private static readonly IntPtr selSetWriteabilityHandler_Handle = Selector.GetHandle("setWriteabilityHandler:");
|
|
|
|
private static readonly IntPtr class_ptr = Class.GetHandle("NSFileHandle");
|
|
|
|
private static NSString _OperationException;
|
|
|
|
private static NSString _ReadCompletionNotification;
|
|
|
|
private static NSString _ReadToEndOfFileCompletionNotification;
|
|
|
|
private static NSString _ConnectionAcceptedNotification;
|
|
|
|
private static NSString _DataAvailableNotification;
|
|
|
|
public override IntPtr ClassHandle => class_ptr;
|
|
|
|
public virtual int FileDescriptor
|
|
{
|
|
[Export("fileDescriptor")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.int_objc_msgSend(base.Handle, selFileDescriptorHandle);
|
|
}
|
|
return Messaging.int_objc_msgSendSuper(base.SuperHandle, selFileDescriptorHandle);
|
|
}
|
|
}
|
|
|
|
[Field("NSFileHandleOperationException", "Foundation")]
|
|
public static NSString OperationException
|
|
{
|
|
get
|
|
{
|
|
if (_OperationException == null)
|
|
{
|
|
_OperationException = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSFileHandleOperationException");
|
|
}
|
|
return _OperationException;
|
|
}
|
|
}
|
|
|
|
[Field("NSFileHandleReadCompletionNotification", "Foundation")]
|
|
public static NSString ReadCompletionNotification
|
|
{
|
|
get
|
|
{
|
|
if (_ReadCompletionNotification == null)
|
|
{
|
|
_ReadCompletionNotification = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSFileHandleReadCompletionNotification");
|
|
}
|
|
return _ReadCompletionNotification;
|
|
}
|
|
}
|
|
|
|
[Field("NSFileHandleReadToEndOfFileCompletionNotification", "Foundation")]
|
|
public static NSString ReadToEndOfFileCompletionNotification
|
|
{
|
|
get
|
|
{
|
|
if (_ReadToEndOfFileCompletionNotification == null)
|
|
{
|
|
_ReadToEndOfFileCompletionNotification = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSFileHandleReadToEndOfFileCompletionNotification");
|
|
}
|
|
return _ReadToEndOfFileCompletionNotification;
|
|
}
|
|
}
|
|
|
|
[Field("NSFileHandleConnectionAcceptedNotification", "Foundation")]
|
|
public static NSString ConnectionAcceptedNotification
|
|
{
|
|
get
|
|
{
|
|
if (_ConnectionAcceptedNotification == null)
|
|
{
|
|
_ConnectionAcceptedNotification = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSFileHandleConnectionAcceptedNotification");
|
|
}
|
|
return _ConnectionAcceptedNotification;
|
|
}
|
|
}
|
|
|
|
[Field("NSFileHandleDataAvailableNotification", "Foundation")]
|
|
public static NSString DataAvailableNotification
|
|
{
|
|
get
|
|
{
|
|
if (_DataAvailableNotification == null)
|
|
{
|
|
_DataAvailableNotification = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSFileHandleDataAvailableNotification");
|
|
}
|
|
return _DataAvailableNotification;
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
[Export("initWithCoder:")]
|
|
public NSFileHandle(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 NSFileHandle(NSObjectFlag t)
|
|
: base(t)
|
|
{
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public NSFileHandle(IntPtr handle)
|
|
: base(handle)
|
|
{
|
|
}
|
|
|
|
[Export("availableData")]
|
|
public virtual NSData AvailableData()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return (NSData)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selAvailableDataHandle));
|
|
}
|
|
return (NSData)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selAvailableDataHandle));
|
|
}
|
|
|
|
[Export("readDataToEndOfFile")]
|
|
public virtual NSData ReadDataToEndOfFile()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return (NSData)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selReadDataToEndOfFileHandle));
|
|
}
|
|
return (NSData)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selReadDataToEndOfFileHandle));
|
|
}
|
|
|
|
[Export("readDataOfLength:")]
|
|
public virtual NSData ReadDataOfLength(ulong length)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return (NSData)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_UInt64(base.Handle, selReadDataOfLength_Handle, length));
|
|
}
|
|
return (NSData)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper_UInt64(base.SuperHandle, selReadDataOfLength_Handle, length));
|
|
}
|
|
|
|
[Export("writeData:")]
|
|
public virtual void WriteData(NSData data)
|
|
{
|
|
if (data == null)
|
|
{
|
|
throw new ArgumentNullException("data");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selWriteData_Handle, data.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selWriteData_Handle, data.Handle);
|
|
}
|
|
}
|
|
|
|
[Export("offsetInFile")]
|
|
public virtual ulong OffsetInFile()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.UInt64_objc_msgSend(base.Handle, selOffsetInFileHandle);
|
|
}
|
|
return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selOffsetInFileHandle);
|
|
}
|
|
|
|
[Export("seekToEndOfFile")]
|
|
public virtual ulong SeekToEndOfFile()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.UInt64_objc_msgSend(base.Handle, selSeekToEndOfFileHandle);
|
|
}
|
|
return Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selSeekToEndOfFileHandle);
|
|
}
|
|
|
|
[Export("seekToFileOffset:")]
|
|
public virtual void SeekToFileOffset(ulong offset)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_UInt64(base.Handle, selSeekToFileOffset_Handle, offset);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_UInt64(base.SuperHandle, selSeekToFileOffset_Handle, offset);
|
|
}
|
|
}
|
|
|
|
[Export("truncateFileAtOffset:")]
|
|
public virtual void TruncateFileAtOffset(ulong offset)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_UInt64(base.Handle, selTruncateFileAtOffset_Handle, offset);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_UInt64(base.SuperHandle, selTruncateFileAtOffset_Handle, offset);
|
|
}
|
|
}
|
|
|
|
[Export("synchronizeFile")]
|
|
public virtual void SynchronizeFile()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selSynchronizeFileHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selSynchronizeFileHandle);
|
|
}
|
|
}
|
|
|
|
[Export("closeFile")]
|
|
public virtual void CloseFile()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selCloseFileHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selCloseFileHandle);
|
|
}
|
|
}
|
|
|
|
[Export("fileHandleWithStandardInput")]
|
|
public static NSFileHandle FromStandardInput()
|
|
{
|
|
return (NSFileHandle)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(class_ptr, selFileHandleWithStandardInputHandle));
|
|
}
|
|
|
|
[Export("fileHandleWithStandardOutput")]
|
|
public static NSFileHandle FromStandardOutput()
|
|
{
|
|
return (NSFileHandle)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(class_ptr, selFileHandleWithStandardOutputHandle));
|
|
}
|
|
|
|
[Export("fileHandleWithStandardError")]
|
|
public static NSFileHandle FromStandardError()
|
|
{
|
|
return (NSFileHandle)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(class_ptr, selFileHandleWithStandardErrorHandle));
|
|
}
|
|
|
|
[Export("fileHandleWithNullDevice")]
|
|
public static NSFileHandle FromNullDevice()
|
|
{
|
|
return (NSFileHandle)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(class_ptr, selFileHandleWithNullDeviceHandle));
|
|
}
|
|
|
|
[Export("fileHandleForReadingAtPath:")]
|
|
public static NSFileHandle OpenRead(string path)
|
|
{
|
|
if (path == null)
|
|
{
|
|
throw new ArgumentNullException("path");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(path);
|
|
NSFileHandle result = (NSFileHandle)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(class_ptr, selFileHandleForReadingAtPath_Handle, intPtr));
|
|
NSString.ReleaseNative(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("fileHandleForWritingAtPath:")]
|
|
public static NSFileHandle OpenWrite(string path)
|
|
{
|
|
if (path == null)
|
|
{
|
|
throw new ArgumentNullException("path");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(path);
|
|
NSFileHandle result = (NSFileHandle)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(class_ptr, selFileHandleForWritingAtPath_Handle, intPtr));
|
|
NSString.ReleaseNative(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("fileHandleForUpdatingAtPath:")]
|
|
public static NSFileHandle OpenUpdate(string path)
|
|
{
|
|
if (path == null)
|
|
{
|
|
throw new ArgumentNullException("path");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(path);
|
|
NSFileHandle result = (NSFileHandle)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(class_ptr, selFileHandleForUpdatingAtPath_Handle, intPtr));
|
|
NSString.ReleaseNative(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("fileHandleForReadingFromURL:error:")]
|
|
public static NSFileHandle OpenReadUrl(NSUrl url, out NSError error)
|
|
{
|
|
if (url == null)
|
|
{
|
|
throw new ArgumentNullException("url");
|
|
}
|
|
IntPtr intPtr = Marshal.AllocHGlobal(4);
|
|
Marshal.WriteInt32(intPtr, 0);
|
|
NSFileHandle result = (NSFileHandle)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr_IntPtr(class_ptr, selFileHandleForReadingFromURLError_Handle, url.Handle, intPtr));
|
|
IntPtr intPtr2 = Marshal.ReadIntPtr(intPtr);
|
|
error = ((intPtr2 != IntPtr.Zero) ? ((NSError)Runtime.GetNSObject(intPtr2)) : null);
|
|
Marshal.FreeHGlobal(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("fileHandleForWritingToURL:error:")]
|
|
public static NSFileHandle OpenWriteUrl(NSUrl url, out NSError error)
|
|
{
|
|
if (url == null)
|
|
{
|
|
throw new ArgumentNullException("url");
|
|
}
|
|
IntPtr intPtr = Marshal.AllocHGlobal(4);
|
|
Marshal.WriteInt32(intPtr, 0);
|
|
NSFileHandle result = (NSFileHandle)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr_IntPtr(class_ptr, selFileHandleForWritingToURLError_Handle, url.Handle, intPtr));
|
|
IntPtr intPtr2 = Marshal.ReadIntPtr(intPtr);
|
|
error = ((intPtr2 != IntPtr.Zero) ? ((NSError)Runtime.GetNSObject(intPtr2)) : null);
|
|
Marshal.FreeHGlobal(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("fileHandleForUpdatingURL:error:")]
|
|
public static NSFileHandle OpenUpdateUrl(NSUrl url, out NSError error)
|
|
{
|
|
if (url == null)
|
|
{
|
|
throw new ArgumentNullException("url");
|
|
}
|
|
IntPtr intPtr = Marshal.AllocHGlobal(4);
|
|
Marshal.WriteInt32(intPtr, 0);
|
|
NSFileHandle result = (NSFileHandle)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr_IntPtr(class_ptr, selFileHandleForUpdatingURLError_Handle, url.Handle, intPtr));
|
|
IntPtr intPtr2 = Marshal.ReadIntPtr(intPtr);
|
|
error = ((intPtr2 != IntPtr.Zero) ? ((NSError)Runtime.GetNSObject(intPtr2)) : null);
|
|
Marshal.FreeHGlobal(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("readInBackgroundAndNotifyForModes:")]
|
|
public virtual void ReadInBackground(NSString[] notifyRunLoopModes)
|
|
{
|
|
if (notifyRunLoopModes == null)
|
|
{
|
|
throw new ArgumentNullException("notifyRunLoopModes");
|
|
}
|
|
NSArray nSArray = NSArray.FromNSObjects(notifyRunLoopModes);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selReadInBackgroundAndNotifyForModes_Handle, nSArray.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selReadInBackgroundAndNotifyForModes_Handle, nSArray.Handle);
|
|
}
|
|
nSArray.Dispose();
|
|
}
|
|
|
|
[Export("readInBackgroundAndNotify")]
|
|
public virtual void ReadInBackground()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selReadInBackgroundAndNotifyHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selReadInBackgroundAndNotifyHandle);
|
|
}
|
|
}
|
|
|
|
[Export("readToEndOfFileInBackgroundAndNotifyForModes:")]
|
|
public virtual void ReadToEndOfFileInBackground(NSString[] notifyRunLoopModes)
|
|
{
|
|
if (notifyRunLoopModes == null)
|
|
{
|
|
throw new ArgumentNullException("notifyRunLoopModes");
|
|
}
|
|
NSArray nSArray = NSArray.FromNSObjects(notifyRunLoopModes);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selReadToEndOfFileInBackgroundAndNotifyForModes_Handle, nSArray.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selReadToEndOfFileInBackgroundAndNotifyForModes_Handle, nSArray.Handle);
|
|
}
|
|
nSArray.Dispose();
|
|
}
|
|
|
|
[Export("readToEndOfFileInBackgroundAndNotify")]
|
|
public virtual void ReadToEndOfFileInBackground()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selReadToEndOfFileInBackgroundAndNotifyHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selReadToEndOfFileInBackgroundAndNotifyHandle);
|
|
}
|
|
}
|
|
|
|
[Export("acceptConnectionInBackgroundAndNotifyForModes:")]
|
|
public virtual void AcceptConnectionInBackground(NSString[] notifyRunLoopModes)
|
|
{
|
|
if (notifyRunLoopModes == null)
|
|
{
|
|
throw new ArgumentNullException("notifyRunLoopModes");
|
|
}
|
|
NSArray nSArray = NSArray.FromNSObjects(notifyRunLoopModes);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selAcceptConnectionInBackgroundAndNotifyForModes_Handle, nSArray.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selAcceptConnectionInBackgroundAndNotifyForModes_Handle, nSArray.Handle);
|
|
}
|
|
nSArray.Dispose();
|
|
}
|
|
|
|
[Export("acceptConnectionInBackgroundAndNotify")]
|
|
public virtual void AcceptConnectionInBackground()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selAcceptConnectionInBackgroundAndNotifyHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selAcceptConnectionInBackgroundAndNotifyHandle);
|
|
}
|
|
}
|
|
|
|
[Export("waitForDataInBackgroundAndNotifyForModes:")]
|
|
public virtual void WaitForDataInBackground(NSString[] notifyRunLoopModes)
|
|
{
|
|
if (notifyRunLoopModes == null)
|
|
{
|
|
throw new ArgumentNullException("notifyRunLoopModes");
|
|
}
|
|
NSArray nSArray = NSArray.FromNSObjects(notifyRunLoopModes);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selWaitForDataInBackgroundAndNotifyForModes_Handle, nSArray.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selWaitForDataInBackgroundAndNotifyForModes_Handle, nSArray.Handle);
|
|
}
|
|
nSArray.Dispose();
|
|
}
|
|
|
|
[Export("waitForDataInBackgroundAndNotify")]
|
|
public virtual void WaitForDataInBackground()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selWaitForDataInBackgroundAndNotifyHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selWaitForDataInBackgroundAndNotifyHandle);
|
|
}
|
|
}
|
|
|
|
[Export("initWithFileDescriptor:closeOnDealloc:")]
|
|
public NSFileHandle(int fd, bool closeOnDealloc)
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend_int_bool(base.Handle, selInitWithFileDescriptorCloseOnDealloc_Handle, fd, closeOnDealloc);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper_int_bool(base.SuperHandle, selInitWithFileDescriptorCloseOnDealloc_Handle, fd, closeOnDealloc);
|
|
}
|
|
}
|
|
|
|
[Export("initWithFileDescriptor:")]
|
|
public NSFileHandle(int fd)
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend_int(base.Handle, selInitWithFileDescriptor_Handle, fd);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper_int(base.SuperHandle, selInitWithFileDescriptor_Handle, fd);
|
|
}
|
|
}
|
|
|
|
[Export("setReadabilityHandler:")]
|
|
public unsafe virtual void SetReadabilityHandler(NSFileHandleUpdateHandler readCallback)
|
|
{
|
|
BlockLiteral* ptr;
|
|
if (readCallback == null)
|
|
{
|
|
ptr = null;
|
|
}
|
|
else
|
|
{
|
|
BlockLiteral blockLiteral = default(BlockLiteral);
|
|
ptr = &blockLiteral;
|
|
blockLiteral.SetupBlock(Trampolines.SDNSFileHandleUpdateHandler.Handler, readCallback);
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetReadabilityHandler_Handle, (IntPtr)(void*)ptr);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetReadabilityHandler_Handle, (IntPtr)(void*)ptr);
|
|
}
|
|
if (ptr != null)
|
|
{
|
|
ptr->CleanupBlock();
|
|
}
|
|
}
|
|
|
|
[Export("setWriteabilityHandler:")]
|
|
public unsafe virtual void SetWriteabilityHandle(NSFileHandleUpdateHandler writeCallback)
|
|
{
|
|
BlockLiteral* ptr;
|
|
if (writeCallback == null)
|
|
{
|
|
ptr = null;
|
|
}
|
|
else
|
|
{
|
|
BlockLiteral blockLiteral = default(BlockLiteral);
|
|
ptr = &blockLiteral;
|
|
blockLiteral.SetupBlock(Trampolines.SDNSFileHandleUpdateHandler.Handler, writeCallback);
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetWriteabilityHandler_Handle, (IntPtr)(void*)ptr);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetWriteabilityHandler_Handle, (IntPtr)(void*)ptr);
|
|
}
|
|
if (ptr != null)
|
|
{
|
|
ptr->CleanupBlock();
|
|
}
|
|
}
|
|
}
|
|
}
|