public BasicCapabilityResult GetBasicValue()
{
var oneValue = new CapabilityOneValue(_twainType, 0);
var twainCapability = TwainCapability.From(_capability, oneValue);
var result = Twain32Native.DsCapability(
_applicationId,
_sourceId,
DataGroup.Control,
DataArgumentType.Capability,
Message.Get,
twainCapability);
if (result != TwainResult.Success)
{
var conditionCode = GetStatus();
log.Debug(string.Format("Failed to get capability:{0} reason: {1}",
_capability, conditionCode));
return(new BasicCapabilityResult()
{
ConditionCode = conditionCode,
ErrorCode = result
});
}
twainCapability.ReadBackValue();
return(new BasicCapabilityResult()
{
RawBasicValue = oneValue.Value
});
}
protected void SetValue <T>(T value)
{
var rawValue = Convert.ToInt32(value);
var oneValue = new CapabilityOneValue(_twainType, rawValue);
var twainCapability = TwainCapability.From(_capability, oneValue);
var result = Twain32Native.DsCapability(
_applicationId,
_sourceId,
DataGroup.Control,
DataArgumentType.Capability,
Message.Set,
twainCapability);
if (result == TwainResult.Success)
{
return;
}
if (result == TwainResult.Failure)
{
throw new TwainException("Failed to set capability.", result, GetStatus());
}
if (result != TwainResult.CheckStatus)
{
throw new TwainException("Failed to set capability.", result);
}
}
public List <object> GetValue()
{
var twainCapability = TwainCapability.From(_capability);
var result = Twain32Native.DsCapability(
_applicationId,
_sourceId,
DataGroup.Control,
DataArgumentType.Capability,
Message.Get,
twainCapability);
if (result != TwainResult.Success)
{
var conditionCode = GetStatus();
log.Debug(string.Format("Failed to get capability:{0} reason: {1}",
_capability, conditionCode));
return(null);
/*return new BasicCapabilityResult()
* {
* ConditionCode = conditionCode,
* ErrorCode = result
* };*/
}
var ojbts = new List <object>();
CapabilityReader.ReadValue(twainCapability).PopulateFromCapValues(ojbts);
return(ojbts);
}
private void _rdTransferFile_CheckedChanged(object sender, System.EventArgs e)
{
int format;
string fileName;
_transferMode = TwainTransferMode.File;
_cmbFileFormats.Enabled = true;
_btnBrowse.Enabled = true;
fileName = this._txtFileName.Text;
_btnOK.Enabled = (fileName != "");
// disable other options
_cbUseBufferSize.Enabled = false;
_txtBufferSize.Enabled = false;
_btnLEADFormats.Enabled = false;
try
{
TwainCapability twnCap = _session.GetCapability(TwainCapabilityType.ImageImageFileFormat, TwainGetCapabilityMode.GetValues);
switch (twnCap.Information.ContainerType)
{
case TwainContainerType.Enumeration:
{
_cmbFileFormats.Items.Clear();
int count = twnCap.EnumerationCapability.Count;
_format = new RasterImageFormat[count];
for (int i = 0; i < count; i++)
{
if (twnCap.EnumerationCapability.ItemType == TwainItemType.Uint16)
{
format = Convert.ToUInt16(twnCap.EnumerationCapability.GetValue(i));
AddScannerFormats(format, i);
}
}
break;
}
case TwainContainerType.OneValue:
{
_cmbFileFormats.Items.Clear();
if (twnCap.OneValueCapability.ItemType == TwainItemType.Uint16)
{
_format = new RasterImageFormat[1];
format = Convert.ToUInt16(twnCap.OneValueCapability.Value);
AddScannerFormats(format, 0);
}
break;
}
}
_cmbFileFormats.SelectedIndex = 0;
}
catch (Exception ex)
{
Messager.ShowError(this, ex);
}
}
/// <summary>
/// Reads the value from a <see cref="TwainCapability" /> that was returned
/// from a TWAIN source.
/// </summary>
/// <param name="capability">The capability.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">
/// capability
/// or
/// memoryManager
/// </exception>
/// <exception cref="System.ArgumentException">capability</exception>
public static CapabilityReader ReadValue(TwainCapability capability)
{
if (capability == null)
{
throw new ArgumentNullException("capability");
}
if (capability.Handle != IntPtr.Zero)
{
IntPtr baseAddr = IntPtr.Zero;
try
{
baseAddr = Kernel32Native.GlobalLock(capability.Handle);
switch (capability.ContainerType)
{
case ContainerType.Array:
return(new CapabilityReader
{
ContainerType = capability.ContainerType,
}.ReadArrayValue(baseAddr));
case ContainerType.Enum:
return(new CapabilityReader
{
ContainerType = capability.ContainerType,
}.ReadEnumValue(baseAddr));
case ContainerType.One:
return(new CapabilityReader
{
ContainerType = capability.ContainerType,
}.ReadOneValue(baseAddr));
case ContainerType.Range:
return(new CapabilityReader
{
ContainerType = capability.ContainerType,
}.ReadRangeValue(baseAddr));
default:
throw new ArgumentException("Capability has bad format");
}
}
finally
{
if (baseAddr != IntPtr.Zero)
{
//memoryManager.Unlock(baseAddr);
Kernel32Native.GlobalUnlock(capability.Handle);
}
}
}
return(new CapabilityReader());
}
/// <summary>
/// Reads the value from a <see cref="TwainCapability" /> that was returned
/// from a TWAIN source.
/// </summary>
/// <param name="capability">The capability.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">
/// capability
/// or
/// memoryManager
/// </exception>
/// <exception cref="System.ArgumentException">capability</exception>
public static CapabilityReader ReadValue(TwainCapability capability)
{
if (capability == null) { throw new ArgumentNullException("capability"); }
if (capability.Handle != IntPtr.Zero)
{
IntPtr baseAddr = IntPtr.Zero;
try
{
baseAddr = Kernel32Native.GlobalLock(capability.Handle);
switch (capability.ContainerType)
{
case ContainerType.Array:
return new CapabilityReader
{
ContainerType = capability.ContainerType,
}.ReadArrayValue(baseAddr);
case ContainerType.Enum:
return new CapabilityReader
{
ContainerType = capability.ContainerType,
}.ReadEnumValue(baseAddr);
case ContainerType.One:
return new CapabilityReader
{
ContainerType = capability.ContainerType,
}.ReadOneValue(baseAddr);
case ContainerType.Range:
return new CapabilityReader
{
ContainerType = capability.ContainerType,
}.ReadRangeValue(baseAddr);
default:
throw new ArgumentException("Capability has bad format");
}
}
finally
{
if (baseAddr != IntPtr.Zero)
{
//memoryManager.Unlock(baseAddr);
Kernel32Native.GlobalUnlock(capability.Handle);
}
}
}
return new CapabilityReader();
}
protected void SetValue <T>(T value)
{
/*log.Debug(string.Format("Attempting to set capabilities:{0}, value:{1}, type:{1}",
* _capability, value, _twainType));*/
Logger.WriteLog(LOG_LEVEL.LL_NORMAL_LOG, string.Format("Attempting to set capabilities:{0}, value:{1}, type:{2}",
_capability, value, _twainType.ToString()));
int rawValue = Convert.ToInt32(value);
var oneValue = new CapabilityOneValue(_twainType, rawValue);
var twainCapability = TwainCapability.From(_capability, oneValue);
TwainResult result = Twain32Native.DsCapability(
_applicationId,
_sourceId,
DataGroup.Control,
DataArgumentType.Capability,
Message.Set,
twainCapability);
if (result != TwainResult.Success)
{
Logger.WriteLog(LOG_LEVEL.LL_SUB_FUNC, string.Format("Failed to set capabilities:{0}, value:{1}, type:{2}, result:{3}",
_capability, value, _twainType, result));
if (result == TwainResult.Failure)
{
var conditionCode = GetStatus();
Logger.WriteLog(LOG_LEVEL.LL_SERIOUS_ERROR, string.Format("Failed to set capabilites:{0} reason: {1}",
_capability, conditionCode));
throw new TwainException("Failed to set capability.", result, conditionCode);
}
else if (result == TwainResult.CheckStatus)
{
Logger.WriteLog(LOG_LEVEL.LL_SUB_FUNC, "Value changed but not to requested value");
}
else
{
throw new TwainException("Failed to set capability.", result);
}
}
else
{
Logger.WriteLog(LOG_LEVEL.LL_NORMAL_LOG, "Set capabilities:" + _capability + " successfully");
}
}
protected void SetValue <T>(T value)
{
log.Debug(string.Format("Attempting to set capabilities:{0}, value:{1}, type:{1}",
_capability, value, _twainType));
int rawValue = Convert.ToInt32(value);
var oneValue = new CapabilityOneValue(_twainType, rawValue);
var twainCapability = TwainCapability.From(_capability, oneValue);
TwainResult result = Twain32Native.DsCapability(
_applicationId,
_sourceId,
DataGroup.Control,
DataArgumentType.Capability,
Message.Set,
twainCapability);
if (result != TwainResult.Success)
{
log.Debug(string.Format("Failed to set capabilities:{0}, value:{1}, type:{1}, result:{2}",
_capability, value, _twainType, result));
if (result == TwainResult.Failure)
{
var conditionCode = GetStatus();
log.Error(string.Format("Failed to set capabilites:{0} reason: {1}",
_capability, conditionCode));
throw new TwainException("Failed to set capability.", result, conditionCode);
}
else if (result == TwainResult.CheckStatus)
{
log.Debug("Value changed but not to requested value");
}
else
{
throw new TwainException("Failed to set capability.", result);
}
}
else
{
log.Debug("Set capabilities successfully");
}
}
private void SetTransferMode()
{
using (TwainCapability twnCap = new TwainCapability())
{
try
{
twnCap.Information.Type = TwainCapabilityType.ImageTransferMechanism;
twnCap.Information.ContainerType = TwainContainerType.OneValue;
twnCap.OneValueCapability.ItemType = TwainItemType.Uint16;
twnCap.OneValueCapability.Value = (UInt16)TwainTransferMode.File;
// Set the value of ICAP_XFERMECH (Image Transfer Mechanism) capability
twainSession.SetCapability(twnCap, TwainSetCapabilityMode.Set);
}
catch (Exception ex)
{
throw ex;
}
}
}
private void SetTransferMode()
{
using (TwainCapability twnCap = new TwainCapability())
{
try
{
twnCap.Information.Type = TwainCapabilityType.ImageTransferMechanism;
twnCap.Information.ContainerType = TwainContainerType.OneValue;
twnCap.OneValueCapability.ItemType = TwainItemType.Uint16;
twnCap.OneValueCapability.Value = (UInt16)_twaintransferMode;
// Set the value of ICAP_XFERMECH (Image Transfer Mechanism) capability
_twainSession.SetCapability(twnCap, TwainSetCapabilityMode.Set);
}
catch (Exception ex)
{
string errorMsg = string.Format("Error set TwainCapabilityType.ImageTranserMechanism is {0}", ex.Message);
AddErrorToErrorList(errorMsg);
}
}
}
private void listCapabilities_SelectedIndexChanged(object sender, EventArgs e)
{
if (this.listCapabilities.SelectedIndex == -1)
{
return;
}
DeviceCapability cap = (DeviceCapability)this.listCapabilities.SelectedItem;
this.listValues.Items.Clear();
this.lblCapType.Text = _device.Controller.GetCapabilityTwainType(cap).ToString();
QueryOperation operations = _device.GetQueryOperations(cap);
FillOperationList(operations);
if ((operations & QueryOperation.TWQC_GET) == QueryOperation.TWQC_GET)
{
TwainCapability capability = new TwainCapability(cap, TwainContainer.TWON_DONTCARE16, IntPtr.Zero);
if (_device.Controller.SendCommand(TwainTriplet.CapabilityGet, _device.Identity, capability) == TwainReturnCode.TWRC_SUCCESS)
{
this.lblGetContainer.Text = capability.ContainerType.ToString();
// Always use a TwainMemory object when working with memory returned from a driver.
TwainMemory memory = _device.Controller.CreateTwainMemory(capability.Data);
try
{
object vals = _device.Controller.ReadTwainContainerData(capability.ContainerType, memory);
FillValueList(vals, cap);
}
catch (Exception ex)
{
MessageBox.Show("ReadTwainContainerData failed for " + cap.ToString() + "\r\n\r\n" + ex.Message + "\r\n" + ex.StackTrace);
}
finally
{
memory.Dispose();
}
}
else
{
this.lblGetContainer.Text = "Unknown";
}
}
else
{
this.lblGetContainer.Text = "Not Supported";
}
if ((operations & QueryOperation.TWQC_GETCURRENT) == QueryOperation.TWQC_GETCURRENT)
{
TwainCapability capability = new TwainCapability(cap, TwainContainer.TWON_DONTCARE16, IntPtr.Zero);
if (_device.Controller.SendCommand(TwainTriplet.CapabilityGet, _device.Identity, capability) == TwainReturnCode.TWRC_SUCCESS)
{
this.lblGetCurrentContainer.Text = capability.ContainerType.ToString();
// Don't forget to free the memory allocated by the driver.
_device.Controller.FreeTwainMemory(capability.Data);
}
else
{
this.lblGetContainer.Text = "Unknown";
}
}
else
{
this.lblGetCurrentContainer.Text = "Not Supported";
}
}
private void CheckTransferMode(object sender, System.EventArgs e)
{
bool fileMode = false, memoryMode = false, nativeMode = false;
int xfer = 0;
TwainCapability twnCap = null;
try
{
twnCap = _session.GetCapability(TwainCapabilityType.ImageTransferMechanism, TwainGetCapabilityMode.GetValues);
switch (twnCap.Information.ContainerType)
{
case TwainContainerType.OneValue:
{
if (twnCap.OneValueCapability.ItemType == TwainItemType.Uint16)
{
xfer = Convert.ToUInt16(twnCap.OneValueCapability.Value);
if (xfer == (int)TwainCapabilityValue.TransferMechanismFile)
{
fileMode = true;
}
if (xfer == (int)TwainCapabilityValue.TransferMechanismMemory)
{
memoryMode = true;
}
if (xfer == (int)TwainCapabilityValue.TransferMechanismNative)
{
nativeMode = true;
}
}
break;
}
case TwainContainerType.Enumeration:
{
int count = twnCap.EnumerationCapability.Count;
for (int i = 0; i < count; i++)
{
if (twnCap.EnumerationCapability.ItemType == TwainItemType.Uint16)
{
xfer = Convert.ToUInt16(twnCap.EnumerationCapability.GetValue(i));
if (xfer == (int)TwainCapabilityValue.TransferMechanismFile)
{
fileMode = true;
}
if (xfer == (int)TwainCapabilityValue.TransferMechanismMemory)
{
memoryMode = true;
}
if (xfer == (int)TwainCapabilityValue.TransferMechanismNative)
{
nativeMode = true;
}
}
}
break;
}
}
}
catch (Exception ex)
{
Messager.ShowError(this, ex);
return;
}
_rdTransferFile.Enabled = fileMode;
_rdTransferMemory.Enabled = memoryMode;
_rdTransferNative.Enabled = nativeMode;
if (memoryMode)
{
_rdTransferMemory.Checked = true;
_rdTransferMemory_CheckedChanged(sender, e);
}
if (fileMode)
{
_rdTransferFile.Checked = true;
_rdTransferFile_CheckedChanged(sender, e);
}
if (nativeMode)
{
_rdTransferNative.Checked = true;
_rdTransferNative_CheckedChanged(sender, e);
}
_txtFileName_TextChanged(sender, e);
}
private bool Open()
{
if(fTwain.OpenDataSource(fIdent))
{
fState = StateType.Idle;
fCapabilitySupportedTypes = new TwainCapability(fTwain, fIdent, TwCap.SupportedCapabilities);
fCapabilityPixelType = new TwainCapability(fTwain, fIdent, TwCap.IPixelType);
fCapabilityPageSize = new TwainCapability(fTwain, fIdent, TwCap.SupportedSizes);
fCapabilityResolutionX = new TwainCapability(fTwain, fIdent, TwCap.XResolution);
fCapabilityResolutionY = new TwainCapability(fTwain, fIdent, TwCap.YResolution);
fCapabilityFeederEnabled = new TwainCapability(fTwain, fIdent, TwCap.FeederEnabled);
fCapabilityFeederLoaded = new TwainCapability(fTwain, fIdent, TwCap.FeederLoaded);
fCapabilityBitDepthReduction = new TwainCapability(fTwain, fIdent, TwCap.BitDepthReduction);
fCapabilityThreshold = new TwainCapability(fTwain, fIdent, TwCap.Threshold);
fCapabilityBrightness = new TwainCapability(fTwain, fIdent, TwCap.Brightness);
fCapabilityContrast = new TwainCapability(fTwain, fIdent, TwCap.Contrast);
}
return IsOpen;
}
