static IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, ref Native.KBDLLHOOKSTRUCT lParam)
 {
     bool cancel = false;
     if(nCode == Native.HC_ACTION) {
         KeybordCaptureEventArgs e = new KeybordCaptureEventArgs(lParam);
         switch(wParam.ToInt32()) {
             case Native.WM_KEYDOWN:
                 if(KeyDown != null)
                     KeyDown(null, e);
                 break;
             case Native.WM_KEYUP:
                 if(KeyUp != null)
                     KeyUp(null, e);
                 break;
             case Native.WM_SYSKEYDOWN:
                 if(SysKeyDown != null)
                     SysKeyDown(null, e);
                 break;
             case Native.WM_SYSKEYUP:
                 if(SysKeyUp != null)
                     SysKeyUp(null, e);
                 break;
         }
         cancel = e.Cancel;
     }
     return cancel ? (IntPtr)1 : Native.CallNextHookEx(s_hook, nCode, wParam, ref lParam);
 }

        internal void PopulateConfiguration(ref Native.Configuration configuration)
        {
            var migrationHandle = GCHandle.Alloc(this);

            configuration.migration_callback = MigrationCallback;
            configuration.managed_migration_handle = GCHandle.ToIntPtr(migrationHandle);
        }

 internal UnixFileSystemInfo(String path, Native.Stat stat)
 {
     this.originalPath = path;
     this.fullPath = UnixPath.GetFullPath (path);
     this.stat = stat;
     this.valid = true;
 }

    public App(string nibName)
    {
        NSObject app = (NSObject) new Class("NSApplication").Call("sharedApplication");

        // Load our nib. This will instantiate all of the native objects and wire them together.
        // The C# SimpleLayoutView will be created the first time Objective-C calls one of the
        // methods SimpleLayoutView added or overrode.
        NSObject dict = new Class("NSMutableDictionary").Call("alloc").Call("init").To<NSObject>();
        NSObject key = new Class("NSString").Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("NSOwner")).To<NSObject>();
        dict.Call("setObject:forKey:", app, key);

        NSObject bundle = new Class("NSBundle").Call("mainBundle").To<NSObject>();

        NSObject nib = new Class("NSString").Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto(nibName)).To<NSObject>();
        sbyte loaded = (sbyte) bundle.Call("loadNibFile:externalNameTable:withZone:", nib, dict, null);
        if (loaded != 1)
            throw new InvalidOperationException("Couldn't load the nib file");

        // We need an NSAutoreleasePool to do Native.Call, but we don't want to have one
        // hanging around while we're in the main event loop because that may hide bugs.
        // So, we'll instantiate a Native instance here and call Invoke later which can
        // be done without an NSAutoreleasePool.
        m_run = new Native(app, new Selector("run"));

        dict.release();
    }

		public UnixStream Create (Native.FilePermissions mode)
		{
			int fd = Native.Syscall.creat (FullPath, mode);
			if (fd < 0)
				UnixMarshal.ThrowExceptionForLastError ();
			base.Refresh ();
			return new UnixStream (fd);
		}

 /// <summary>
 /// Creates new instance of this type.
 /// </summary>
 /// <param name="name">Name of the port.</param>
 /// <param name="displayName">Display name of this port.</param>
 /// <param name="description">Description of this port.</param>
 /// <param name="enumConfig">Enumeration config.</param>
 /// <param name="defaultValue">Default value to use.</param>
 public NativeInputPortConfiguration(string name, string displayName, string description, string enumConfig, Native.FlowInputData defaultValue)
 {
     this.Name = Marshal.StringToHGlobalUni(name);
     this.HumanName = Marshal.StringToHGlobalUni(displayName);
     this.Description = Marshal.StringToHGlobalUni(description);
     this.EnumConfig = Marshal.StringToHGlobalUni(enumConfig);
     this.DefaultValue = defaultValue;
 }

		private static Native.Group CopyGroup (Native.Group group)
		{
			Native.Group g = new Native.Group ();

			g.gr_gid    = group.gr_gid;
			g.gr_mem    = group.gr_mem;
			g.gr_name   = group.gr_name;
			g.gr_passwd = group.gr_passwd;

			return g;
		}

		private static string strerror_r (Native.Errno errno)
		{
			StringBuilder buf = new StringBuilder (16);
			int r = 0;
			do {
				buf.Capacity *= 2;
				r = Native.Syscall.strerror_r (errno, buf);
			} while (r == -1 && Native.Stdlib.GetLastError() == Native.Errno.ERANGE);

			if (r == -1)
				return "** Unknown error code: " + ((int) errno) + "**";
			return buf.ToString();
		}

		private static Native.Passwd CopyPasswd (Native.Passwd pw)
		{
			Native.Passwd p = new Native.Passwd ();

			p.pw_name   = pw.pw_name;
			p.pw_passwd = pw.pw_passwd;
			p.pw_uid    = pw.pw_uid;
			p.pw_gid    = pw.pw_gid;
			p.pw_gecos  = pw.pw_gecos;
			p.pw_dir    = pw.pw_dir;
			p.pw_shell  = pw.pw_shell;

			return p;
		}

        public static SharedRealmHandle OpenWithSync(Realms.Native.Configuration configuration, Native.SyncConfiguration syncConfiguration, RealmSchema schema, byte[] encryptionKey)
        {
            DoInitialFileSystemConfiguration();

            var marshaledSchema = new SharedRealmHandle.SchemaMarshaler(schema);

            NativeException nativeException;
            var result = NativeMethods.open_with_sync(configuration, syncConfiguration, marshaledSchema.Objects, marshaledSchema.Objects.Length, marshaledSchema.Properties, encryptionKey, out nativeException);
            nativeException.ThrowIfNecessary();

            var handle = new SharedRealmHandle();
            handle.SetHandle(result);
            return handle;
        }

        public static void DoEnableDisable(
            Native.DeviceInfoListHandle devs, ref Native.SP_DEVINFO_DATA devInfo,
            string deviceId, EnableDisableParameters parms
        )
        {
            if (devInfo.ClassGuid != parms.ClassGuid)
                return;
            if (devInfo.DevInst != parms.DevInst)
                return;

            var options = parms.AppParams.Options;

            if ((options.Count == 0) || options.Contains("disable")) {
                Console.WriteLine(
                    "// Physical ID for volume {0} is #{1}. You can use this ID to re-enable the volume.",
                    parms.DriveLetter, devInfo.DevInst
                );

                Console.Write("Disabling volume {0}... ", parms.DriveLetter);
                try {
                    Native.ChangeDeviceEnabledState(
                        devs, ref devInfo,
                        DiClassInstallState.DICS_DISABLE,
                        DiClassInstallScope.DICS_FLAG_CONFIGSPECIFIC,
                        DiClassInstallFunction.DIF_PROPERTYCHANGE
                    );

                    Console.WriteLine("ok.");
                } catch (Exception ex) {
                    Console.WriteLine("failed.");
                }
            }

            if ((options.Count == 0) || options.Contains("enable")) {
                Console.Write("Enabling volume {0}... ", parms.DriveLetter);
                try {
                    Native.ChangeDeviceEnabledState(
                        devs, ref devInfo,
                        DiClassInstallState.DICS_ENABLE,
                        DiClassInstallScope.DICS_FLAG_CONFIGSPECIFIC,
                        DiClassInstallFunction.DIF_PROPERTYCHANGE
                    );

                    Console.WriteLine("ok.");
                } catch (Exception ex) {
                    Console.WriteLine("failed.");
                }
            }
        }

 public void SendKeyboardKey( Native.KeyboardKeys key )
 {
     NativeKeySendingEventArgs e = new NativeKeySendingEventArgs( key );
     if( this.KeySending != null )
     {
         this.KeySending( this, e );
     }
     if( !e.Cancel )
     {
         KeyboardProcessor.Process( key );
         if( this.KeySent != null )
         {
             this.KeySent( this, new NativeKeySentEventArgs( key ) );
         }
     }
 }

        /// <summary>
        /// XmCreateXXの呼び出し
        /// </summary>
        public static IntPtr CallCreate2P(Native.Motif.CreateSymbol sym, Widgets.IWidget parent,string name, Native.Xt.XtArg[] args)
        {
            if (null ==args || 0 == args.Length) {
                return Instance.xmCreateFuncs[(int)sym](parent.NativeHandle.Widget, name, null, 0);
            }

            Native.Xt.NativeXtArg[] au = new Native.Xt.NativeXtArg[args.Length];
            int argc = ExtremeSports.TnkConvertResourceEx(args, au, true);
            foreach(Native.Xt.NativeXtArg k in au) {
                System.Diagnostics.Debug.WriteLine($"NA<A>: {k.Name} : {k.Value}");
            }
            System.Diagnostics.Debug.WriteLine($"XM_CVT {au.Length} -> {argc}");
            IntPtr wgt = Instance.xmCreateFuncs[(int)sym](parent.NativeHandle.Widget, name, au, argc);
            ExtremeSports.TnkFreeDeepCopyArg(au);

            return wgt;
        }

		public void RestoreFilePosition (Native.FilePosition pos)
		{
			AssertNotDisposed ();
			if (pos == null)
				throw new ArgumentNullException ("value");
			int r = Native.Stdlib.fsetpos (file, pos);
			UnixMarshal.ThrowExceptionForLastErrorIf (r);
			GC.KeepAlive (this);
		}

		public void SaveFilePosition (Native.FilePosition pos)
		{
			AssertNotDisposed ();
			int r = Native.Stdlib.fgetpos (file, pos);
			UnixMarshal.ThrowExceptionForLastErrorIf (r);
			GC.KeepAlive (this);
		}

		public UnixUserInfo (Native.Passwd passwd)
		{
			this.passwd = CopyPasswd (passwd);
		}

    public void Time()
    {
        Class klass = new Class("NSString");
        NSObject str1 = (NSObject) klass.Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("hello world"));
        NSObject str2 = (NSObject) klass.Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("100"));
        NSObject str3 = (NSObject) klass.Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("foo"));

        Stopwatch timer = Stopwatch.StartNew();
        for (int i = 0; i < 10000; ++i)
        {
            str3.Call("hasPrefix:", str1);
        }
        Console.WriteLine("{0}	{1:0.0} secs", new Native(str3, new Selector("hasPrefix:")), timer.ElapsedMilliseconds/1000.0);

        timer = Stopwatch.StartNew();
        for (int i = 0; i < 10000; ++i)
        {
            str2.Call("intValue");
        }
        Console.WriteLine("{0}	{1:0.0} secs", new Native(str2, new Selector("intValue")), timer.ElapsedMilliseconds/1000.0);

        timer = Stopwatch.StartNew();
        for (int i = 0; i < 10000; ++i)
        {
            str1.Call("uppercaseString");
        }
        Console.WriteLine("{0}	{1:0.0} secs", new Native(str1, new Selector("uppercaseString")), timer.ElapsedMilliseconds/1000.0);

        Native native = new Native(str1, new Selector("uppercaseString"));
        timer = Stopwatch.StartNew();
        for (int i = 0; i < 10000; ++i)
        {
            native.Invoke();
        }
        Console.WriteLine("Native {0}	{1:0.0} secs", native, timer.ElapsedMilliseconds/1000.0);

        string s = "hello world";
        timer = Stopwatch.StartNew();
        for (int i = 0; i < 10000; ++i)
        {
            s.ToUpper();
        }
        Console.WriteLine("Managed ToUpper: {0:0.0} secs", timer.ElapsedMilliseconds/1000.0);
    }

		// Read the specified symbolic link.  If the file isn't a symbolic link,
		// return null; otherwise, return the contents of the symbolic link.
		//
		// readlink(2) is horribly evil, as there is no way to query how big the
		// symlink contents are.  Consequently, it's trial and error...
		private static string ReadSymbolicLink (string path, out Native.Errno errno)
		{
			errno = (Native.Errno) 0;
			StringBuilder buf = new StringBuilder (256);
			do {
				int r = Native.Syscall.readlink (path, buf);
				if (r < 0) {
					errno = Native.Stdlib.GetLastError ();
					return null;
				}
				else if (r == buf.Capacity) {
					buf.Capacity *= 2;
				}
				else
					return buf.ToString (0, r);
			} while (true);
		}

 public long GetConfigurationValue(Native.PathconfName name)
 {
     long r = Native.Syscall.pathconf (FullPath, name);
     if (r == -1 && Native.Stdlib.GetLastError () != (Native.Errno)0)
         UnixMarshal.ThrowExceptionForLastError ();
     return r;
 }

 internal static bool IsSet(Native.FilePermissions mode, Native.FilePermissions type)
 {
     return (mode & type) == type;
 }