mirror of
https://github.com/soukoku/ntwain.git
synced 2025-04-05 20:59:23 +08:00
684 lines
27 KiB
C#
684 lines
27 KiB
C#
using NTwain.Data;
|
|
using NTwain.Values;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
namespace NTwain
|
|
{
|
|
/// <summary>
|
|
/// Defines common methods on <see cref="TwainSession"/> using the raw
|
|
/// TWAIN triplet api.
|
|
/// </summary>
|
|
public static class TwainSessionExtensions
|
|
{
|
|
/// <summary>
|
|
/// Gets the manager status. Only call this at state 2 or higher.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <returns></returns>
|
|
public static TWStatus GetManagerStatus(this TwainSession session)
|
|
{
|
|
TWStatus stat;
|
|
session.DGControl.Status.GetManager(out stat);
|
|
return stat;
|
|
}
|
|
/// <summary>
|
|
/// Gets the source status. Only call this at state 4 or higher.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <returns></returns>
|
|
public static TWStatus GetSourceStatus(this TwainSession session)
|
|
{
|
|
TWStatus stat;
|
|
session.DGControl.Status.GetSource(out stat);
|
|
return stat;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets list of sources available in the system.
|
|
/// Only call this at state 2 or higher.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <returns></returns>
|
|
public static IList<TWIdentity> GetSources(this TwainSession session)
|
|
{
|
|
List<TWIdentity> list = new List<TWIdentity>();
|
|
|
|
// now enumerate
|
|
TWIdentity srcId;
|
|
var rc = session.DGControl.Identity.GetFirst(out srcId);
|
|
if (rc == ReturnCode.Success) { list.Add(srcId); }
|
|
do
|
|
{
|
|
rc = session.DGControl.Identity.GetNext(out srcId);
|
|
if (rc == ReturnCode.Success)
|
|
{
|
|
list.Add(srcId);
|
|
}
|
|
} while (rc == ReturnCode.Success);
|
|
|
|
return list;
|
|
}
|
|
|
|
#region common caps
|
|
|
|
/// <summary>
|
|
/// Gets the current value for a general capability. This only works for types that are under 32bit.
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="capId">The cap id.</param>
|
|
/// <returns></returns>
|
|
public static T GetCurrentCap<T>(this TwainSession session, CapabilityId capId) where T : struct,IConvertible
|
|
{
|
|
using (TWCapability cap = new TWCapability(capId))
|
|
{
|
|
var rc = session.DGControl.Capability.GetCurrent(cap);
|
|
if (rc == ReturnCode.Success)
|
|
{
|
|
switch (cap.ContainerType)
|
|
{
|
|
case ContainerType.Enum:
|
|
var enu = cap.GetEnumValue();
|
|
if (enu.ItemType < ItemType.Frame)
|
|
{
|
|
// does this work?
|
|
return ConvertValueToType<T>(enu.ItemList[enu.CurrentIndex].ToString(), true);
|
|
}
|
|
break;
|
|
case ContainerType.OneValue:
|
|
var one = cap.GetOneValue();
|
|
if (one.ItemType < ItemType.Frame)
|
|
{
|
|
return ConvertValueToType<T>(one.Item, true);
|
|
}
|
|
break;
|
|
case ContainerType.Range:
|
|
var range = cap.GetRangeValue();
|
|
if (range.ItemType < ItemType.Frame)
|
|
{
|
|
return ConvertValueToType<T>(range.CurrentValue, true);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return default(T);
|
|
}
|
|
|
|
static ushort GetLowerWord(uint value)
|
|
{
|
|
return (ushort)(value & 0xffff);
|
|
}
|
|
static uint GetUpperWord(uint value)
|
|
{
|
|
return (ushort)(value >> 16);
|
|
}
|
|
|
|
static T ConvertValueToType<T>(object value, bool tryUpperWord) where T : struct,IConvertible
|
|
{
|
|
var returnType = typeof(T);
|
|
if (returnType.IsEnum)
|
|
{
|
|
if (tryUpperWord)
|
|
{
|
|
// small routine to see if works with bad sources that put
|
|
// 16bit value in the upper word instead of lower word.
|
|
var rawType = Enum.GetUnderlyingType(returnType);
|
|
if (typeof(ushort).IsAssignableFrom(rawType))
|
|
{
|
|
var intVal = Convert.ToUInt32(value);
|
|
var enumVal = GetLowerWord(intVal);
|
|
if (!Enum.IsDefined(returnType, enumVal))
|
|
{
|
|
return (T)Enum.ToObject(returnType, GetUpperWord(intVal));
|
|
}
|
|
}
|
|
}
|
|
// this may work better?
|
|
return (T)Enum.ToObject(returnType, value);
|
|
//// cast to underlying type first then to the enum
|
|
//return (T)Convert.ChangeType(value, rawType);
|
|
}
|
|
return (T)Convert.ChangeType(value, returnType);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A generic method that returns the data in a <see cref="TWCapability" />.
|
|
/// </summary>
|
|
/// <typeparam name="TCapVal">The expected capability value type.</typeparam>
|
|
/// <param name="capability">The capability returned from the source.</param>
|
|
/// <param name="toPopulate">The list to populate if necessary.</param>
|
|
/// <returns></returns>
|
|
public static IList<TCapVal> ReadMultiCapValues<TCapVal>(this TWCapability capability, IList<TCapVal> toPopulate) where TCapVal : struct,IConvertible
|
|
{
|
|
return ReadMultiCapValues<TCapVal>(capability, toPopulate, true);
|
|
}
|
|
static IList<TCapVal> ReadMultiCapValues<TCapVal>(this TWCapability capability, IList<TCapVal> toPopulate, bool tryUpperWord) where TCapVal : struct,IConvertible
|
|
{
|
|
if (toPopulate == null) { toPopulate = new List<TCapVal>(); }
|
|
|
|
switch (capability.ContainerType)
|
|
{
|
|
case ContainerType.OneValue:
|
|
var value = capability.GetOneValue();
|
|
if (value != null)
|
|
{
|
|
var val = ConvertValueToType<TCapVal>(value.Item, tryUpperWord);// (T)Convert.ToUInt16(value.Item);
|
|
toPopulate.Add(val);
|
|
}
|
|
break;
|
|
case ContainerType.Array:
|
|
var arr = capability.GetArrayValue();
|
|
if (arr != null && arr.ItemList != null)
|
|
{
|
|
for (int i = 0; i < arr.ItemList.Length; i++)
|
|
{
|
|
var val = ConvertValueToType<TCapVal>(arr.ItemList[i], tryUpperWord);// (T)Convert.ToUInt16(enumr.ItemList[i]);
|
|
toPopulate.Add(val);
|
|
}
|
|
}
|
|
break;
|
|
case ContainerType.Enum:
|
|
var enumr = capability.GetEnumValue();
|
|
if (enumr != null && enumr.ItemList != null)
|
|
{
|
|
for (int i = 0; i < enumr.ItemList.Length; i++)
|
|
{
|
|
var val = ConvertValueToType<TCapVal>(enumr.ItemList[i], tryUpperWord);// (T)Convert.ToUInt16(enumr.ItemList[i]);
|
|
toPopulate.Add(val);
|
|
}
|
|
}
|
|
break;
|
|
case ContainerType.Range:
|
|
var range = capability.GetRangeValue();
|
|
if (range != null)
|
|
{
|
|
for (uint i = range.MinValue; i < range.MaxValue; i += range.StepSize)
|
|
{
|
|
var val = ConvertValueToType<TCapVal>(i, tryUpperWord);
|
|
toPopulate.Add(val);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return toPopulate;
|
|
}
|
|
|
|
/// <summary>
|
|
/// A generic method that tries to get capability values from current <see cref="TwainSession" />.
|
|
/// </summary>
|
|
/// <typeparam name="TCapVal">The expected capability value type.</typeparam>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="capabilityId">The capability unique identifier.</param>
|
|
/// <param name="tryUpperWord">if set to <c>true</c> then apply to workaround for certain bad sources.</param>
|
|
/// <returns></returns>
|
|
public static IList<TCapVal> GetCapabilityValues<TCapVal>(this TwainSession session, CapabilityId capabilityId, bool tryUpperWord) where TCapVal : struct,IConvertible
|
|
{
|
|
var list = new List<TCapVal>();
|
|
using (TWCapability cap = new TWCapability(capabilityId))
|
|
{
|
|
var rc = session.DGControl.Capability.Get(cap);
|
|
if (rc == ReturnCode.Success)
|
|
{
|
|
cap.ReadMultiCapValues<TCapVal>(list, tryUpperWord);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets list of capabilities supported by current source.
|
|
/// Only call this at state 4 or higher.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <returns></returns>
|
|
internal static IList<CapabilityId> GetCapabilities(this TwainSession session)
|
|
{
|
|
return session.GetCapabilityValues<CapabilityId>(CapabilityId.CapSupportedCaps, false);
|
|
}
|
|
|
|
#region xfer mech
|
|
|
|
/// <summary>
|
|
/// Gets the supported image <see cref="XferMech"/> for the current source.
|
|
/// Only call this at state 4 or higher.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <returns></returns>
|
|
public static IList<XferMech> CapGetImageXferMech(this TwainSession session)
|
|
{
|
|
return session.GetCapabilityValues<XferMech>(CapabilityId.ICapXferMech, true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region compression
|
|
|
|
/// <summary>
|
|
/// Gets the supported <see cref="Compression"/> for the current source.
|
|
/// Only call this at state 4 or higher.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <returns></returns>
|
|
public static IList<Compression> CapGetCompression(this TwainSession session)
|
|
{
|
|
return session.GetCapabilityValues<Compression>(CapabilityId.ICapCompression, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the image compression for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="compression">The compression.</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetImageCompression(this TwainSession session, Compression compression)
|
|
{
|
|
using (TWCapability compressCap = new TWCapability(CapabilityId.ICapCompression, new TWOneValue { Item = (uint)compression, ItemType = Values.ItemType.UInt16 }))
|
|
{
|
|
return session.DGControl.Capability.Set(compressCap);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region image format
|
|
|
|
/// <summary>
|
|
/// Gets the supported <see cref="FileFormat"/> for the current source.
|
|
/// Only call this at state 4 or higher.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <returns></returns>
|
|
public static IList<FileFormat> CapGetImageFileFormat(this TwainSession session)
|
|
{
|
|
return session.GetCapabilityValues<FileFormat>(CapabilityId.ICapImageFileFormat, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the image format for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="format">The format.</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetImageFormat(this TwainSession session, FileFormat format)
|
|
{
|
|
using (TWCapability formatCap = new TWCapability(CapabilityId.ICapImageFileFormat, new TWOneValue { Item = (uint)format, ItemType = Values.ItemType.UInt16 }))
|
|
{
|
|
return session.DGControl.Capability.Set(formatCap);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region pixel type
|
|
|
|
/// <summary>
|
|
/// Gets the supported <see cref="PixelType"/> for the current source.
|
|
/// Only call this at state 4 or higher.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <returns></returns>
|
|
public static IList<PixelType> CapGetPixelTypes(this TwainSession session)
|
|
{
|
|
return session.GetCapabilityValues<PixelType>(CapabilityId.ICapPixelType, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the pixel type for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="type">The type.</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetPixelType(this TwainSession session, PixelType type)
|
|
{
|
|
var one = new TWOneValue();
|
|
one.Item = (uint)type;
|
|
one.ItemType = ItemType.UInt16;
|
|
using (TWCapability dx = new TWCapability(CapabilityId.ICapPixelType, one))
|
|
{
|
|
return session.DGControl.Capability.Set(dx);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region dpi
|
|
|
|
/// <summary>
|
|
/// Gets the supported DPI values for the current source.
|
|
/// Only call this at state 4 or higher.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <returns></returns>
|
|
public static IList<int> CapGetDPIs(this TwainSession session)
|
|
{
|
|
return session.GetCapabilityValues<int>(CapabilityId.ICapXResolution, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the DPI value for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="dpi">The DPI.</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetDPI(this TwainSession session, int dpi)
|
|
{
|
|
return CapSetDPI(session, dpi, dpi);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the DPI value for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="xDPI">The x DPI.</param>
|
|
/// <param name="yDPI">The y DPI.</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetDPI(this TwainSession session, int xDPI, int yDPI)
|
|
{
|
|
TWOneValue one = new TWOneValue();
|
|
one.Item = (uint)xDPI;// ((uint)dpi) << 16;
|
|
one.ItemType = ItemType.Fix32;
|
|
|
|
using (TWCapability xres = new TWCapability(CapabilityId.ICapXResolution, one))
|
|
{
|
|
var rc = session.DGControl.Capability.Set(xres);
|
|
if (rc == ReturnCode.Success)
|
|
{
|
|
one.Item = (uint)yDPI;
|
|
using (TWCapability yres = new TWCapability(CapabilityId.ICapYResolution, one))
|
|
{
|
|
rc = session.DGControl.Capability.Set(yres);
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region supported paper size
|
|
|
|
/// <summary>
|
|
/// Gets the supported <see cref="SupportedSize"/> for the current source.
|
|
/// Only call this at state 4 or higher.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <returns></returns>
|
|
public static IList<SupportedSize> CapGetSupportedSizes(this TwainSession session)
|
|
{
|
|
return session.GetCapabilityValues<SupportedSize>(CapabilityId.ICapSupportedSizes, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the supported paper size for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="size">The size.</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetSupportedSize(this TwainSession session, SupportedSize size)
|
|
{
|
|
var one = new TWOneValue();
|
|
one.Item = (uint)size;
|
|
one.ItemType = ItemType.UInt16;
|
|
|
|
using (TWCapability xres = new TWCapability(CapabilityId.ICapSupportedSizes, one))
|
|
{
|
|
var rc = session.DGControl.Capability.Set(xres);
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region onesie flags
|
|
|
|
/// <summary>
|
|
/// Change the auto deskew flag for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="useIt">if set to <c>true</c> [use it].</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetAutoDeskew(this TwainSession session, bool useIt)
|
|
{
|
|
var rc = ReturnCode.Failure;
|
|
if (session.SupportedCaps.Contains(CapabilityId.ICapAutomaticDeskew))
|
|
{
|
|
|
|
if (session.SourceId.ProtocolMajor >= 2)
|
|
{
|
|
// if using twain 2.0 will need to use enum instead of onevalue (yuck)
|
|
TWEnumeration en = new TWEnumeration();
|
|
en.ItemList = new object[] { (uint)(useIt ? 1 : 0) };
|
|
en.ItemType = ItemType.Bool;
|
|
|
|
using (TWCapability dx = new TWCapability(CapabilityId.ICapAutomaticDeskew, en))
|
|
{
|
|
rc = session.DGControl.Capability.Set(dx);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TWOneValue one = new TWOneValue();
|
|
one.Item = (uint)(useIt ? 1 : 0);
|
|
one.ItemType = ItemType.Bool;
|
|
|
|
using (TWCapability capValue = new TWCapability(CapabilityId.ICapAutomaticDeskew, one))
|
|
{
|
|
rc = session.DGControl.Capability.Set(capValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the auto rotate flag for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="useIt">if set to <c>true</c> [use it].</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetAutoRotate(this TwainSession session, bool useIt)
|
|
{
|
|
var rc = ReturnCode.Failure;
|
|
if (session.SupportedCaps.Contains(CapabilityId.ICapAutomaticRotate))
|
|
{
|
|
if (session.SourceId.ProtocolMajor >= 2)
|
|
{
|
|
// if using twain 2.0 will need to use enum instead of onevalue (yuck)
|
|
TWEnumeration en = new TWEnumeration();
|
|
en.ItemList = new object[] { (uint)(useIt ? 1 : 0) };
|
|
en.ItemType = ItemType.Bool;
|
|
|
|
using (TWCapability dx = new TWCapability(CapabilityId.ICapAutomaticRotate, en))
|
|
{
|
|
rc = session.DGControl.Capability.Set(dx);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TWOneValue one = new TWOneValue();
|
|
one.Item = (uint)(useIt ? 1 : 0);
|
|
one.ItemType = ItemType.Bool;
|
|
|
|
using (TWCapability capValue = new TWCapability(CapabilityId.ICapAutomaticRotate, one))
|
|
{
|
|
rc = session.DGControl.Capability.Set(capValue);
|
|
}
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the auto border detection flag for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="useIt">if set to <c>true</c> [use it].</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetBorderDetection(this TwainSession session, bool useIt)
|
|
{
|
|
var rc = ReturnCode.Failure;
|
|
if (session.SupportedCaps.Contains(CapabilityId.ICapAutomaticBorderDetection))
|
|
{
|
|
// this goes along with undefinedimagesize so that also
|
|
// needs to be set
|
|
if (session.SourceId.ProtocolMajor >= 2)
|
|
{
|
|
// if using twain 2.0 will need to use enum instead of onevalue (yuck)
|
|
TWEnumeration en = new TWEnumeration();
|
|
en.ItemList = new object[] { (uint)(useIt ? 1 : 0) };
|
|
en.ItemType = ItemType.Bool;
|
|
|
|
using (TWCapability dx = new TWCapability(CapabilityId.ICapUndefinedImageSize, en))
|
|
{
|
|
rc = session.DGControl.Capability.Set(dx);
|
|
}
|
|
using (TWCapability dx = new TWCapability(CapabilityId.ICapAutomaticBorderDetection, en))
|
|
{
|
|
rc = session.DGControl.Capability.Set(dx);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TWOneValue one = new TWOneValue();
|
|
one.Item = (uint)(useIt ? 1 : 0);
|
|
one.ItemType = ItemType.Bool;
|
|
|
|
using (TWCapability capValue = new TWCapability(CapabilityId.ICapUndefinedImageSize, one))
|
|
{
|
|
rc = session.DGControl.Capability.Set(capValue);
|
|
}
|
|
using (TWCapability capValue = new TWCapability(CapabilityId.ICapAutomaticBorderDetection, one))
|
|
{
|
|
rc = session.DGControl.Capability.Set(capValue);
|
|
}
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the duplex flag for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="useIt">if set to <c>true</c> [use it].</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetDuplex(this TwainSession session, bool useIt)
|
|
{
|
|
if (session.SourceId.ProtocolMajor >= 2)
|
|
{
|
|
// twain 2 likes to use enum :(
|
|
|
|
TWEnumeration en = new TWEnumeration();
|
|
en.ItemList = new object[] { (uint)(useIt ? 1 : 0) };
|
|
en.ItemType = ItemType.Bool;
|
|
|
|
using (TWCapability dx = new TWCapability(CapabilityId.CapDuplexEnabled, en))
|
|
{
|
|
return session.DGControl.Capability.Set(dx);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TWOneValue one = new TWOneValue();
|
|
one.Item = (uint)(useIt ? 1 : 0);
|
|
one.ItemType = ItemType.Bool;
|
|
|
|
using (TWCapability dx = new TWCapability(CapabilityId.CapDuplexEnabled, one))
|
|
{
|
|
return session.DGControl.Capability.Set(dx);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Change the use feeder flag for the current source.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="useIt">if set to <c>true</c> [use it].</param>
|
|
/// <returns></returns>
|
|
public static ReturnCode CapSetFeeder(this TwainSession session, bool useIt)
|
|
{
|
|
var rc = ReturnCode.Failure;
|
|
if (session.SupportedCaps.Contains(CapabilityId.CapFeederEnabled))
|
|
{
|
|
if (session.SourceId.ProtocolMajor >= 2)
|
|
{
|
|
// if using twain 2.0 will need to use enum instead of onevalue (yuck)
|
|
TWEnumeration en = new TWEnumeration();
|
|
en.ItemList = new object[] { (ushort)(useIt ? 1 : 0) };
|
|
en.ItemType = ItemType.Bool;
|
|
|
|
|
|
|
|
// we will never set feeder off, only autofeed and autoscan
|
|
// but if it is to SET then enable feeder needs to be set first
|
|
if (useIt)
|
|
{
|
|
using (TWCapability dx = new TWCapability(CapabilityId.CapFeederEnabled, en))
|
|
{
|
|
rc = session.DGControl.Capability.Set(dx);
|
|
}
|
|
}
|
|
|
|
// to really use feeder we must also set autofeed or autoscan, but only
|
|
// for one of them since setting autoscan also sets autofeed
|
|
if (session.SupportedCaps.Contains(CapabilityId.CapAutoScan))
|
|
{
|
|
using (TWCapability dx = new TWCapability(CapabilityId.CapAutoScan, en))
|
|
{
|
|
rc = session.DGControl.Capability.Set(dx);
|
|
}
|
|
}
|
|
else if (session.SupportedCaps.Contains(CapabilityId.CapAutoFeed))
|
|
{
|
|
using (TWCapability dx = new TWCapability(CapabilityId.CapAutoFeed, en))
|
|
{
|
|
rc = session.DGControl.Capability.Set(dx);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TWOneValue one = new TWOneValue();
|
|
one.Item = (uint)(useIt ? 1 : 0);
|
|
one.ItemType = ItemType.Bool;
|
|
|
|
if (useIt)
|
|
{
|
|
using (TWCapability enabled = new TWCapability(CapabilityId.CapFeederEnabled, one))
|
|
{
|
|
rc = session.DGControl.Capability.Set(enabled);
|
|
}
|
|
}
|
|
// to really use feeder we must also set autofeed or autoscan, but only
|
|
// for one of them since setting autoscan also sets autofeed
|
|
if (session.SupportedCaps.Contains(CapabilityId.CapAutoScan))
|
|
{
|
|
using (TWCapability autoScan = new TWCapability(CapabilityId.CapAutoScan, one))
|
|
{
|
|
rc = session.DGControl.Capability.Set(autoScan);
|
|
}
|
|
}
|
|
else if (session.SupportedCaps.Contains(CapabilityId.CapAutoFeed))
|
|
{
|
|
using (TWCapability autoScan = new TWCapability(CapabilityId.CapAutoFeed, one))
|
|
{
|
|
rc = session.DGControl.Capability.Set(autoScan);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|
|
}
|