mirror of
https://github.com/soukoku/ntwain.git
synced 2025-04-05 17:57:44 +08:00
Try to fix range value reader.
This commit is contained in:
Eugene Wang
parent
22fd782d27
commit
439af52300
@ -2,7 +2,7 @@
|
||||
<PropertyGroup>
|
||||
<!--change these in each release-->
|
||||
<VersionPrefix>4.0.0.0</VersionPrefix>
|
||||
<VersionSuffix>alpha.10</VersionSuffix>
|
||||
<VersionSuffix>alpha.11</VersionSuffix>
|
||||
|
||||
<!--keep it the same until major # changes-->
|
||||
<AssemblyVersion>4.0.0.0</AssemblyVersion>
|
||||
|
||||
@ -6,26 +6,26 @@ using System.Text;
|
||||
|
||||
namespace NTwain.Data
|
||||
{
|
||||
/// <summary>
|
||||
/// Contains methods for reading pointers into various things.
|
||||
/// </summary>
|
||||
public static class ValueReader
|
||||
{
|
||||
/// <summary>
|
||||
/// Reads pointer as UTF8 string.
|
||||
/// Contains methods for reading pointers into various things.
|
||||
/// </summary>
|
||||
/// <param name="data">Pointer to string.</param>
|
||||
/// <param name="memMgr"></param>
|
||||
/// <param name="length">Number of bytes to read.</param>
|
||||
/// <returns></returns>
|
||||
public static unsafe string? PtrToStringUTF8(this IntPtr data, IMemoryManager memMgr, int length)
|
||||
public static class ValueReader
|
||||
{
|
||||
string? val = null;
|
||||
var locked = memMgr.Lock(data);
|
||||
if (locked != IntPtr.Zero)
|
||||
{
|
||||
try
|
||||
/// <summary>
|
||||
/// Reads pointer as UTF8 string.
|
||||
/// </summary>
|
||||
/// <param name="data">Pointer to string.</param>
|
||||
/// <param name="memMgr"></param>
|
||||
/// <param name="length">Number of bytes to read.</param>
|
||||
/// <returns></returns>
|
||||
public static unsafe string? PtrToStringUTF8(this IntPtr data, IMemoryManager memMgr, int length)
|
||||
{
|
||||
string? val = null;
|
||||
var locked = memMgr.Lock(data);
|
||||
if (locked != IntPtr.Zero)
|
||||
{
|
||||
try
|
||||
{
|
||||
#if NETFRAMEWORK
|
||||
// safe method but with 2 copies (arr and parsed string)
|
||||
//var bytes = new byte[length];
|
||||
@ -35,490 +35,440 @@ namespace NTwain.Data
|
||||
// does this work?
|
||||
val = Encoding.UTF8.GetString((byte*)locked, length);
|
||||
#else
|
||||
val = Marshal.PtrToStringUTF8(locked, length);
|
||||
val = Marshal.PtrToStringUTF8(locked, length);
|
||||
#endif
|
||||
}
|
||||
finally
|
||||
{
|
||||
memMgr.Unlock(data);
|
||||
}
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
static T MarshalTo<T>(IntPtr ptr) => Marshal.PtrToStructure<T>(ptr)!;
|
||||
|
||||
|
||||
// these contain parts from the original TWAIN.CapabilityToCsv()
|
||||
|
||||
public static TWTY DetermineValueType(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true)
|
||||
{
|
||||
var type = TWTY.Invalid;
|
||||
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
type = (TWTY)(ushort)(uint)Marshal.ReadInt32(lockedPtr);
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
type = (TWTY)(ushort)Marshal.ReadInt16(lockedPtr);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
|
||||
return type;
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Reads a one value out of a cap. This can only be done once if memory is freed.
|
||||
/// </summary>
|
||||
/// <typeparam name="TValue"></typeparam>
|
||||
/// <param name="cap"></param>
|
||||
/// <param name="memMgr"></param>
|
||||
/// <param name="freeMemory"></param>
|
||||
/// <returns></returns>
|
||||
public static TValue ReadOneValue<TValue>(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true) where TValue : struct
|
||||
{
|
||||
if (cap.ConType != TWON.ONEVALUE || cap.hContainer == IntPtr.Zero) return default;
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
TWTY itemType;
|
||||
// Mac has a level of indirection and a different structure (ick)...
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
// Crack the container...
|
||||
var onevalue = MarshalTo<TW_ONEVALUE_MACOSX>(lockedPtr);
|
||||
itemType = (TWTY)onevalue.ItemType;
|
||||
lockedPtr += Marshal.SizeOf(onevalue);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Crack the container...
|
||||
var onevalue = MarshalTo<TW_ONEVALUE>(lockedPtr);
|
||||
itemType = onevalue.ItemType;
|
||||
lockedPtr += Marshal.SizeOf(onevalue);
|
||||
}
|
||||
|
||||
return ReadTWTYData<TValue>(lockedPtr, itemType, 0);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static Enumeration<TValue> ReadEnumeration<TValue>(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true) where TValue : struct
|
||||
{
|
||||
Enumeration<TValue> retVal = new();
|
||||
|
||||
if (cap.ConType != TWON.ENUMERATION || cap.hContainer == IntPtr.Zero) return retVal;
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
TWTY itemType;
|
||||
int count = 0;
|
||||
|
||||
// Mac has a level of indirection and a different structure (ick)...
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
// Crack the container...
|
||||
var twenumerationmacosx = MarshalTo<TW_ENUMERATION_MACOSX>(lockedPtr);
|
||||
itemType = (TWTY)twenumerationmacosx.ItemType;
|
||||
count = (int)twenumerationmacosx.NumItems;
|
||||
retVal.DefaultIndex = (int)twenumerationmacosx.DefaultIndex;
|
||||
retVal.CurrentIndex = (int)twenumerationmacosx.CurrentIndex;
|
||||
lockedPtr += Marshal.SizeOf(twenumerationmacosx);
|
||||
}
|
||||
// Windows or the 2.4+ Linux DSM...
|
||||
else
|
||||
{
|
||||
// Crack the container...
|
||||
var twenumeration = MarshalTo<TW_ENUMERATION>(lockedPtr);
|
||||
itemType = twenumeration.ItemType;
|
||||
count = (int)twenumeration.NumItems;
|
||||
retVal.DefaultIndex = (int)twenumeration.DefaultIndex;
|
||||
retVal.CurrentIndex = (int)twenumeration.CurrentIndex;
|
||||
lockedPtr += Marshal.SizeOf(twenumeration);
|
||||
}
|
||||
// The -2.3 Linux DSM...
|
||||
//else if (twain.m_blFound020302Dsm64bit && (twain.m_linuxdsm == TWAIN.LinuxDsm.Is020302Dsm64bit))
|
||||
//{
|
||||
// // Crack the container...
|
||||
// var twenumerationlinux64 = MarshalTo<TW_ENUMERATION_LINUX64>(lockedPtr);
|
||||
// itemType = twenumerationlinux64.ItemType;
|
||||
// count = (int)twenumerationlinux64.NumItems;
|
||||
// retVal.DefaultIndex = (int)twenumerationlinux64.DefaultIndex;
|
||||
// retVal.CurrentIndex = (int)twenumerationlinux64.CurrentIndex;
|
||||
// lockedPtr += Marshal.SizeOf(twenumerationlinux64);
|
||||
//}
|
||||
// This shouldn't be possible, but what the hey...
|
||||
//else
|
||||
//{
|
||||
// Log.Error("This is serious, you win a cookie for getting here...");
|
||||
// return retVal;
|
||||
//}
|
||||
|
||||
retVal.Items = new TValue[count];
|
||||
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
retVal.Items[i] = ReadTWTYData<TValue>(lockedPtr, itemType, i);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
return retVal;
|
||||
}
|
||||
|
||||
public static IList<TValue> ReadArray<TValue>(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true) where TValue : struct
|
||||
{
|
||||
if (cap.ConType != TWON.ARRAY || cap.hContainer == IntPtr.Zero) return Array.Empty<TValue>();
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
TWTY itemType;
|
||||
uint count;
|
||||
|
||||
// Mac has a level of indirection and a different structure (ick)...
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
// Crack the container...
|
||||
var twarraymacosx = MarshalTo<TW_ARRAY_MACOSX>(lockedPtr);
|
||||
itemType = (TWTY)twarraymacosx.ItemType;
|
||||
count = twarraymacosx.NumItems;
|
||||
lockedPtr += Marshal.SizeOf(twarraymacosx);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Crack the container...
|
||||
var twarray = MarshalTo<TW_ARRAY>(lockedPtr);
|
||||
itemType = twarray.ItemType;
|
||||
count = twarray.NumItems;
|
||||
lockedPtr += Marshal.SizeOf(twarray);
|
||||
}
|
||||
|
||||
var arr = new TValue[count];
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
arr[i] = ReadTWTYData<TValue>(lockedPtr, itemType, i);
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static Range<TValue> ReadRange<TValue>(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true) where TValue : struct
|
||||
{
|
||||
var retVal = new Range<TValue>();
|
||||
|
||||
if (cap.ConType != TWON.RANGE || cap.hContainer == IntPtr.Zero) return retVal;
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
TW_RANGE twrange = default;
|
||||
TW_RANGE_FIX32 twrangefix32 = default;
|
||||
|
||||
// Mac has a level of indirection and a different structure (ick)...
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
var twrangemacosx = MarshalTo<TW_RANGE_MACOSX>(lockedPtr);
|
||||
var twrangefix32macosx = MarshalTo<TW_RANGE_FIX32_MACOSX>(lockedPtr);
|
||||
twrange.ItemType = (TWTY)twrangemacosx.ItemType;
|
||||
twrange.MinValue = twrangemacosx.MinValue;
|
||||
twrange.MaxValue = twrangemacosx.MaxValue;
|
||||
twrange.StepSize = twrangemacosx.StepSize;
|
||||
twrange.DefaultValue = twrangemacosx.DefaultValue;
|
||||
twrange.CurrentValue = twrangemacosx.CurrentValue;
|
||||
twrangefix32.ItemType = (TWTY)twrangefix32macosx.ItemType;
|
||||
twrangefix32.MinValue = twrangefix32macosx.MinValue;
|
||||
twrangefix32.MaxValue = twrangefix32macosx.MaxValue;
|
||||
twrangefix32.StepSize = twrangefix32macosx.StepSize;
|
||||
twrangefix32.DefaultValue = twrangefix32macosx.DefaultValue;
|
||||
twrangefix32.CurrentValue = twrangefix32macosx.CurrentValue;
|
||||
}
|
||||
// Windows or the 2.4+ Linux DSM...
|
||||
else
|
||||
{
|
||||
twrange = MarshalTo<TW_RANGE>(lockedPtr);
|
||||
twrangefix32 = MarshalTo<TW_RANGE_FIX32>(lockedPtr);
|
||||
}
|
||||
// The -2.3 Linux DSM...
|
||||
//else
|
||||
//{
|
||||
// var twrangelinux64 = MarshalTo<TW_RANGE_LINUX64>(lockedPtr);
|
||||
// var twrangefix32macosx = MarshalTo<TW_RANGE_FIX32_MACOSX>(lockedPtr);
|
||||
// twrange.ItemType = twrangelinux64.ItemType;
|
||||
// twrange.MinValue = (uint)twrangelinux64.MinValue;
|
||||
// twrange.MaxValue = (uint)twrangelinux64.MaxValue;
|
||||
// twrange.StepSize = (uint)twrangelinux64.StepSize;
|
||||
// twrange.DefaultValue = (uint)twrangelinux64.DefaultValue;
|
||||
// twrange.CurrentValue = (uint)twrangelinux64.CurrentValue;
|
||||
// twrangefix32.ItemType = (TWTY)twrangefix32macosx.ItemType;
|
||||
// twrangefix32.MinValue = twrangefix32macosx.MinValue;
|
||||
// twrangefix32.MaxValue = twrangefix32macosx.MaxValue;
|
||||
// twrangefix32.StepSize = twrangefix32macosx.StepSize;
|
||||
// twrangefix32.DefaultValue = twrangefix32macosx.DefaultValue;
|
||||
// twrangefix32.CurrentValue = twrangefix32macosx.CurrentValue;
|
||||
//}
|
||||
|
||||
switch (twrange.ItemType)
|
||||
{
|
||||
// use dynamic since I know they fit the type.
|
||||
case TWTY.FIX32:
|
||||
retVal.MinValue = (dynamic)twrangefix32.MinValue;
|
||||
retVal.MaxValue = (dynamic)twrangefix32.MaxValue;
|
||||
retVal.StepSize = (dynamic)twrangefix32.StepSize;
|
||||
retVal.CurrentValue = (dynamic)twrangefix32.CurrentValue;
|
||||
retVal.DefaultValue = (dynamic)twrangefix32.DefaultValue;
|
||||
break;
|
||||
case TWTY.INT8:
|
||||
case TWTY.UINT8:
|
||||
case TWTY.INT16:
|
||||
case TWTY.BOOL:
|
||||
case TWTY.UINT16:
|
||||
case TWTY.INT32:
|
||||
case TWTY.UINT32:
|
||||
retVal.MinValue = (dynamic)twrange.MinValue;
|
||||
retVal.MaxValue = (dynamic)twrange.MaxValue;
|
||||
retVal.StepSize = (dynamic)twrange.StepSize;
|
||||
retVal.CurrentValue = (dynamic)twrange.CurrentValue;
|
||||
retVal.DefaultValue = (dynamic)twrange.DefaultValue;
|
||||
break;
|
||||
default:
|
||||
throw new NotSupportedException($"The value type {twrange.ItemType} is not supported as range.");
|
||||
|
||||
}
|
||||
return retVal;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Read the pointer as string. This is for cap's one value string pointer
|
||||
/// that
|
||||
/// </summary>
|
||||
/// <param name="memMgr"></param>
|
||||
/// <param name="cap"></param>
|
||||
/// <param name="freeMemory"></param>
|
||||
/// <returns></returns>
|
||||
public static string? ReadString(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true)
|
||||
{
|
||||
if (cap.hContainer == IntPtr.Zero) return null;
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
if (cap.ConType == TWON.ONEVALUE)
|
||||
{
|
||||
TWTY itemType;
|
||||
// Mac has a level of indirection and a different structure (ick)...
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
// Crack the container...
|
||||
var onevalue = MarshalTo<TW_ONEVALUE_MACOSX>(lockedPtr);
|
||||
itemType = (TWTY)onevalue.ItemType;
|
||||
lockedPtr += Marshal.SizeOf(onevalue);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Crack the container...
|
||||
var onevalue = MarshalTo<TW_ONEVALUE>(lockedPtr);
|
||||
itemType = onevalue.ItemType;
|
||||
lockedPtr += Marshal.SizeOf(onevalue);
|
||||
}
|
||||
|
||||
switch (itemType)
|
||||
{
|
||||
case TWTY.STR32:
|
||||
return MarshalTo<TW_STR32>(lockedPtr).ToString();
|
||||
case TWTY.STR64:
|
||||
return MarshalTo<TW_STR64>(lockedPtr).ToString();
|
||||
case TWTY.STR128:
|
||||
return MarshalTo<TW_STR128>(lockedPtr).ToString();
|
||||
case TWTY.STR255:
|
||||
return MarshalTo<TW_STR255>(lockedPtr).ToString();
|
||||
case TWTY.HANDLE:
|
||||
// TODO: how to determine the length of this thing???
|
||||
// null-terminated and encoded string?
|
||||
// good chance this ain't right.
|
||||
using (var stream = new MemoryStream())
|
||||
{
|
||||
byte read = Marshal.ReadByte(lockedPtr);
|
||||
while (read != 0)
|
||||
{
|
||||
stream.WriteByte(read);
|
||||
read = Marshal.ReadByte(lockedPtr);
|
||||
lockedPtr += 1;
|
||||
}
|
||||
// which one?
|
||||
//return Encoding.Unicode.GetString(Encoding.Convert(Language.GetEncoding(), Encoding.Unicode, stream.ToArray()));
|
||||
return Language.GetEncoding().GetString(stream.ToArray());
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
memMgr.Unlock(data);
|
||||
}
|
||||
}
|
||||
return val;
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
|
||||
static T MarshalTo<T>(IntPtr ptr) => Marshal.PtrToStructure<T>(ptr)!;
|
||||
|
||||
|
||||
// these contain parts from the original TWAIN.CapabilityToCsv()
|
||||
|
||||
public static TWTY DetermineValueType(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
var type = TWTY.Invalid;
|
||||
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
type = (TWTY)(ushort)(uint)Marshal.ReadInt32(lockedPtr);
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
type = (TWTY)(ushort)Marshal.ReadInt16(lockedPtr);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
|
||||
return type;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Reads a one value out of a cap. This can only be done once if memory is freed.
|
||||
/// </summary>
|
||||
/// <typeparam name="TValue"></typeparam>
|
||||
/// <param name="cap"></param>
|
||||
/// <param name="memMgr"></param>
|
||||
/// <param name="freeMemory"></param>
|
||||
/// <returns></returns>
|
||||
public static TValue ReadOneValue<TValue>(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true) where TValue : struct
|
||||
{
|
||||
if (cap.ConType != TWON.ONEVALUE || cap.hContainer == IntPtr.Zero) return default;
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
TWTY itemType;
|
||||
// Mac has a level of indirection and a different structure (ick)...
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
// Crack the container...
|
||||
var onevalue = MarshalTo<TW_ONEVALUE_MACOSX>(lockedPtr);
|
||||
itemType = (TWTY)onevalue.ItemType;
|
||||
lockedPtr += Marshal.SizeOf(onevalue);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Crack the container...
|
||||
var onevalue = MarshalTo<TW_ONEVALUE>(lockedPtr);
|
||||
itemType = onevalue.ItemType;
|
||||
lockedPtr += Marshal.SizeOf(onevalue);
|
||||
}
|
||||
|
||||
return ReadTWTYData<TValue>(lockedPtr, itemType, 0);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static Enumeration<TValue> ReadEnumeration<TValue>(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true) where TValue : struct
|
||||
{
|
||||
Enumeration<TValue> retVal = new();
|
||||
|
||||
if (cap.ConType != TWON.ENUMERATION || cap.hContainer == IntPtr.Zero) return retVal;
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
TWTY itemType;
|
||||
int count = 0;
|
||||
|
||||
// Mac has a level of indirection and a different structure (ick)...
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
// Crack the container...
|
||||
var twenumerationmacosx = MarshalTo<TW_ENUMERATION_MACOSX>(lockedPtr);
|
||||
itemType = (TWTY)twenumerationmacosx.ItemType;
|
||||
count = (int)twenumerationmacosx.NumItems;
|
||||
retVal.DefaultIndex = (int)twenumerationmacosx.DefaultIndex;
|
||||
retVal.CurrentIndex = (int)twenumerationmacosx.CurrentIndex;
|
||||
lockedPtr += Marshal.SizeOf(twenumerationmacosx);
|
||||
}
|
||||
// Windows or the 2.4+ Linux DSM...
|
||||
else
|
||||
{
|
||||
// Crack the container...
|
||||
var twenumeration = MarshalTo<TW_ENUMERATION>(lockedPtr);
|
||||
itemType = twenumeration.ItemType;
|
||||
count = (int)twenumeration.NumItems;
|
||||
retVal.DefaultIndex = (int)twenumeration.DefaultIndex;
|
||||
retVal.CurrentIndex = (int)twenumeration.CurrentIndex;
|
||||
lockedPtr += Marshal.SizeOf(twenumeration);
|
||||
}
|
||||
// The -2.3 Linux DSM...
|
||||
//else if (twain.m_blFound020302Dsm64bit && (twain.m_linuxdsm == TWAIN.LinuxDsm.Is020302Dsm64bit))
|
||||
//{
|
||||
// // Crack the container...
|
||||
// var twenumerationlinux64 = MarshalTo<TW_ENUMERATION_LINUX64>(lockedPtr);
|
||||
// itemType = twenumerationlinux64.ItemType;
|
||||
// count = (int)twenumerationlinux64.NumItems;
|
||||
// retVal.DefaultIndex = (int)twenumerationlinux64.DefaultIndex;
|
||||
// retVal.CurrentIndex = (int)twenumerationlinux64.CurrentIndex;
|
||||
// lockedPtr += Marshal.SizeOf(twenumerationlinux64);
|
||||
//}
|
||||
// This shouldn't be possible, but what the hey...
|
||||
//else
|
||||
//{
|
||||
// Log.Error("This is serious, you win a cookie for getting here...");
|
||||
// return retVal;
|
||||
//}
|
||||
|
||||
retVal.Items = new TValue[count];
|
||||
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
retVal.Items[i] = ReadTWTYData<TValue>(lockedPtr, itemType, i);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
return retVal;
|
||||
}
|
||||
|
||||
public static IList<TValue> ReadArray<TValue>(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true) where TValue : struct
|
||||
{
|
||||
if (cap.ConType != TWON.ARRAY || cap.hContainer == IntPtr.Zero) return Array.Empty<TValue>();
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
TWTY itemType;
|
||||
uint count;
|
||||
|
||||
// Mac has a level of indirection and a different structure (ick)...
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
// Crack the container...
|
||||
var twarraymacosx = MarshalTo<TW_ARRAY_MACOSX>(lockedPtr);
|
||||
itemType = (TWTY)twarraymacosx.ItemType;
|
||||
count = twarraymacosx.NumItems;
|
||||
lockedPtr += Marshal.SizeOf(twarraymacosx);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Crack the container...
|
||||
var twarray = MarshalTo<TW_ARRAY>(lockedPtr);
|
||||
itemType = twarray.ItemType;
|
||||
count = twarray.NumItems;
|
||||
lockedPtr += Marshal.SizeOf(twarray);
|
||||
}
|
||||
|
||||
var arr = new TValue[count];
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
arr[i] = ReadTWTYData<TValue>(lockedPtr, itemType, i);
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static Range<TValue> ReadRange<TValue>(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true) where TValue : struct
|
||||
{
|
||||
var retVal = new Range<TValue>();
|
||||
|
||||
if (cap.ConType != TWON.RANGE || cap.hContainer == IntPtr.Zero) return retVal;
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
TWTY itemType;
|
||||
// Mac has a level of indirection and a different structure (ick)...
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
itemType = (TWTY)Marshal.ReadInt32(lockedPtr);
|
||||
lockedPtr += 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Windows or the 2.4+ Linux DSM...
|
||||
itemType = (TWTY)Marshal.ReadInt16(lockedPtr);
|
||||
lockedPtr += 2;
|
||||
}
|
||||
retVal.MinValue = ReadTWTYData<TValue>(lockedPtr, itemType, 0);
|
||||
lockedPtr += 4;
|
||||
retVal.MaxValue = ReadTWTYData<TValue>(lockedPtr, itemType, 0);
|
||||
lockedPtr += 4;
|
||||
retVal.StepSize = ReadTWTYData<TValue>(lockedPtr, itemType, 0);
|
||||
lockedPtr += 4;
|
||||
retVal.CurrentValue = ReadTWTYData<TValue>(lockedPtr, itemType, 0);
|
||||
lockedPtr += 4;
|
||||
retVal.DefaultValue = ReadTWTYData<TValue>(lockedPtr, itemType, 0);
|
||||
lockedPtr += 4;
|
||||
return retVal;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Read the pointer as string. This is for cap's one value string pointer
|
||||
/// that
|
||||
/// </summary>
|
||||
/// <param name="memMgr"></param>
|
||||
/// <param name="cap"></param>
|
||||
/// <param name="freeMemory"></param>
|
||||
/// <returns></returns>
|
||||
public static string? ReadString(this ref TW_CAPABILITY cap, IMemoryManager memMgr, bool freeMemory = true)
|
||||
{
|
||||
if (cap.hContainer == IntPtr.Zero) return null;
|
||||
|
||||
var lockedPtr = memMgr.Lock(cap.hContainer);
|
||||
|
||||
try
|
||||
{
|
||||
if (cap.ConType == TWON.ONEVALUE)
|
||||
{
|
||||
TWTY itemType;
|
||||
// Mac has a level of indirection and a different structure (ick)...
|
||||
if (TWPlatform.IsMacOSX)
|
||||
{
|
||||
// Crack the container...
|
||||
var onevalue = MarshalTo<TW_ONEVALUE_MACOSX>(lockedPtr);
|
||||
itemType = (TWTY)onevalue.ItemType;
|
||||
lockedPtr += Marshal.SizeOf(onevalue);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Crack the container...
|
||||
var onevalue = MarshalTo<TW_ONEVALUE>(lockedPtr);
|
||||
itemType = onevalue.ItemType;
|
||||
lockedPtr += Marshal.SizeOf(onevalue);
|
||||
}
|
||||
|
||||
switch (itemType)
|
||||
{
|
||||
case TWTY.STR32:
|
||||
return MarshalTo<TW_STR32>(lockedPtr).ToString();
|
||||
case TWTY.STR64:
|
||||
return MarshalTo<TW_STR64>(lockedPtr).ToString();
|
||||
case TWTY.STR128:
|
||||
return MarshalTo<TW_STR128>(lockedPtr).ToString();
|
||||
case TWTY.STR255:
|
||||
return MarshalTo<TW_STR255>(lockedPtr).ToString();
|
||||
case TWTY.HANDLE:
|
||||
// TODO: how to determine the length of this thing???
|
||||
// null-terminated and encoded string?
|
||||
// good chance this ain't right.
|
||||
using (var stream = new MemoryStream())
|
||||
{
|
||||
byte read = Marshal.ReadByte(lockedPtr);
|
||||
while (read != 0)
|
||||
{
|
||||
stream.WriteByte(read);
|
||||
read = Marshal.ReadByte(lockedPtr);
|
||||
lockedPtr += 1;
|
||||
}
|
||||
// which one?
|
||||
//return Encoding.Unicode.GetString(Encoding.Convert(Language.GetEncoding(), Encoding.Unicode, stream.ToArray()));
|
||||
return Language.GetEncoding().GetString(stream.ToArray());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (lockedPtr != IntPtr.Zero) memMgr.Unlock(cap.hContainer);
|
||||
if (freeMemory)
|
||||
{
|
||||
memMgr.Free(cap.hContainer);
|
||||
cap.hContainer = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Read the pointer content as a value specified by <see cref="TWTY"/>, except <see cref="TWTY.HANDLE"/>.
|
||||
/// </summary>
|
||||
/// <param name="intptr">A locked pointer to the data pointer. If data is array this is the 0th item.</param>
|
||||
/// <param name="type">The twain type.</param>
|
||||
/// <param name="itemIndex">Index of the item if pointer is array.</param>
|
||||
/// <returns></returns>
|
||||
public static TValue ReadTWTYData<TValue>(this IntPtr intptr, TWTY type, int itemIndex) where TValue : struct
|
||||
{
|
||||
var isEnum = typeof(TValue).IsEnum;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
default:
|
||||
throw new NotSupportedException($"Unsupported item type {type} for reading.");
|
||||
// TODO: verify if needs to read int32 for small types
|
||||
case TWTY.HANDLE:
|
||||
intptr += IntPtr.Size * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.INT8:
|
||||
intptr += 1 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<sbyte, TValue>(MarshalTo<sbyte>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.UINT8:
|
||||
intptr += 1 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<byte, TValue>(MarshalTo<byte>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.INT16:
|
||||
intptr += 2 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<short, TValue>(MarshalTo<short>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.BOOL:
|
||||
case TWTY.UINT16:
|
||||
intptr += 2 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<ushort, TValue>(MarshalTo<ushort>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.INT32:
|
||||
intptr += 4 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<int, TValue>(MarshalTo<int>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.UINT32:
|
||||
intptr += 4 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<uint, TValue>(MarshalTo<uint>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.FIX32:
|
||||
intptr += 4 * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.FRAME:
|
||||
intptr += 16 * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.STR32:
|
||||
intptr += TW_STR32.Size * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.STR64:
|
||||
intptr += TW_STR64.Size * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.STR128:
|
||||
intptr += TW_STR128.Size * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.STR255:
|
||||
intptr += TW_STR255.Size * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
}
|
||||
}
|
||||
|
||||
static TEnum NumericToEnum<TNumber, TEnum>(TNumber num) where TEnum : struct
|
||||
{
|
||||
// TODO: some caps returns a data type that's not the underlying datatype for the enum
|
||||
// so foolproof way is to ToString() it and parse it as the enum type.
|
||||
// this is bad for perf so find better way later
|
||||
var str = num!.ToString();
|
||||
|
||||
if (Enum.TryParse(str, out TEnum parsed))
|
||||
{
|
||||
return parsed;
|
||||
}
|
||||
return default;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Read the pointer content as a value specified by <see cref="TWTY"/>, except <see cref="TWTY.HANDLE"/>.
|
||||
/// </summary>
|
||||
/// <param name="intptr">A locked pointer to the data pointer. If data is array this is the 0th item.</param>
|
||||
/// <param name="type">The twain type.</param>
|
||||
/// <param name="itemIndex">Index of the item if pointer is array.</param>
|
||||
/// <returns></returns>
|
||||
public static TValue ReadTWTYData<TValue>(this IntPtr intptr, TWTY type, int itemIndex) where TValue : struct
|
||||
{
|
||||
var isEnum = typeof(TValue).IsEnum;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
default:
|
||||
throw new NotSupportedException($"Unsupported item type {type} for reading.");
|
||||
// TODO: verify if needs to read int32 for small types
|
||||
case TWTY.HANDLE:
|
||||
intptr += IntPtr.Size * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.INT8:
|
||||
intptr += 1 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<sbyte, TValue>(MarshalTo<sbyte>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.UINT8:
|
||||
intptr += 1 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<byte, TValue>(MarshalTo<byte>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.INT16:
|
||||
intptr += 2 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<short, TValue>(MarshalTo<short>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.BOOL:
|
||||
case TWTY.UINT16:
|
||||
intptr += 2 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<ushort, TValue>(MarshalTo<ushort>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.INT32:
|
||||
intptr += 4 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<int, TValue>(MarshalTo<int>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.UINT32:
|
||||
intptr += 4 * itemIndex;
|
||||
if (isEnum)
|
||||
{
|
||||
return NumericToEnum<uint, TValue>(MarshalTo<uint>(intptr));
|
||||
}
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.FIX32:
|
||||
intptr += 4 * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.FRAME:
|
||||
intptr += 16 * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.STR32:
|
||||
intptr += TW_STR32.Size * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.STR64:
|
||||
intptr += TW_STR64.Size * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.STR128:
|
||||
intptr += TW_STR128.Size * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
case TWTY.STR255:
|
||||
intptr += TW_STR255.Size * itemIndex;
|
||||
return MarshalTo<TValue>(intptr);
|
||||
}
|
||||
}
|
||||
|
||||
static TEnum NumericToEnum<TNumber, TEnum>(TNumber num) where TEnum : struct
|
||||
{
|
||||
// TODO: some caps returns a data type that's not the underlying datatype for the enum
|
||||
// so foolproof way is to ToString() it and parse it as the enum type.
|
||||
// this is bad for perf so find better way later
|
||||
var str = num!.ToString();
|
||||
|
||||
if (Enum.TryParse(str, out TEnum parsed))
|
||||
{
|
||||
return parsed;
|
||||
}
|
||||
return default;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user