774 lines
23 KiB
C#
774 lines
23 KiB
C#
using CPF.Mac.Foundation;
|
|
using CPF.Mac.ObjCRuntime;
|
|
using System;
|
|
using System.ComponentModel;
|
|
|
|
namespace CPF.Mac.AppKit
|
|
{
|
|
[Register("NSPasteboard", true)]
|
|
public class NSPasteboard : NSObject
|
|
{
|
|
private static readonly IntPtr selGeneralPasteboardHandle = Selector.GetHandle("generalPasteboard");
|
|
|
|
private static readonly IntPtr selNameHandle = Selector.GetHandle("name");
|
|
|
|
private static readonly IntPtr selChangeCountHandle = Selector.GetHandle("changeCount");
|
|
|
|
private static readonly IntPtr selPasteboardItemsHandle = Selector.GetHandle("pasteboardItems");
|
|
|
|
private static readonly IntPtr selTypesHandle = Selector.GetHandle("types");
|
|
|
|
private static readonly IntPtr selPasteboardWithName_Handle = Selector.GetHandle("pasteboardWithName:");
|
|
|
|
private static readonly IntPtr selPasteboardWithUniqueNameHandle = Selector.GetHandle("pasteboardWithUniqueName");
|
|
|
|
private static readonly IntPtr selReleaseGloballyHandle = Selector.GetHandle("releaseGlobally");
|
|
|
|
private static readonly IntPtr selClearContentsHandle = Selector.GetHandle("clearContents");
|
|
|
|
private static readonly IntPtr selWriteObjects_Handle = Selector.GetHandle("writeObjects:");
|
|
|
|
private static readonly IntPtr selReadObjectsForClassesOptions_Handle = Selector.GetHandle("readObjectsForClasses:options:");
|
|
|
|
private static readonly IntPtr selIndexOfPasteboardItem_Handle = Selector.GetHandle("indexOfPasteboardItem:");
|
|
|
|
private static readonly IntPtr selCanReadItemWithDataConformingToTypes_Handle = Selector.GetHandle("canReadItemWithDataConformingToTypes:");
|
|
|
|
private static readonly IntPtr selCanReadObjectForClassesOptions_Handle = Selector.GetHandle("canReadObjectForClasses:options:");
|
|
|
|
private static readonly IntPtr selDeclareTypesOwner_Handle = Selector.GetHandle("declareTypes:owner:");
|
|
|
|
private static readonly IntPtr selAddTypesOwner_Handle = Selector.GetHandle("addTypes:owner:");
|
|
|
|
private static readonly IntPtr selAvailableTypeFromArray_Handle = Selector.GetHandle("availableTypeFromArray:");
|
|
|
|
private static readonly IntPtr selSetDataForType_Handle = Selector.GetHandle("setData:forType:");
|
|
|
|
private static readonly IntPtr selSetPropertyListForType_Handle = Selector.GetHandle("setPropertyList:forType:");
|
|
|
|
private static readonly IntPtr selSetStringForType_Handle = Selector.GetHandle("setString:forType:");
|
|
|
|
private static readonly IntPtr selDataForType_Handle = Selector.GetHandle("dataForType:");
|
|
|
|
private static readonly IntPtr selPropertyListForType_Handle = Selector.GetHandle("propertyListForType:");
|
|
|
|
private static readonly IntPtr selStringForType_Handle = Selector.GetHandle("stringForType:");
|
|
|
|
private static readonly IntPtr class_ptr = Class.GetHandle("NSPasteboard");
|
|
|
|
private static object __mt_GeneralPasteboard_var_static;
|
|
|
|
private object __mt_PasteboardItems_var;
|
|
|
|
private static NSString _NSStringType;
|
|
|
|
private static NSString _NSFilenamesType;
|
|
|
|
private static NSString _NSPostScriptType;
|
|
|
|
private static NSString _NSTiffType;
|
|
|
|
private static NSString _NSRtfType;
|
|
|
|
private static NSString _NSTabularTextType;
|
|
|
|
private static NSString _NSFontType;
|
|
|
|
private static NSString _NSRulerType;
|
|
|
|
private static NSString _NSFileContentsType;
|
|
|
|
private static NSString _NSColorType;
|
|
|
|
private static NSString _NSRtfdType;
|
|
|
|
private static NSString _NSHtmlType;
|
|
|
|
private static NSString _NSPictType;
|
|
|
|
private static NSString _NSUrlType;
|
|
|
|
private static NSString _NSPdfType;
|
|
|
|
private static NSString _NSVCardType;
|
|
|
|
private static NSString _NSFilesPromiseType;
|
|
|
|
private static NSString _NSMultipleTextSelectionType;
|
|
|
|
private static NSString _NSGeneralPasteboardName;
|
|
|
|
private static NSString _NSFontPasteboardName;
|
|
|
|
private static NSString _NSRulerPasteboardName;
|
|
|
|
private static NSString _NSFindPasteboardName;
|
|
|
|
private static NSString _NSDragPasteboardName;
|
|
|
|
public override IntPtr ClassHandle => class_ptr;
|
|
|
|
public static NSPasteboard GeneralPasteboard
|
|
{
|
|
[Export("generalPasteboard")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
return (NSPasteboard)(__mt_GeneralPasteboard_var_static = (NSPasteboard)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(class_ptr, selGeneralPasteboardHandle)));
|
|
}
|
|
}
|
|
|
|
public virtual string Name
|
|
{
|
|
[Export("name")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selNameHandle));
|
|
}
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selNameHandle));
|
|
}
|
|
}
|
|
|
|
public virtual long ChangeCount
|
|
{
|
|
[Export("changeCount")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.Int64_objc_msgSend(base.Handle, selChangeCountHandle);
|
|
}
|
|
return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selChangeCountHandle);
|
|
}
|
|
}
|
|
|
|
public virtual NSPasteboardItem[] PasteboardItems
|
|
{
|
|
[Export("pasteboardItems")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
return (NSPasteboardItem[])(__mt_PasteboardItems_var = ((!IsDirectBinding) ? NSArray.ArrayFromHandle<NSPasteboardItem>(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selPasteboardItemsHandle)) : NSArray.ArrayFromHandle<NSPasteboardItem>(Messaging.IntPtr_objc_msgSend(base.Handle, selPasteboardItemsHandle))));
|
|
}
|
|
}
|
|
|
|
public virtual string[] Types
|
|
{
|
|
[Export("types")]
|
|
get
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSArray.StringArrayFromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selTypesHandle));
|
|
}
|
|
return NSArray.StringArrayFromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selTypesHandle));
|
|
}
|
|
}
|
|
|
|
[Field("NSStringPboardType", "AppKit")]
|
|
public static NSString NSStringType
|
|
{
|
|
get
|
|
{
|
|
if (_NSStringType == null)
|
|
{
|
|
_NSStringType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSStringPboardType");
|
|
}
|
|
return _NSStringType;
|
|
}
|
|
}
|
|
|
|
[Field("NSFilenamesPboardType", "AppKit")]
|
|
public static NSString NSFilenamesType
|
|
{
|
|
get
|
|
{
|
|
if (_NSFilenamesType == null)
|
|
{
|
|
_NSFilenamesType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSFilenamesPboardType");
|
|
}
|
|
return _NSFilenamesType;
|
|
}
|
|
}
|
|
|
|
[Field("NSPostScriptPboardType", "AppKit")]
|
|
public static NSString NSPostScriptType
|
|
{
|
|
get
|
|
{
|
|
if (_NSPostScriptType == null)
|
|
{
|
|
_NSPostScriptType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSPostScriptPboardType");
|
|
}
|
|
return _NSPostScriptType;
|
|
}
|
|
}
|
|
|
|
[Field("NSTIFFPboardType", "AppKit")]
|
|
public static NSString NSTiffType
|
|
{
|
|
get
|
|
{
|
|
if (_NSTiffType == null)
|
|
{
|
|
_NSTiffType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSTIFFPboardType");
|
|
}
|
|
return _NSTiffType;
|
|
}
|
|
}
|
|
|
|
[Field("NSRTFPboardType", "AppKit")]
|
|
public static NSString NSRtfType
|
|
{
|
|
get
|
|
{
|
|
if (_NSRtfType == null)
|
|
{
|
|
_NSRtfType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSRTFPboardType");
|
|
}
|
|
return _NSRtfType;
|
|
}
|
|
}
|
|
|
|
[Field("NSTabularTextPboardType", "AppKit")]
|
|
public static NSString NSTabularTextType
|
|
{
|
|
get
|
|
{
|
|
if (_NSTabularTextType == null)
|
|
{
|
|
_NSTabularTextType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSTabularTextPboardType");
|
|
}
|
|
return _NSTabularTextType;
|
|
}
|
|
}
|
|
|
|
[Field("NSFontPboardType", "AppKit")]
|
|
public static NSString NSFontType
|
|
{
|
|
get
|
|
{
|
|
if (_NSFontType == null)
|
|
{
|
|
_NSFontType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSFontPboardType");
|
|
}
|
|
return _NSFontType;
|
|
}
|
|
}
|
|
|
|
[Field("NSRulerPboardType", "AppKit")]
|
|
public static NSString NSRulerType
|
|
{
|
|
get
|
|
{
|
|
if (_NSRulerType == null)
|
|
{
|
|
_NSRulerType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSRulerPboardType");
|
|
}
|
|
return _NSRulerType;
|
|
}
|
|
}
|
|
|
|
[Field("NSFileContentsPboardType", "AppKit")]
|
|
public static NSString NSFileContentsType
|
|
{
|
|
get
|
|
{
|
|
if (_NSFileContentsType == null)
|
|
{
|
|
_NSFileContentsType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSFileContentsPboardType");
|
|
}
|
|
return _NSFileContentsType;
|
|
}
|
|
}
|
|
|
|
[Field("NSColorPboardType", "AppKit")]
|
|
public static NSString NSColorType
|
|
{
|
|
get
|
|
{
|
|
if (_NSColorType == null)
|
|
{
|
|
_NSColorType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSColorPboardType");
|
|
}
|
|
return _NSColorType;
|
|
}
|
|
}
|
|
|
|
[Field("NSRTFDPboardType", "AppKit")]
|
|
public static NSString NSRtfdType
|
|
{
|
|
get
|
|
{
|
|
if (_NSRtfdType == null)
|
|
{
|
|
_NSRtfdType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSRTFDPboardType");
|
|
}
|
|
return _NSRtfdType;
|
|
}
|
|
}
|
|
|
|
[Field("NSHTMLPboardType", "AppKit")]
|
|
public static NSString NSHtmlType
|
|
{
|
|
get
|
|
{
|
|
if (_NSHtmlType == null)
|
|
{
|
|
_NSHtmlType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSHTMLPboardType");
|
|
}
|
|
return _NSHtmlType;
|
|
}
|
|
}
|
|
|
|
[Field("NSPICTPboardType", "AppKit")]
|
|
public static NSString NSPictType
|
|
{
|
|
get
|
|
{
|
|
if (_NSPictType == null)
|
|
{
|
|
_NSPictType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSPICTPboardType");
|
|
}
|
|
return _NSPictType;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLPboardType", "AppKit")]
|
|
public static NSString NSUrlType
|
|
{
|
|
get
|
|
{
|
|
if (_NSUrlType == null)
|
|
{
|
|
_NSUrlType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSURLPboardType");
|
|
}
|
|
return _NSUrlType;
|
|
}
|
|
}
|
|
|
|
[Field("NSPDFPboardType", "AppKit")]
|
|
public static NSString NSPdfType
|
|
{
|
|
get
|
|
{
|
|
if (_NSPdfType == null)
|
|
{
|
|
_NSPdfType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSPDFPboardType");
|
|
}
|
|
return _NSPdfType;
|
|
}
|
|
}
|
|
|
|
[Field("NSVCardPboardType", "AppKit")]
|
|
public static NSString NSVCardType
|
|
{
|
|
get
|
|
{
|
|
if (_NSVCardType == null)
|
|
{
|
|
_NSVCardType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSVCardPboardType");
|
|
}
|
|
return _NSVCardType;
|
|
}
|
|
}
|
|
|
|
[Field("NSFilesPromisePboardType", "AppKit")]
|
|
public static NSString NSFilesPromiseType
|
|
{
|
|
get
|
|
{
|
|
if (_NSFilesPromiseType == null)
|
|
{
|
|
_NSFilesPromiseType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSFilesPromisePboardType");
|
|
}
|
|
return _NSFilesPromiseType;
|
|
}
|
|
}
|
|
|
|
[Field("NSMultipleTextSelectionPboardType", "AppKit")]
|
|
public static NSString NSMultipleTextSelectionType
|
|
{
|
|
get
|
|
{
|
|
if (_NSMultipleTextSelectionType == null)
|
|
{
|
|
_NSMultipleTextSelectionType = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSMultipleTextSelectionPboardType");
|
|
}
|
|
return _NSMultipleTextSelectionType;
|
|
}
|
|
}
|
|
|
|
[Field("NSGeneralPboard", "AppKit")]
|
|
public static NSString NSGeneralPasteboardName
|
|
{
|
|
get
|
|
{
|
|
if (_NSGeneralPasteboardName == null)
|
|
{
|
|
_NSGeneralPasteboardName = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSGeneralPboard");
|
|
}
|
|
return _NSGeneralPasteboardName;
|
|
}
|
|
}
|
|
|
|
[Field("NSFontPboard", "AppKit")]
|
|
public static NSString NSFontPasteboardName
|
|
{
|
|
get
|
|
{
|
|
if (_NSFontPasteboardName == null)
|
|
{
|
|
_NSFontPasteboardName = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSFontPboard");
|
|
}
|
|
return _NSFontPasteboardName;
|
|
}
|
|
}
|
|
|
|
[Field("NSRulerPboard", "AppKit")]
|
|
public static NSString NSRulerPasteboardName
|
|
{
|
|
get
|
|
{
|
|
if (_NSRulerPasteboardName == null)
|
|
{
|
|
_NSRulerPasteboardName = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSRulerPboard");
|
|
}
|
|
return _NSRulerPasteboardName;
|
|
}
|
|
}
|
|
|
|
[Field("NSFindPboard", "AppKit")]
|
|
public static NSString NSFindPasteboardName
|
|
{
|
|
get
|
|
{
|
|
if (_NSFindPasteboardName == null)
|
|
{
|
|
_NSFindPasteboardName = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSFindPboard");
|
|
}
|
|
return _NSFindPasteboardName;
|
|
}
|
|
}
|
|
|
|
[Field("NSDragPboard", "AppKit")]
|
|
public static NSString NSDragPasteboardName
|
|
{
|
|
get
|
|
{
|
|
if (_NSDragPasteboardName == null)
|
|
{
|
|
_NSDragPasteboardName = Dlfcn.GetStringConstant(Libraries.AppKit.Handle, "NSDragPboard");
|
|
}
|
|
return _NSDragPasteboardName;
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
[Export("initWithCoder:")]
|
|
public NSPasteboard(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 NSPasteboard(NSObjectFlag t)
|
|
: base(t)
|
|
{
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public NSPasteboard(IntPtr handle)
|
|
: base(handle)
|
|
{
|
|
}
|
|
|
|
[Export("pasteboardWithName:")]
|
|
public static NSPasteboard FromName(string name)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (name == null)
|
|
{
|
|
throw new ArgumentNullException("name");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(name);
|
|
NSPasteboard result = (NSPasteboard)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(class_ptr, selPasteboardWithName_Handle, intPtr));
|
|
NSString.ReleaseNative(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("pasteboardWithUniqueName")]
|
|
public static NSPasteboard CreateWithUniqueName()
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
return (NSPasteboard)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(class_ptr, selPasteboardWithUniqueNameHandle));
|
|
}
|
|
|
|
[Export("releaseGlobally")]
|
|
public virtual void ReleaseGlobally()
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selReleaseGloballyHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selReleaseGloballyHandle);
|
|
}
|
|
}
|
|
|
|
[Export("clearContents")]
|
|
public virtual long ClearContents()
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.Int64_objc_msgSend(base.Handle, selClearContentsHandle);
|
|
}
|
|
return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selClearContentsHandle);
|
|
}
|
|
|
|
[Export("writeObjects:")]
|
|
public virtual bool WriteObjects(NSPasteboardReading[] objects)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (objects == null)
|
|
{
|
|
throw new ArgumentNullException("objects");
|
|
}
|
|
NSArray nSArray = NSArray.FromNSObjects(objects);
|
|
bool result = (!IsDirectBinding) ? Messaging.bool_objc_msgSendSuper_IntPtr(base.SuperHandle, selWriteObjects_Handle, nSArray.Handle) : Messaging.bool_objc_msgSend_IntPtr(base.Handle, selWriteObjects_Handle, nSArray.Handle);
|
|
nSArray.Dispose();
|
|
return result;
|
|
}
|
|
|
|
[Export("readObjectsForClasses:options:")]
|
|
public virtual NSObject[] ReadObjectsForClasses(NSPasteboardReading[] classArray, NSDictionary options)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (classArray == null)
|
|
{
|
|
throw new ArgumentNullException("classArray");
|
|
}
|
|
if (options == null)
|
|
{
|
|
throw new ArgumentNullException("options");
|
|
}
|
|
NSArray nSArray = NSArray.FromNSObjects(classArray);
|
|
NSObject[] result = (!IsDirectBinding) ? NSArray.ArrayFromHandle<NSObject>(Messaging.IntPtr_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selReadObjectsForClassesOptions_Handle, nSArray.Handle, options.Handle)) : NSArray.ArrayFromHandle<NSObject>(Messaging.IntPtr_objc_msgSend_IntPtr_IntPtr(base.Handle, selReadObjectsForClassesOptions_Handle, nSArray.Handle, options.Handle));
|
|
nSArray.Dispose();
|
|
return result;
|
|
}
|
|
|
|
[Export("indexOfPasteboardItem:")]
|
|
public virtual ulong IndexOf(NSPasteboardItem pasteboardItem)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (pasteboardItem == null)
|
|
{
|
|
throw new ArgumentNullException("pasteboardItem");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.UInt64_objc_msgSend_IntPtr(base.Handle, selIndexOfPasteboardItem_Handle, pasteboardItem.Handle);
|
|
}
|
|
return Messaging.UInt64_objc_msgSendSuper_IntPtr(base.SuperHandle, selIndexOfPasteboardItem_Handle, pasteboardItem.Handle);
|
|
}
|
|
|
|
[Export("canReadItemWithDataConformingToTypes:")]
|
|
public virtual bool CanReadItemWithDataConformingToTypes(string[] utiTypes)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (utiTypes == null)
|
|
{
|
|
throw new ArgumentNullException("utiTypes");
|
|
}
|
|
NSArray nSArray = NSArray.FromStrings(utiTypes);
|
|
bool result = (!IsDirectBinding) ? Messaging.bool_objc_msgSendSuper_IntPtr(base.SuperHandle, selCanReadItemWithDataConformingToTypes_Handle, nSArray.Handle) : Messaging.bool_objc_msgSend_IntPtr(base.Handle, selCanReadItemWithDataConformingToTypes_Handle, nSArray.Handle);
|
|
nSArray.Dispose();
|
|
return result;
|
|
}
|
|
|
|
[Export("canReadObjectForClasses:options:")]
|
|
public virtual bool CanReadObjectForClasses(NSObject[] classArray, NSDictionary options)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (classArray == null)
|
|
{
|
|
throw new ArgumentNullException("classArray");
|
|
}
|
|
if (options == null)
|
|
{
|
|
throw new ArgumentNullException("options");
|
|
}
|
|
NSArray nSArray = NSArray.FromNSObjects(classArray);
|
|
bool result = (!IsDirectBinding) ? Messaging.bool_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selCanReadObjectForClassesOptions_Handle, nSArray.Handle, options.Handle) : Messaging.bool_objc_msgSend_IntPtr_IntPtr(base.Handle, selCanReadObjectForClassesOptions_Handle, nSArray.Handle, options.Handle);
|
|
nSArray.Dispose();
|
|
return result;
|
|
}
|
|
|
|
[Export("declareTypes:owner:")]
|
|
public virtual long DeclareTypes(string[] newTypes, NSObject newOwner)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (newTypes == null)
|
|
{
|
|
throw new ArgumentNullException("newTypes");
|
|
}
|
|
NSArray nSArray = NSArray.FromStrings(newTypes);
|
|
long result = (!IsDirectBinding) ? Messaging.Int64_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selDeclareTypesOwner_Handle, nSArray.Handle, newOwner?.Handle ?? IntPtr.Zero) : Messaging.Int64_objc_msgSend_IntPtr_IntPtr(base.Handle, selDeclareTypesOwner_Handle, nSArray.Handle, newOwner?.Handle ?? IntPtr.Zero);
|
|
nSArray.Dispose();
|
|
return result;
|
|
}
|
|
|
|
[Export("addTypes:owner:")]
|
|
public virtual long AddTypes(string[] newTypes, NSObject newOwner)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (newTypes == null)
|
|
{
|
|
throw new ArgumentNullException("newTypes");
|
|
}
|
|
NSArray nSArray = NSArray.FromStrings(newTypes);
|
|
long result = (!IsDirectBinding) ? Messaging.Int64_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selAddTypesOwner_Handle, nSArray.Handle, newOwner?.Handle ?? IntPtr.Zero) : Messaging.Int64_objc_msgSend_IntPtr_IntPtr(base.Handle, selAddTypesOwner_Handle, nSArray.Handle, newOwner?.Handle ?? IntPtr.Zero);
|
|
nSArray.Dispose();
|
|
return result;
|
|
}
|
|
|
|
[Export("availableTypeFromArray:")]
|
|
public virtual string GetAvailableTypeFromArray(string[] types)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (types == null)
|
|
{
|
|
throw new ArgumentNullException("types");
|
|
}
|
|
NSArray nSArray = NSArray.FromStrings(types);
|
|
string result = (!IsDirectBinding) ? NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, selAvailableTypeFromArray_Handle, nSArray.Handle)) : NSString.FromHandle(Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, selAvailableTypeFromArray_Handle, nSArray.Handle));
|
|
nSArray.Dispose();
|
|
return result;
|
|
}
|
|
|
|
[Export("setData:forType:")]
|
|
public virtual bool SetDataForType(NSData data, string dataType)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (data == null)
|
|
{
|
|
throw new ArgumentNullException("data");
|
|
}
|
|
if (dataType == null)
|
|
{
|
|
throw new ArgumentNullException("dataType");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(dataType);
|
|
bool result = (!IsDirectBinding) ? Messaging.bool_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selSetDataForType_Handle, data.Handle, intPtr) : Messaging.bool_objc_msgSend_IntPtr_IntPtr(base.Handle, selSetDataForType_Handle, data.Handle, intPtr);
|
|
NSString.ReleaseNative(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("setPropertyList:forType:")]
|
|
public virtual bool SetPropertyListForType(NSObject plist, string dataType)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (plist == null)
|
|
{
|
|
throw new ArgumentNullException("plist");
|
|
}
|
|
if (dataType == null)
|
|
{
|
|
throw new ArgumentNullException("dataType");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(dataType);
|
|
bool result = (!IsDirectBinding) ? Messaging.bool_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selSetPropertyListForType_Handle, plist.Handle, intPtr) : Messaging.bool_objc_msgSend_IntPtr_IntPtr(base.Handle, selSetPropertyListForType_Handle, plist.Handle, intPtr);
|
|
NSString.ReleaseNative(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("setString:forType:")]
|
|
public virtual bool SetStringForType(string str, string dataType)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (str == null)
|
|
{
|
|
throw new ArgumentNullException("str");
|
|
}
|
|
if (dataType == null)
|
|
{
|
|
throw new ArgumentNullException("dataType");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(str);
|
|
IntPtr intPtr2 = NSString.CreateNative(dataType);
|
|
bool result = (!IsDirectBinding) ? Messaging.bool_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selSetStringForType_Handle, intPtr, intPtr2) : Messaging.bool_objc_msgSend_IntPtr_IntPtr(base.Handle, selSetStringForType_Handle, intPtr, intPtr2);
|
|
NSString.ReleaseNative(intPtr);
|
|
NSString.ReleaseNative(intPtr2);
|
|
return result;
|
|
}
|
|
|
|
[Export("dataForType:")]
|
|
public virtual NSData GetDataForType(string dataType)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (dataType == null)
|
|
{
|
|
throw new ArgumentNullException("dataType");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(dataType);
|
|
NSData result = (!IsDirectBinding) ? ((NSData)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, selDataForType_Handle, intPtr))) : ((NSData)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, selDataForType_Handle, intPtr)));
|
|
NSString.ReleaseNative(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("propertyListForType:")]
|
|
public virtual NSObject GetPropertyListForType(string dataType)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (dataType == null)
|
|
{
|
|
throw new ArgumentNullException("dataType");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(dataType);
|
|
NSObject result = (!IsDirectBinding) ? Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, selPropertyListForType_Handle, intPtr)) : Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, selPropertyListForType_Handle, intPtr));
|
|
NSString.ReleaseNative(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("stringForType:")]
|
|
public virtual string GetStringForType(string dataType)
|
|
{
|
|
NSApplication.EnsureUIThread();
|
|
if (dataType == null)
|
|
{
|
|
throw new ArgumentNullException("dataType");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(dataType);
|
|
string result = (!IsDirectBinding) ? NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, selStringForType_Handle, intPtr)) : NSString.FromHandle(Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, selStringForType_Handle, intPtr));
|
|
NSString.ReleaseNative(intPtr);
|
|
return result;
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
base.Dispose(disposing);
|
|
if (base.Handle == IntPtr.Zero)
|
|
{
|
|
__mt_PasteboardItems_var = null;
|
|
}
|
|
}
|
|
}
|
|
}
|