MacOpenPanel.cs

using System;
using System.Linq;
using System.Runtime.InteropServices;
using UnityEngine;

namespace NativeFileBrowser
{
    public class MacOpenPanel
    {
        // libobjc.dylib: Interact with Objective-C through pure C functions via a reflection-like API
        // https://developer.apple.com/documentation/objectivec/objective-c_runtime
        [DllImport("/usr/lib/libobjc.dylib")]
        private static extern IntPtr objc_getClass([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

        [DllImport("/usr/lib/libobjc.dylib")]
        private static extern IntPtr sel_getUid([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

        // objc_msgSend is a weird one: it's a varargs-like C function (but not quite varargs, e.g. floats are not promoted to doubles).
        // Declare multiple overload aliases to the same EntryPoint in C#, and it works out fine. Add overloads for whatever you end up needing.
        [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
        private static extern IntPtr objc_msgSend_IntPtr_void(IntPtr receiver, IntPtr selector);

        [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
        private static extern IntPtr objc_msgSend_IntPtr_uint(IntPtr receiver, IntPtr selector, uint value);

        [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
        private static extern IntPtr objc_msgSend_IntPtr_ulong(IntPtr receiver, IntPtr selector, ulong value);

        [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
        private static extern IntPtr objc_msgSend_IntPtr_IntPtr(IntPtr receiver, IntPtr selector, IntPtr value);

        [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
        private static extern IntPtr objc_msgSend_IntPtr_IntPtr_ulong(IntPtr receiver, IntPtr selector, IntPtr value1,
            ulong value2);

        [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
        private static extern IntPtr objc_msgSend_IntPtr_string(IntPtr receiver, IntPtr selector,
            [MarshalAs(UnmanagedType.LPUTF8Str)] string value);

        [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
        private static extern int objc_msgSend_int_void(IntPtr receiver, IntPtr selector);

        [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
        private static extern ulong objc_msgSend_ulong_void(IntPtr receiver, IntPtr selector);

        [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
        private static extern void objc_msgSend_void_byte(IntPtr receiver, IntPtr selector, byte value);

        [DllImport("/usr/lib/libobjc.dylib", EntryPoint = "objc_msgSend")]
        private static extern void objc_msgSend_void_IntPtr(IntPtr receiver, IntPtr selector, IntPtr value);

        private enum NSModalResponse
        {
            Continue = -1002,
            Abort = -1001,
            Stop = -1000,
            Cancel = 0,
            Ok = 1,
        }

        // NSOpenPanel docs: https://developer.apple.com/documentation/appkit/nsopenpanel
        private static readonly IntPtr NsOpenPanel = objc_getClass("NSOpenPanel");
        private static readonly IntPtr NsString = objc_getClass("NSString");
        private static readonly IntPtr NsArray = objc_getClass("NSArray");
        private static readonly IntPtr NsUrl = objc_getClass("NSURL");
        private static readonly IntPtr UtType = objc_getClass("UTType");
        private static readonly IntPtr OpenPanel = sel_getUid("openPanel");
        private static readonly IntPtr SetCanChooseFiles = sel_getUid("setCanChooseFiles:");
        private static readonly IntPtr SetCanChooseDirectories = sel_getUid("setCanChooseDirectories:");
        private static readonly IntPtr SetAllowsMultipleSelection = sel_getUid("setAllowsMultipleSelection:");
        private static readonly IntPtr SetAllowedContentTypes = sel_getUid("setAllowedContentTypes:");
        private static readonly IntPtr SetMessage = sel_getUid("setMessage:");
        private static readonly IntPtr SetDirectoryUrl = sel_getUid("setDirectoryURL:");
        private static readonly IntPtr URLs = sel_getUid("URLs");
        private static readonly IntPtr RunModal = sel_getUid("runModal");
        private static readonly IntPtr Path = sel_getUid("path");
        private static readonly IntPtr CStringUsingEncoding = sel_getUid("cStringUsingEncoding:");
        private static readonly IntPtr Count = sel_getUid("count");
        private static readonly IntPtr ObjectAtIndex = sel_getUid("objectAtIndex:");
        private static readonly IntPtr StringWithUtf8String = sel_getUid("stringWithUTF8String:");
        private static readonly IntPtr TypeWithFilenameExtension = sel_getUid("typeWithFilenameExtension:");
        private static readonly IntPtr FileUrlWithPath = sel_getUid("fileURLWithPath:");
        private static readonly IntPtr ArrayWithObjectsCount = sel_getUid("arrayWithObjects:count:");

        // The documentation states canChooseFiles is a property, but "S" is missing from property_getAttributes
        // (and so property_copyAttributeValue("S") also returns null). Not sure what's up with that. I then
        // manually printed class_copyMethodList and found the name of "setCanChooseFiles:" (with colon).

        public static string[] Pick(FileBrowserSettings settings)
        {
            var panel = objc_msgSend_IntPtr_void(NsOpenPanel, OpenPanel);

            objc_msgSend_void_byte(panel, SetCanChooseFiles,
                settings.DialogKind == DialogKind.File ? (byte)1 : (byte)0);
            objc_msgSend_void_byte(panel, SetCanChooseDirectories,
                settings.DialogKind == DialogKind.Folder ? (byte)1 : (byte)0);
            objc_msgSend_void_byte(panel, SetAllowsMultipleSelection,
                settings.MultiSelectKind == MultiSelectKind.Multiple ? (byte)1 : (byte)0);
            if (settings.Title != null)
            {
                // Title is no longer displayed on macos. Set message instead.
                var titleStr = objc_msgSend_IntPtr_string(NsString, StringWithUtf8String, settings.Title);
                objc_msgSend_void_IntPtr(panel, SetMessage, titleStr);
            }

            if (settings.InitialFolder != null)
            {
                var strPath = objc_msgSend_IntPtr_string(NsString, StringWithUtf8String, settings.InitialFolder);
                var url = objc_msgSend_IntPtr_IntPtr(NsUrl, FileUrlWithPath, strPath);
                objc_msgSend_void_IntPtr(panel, SetDirectoryUrl, url);
            }

            if (settings.FileExtensionFilters != null)
            {
                var filters = settings.FileExtensionFilters.SelectMany(f => f.Patterns).Distinct().ToArray();
                var utTypes = Marshal.AllocHGlobal(filters.Length * Marshal.SizeOf<IntPtr>());
                var actualCount = 0;
                foreach (var filterI in filters)
                {
                    var filter = filterI;
                    // mac wants just the extension, not a *.cs glob pattern
                    if (filter.StartsWith("*."))
                        filter = filter.Substring(2);

                    var filterStr = objc_msgSend_IntPtr_string(NsString, StringWithUtf8String, filter);
                    var utType = objc_msgSend_IntPtr_IntPtr(UtType, TypeWithFilenameExtension, filterStr);
                    if (utType == IntPtr.Zero)
                    {
                        Debug.LogError($"Creating a UTType with the filename extension \"{filter}\" returned null");
                    }
                    else
                    {
                        Marshal.WriteIntPtr(utTypes, actualCount++ * Marshal.SizeOf<IntPtr>(), utType);
                    }
                }

                if (actualCount > 0)
                {
                    var array = objc_msgSend_IntPtr_IntPtr_ulong(NsArray, ArrayWithObjectsCount, utTypes,
                        (ulong)actualCount);
                    objc_msgSend_void_IntPtr(panel, SetAllowedContentTypes, array);
                }

                Marshal.FreeHGlobal(utTypes);
            }

            var response = (NSModalResponse)objc_msgSend_int_void(panel, RunModal);
            if (response != NSModalResponse.Ok)
                return Array.Empty<string>();
            var urls = objc_msgSend_IntPtr_void(panel, URLs);
            var count = objc_msgSend_ulong_void(urls, Count);
            var result = new string[count];
            for (var i = 0; i < result.Length; i++)
            {
                var url = objc_msgSend_IntPtr_ulong(urls, ObjectAtIndex, (ulong)i);
                var str = objc_msgSend_IntPtr_void(url, Path);
                const uint utf8 = 4;
                var ptr = objc_msgSend_IntPtr_uint(str, CStringUsingEncoding, utf8);
                var path = Marshal.PtrToStringUTF8(ptr);
                result[i] = path;
            }

            // No need to [panel release] or similar due to things being auto-released, I guess
            // at least, I hope that unity runtime has an auto release pool running
            return result;
        }

        // Debugging help:
        /*
        [DllImport("/usr/lib/libobjc.dylib")]
        private static extern IntPtr object_getClass(IntPtr cls);

        [DllImport("/usr/lib/libobjc.dylib")]
        private static extern IntPtr class_copyMethodList(IntPtr cls, out uint count);

        [DllImport("/usr/lib/libobjc.dylib")]
        private static extern uint method_getNumberOfArguments(IntPtr method);

        [DllImport("/usr/lib/libobjc.dylib")]
        private static extern IntPtr method_copyArgumentType(IntPtr method, uint index);

        [DllImport("/usr/lib/libobjc.dylib")]
        private static extern IntPtr method_getName(IntPtr method);

        [DllImport("/usr/lib/libobjc.dylib")]
        private static extern IntPtr sel_getName(IntPtr sel);

        [DllImport("/usr/lib/libobjc.dylib")]
        private static extern IntPtr class_getSuperclass(IntPtr sel);

        [DllImport("/usr/lib/libobjc.dylib")]
        private static extern IntPtr class_getName(IntPtr sel);

        private static void DumpObjectMethods(IntPtr obj)
        {
            var cls = object_getClass(obj);
            DumpClassMethods(cls);
        }

        private static void DumpClassMethods(IntPtr cls)
        {
            while (cls != IntPtr.Zero)
            {
                Debug.Log("--- class name: " + Marshal.PtrToStringUTF8(class_getName(cls)));
                var methods = class_copyMethodList(cls, out var count);
                for (var i = 0; i < count; i++)
                {
                    var method = Marshal.ReadIntPtr(methods, i * Marshal.SizeOf<IntPtr>());
                    var args = new string[method_getNumberOfArguments(method)];
                    for (var argIndex = 0u; argIndex < args.Length; argIndex++)
                        args[argIndex] = Marshal.PtrToStringUTF8(method_copyArgumentType(method, argIndex));
                    var methodName = Marshal.PtrToStringUTF8(sel_getName(method_getName(method)));
                    Debug.Log($"{methodName} --- {string.Join(", ", args)}");
                }

                cls = class_getSuperclass(cls);
            }
        }
        */
    }
}