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();
}
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 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 SetConnectionName(Connection peer, string name)
{
Native.SteamAPI_ISteamNetworkingSockets_SetConnectionName(nativeSockets, peer, name);
}
public static extern IntPtr open(Native.Configuration configuration,
[MarshalAs(UnmanagedType.LPArray), In] Native.SchemaObject[] objects, int objects_length,
[MarshalAs(UnmanagedType.LPArray), In] Native.SchemaProperty[] properties,
byte[] encryptionKey,
out NativeException ex);
private void CloseDB(C4Database *db)
{
Native.c4db_close(db, null);
Native.c4db_free(db);
}
static void InitializeDesktop(string libvlcDirectoryPath = null)
{
if (PlatformHelper.IsLinux)
{
if (!string.IsNullOrEmpty(libvlcDirectoryPath))
{
throw new InvalidOperationException($"Using {nameof(libvlcDirectoryPath)} is not supported on the Linux platform. " +
$"The recommended way is to have the libvlc librairies in /usr/lib. Use LD_LIBRARY_PATH if you need more customization");
}
// Initializes X threads before calling VLC. This is required for vlc plugins like the VDPAU hardware acceleration plugin.
if (Native.XInitThreads() == 0)
{
#if !NETSTANDARD1_1
Trace.WriteLine("XInitThreads failed");
#endif
}
return;
}
// full path to directory location of libvlc and libvlccore has been provided
if (!string.IsNullOrEmpty(libvlcDirectoryPath))
{
bool loadResult;
if (PlatformHelper.IsWindows)
{
var libvlccorePath = LibVLCCorePath(libvlcDirectoryPath);
loadResult = LoadNativeLibrary(libvlccorePath, out _libvlccoreHandle);
if (!loadResult)
{
Log($"Failed to load required native libraries at {libvlccorePath}");
return;
}
}
var libvlcPath = LibVLCPath(libvlcDirectoryPath);
loadResult = LoadNativeLibrary(libvlcPath, out _libvlcHandle);
if (!loadResult)
{
Log($"Failed to load required native libraries at {libvlcPath}");
}
return;
}
#if !NETSTANDARD1_1
var paths = ComputeLibVLCSearchPaths();
foreach (var path in paths)
{
if (PlatformHelper.IsWindows)
{
LoadNativeLibrary(path.libvlccore, out _libvlccoreHandle);
}
var loadResult = LoadNativeLibrary(path.libvlc, out _libvlcHandle);
if (loadResult)
{
break;
}
}
if (!Loaded)
{
throw new VLCException($"Failed to load required native libraries. Search paths include {string.Join("; ", paths.Select(p => $"{p.libvlc},{p.libvlccore}"))}");
}
#endif
}
// 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);
}
internal static bool IsSet(Native.FilePermissions mode, Native.FilePermissions type)
{
return (mode & type) == type;
}
public bool DestroyPollGroup(PollGroup pollGroup)
{
return(Native.SteamAPI_ISteamNetworkingSockets_DestroyPollGroup(nativeSockets, pollGroup));
}
public long GetConnectionUserData(Connection peer)
{
return(Native.SteamAPI_ISteamNetworkingSockets_GetConnectionUserData(nativeSockets, peer));
}
public bool GetIdentity(ref NetworkingIdentity identity)
{
return(Native.SteamAPI_ISteamNetworkingSockets_GetIdentity(nativeSockets, ref identity));
}
public PollGroup CreatePollGroup()
{
return(Native.SteamAPI_ISteamNetworkingSockets_CreatePollGroup(nativeSockets));
}
public bool CreateSocketPair(Connection connectionLeft, Connection connectionRight, bool useNetworkLoopback, ref NetworkingIdentity identityLeft, ref NetworkingIdentity identityRight)
{
return(Native.SteamAPI_ISteamNetworkingSockets_CreateSocketPair(nativeSockets, connectionLeft, connectionRight, useNetworkLoopback, ref identityLeft, ref identityRight));
}
public bool GetListenSocketAddress(ListenSocket socket, ref Address address)
{
return(Native.SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress(nativeSockets, socket, ref address));
}
public int GetDetailedConnectionStatus(Connection connection, StringBuilder status, int statusLength)
{
return(Native.SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus(nativeSockets, connection, status, statusLength));
}
public void AddMotionEvent(Native.X11.Masks _Mask, EventHandler<Events.Server.MotionEventArgs> listener)
{
ulong mask = (ulong)_Mask;
MotionEventTable.AddHandler(Widget, mask , listener);
}
public bool SetConnectionPollGroup(PollGroup pollGroup, Connection connection)
{
return(Native.SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup(nativeSockets, connection, pollGroup));
}
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);
}
public void RunCallbacks()
{
Native.SteamAPI_ISteamNetworkingSockets_RunCallbacks(nativeSockets);
}
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 bool SetStatusCallback(StatusCallback callback)
{
return(Native.SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetConnectionStatusChanged(nativeUtils, callback));
}
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;
}
public void SetDebugCallback(DebugType detailLevel, DebugCallback callback)
{
Native.SteamAPI_ISteamNetworkingUtils_SetDebugOutputFunction(nativeUtils, detailLevel, callback);
}
public bool GetQuickConnectionStatus(Connection connection, ref ConnectionStatus status)
{
return(Native.SteamAPI_ISteamNetworkingSockets_GetQuickConnectionStatus(nativeSockets, connection, ref status));
}
public bool SetConfigurationValue(ConfigurationValue configurationValue, ConfigurationScope configurationScope, IntPtr scopeObject, ConfigurationDataType dataType, IntPtr value)
{
return(Native.SteamAPI_ISteamNetworkingUtils_SetConfigValue(nativeUtils, configurationValue, configurationScope, scopeObject, dataType, value));
}
private static string VisitDefault(C4Error err) => $"CouchbaseLiteException ({err.domain} / {err.code}): {Native.c4error_getMessage(err)}.";
public bool SetConfigurationValue(Configuration configuration, ConfigurationScope configurationScope, IntPtr scopeObject)
{
return(Native.SteamAPI_ISteamNetworkingUtils_SetConfigValueStruct(nativeUtils, configuration, configurationScope, scopeObject));
}
public bool GetConnectionName(Connection peer, StringBuilder name, int maxLength)
{
return(Native.SteamAPI_ISteamNetworkingSockets_GetConnectionName(nativeSockets, peer, name, maxLength));
}
public ConfigurationValueResult GetConfigurationValue(ConfigurationValue configurationValue, ConfigurationScope configurationScope, IntPtr scopeObject, ref ConfigurationDataType dataType, ref IntPtr result, ref IntPtr resultLength)
{
return(Native.SteamAPI_ISteamNetworkingUtils_GetConfigValue(nativeUtils, configurationValue, configurationScope, scopeObject, ref dataType, ref result, ref resultLength));
}
public IntPtr Open(Native.Configuration configuration, RealmSchema schema, byte[] encryptionKey)
{
var marshaledSchema = new SchemaMarshaler(schema);
NativeException nativeException;
var result = NativeMethods.open(configuration, marshaledSchema.Objects, marshaledSchema.Objects.Length, marshaledSchema.Properties, encryptionKey, out nativeException);
nativeException.ThrowIfNecessary();
return result;
}
public static void Deinitialize()
{
Native.GameNetworkingSockets_Kill();
}
public Body(Native.BodyId bodyId)
{
BodyId = bodyId;
}
public Result FlushMessagesOnConnection(Connection connection)
{
return(Native.SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection(nativeSockets, connection));
}
public static extern int DrawThemeTextEx(IntPtr hTheme, IntPtr hdc, int iPartId, int iStateId, string text, int iCharCount, int dwFlags, ref Native.RECT pRect, ref DTTOPTS pOptions);
public Result SendMessageToConnection(Connection connection, IntPtr data, int length, SendFlags flags)
{
return(Native.SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(nativeSockets, connection, data, (uint)length, flags, IntPtr.Zero));
}
public UnixUserInfo (Native.Passwd passwd)
{
this.passwd = CopyPasswd (passwd);
}
internal override void DecRef(Context ctx, IntPtr obj)
{
Native.Z3_model_dec_ref(ctx.nCtx, obj);
}
public void SaveFilePosition (Native.FilePosition pos)
{
AssertNotDisposed ();
int r = Native.Stdlib.fgetpos (file, pos);
UnixMarshal.ThrowExceptionForLastErrorIf (r);
GC.KeepAlive (this);
}
internal BoolSort(Context ctx) : base(ctx, Native.Z3_mk_bool_sort(ctx.nCtx))
{
Contract.Requires(ctx != null);
}
public static string GetConfigurationString (Native.ConfstrName name)
{
ulong len = Native.Syscall.confstr (name, null, 0);
if (len == unchecked ((ulong) (-1)))
UnixMarshal.ThrowExceptionForLastError ();
if (len == 0)
return "";
StringBuilder buf = new StringBuilder ((int) len+1);
len = Native.Syscall.confstr (name, buf, len);
if (len == unchecked ((ulong) (-1)))
UnixMarshal.ThrowExceptionForLastError ();
return buf.ToString ();
}
public static FrontalFaceDetector GetFrontalFaceDetector()
{
var ret = Native.get_frontal_face_detector();
return(new FrontalFaceDetector(ret));
}
public bool CanAccess(Native.AccessModes mode)
{
int r = Native.Syscall.access (FullPath, mode);
return r == 0;
}
protected override void DisposeUnmanaged()
{
base.DisposeUnmanaged();
Native.frontal_face_detector_delete(this.NativePtr);
}
internal static bool IsFileType(Native.FilePermissions mode, Native.FilePermissions type)
{
return (mode & Native.FilePermissions.S_IFMT) == type;
}
private C4Database *OpenDB()
{
var database = (C4Database *)LiteCoreBridge.Check(err => Native.c4db_open(DatabasePath(),
Native.c4db_getConfig(Db), err));
return(database);
}
protected virtual bool GetFileStatus(string path, out Native.Stat stat)
{
return Native.Syscall.stat (path, out stat) == 0;
}
public bool GetConnectionInfo(Connection connection, ref ConnectionInfo info)
{
return(Native.SteamAPI_ISteamNetworkingSockets_GetConnectionInfo(nativeSockets, connection, ref info));
}
unsafe void ScanSection(Native.IMAGE_SECTION_HEADER sectionHdr)
{
long sectionDataAddr = loadAddr + sectionHdr.PointerToRawData;
Console.WriteLine("\nScanning section '{0}' at 0x{1:X2}...\n", sectionHdr.Name, sectionDataAddr);
byte* dataPtr = (byte*)(sectionDataAddr);
byte* endPtr = (byte*)(dataPtr + sectionHdr.SizeOfRawData);
while (dataPtr < endPtr)
{
if (*dataPtr == 0x0A)
{
byte* originalPtr = dataPtr;
int nullskiplevel = 0;
rescan:
int t = nullskiplevel;
dataPtr = originalPtr;
byte[] data = null;
using (var ms = new MemoryStream())
using (var bw = new BinaryWriter(ms))
{
for (; *(short*)dataPtr != 0 || t-- > 0; dataPtr++)
{
bw.Write(*dataPtr);
}
// do we still need this?
// the extra null byte on the descriptor proto is causing the deserializer to freak out
// bw.Write((byte)0);
data = ms.ToArray();
}
dataPtr++;
if (data.Length < 2)
{
dataPtr = originalPtr + 1;
continue;
}
byte strLen = data[1];
if (data.Length - 2 < strLen)
{
dataPtr = originalPtr + 1;
continue;
}
string protoName = Encoding.ASCII.GetString(data, 2, strLen);
if (!protoName.EndsWith(".proto"))
{
dataPtr = originalPtr + 1;
continue;
}
if (!HandleProto(protoName, data))
{
nullskiplevel++;
goto rescan;
}
}
else
{
dataPtr++;
}
}
}
/// <summary>
/// Conversion of models to strings.
/// </summary>
/// <returns>A string representation of the model.</returns>
public override string ToString()
{
return(Native.Z3_model_to_string(Context.nCtx, NativeObject));
}
