static Module()
{
// Initialize the platform-specific "constants". Suffix should end
// up being the same as G_MODULE_SUFFIX in C code.
var emptyName = GMarshal.StringToUtf8Ptr(string.Empty);
var path_ = g_module_build_path(IntPtr.Zero, emptyName);
var path = GMarshal.Utf8PtrToString(path_, true);
GMarshal.Free(emptyName);
var parts = path.Split('.');
Prefix = parts[0];
Suffix = parts[1];
// Hack to detect macOS
if (File.Exists("/usr/lib/libSystem.dylib"))
{
LibrarySuffix = "dylib";
}
else
{
LibrarySuffix = Suffix;
}
}
public void TestRegister4()
{
// this should register successfully
var testEnum4GType = typeof(TestEnum4).GetGType();
Assert.That(testEnum4GType, Is.Not.EqualTo(GType.Invalid),
"Failed to register an enum");
// make sure the type is not re-registed.
Assert.That(testEnum4GType, Is.EqualTo(typeof(TestEnum4).GetGType()));
// a couple more GType checks
Assert.That((Type)testEnum4GType, Is.EqualTo(typeof(TestEnum4)));
Assert.That(testEnum4GType.IsA(GType.Enum), Is.True);
// make sure that we set the typename, value name and value nick
Assert.That(testEnum4GType.Name, Is.EqualTo("GISharp-Core-Test-GObject-EnumTests+TestEnum4"));
using (var enum4TypeClass = (EnumClass)TypeClass.Get(testEnum4GType)) {
var value = GISharp.GObject.Enum.GetValue(enum4TypeClass, 1);
Assert.That(value.Value, Is.EqualTo((int)TestEnum4.One));
var valueName = GMarshal.Utf8PtrToString(value.ValueName);
Assert.That(valueName, Is.EqualTo("One"));
var valueNick = GMarshal.Utf8PtrToString(value.ValueNick);
Assert.That(valueNick, Is.EqualTo("One"));
}
Utility.AssertNoGLibLog();
}
/// <summary>
/// Gets the string associated with the given <see cref="Quark"/>.
/// </summary>
/// <returns>
/// the string associated with the <see cref="Quark"/>
/// </returns>
public override string ToString()
{
var ret_ = g_quark_to_string(value);
var ret = GMarshal.Utf8PtrToString(ret_);
return(ret);
}
/// <summary>
/// Retrieve an arbitrary attribute associated with this node.
/// </summary>
/// <returns>The attribute or <c>null</c> if no such attribute exists.</returns>
/// <param name="name">Name.</param>
public string GetAttribute(string name)
{
IntPtr native_name = GMarshal.StringToUtf8Ptr(name);
IntPtr raw_ret = g_base_info_get_attribute(Handle, native_name);
string ret = GMarshal.Utf8PtrToString(raw_ret);
GMarshal.Free(native_name);
return(ret);
}
internal static string GetVersion(string @namespace)
{
IntPtr native_namespace = GMarshal.StringToUtf8Ptr(@namespace);
IntPtr raw_ret = g_irepository_get_version(IntPtr.Zero, native_namespace);
string ret = GMarshal.Utf8PtrToString(raw_ret);
GMarshal.Free(native_namespace);
return(ret);
}
bool IterateAttributes(ref AttributeIter iterator, out string name, out string value)
{
IntPtr native_name;
IntPtr native_value;
bool ret = g_base_info_iterate_attributes(Handle, ref iterator, out native_name, out native_value);
name = GMarshal.Utf8PtrToString(native_name);
value = GMarshal.Utf8PtrToString(native_value);
return(ret);
}
bool IterateReturnAttributes(ref AttributeIter iterator, out string name, out string value)
{
IntPtr namePtr;
IntPtr valuePtr;
var ret = g_callable_info_iterate_return_attributes(Handle, ref iterator, out namePtr, out valuePtr);
name = GMarshal.Utf8PtrToString(namePtr);
value = GMarshal.Utf8PtrToString(valuePtr);
return(ret);
}
static void Log(IntPtr logDomainPtr, uint log_level, IntPtr messagePtr, IntPtr user_data)
{
try {
var logDomain = GMarshal.Utf8PtrToString(logDomainPtr);
var message = GMarshal.Utf8PtrToString(messagePtr);
Assert.Fail($"({logDomain}) {log_level} {message}");
}
catch (Exception ex) {
Console.Error.WriteLine(ex);
}
}
protected RegisteredTypeInfo(IntPtr raw) : base(raw)
{
_TypeInit = new Lazy <string> (() => {
IntPtr raw_ret = g_registered_type_info_get_type_init(Handle);
return(GMarshal.Utf8PtrToString(raw_ret));
});
_TypeName = new Lazy <string> (() => {
IntPtr raw_ret = g_registered_type_info_get_type_name(Handle);
return(GMarshal.Utf8PtrToString(raw_ret));
});
_GType = new Lazy <GType> (() =>
g_registered_type_info_get_g_type(Handle));
}
static void UnmanagedFunc(IntPtr logDomain_, LogLevelFlags logLevel_, IntPtr message_, IntPtr userData_)
{
try {
var gcHandle = (GCHandle)userData_;
var userData = (UnmanagedLogFuncFuncData)gcHandle.Target;
var logDomain = GMarshal.Utf8PtrToString(logDomain_);
var message = GMarshal.Utf8PtrToString(message_);
userData.Func(logDomain, logLevel_, message);
if (userData.IsAsync)
{
gcHandle.Free();
}
}
catch (Exception ex) {
ex.LogUnhandledException();
}
}
protected BaseInfo(IntPtr raw)
{
Handle = raw;
_Namespace = new Lazy <string> (() => {
var ret = g_base_info_get_namespace(Handle);
return(GMarshal.Utf8PtrToString(ret));
});
_Name = new Lazy <string> (() => {
// calling g_base_info_get_name on a TypeInfo will cause a crash.
var typeInfo = this as TypeInfo;
if (typeInfo != null)
{
return(null);
}
var ret = g_base_info_get_name(Handle);
return(GMarshal.Utf8PtrToString(ret));
});
}
public void TestRegister5()
{
// make sure that we can override name and nick with attributes
var testEnum5GType = typeof(TestEnum5).GetGType();
Assert.That(testEnum5GType.Name, Is.EqualTo("TestEnum5GTypeName"));
using (var enum5TypeClass = (EnumClass)TypeClass.Get(testEnum5GType)) {
var value1 = GISharp.GObject.Enum.GetValue(enum5TypeClass, 1);
Assert.That(value1.Value, Is.EqualTo((int)TestEnum5.One));
var value1Name = GMarshal.Utf8PtrToString(value1.ValueName);
Assert.That(value1Name, Is.EqualTo("test_enum_5_value_one"));
var value1Nick = GMarshal.Utf8PtrToString(value1.ValueNick);
Assert.That(value1Nick, Is.EqualTo("One"));
var value2 = GISharp.GObject.Enum.GetValue(enum5TypeClass, 2);
Assert.That(value2.Value, Is.EqualTo((int)TestEnum5.Two));
var value2Name = GMarshal.Utf8PtrToString(value2.ValueName);
Assert.That(value2Name, Is.EqualTo("Two"));
var value2Nick = GMarshal.Utf8PtrToString(value2.ValueNick);
Assert.That(value2Nick, Is.EqualTo("test_enum_5_value_two"));
}
Utility.AssertNoGLibLog();
}
public void TestRegister5()
{
// make sure that we can override name and nick with attributes
var testFlags5GType = typeof(TestFlags5).GetGType();
Assert.That(testFlags5GType.Name, Is.EqualTo("TestFlags5GTypeName"));
using (var flags5TypeClass = (FlagsClass)TypeClass.Get(testFlags5GType)) {
var value1 = Flags.GetFirstValue(flags5TypeClass, 1);
Assert.That(value1.Value, Is.EqualTo((int)TestFlags5.One));
var value1Name = GMarshal.Utf8PtrToString(value1.ValueName);
Assert.That(value1Name, Is.EqualTo("test_flags_5_value_one"));
var value1Nick = GMarshal.Utf8PtrToString(value1.ValueNick);
Assert.That(value1Nick, Is.EqualTo("One"));
var value2 = Flags.GetFirstValue(flags5TypeClass, 2);
Assert.That(value2.Value, Is.EqualTo((int)TestFlags5.Two));
var value2Name = GMarshal.Utf8PtrToString(value2.ValueName);
Assert.That(value2Name, Is.EqualTo("Two"));
var value2Nick = GMarshal.Utf8PtrToString(value2.ValueNick);
Assert.That(value2Nick, Is.EqualTo("test_flags_5_value_two"));
}
Utility.AssertNoGLibLog();
}
static object MarshalOutArg(Argument arg, TypeInfo info, Transfer ownership, ref Action free)
{
if (info.IsPointer)
{
switch (info.Tag)
{
case TypeTag.Array:
switch (info.ArrayType)
{
case ArrayType.C:
var arrayType = info.GetParamType(0);
if (arrayType.Tag == TypeTag.UTF8 && info.IsZeroTerminated)
{
// This is a Strv
return(GMarshal.GStrvPtrToStringArray(arg.Pointer, ownership != Transfer.Nothing, ownership == Transfer.Everything));
}
throw new NotImplementedException();
default:
throw new NotImplementedException();
}
case TypeTag.UTF8:
var ret = GMarshal.Utf8PtrToString(arg.Pointer, ownership != Transfer.Nothing);
return(ret);
case TypeTag.Interface:
switch (info.Interface.InfoType)
{
case InfoType.Interface:
case InfoType.Object:
if (arg.Pointer == IntPtr.Zero)
{
return(null);
}
return(new DynamicGObject(arg.Pointer));
case InfoType.Struct:
if (arg.Pointer == IntPtr.Zero)
{
return(null);
}
return(new DynamicStruct(arg.Pointer, (StructInfo)info.Interface));
default:
throw new NotImplementedException();
}
case TypeTag.Void:
return(arg.Pointer);
default:
throw new NotImplementedException();
}
}
else
{
switch (info.Tag)
{
case TypeTag.Boolean:
return(arg.Boolean);
case TypeTag.Int8:
return(arg.Int8);
case TypeTag.UInt8:
return(arg.UInt8);
case TypeTag.Int16:
return(arg.Int16);
case TypeTag.UInt16:
return(arg.UInt16);
case TypeTag.Int32:
return(arg.Int32);
case TypeTag.UInt32:
return(arg.UInt32);
case TypeTag.Int64:
return(arg.Int64);
case TypeTag.UInt64:
return(arg.UInt64);
case TypeTag.Void:
return(null);
default:
throw new NotImplementedException();
}
}
}
