public void Dispose()
{
if (variant != IntPtr.Zero)
{
NativeApiProxy.FreeVariant(variant);
}
}
public void Assign(IValue value, Int32 number = 0)
{
switch (value.DataType)
{
case DataType.String:
String str = value.AsString();
NativeApiProxy.SetVariantStr(variant, number, str, str.Length);
break;
case DataType.Boolean:
NativeApiProxy.SetVariantBool(variant, number, value.AsBoolean());
break;
case DataType.Number:
Decimal num = value.AsNumber();
if (num % 1 == 0)
{
NativeApiProxy.SetVariantInt(variant, number, Convert.ToInt32(value.AsNumber()));
}
else
{
NativeApiProxy.SetVariantReal(variant, number, Convert.ToDouble(value.AsNumber()));
}
break;
case DataType.Object when value.AsObject() is BinaryDataContext binaryData:
NativeApiProxy.SetVariantBlob(variant, number, binaryData.Buffer, binaryData.Buffer.Length);
break;
default:
NativeApiProxy.SetVariantEmpty(variant, number);
break;
}
}
public void SetPropValue(int propNum, IValue newVal)
{
var variant = new NativeApiVariant();
variant.SetValue(newVal);
NativeApiProxy.SetPropVal(_object, propNum, ref variant);
variant.Clear();
}
public void SetPropValue(int propNum, IValue value)
{
using (var variant = new NativeApiVariant())
{
variant.Assign(value);
NativeApiProxy.SetPropVal(_object, propNum, variant.Ptr);
};
}
public string GetPropName(int propNum)
{
var name = String.Empty;
NativeApiProxy.GetPropName(_object, propNum, 0,
n => name = NativeApiProxy.Str(n)
);
return(name);
}
public IValue GetPropValue(int propNum)
{
var result = ValueFactory.Create();
NativeApiProxy.GetPropVal(_object, propNum,
variant => result = NativeApiVariant.GetValue(variant)
);
return(result);
}
public int FindProperty(string name)
{
var propNumber = NativeApiProxy.FindProp(_object, name);
if (propNumber < 0)
{
throw RuntimeException.PropNotFoundException(name);
}
return(propNumber);
}
public NativeApiComponent(IHostApplication host, NativeApiLibrary library, String typeName, String componentName)
{
_host = host;
_object = NativeApiProxy.GetClassObject(library.Module, componentName,
(wcode, source, descr, scode) => _host.Echo("ОШИБКА: " + S(source) + " - " + S(descr), Status(wcode)),
(source, message, data) => _host.Echo("СОБЫТИЕ: " + S(source) + " - " + S(message) + " - " + S(data)),
(status) => _host.Echo("СТАТУС: " + S(status))
);
DefineType(TypeManager.GetTypeByName(typeName));
}
public int FindMethod(string name)
{
var methodNumber = NativeApiProxy.FindMethod(_object, name);
if (methodNumber < 0)
{
throw RuntimeException.MethodNotFoundException(name);
}
return(methodNumber);
}
private void SetDefValues(int methodNumber, int paramCount, IValue[] arguments)
{
for (int i = 0; i < paramCount; i++)
{
if (arguments[i] == null)
{
NativeApiProxy.GetParamDefValue(_object, methodNumber, i,
variant => arguments[i] = NativeApiVariant.GetValue(variant)
);
}
}
}
public void CallAsProcedure(int methodNumber, IValue[] arguments)
{
int paramCount = NativeApiProxy.GetNParams(_object, methodNumber);
using (var variant = new NativeApiVariant(paramCount))
{
SetDefValues(methodNumber, paramCount, arguments);
for (int i = 0; i < paramCount; i++)
{
variant.Assign(arguments[i], i);
}
NativeApiProxy.CallAsProc(_object, methodNumber, variant.Ptr);
}
}
public void CallAsProcedure(int methodNumber, IValue[] arguments)
{
var paramArray = IntPtr.Zero;
int paramCount = NativeApiProxy.GetNParams(_object, methodNumber);
if (paramCount > 0)
{
paramArray = Marshal.AllocHGlobal(NativeApiVariant.Size * paramCount);
}
SetDefValues(methodNumber, paramCount, arguments);
NativeApiVariant.SetValue(paramArray, arguments, paramCount);
NativeApiProxy.CallAsProc(_object, methodNumber, paramArray);
NativeApiVariant.GetValue(arguments, paramArray, paramCount);
NativeApiVariant.Clear(paramArray, paramCount);
Marshal.FreeHGlobal(paramArray);
}
public static IValue Value(IntPtr variant, Int32 number = 0)
{
IValue value = ValueFactory.Create();
NativeApiProxy.GetVariant(variant, number,
(v, n) => value = ValueFactory.Create(),
(v, n, r) => value = ValueFactory.Create(r),
(v, n, r) => value = ValueFactory.Create((Decimal)r),
(v, n, r) => value = ValueFactory.Create((Decimal)r),
(v, n, r, s) => value = ValueFactory.Create(Marshal.PtrToStringUni(r, s)),
(v, n, r, s) => {
byte[] buffer = new byte[s];
Marshal.Copy(r, buffer, 0, s);
value = ValueFactory.Create(new BinaryDataContext(buffer));
}
);
return(value);
}
public void CallAsFunction(int methodNumber, IValue[] arguments, out IValue retValue)
{
var result = ValueFactory.Create();
int paramCount = NativeApiProxy.GetNParams(_object, methodNumber);
using (var variant = new NativeApiVariant(paramCount))
{
SetDefValues(methodNumber, paramCount, arguments);
for (int i = 0; i < paramCount; i++)
{
variant.Assign(arguments[i], i);
}
NativeApiProxy.CallAsFunc(_object, methodNumber, variant.Ptr,
res => result = NativeApiVariant.Value(res)
);
}
retValue = result;
}
public MethodInfo GetMethodInfo(int methodNumber)
{
if (methodNumber < 0)
{
throw new RuntimeException("Метод не найден");
}
var name = String.Empty;
var alias = String.Empty;
NativeApiProxy.GetMethodName(_object, methodNumber, 0,
str => name = NativeApiProxy.Str(str)
);
NativeApiProxy.GetMethodName(_object, methodNumber, 1,
str => alias = NativeApiProxy.Str(str)
);
var paramCount = NativeApiProxy.GetNParams(_object, methodNumber);
var paramArray = new ParameterDefinition[paramCount];
for (int i = 0; i < paramCount; i++)
{
NativeApiProxy.GetParamDefValue(_object, methodNumber, i, variant =>
{
if (NativeApiVariant.NotEmpty(variant))
{
paramArray[i].HasDefaultValue = true;
paramArray[i].DefaultValueIndex = ParameterDefinition.UNDEFINED_VALUE_INDEX;
}
});
}
return(new MethodInfo
{
Name = name,
Alias = alias,
IsFunction = NativeApiProxy.HasRetVal(_object, methodNumber),
IsDeprecated = false,
IsExport = false,
ThrowOnUseDeprecated = false,
Params = paramArray,
});
}
public void CallAsFunction(int methodNumber, IValue[] arguments, out IValue retValue)
{
var paramArray = IntPtr.Zero;
int paramCount = NativeApiProxy.GetNParams(_object, methodNumber);
if (paramCount > 0)
{
paramArray = Marshal.AllocHGlobal(NativeApiVariant.Size * paramCount);
}
SetDefValues(methodNumber, paramCount, arguments);
NativeApiVariant.SetValue(paramArray, arguments, paramCount);
IValue result = retValue = ValueFactory.Create();
bool ok = NativeApiProxy.CallAsFunc(_object, methodNumber, paramArray,
variant => result = NativeApiVariant.GetValue(variant)
);
NativeApiVariant.GetValue(arguments, paramArray, paramCount);
NativeApiVariant.Clear(paramArray, paramCount);
Marshal.FreeHGlobal(paramArray);
if (ok)
{
retValue = result;
}
}
public bool IsPropWritable(int propNum)
{
return(NativeApiProxy.IsPropWritable(_object, propNum));
}
public NativeApiVariant(Int32 count = 1)
{
variant = NativeApiProxy.CreateVariant(count);
}
public void Dispose()
{
try { NativeApiProxy.DestroyObject(_object); } catch (Exception) { }
}
private String S(IntPtr ptr)
{
return(NativeApiProxy.Str(ptr));
}
public int GetMethodsCount()
{
return(NativeApiProxy.GetNMethods(_object));
}
public int GetPropCount()
{
return(NativeApiProxy.GetNProps(_object));
}
