extern static IntPtr g_param_spec_flags(
IntPtr name,
IntPtr nick,
IntPtr blurb,
GType flagsType,
int defaultValue,
ParamFlags flags);
static extern IntPtr g_param_spec_variant(
IntPtr name,
IntPtr nick,
IntPtr blurb,
IntPtr type,
IntPtr defaultValue,
ParamFlags flags);
static IntPtr New (string name, string nick, string blurb, ParamFlags flags)
{
if (name == null) {
throw new ArgumentNullException (nameof (name));
}
if (nick == null) {
throw new ArgumentNullException (nameof (nick));
}
if (blurb == null) {
throw new ArgumentNullException (nameof (blurb));
}
var namePtr = GMarshal.StringToUtf8Ptr (name);
var nickPtr = GMarshal.StringToUtf8Ptr (nick);
var blurbPtr = GMarshal.StringToUtf8Ptr (blurb);
var ret = g_param_spec_pointer (namePtr, nickPtr, blurbPtr, flags);
// Any strings that have the cooresponding static flag set must not
// be freed because they are passed to g_intern_static_string().
if (!flags.HasFlag (ParamFlags.StaticName)) {
GMarshal.Free (namePtr);
}
if (!flags.HasFlag (ParamFlags.StaticNick)) {
GMarshal.Free (nickPtr);
}
if (!flags.HasFlag (ParamFlags.StaticBlurb)) {
GMarshal.Free (blurbPtr);
}
return ret;
}
extern static IntPtr g_param_spec_float(
IntPtr name,
IntPtr nick,
IntPtr blurb,
float min,
float max,
float defaultValue,
ParamFlags flags);
extern static IntPtr g_param_spec_ulong(
IntPtr name,
IntPtr nick,
IntPtr blurb,
nulong min,
nulong max,
nulong defaultValue,
ParamFlags flags);
extern static IntPtr g_param_spec_int64(
IntPtr name,
IntPtr nick,
IntPtr blurb,
long min,
long max,
long defaultValue,
ParamFlags flags);
extern static IntPtr g_param_spec_uint(
IntPtr name,
IntPtr nick,
IntPtr blurb,
uint min,
uint max,
uint defaultValue,
ParamFlags flags);
extern static IntPtr g_param_spec_char(
IntPtr name,
IntPtr nick,
IntPtr blurb,
sbyte min,
sbyte max,
sbyte defaultValue,
ParamFlags flags);
extern static IntPtr g_param_spec_double(
IntPtr name,
IntPtr nick,
IntPtr blurb,
double min,
double max,
double defaultValue,
ParamFlags flags);
internal ParamRow(
ParamFlags flags,
ushort sequence,
uint name)
{
this.Flags = flags;
this.Sequence = sequence;
this.Name = name;
}
internal ParamRow(
ParamFlags flags,
ushort sequence,
uint name)
{
this.Flags = flags;
this.Sequence = sequence;
this.Name = name;
}
internal ParamSpec(string name, string nick, string blurb, GType type, ParamFlags pflags)
{
int flags = (int) pflags;
IntPtr p_name = GLib.Marshaller.StringToPtrGStrdup (name);
IntPtr p_nick = GLib.Marshaller.StringToPtrGStrdup (nick);
IntPtr p_blurb = GLib.Marshaller.StringToPtrGStrdup (blurb);
if (type == GType.Char)
handle = g_param_spec_char (p_name, p_nick, p_blurb, SByte.MinValue, SByte.MaxValue, 0, flags);
else if (type == GType.UChar)
handle = g_param_spec_uchar (p_name, p_nick, p_blurb, Byte.MinValue, Byte.MaxValue, 0, flags);
else if (type == GType.Boolean)
handle = g_param_spec_boolean (p_name, p_nick, p_blurb, false, flags);
else if (type == GType.Int)
handle = g_param_spec_int (p_name, p_nick, p_blurb, Int32.MinValue, Int32.MaxValue, 0, flags);
else if (type == GType.UInt)
handle = g_param_spec_uint (p_name, p_nick, p_blurb, 0, UInt32.MaxValue, 0, flags);
else if (type == GType.Long)
handle = g_param_spec_long (p_name, p_nick, p_blurb, IntPtr.Zero, IntPtr.Size == 4 ? new IntPtr (Int32.MaxValue) : new IntPtr (Int64.MaxValue), IntPtr.Zero, flags);
else if (type == GType.ULong)
handle = g_param_spec_ulong (p_name, p_nick, p_blurb, UIntPtr.Zero, UIntPtr.Size == 4 ? new UIntPtr (UInt32.MaxValue) : new UIntPtr (UInt64.MaxValue), UIntPtr.Zero, flags);
else if (type == GType.Int64)
handle = g_param_spec_int64 (p_name, p_nick, p_blurb, Int64.MinValue, Int64.MaxValue, 0, flags);
else if (type == GType.UInt64)
handle = g_param_spec_uint64 (p_name, p_nick, p_blurb, 0, UInt64.MaxValue, 0, flags);
else if (type.GetBaseType () == GType.Enum)
handle = g_param_spec_enum (p_name, p_nick, p_blurb, type.Val, (int) (Enum.GetValues((Type)type).GetValue (0)), flags);
/*else if (type == GType.Flags)
* g_param_spec_flags (p_name, p_nick, p_blurb, type.Val, Enum.GetValues((Type)type) [0], flags);
* TODO:
* Both g_param_spec_enum and g_param_spec_flags expect default property values and the members of the enum seemingly cannot be enumerated
*/
else if (type == GType.Float)
handle = g_param_spec_float (p_name, p_nick, p_blurb, Single.MinValue, Single.MaxValue, 0.0f, flags);
else if (type == GType.Double)
handle = g_param_spec_double (p_name, p_nick, p_blurb, Double.MinValue, Double.MaxValue, 0.0, flags);
else if (type == GType.String)
handle = g_param_spec_string (p_name, p_nick, p_blurb, IntPtr.Zero, flags);
else if (type == GType.Pointer)
handle = g_param_spec_pointer (p_name, p_nick, p_blurb, flags);
else if (type.Val == g_gtype_get_type ())
handle = g_param_spec_gtype (p_name, p_nick, p_blurb, GType.None.Val, flags);
else if (g_type_is_a (type.Val, GType.Boxed.Val))
handle = g_param_spec_boxed (p_name, p_nick, p_blurb, type.Val, flags);
else if (g_type_is_a (type.Val, GType.Object.Val))
handle = g_param_spec_object (p_name, p_nick, p_blurb, type.Val, flags);
else
throw new ArgumentException ("type:" + type.ToString ());
GLib.Marshaller.Free (p_name);
GLib.Marshaller.Free (p_nick);
GLib.Marshaller.Free (p_blurb);
}
T TestParamSpec <T> (GType type, Func <string, string, string, ParamFlags, T> instantiate) where T : ParamSpec
{
const ParamFlags flags = ParamFlags.Readwrite | ParamFlags.StaticStrings;
Assert.That(() => instantiate(null, "nick", "blurb", flags),
Throws.TypeOf <ArgumentNullException> ());
Assert.That(() => instantiate("name", null, "blurb", flags),
Throws.TypeOf <ArgumentNullException> ());
Assert.That(() => instantiate("name", "nick", null, flags),
Throws.TypeOf <ArgumentNullException> ());
var param = instantiate("name", "nick", "blurb", flags);
Assert.That(param.Name, Is.EqualTo("name"));
Assert.That(param.Nick, Is.EqualTo("nick"));
Assert.That(param.Blurb, Is.EqualTo("blurb"));
Assert.That(param.RedirectTarget, Is.Null);
Assert.That(param.ValueType, Is.EqualTo(type));
return(param);
}
public ParamSpecUInt(string name, string nick, string blurb, uint min, uint max, uint defaultValue, ParamFlags flags)
: this(New(name, nick, blurb, min, max, defaultValue, flags), Transfer.None)
{
}
public ParamSpecBoxed(string name, string nick, string blurb, GType boxedType, ParamFlags flags)
: this(New(name, nick, blurb, boxedType, flags), Transfer.None)
{
}
internal ParamInfo(
uint paramRowId,
uint paramSequence,
IName paramName,
ParamFlags paramFlags
) {
this.ParamSequence = paramSequence;
this.ParamRowId = paramRowId;
this.ParamName = paramName;
this.ParamFlags = paramFlags;
}
extern static IntPtr g_param_spec_gtype(
IntPtr name,
IntPtr nick,
IntPtr blurb,
GType isAType,
ParamFlags flags);
public ParamSpecDouble(string name, string nick, string blurb, double min, double max, double defaultValue, ParamFlags flags)
: this(New(name, nick, blurb, min, max, defaultValue, flags), Transfer.None)
{
}
internal ParamSpec(string name, string nick, string blurb, GType type, ParamFlags pflags)
{
int flags = (int)pflags;
IntPtr p_name = GLib.Marshaller.StringToPtrGStrdup(name);
IntPtr p_nick = GLib.Marshaller.StringToPtrGStrdup(nick);
IntPtr p_blurb = GLib.Marshaller.StringToPtrGStrdup(blurb);
if (type == GType.Char)
{
handle = g_param_spec_char(p_name, p_nick, p_blurb, SByte.MinValue, SByte.MaxValue, 0, flags);
}
else if (type == GType.UChar)
{
handle = g_param_spec_uchar(p_name, p_nick, p_blurb, Byte.MinValue, Byte.MaxValue, 0, flags);
}
else if (type == GType.Boolean)
{
handle = g_param_spec_boolean(p_name, p_nick, p_blurb, false, flags);
}
else if (type == GType.Int)
{
handle = g_param_spec_int(p_name, p_nick, p_blurb, Int32.MinValue, Int32.MaxValue, 0, flags);
}
else if (type == GType.UInt)
{
handle = g_param_spec_uint(p_name, p_nick, p_blurb, 0, UInt32.MaxValue, 0, flags);
}
else if (type == GType.Long)
{
handle = g_param_spec_long(p_name, p_nick, p_blurb, IntPtr.Zero, IntPtr.Size == 4 ? new IntPtr(Int32.MaxValue) : new IntPtr(Int64.MaxValue), IntPtr.Zero, flags);
}
else if (type == GType.ULong)
{
handle = g_param_spec_ulong(p_name, p_nick, p_blurb, UIntPtr.Zero, UIntPtr.Size == 4 ? new UIntPtr(UInt32.MaxValue) : new UIntPtr(UInt64.MaxValue), UIntPtr.Zero, flags);
}
else if (type == GType.Int64)
{
handle = g_param_spec_int64(p_name, p_nick, p_blurb, Int64.MinValue, Int64.MaxValue, 0, flags);
}
else if (type == GType.UInt64)
{
handle = g_param_spec_uint64(p_name, p_nick, p_blurb, 0, UInt64.MaxValue, 0, flags);
}
/*
* else if (type == GType.Enum)
* else if (type == GType.Flags)
* TODO:
* Both g_param_spec_enum and g_param_spec_flags expect default property values and the members of the enum seemingly cannot be enumerated
*/
else if (type == GType.Float)
{
handle = g_param_spec_float(p_name, p_nick, p_blurb, Single.MinValue, Single.MaxValue, 0.0f, flags);
}
else if (type == GType.Double)
{
handle = g_param_spec_double(p_name, p_nick, p_blurb, Double.MinValue, Double.MaxValue, 0.0, flags);
}
else if (type == GType.String)
{
handle = g_param_spec_string(p_name, p_nick, p_blurb, IntPtr.Zero, flags);
}
else if (type == GType.Pointer)
{
handle = g_param_spec_pointer(p_name, p_nick, p_blurb, flags);
}
else if (type.Val == g_gtype_get_type())
{
handle = g_param_spec_gtype(p_name, p_nick, p_blurb, GType.None.Val, flags);
}
else if (g_type_is_a(type.Val, GType.Boxed.Val))
{
handle = g_param_spec_boxed(p_name, p_nick, p_blurb, type.Val, flags);
}
else if (g_type_is_a(type.Val, GType.Object.Val))
{
handle = g_param_spec_object(p_name, p_nick, p_blurb, type.Val, flags);
}
else
{
throw new ArgumentException("type");
}
GLib.Marshaller.Free(p_name);
GLib.Marshaller.Free(p_nick);
GLib.Marshaller.Free(p_blurb);
}
public ParamSpecChar(string name, string nick, string blurb, sbyte min, sbyte max, sbyte defaultValue, ParamFlags flags)
: this(New(name, nick, blurb, min, max, defaultValue, flags), Transfer.None)
{
}
extern static IntPtr g_param_spec_pointer (
IntPtr name,
IntPtr nick,
IntPtr blurb,
ParamFlags flags);
extern static IntPtr g_param_spec_boxed(
IntPtr name,
IntPtr nick,
IntPtr blurb,
GType boxedType,
ParamFlags flags);
public ParamSpecInt64(string name, string nick, string blurb, long min, long max, long defaultValue, ParamFlags flags)
: this(New(name, nick, blurb, min, max, defaultValue, flags), Transfer.None)
{
}
public ParamSpecPointer (string name, string nick, string blurb, ParamFlags flags)
: this (New (name, nick, blurb, flags), Transfer.None)
{
}
public ParamSpecValueArray(string name, string nick, string blurb, ParamSpec elementSpec, ParamFlags flags)
: this(New(name, nick, blurb, elementSpec, flags), Transfer.None)
{
}
extern static IntPtr g_param_spec_param(
IntPtr name,
IntPtr nick,
IntPtr blurb,
GType paramType,
ParamFlags flags);
public ParamSpecParam(string name, string nick, string blurb, GType paramType, ParamFlags flags)
: this(New(name, nick, blurb, paramType, flags), Transfer.None)
{
}
extern static IntPtr g_param_spec_object(
IntPtr name,
IntPtr nick,
IntPtr blurb,
GType objectType,
ParamFlags flags);
public ParamSpecObject(string name, string nick, string blurb, GType objectType, ParamFlags flags)
: this(New(name, nick, blurb, objectType, flags), Transfer.None)
{
}
extern static IntPtr g_param_spec_value_array(
IntPtr name,
IntPtr nick,
IntPtr blurb,
IntPtr elementSpec,
ParamFlags flags);
static IntPtr New(string name, string nick, string blurb, GType flagsType, int defaultValue, ParamFlags flags)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (nick == null)
{
throw new ArgumentNullException(nameof(nick));
}
if (blurb == null)
{
throw new ArgumentNullException(nameof(blurb));
}
if (!flagsType.IsA(GType.Flags))
{
throw new ArgumentException("Expecting an enum type", nameof(flagsType));
}
var namePtr = GMarshal.StringToUtf8Ptr(name);
var nickPtr = GMarshal.StringToUtf8Ptr(nick);
var blurbPtr = GMarshal.StringToUtf8Ptr(blurb);
var ret = g_param_spec_flags(namePtr, nickPtr, blurbPtr, flagsType, defaultValue, flags);
// Any strings that have the cooresponding static flag set must not
// be freed because they are passed to g_intern_static_string().
if (!flags.HasFlag(ParamFlags.StaticName))
{
GMarshal.Free(namePtr);
}
if (!flags.HasFlag(ParamFlags.StaticNick))
{
GMarshal.Free(nickPtr);
}
if (!flags.HasFlag(ParamFlags.StaticBlurb))
{
GMarshal.Free(blurbPtr);
}
return(ret);
}
public ParamSpecUnichar(string name, string nick, string blurb, int defaultValue, ParamFlags flags)
: this(New(name, nick, blurb, (uint)defaultValue, flags), Transfer.None)
{
}
static IntPtr New(string name, string nick, string blurb, ParamSpec elementSpec, ParamFlags flags)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (nick == null)
{
throw new ArgumentNullException(nameof(nick));
}
if (blurb == null)
{
throw new ArgumentNullException(nameof(blurb));
}
var namePtr = GMarshal.StringToUtf8Ptr(name);
var nickPtr = GMarshal.StringToUtf8Ptr(nick);
var blurbPtr = GMarshal.StringToUtf8Ptr(blurb);
var elementSpecPtr = elementSpec?.Handle ?? IntPtr.Zero;
var ret = g_param_spec_value_array(namePtr, nickPtr, blurbPtr, elementSpecPtr, flags);
GC.KeepAlive(elementSpec);
// Any strings that have the cooresponding static flag set must not
// be freed because they are passed to g_intern_static_string().
if (!flags.HasFlag(ParamFlags.StaticName))
{
GMarshal.Free(namePtr);
}
if (!flags.HasFlag(ParamFlags.StaticNick))
{
GMarshal.Free(nickPtr);
}
if (!flags.HasFlag(ParamFlags.StaticBlurb))
{
GMarshal.Free(blurbPtr);
}
return(ret);
}
