lsm/ntwain
1
0
Fork 0
mirror of https://github.com/soukoku/ntwain.git synced 2025-04-05 20:59:23 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Refactoring different xfer modes and types.

Browse Source
This commit is contained in:
soukoku 2014-04-06 07:08:52 -04:00
parent 4c3e2a50b3
commit 69feecde8d
4 changed files with 384 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

218
NTwain/TransferReadyEventArgs.cs
View File

@ -2,6 +2,7 @@
using NTwain.Data; using NTwain.Data;
using NTwain.Values; using NTwain.Values;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
namespace NTwain namespace NTwain
{ {
@ -10,50 +11,6 @@ namespace NTwain
/// </summary> /// </summary>
public class TransferReadyEventArgs : EventArgs public class TransferReadyEventArgs : EventArgs
{ {
/// <summary>
/// Initializes a new instance of the <see cref="TransferReadyEventArgs" /> class.
/// </summary>
/// <param name="pending">The pending data.</param>
/// <param name="supportedFormats">The formats.</param>
/// <param name="currentFormat">The current format.</param>
/// <param name="supportedCompressions">The compressions.</param>
/// <param name="currentCompression">The current compression.</param>
/// <param name="canDoFileXfer">if set to <c>true</c> then allow file xfer properties.</param>
/// <param name="imageInfo">The image info.</param>
internal TransferReadyEventArgs(TWPendingXfers pending, IList<FileFormat> supportedFormats, FileFormat currentFormat,
IList<Compression> supportedCompressions, Compression currentCompression, bool canDoFileXfer, TWImageInfo imageInfo)
{
PendingCount = pending.Count;
EndOfJob = pending.EndOfJob == 0;
_imageCompression = currentCompression;
SupportedCompressions = supportedCompressions;
_imageFormat = currentFormat;
SupportedFormats = supportedFormats;
CanDoFileXfer = canDoFileXfer;
ImageInfo = imageInfo;
}
/// <summary>
/// Gets the image info for the current transfer.
/// </summary>
/// <value>
/// The image info.
/// </value>
public TWImageInfo ImageInfo { get; private set; }
/// <summary>
/// Gets the known pending transfer count. This may not be appilicable
/// for certain scanning modes.
/// </summary>
/// <value>The pending count.</value>
public int PendingCount { get; private set; }
/// <summary>
/// Gets a value indicating whether current transfer signifies an end of job.
/// </summary>
/// <value><c>true</c> if transfer is end of job; otherwise, <c>false</c>.</value>
public bool EndOfJob { get; private set; }
/// <summary> /// <summary>
/// Gets or sets a value indicating whether the current transfer should be canceled /// Gets or sets a value indicating whether the current transfer should be canceled
/// and continue next transfer if there are more data. /// and continue next transfer if there are more data.
@ -68,97 +25,126 @@ namespace NTwain
public bool CancelAll { get; set; } public bool CancelAll { get; set; }
/// <summary> /// <summary>
/// Gets or sets a value indicating whether file transfer is supported. /// Gets a value indicating whether current transfer signifies an end of job in TWAIN world.
/// </summary> /// </summary>
/// <value> /// <value><c>true</c> if transfer is end of job; otherwise, <c>false</c>.</value>
/// <c>true</c> if this instance can do file transfer; otherwise, <c>false</c>. public bool EndOfJob { get; internal set; }
/// </value>
public bool CanDoFileXfer { get; private set; }
/// <summary> /// <summary>
/// Gets or sets the desired output file path if file transfer is supported. /// Gets the known pending transfer count. This may not be appilicable
/// Note that not all sources will support the specified image type and compression /// for certain scanning modes.
/// when file transfer is used.
/// </summary> /// </summary>
/// <value> /// <value>The pending count.</value>
/// The output file. public int PendingTransferCount { get; internal set; }
/// </value>
public string OutputFile { get; set; } #region image use
/// <summary> /// <summary>
/// Gets the supported compression for image xfer. /// Gets the tentative image information for the current transfer if applicable.
/// This may differ from the final image depending on the transfer mode used.
/// </summary> /// </summary>
/// <value> /// <value>
/// The supported compressions. /// The image info.
/// </value> /// </value>
public IList<Compression> SupportedCompressions { get; private set; } public TWImageInfo PendingImageInfo { get; internal set; }
private Compression _imageCompression; ///// <summary>
///// Gets or sets a value indicating whether file transfer is supported.
///// </summary>
///// <value>
///// <c>true</c> if this instance can do file transfer; otherwise, <c>false</c>.
///// </value>
//public bool CanDoFileXfer { get; private set; }
/// <summary> ///// <summary>
/// Gets or sets the image compression for image xfer. ///// Gets or sets the desired output file path if file transfer is supported.
/// </summary> ///// Note that not all sources will support the specified image type and compression
/// <value> ///// when file transfer is used.
/// The image compression. ///// </summary>
/// </value> ///// <value>
/// <exception cref="System.NotSupportedException"></exception> ///// The output file.
public Compression ImageCompression ///// </value>
{ //public string OutputFile { get; set; }
get { return _imageCompression; }
set
{
if (SupportedCompressions.Contains(value))
{
_imageCompression = value;
}
else
{
throw new NotSupportedException(string.Format("{0} is not supported.", value));
}
}
}
///// <summary>
///// Gets the supported compression for image xfer.
///// </summary>
///// <value>
///// The supported compressions.
///// </value>
//public IList<Compression> SupportedImageCompressions { get; internal set; }
/// <summary> //private Compression _imageCompression;
/// Gets the supported file formats for image file xfer.
/// </summary>
/// <value>
/// The supported formats.
/// </value>
public IList<FileFormat> SupportedFormats { get; private set; }
private FileFormat _imageFormat; ///// <summary>
/// <summary> ///// Gets or sets the image compression for image xfer.
/// Gets or sets the image format for image xfer. ///// </summary>
/// </summary> ///// <value>
/// <value> ///// The image compression.
/// The image format. ///// </value>
/// </value> ///// <exception cref="System.NotSupportedException"></exception>
/// <exception cref="System.NotSupportedException"></exception> //public Compression ImageCompression
public FileFormat ImageFormat //{
{ // get { return _imageCompression; }
get { return _imageFormat; } // set
set // {
{ // if (SupportedImageCompressions.Contains(value))
if (SupportedFormats.Contains(value)) // {
{ // _imageCompression = value;
_imageFormat = value; // }
} // else
else // {
{ // throw new NotSupportedException(string.Format("{0} is not supported.", value));
throw new NotSupportedException(string.Format("{0} is not supported.", value)); // }
} // }
} //}
}
///// <summary> ///// <summary>
///// Gets or sets the audio file format if <see cref="OutputFile"/> is specified ///// Gets the supported file formats for image file xfer.
///// and the data to be transferred is audio.
///// </summary> ///// </summary>
///// <value> ///// <value>
///// The audio file format. ///// The supported formats.
///// </value> ///// </value>
//public AudioFileFormat AudioFileFormat { get; set; } //public IList<FileFormat> SupportedImageFormats { get; internal set; }
//private FileFormat _imageFormat;
///// <summary>
///// Gets or sets the image format for image xfer.
///// </summary>
///// <value>
///// The image format.
///// </value>
///// <exception cref="System.NotSupportedException"></exception>
//public FileFormat ImageFormat
//{
// get { return _imageFormat; }
// set
// {
// if (SupportedImageFormats.Contains(value))
// {
// _imageFormat = value;
// }
// else
// {
// throw new NotSupportedException(string.Format("{0} is not supported.", value));
// }
// }
//}
#endregion
#region audio use
/// <summary>
/// Gets the audio information for the current transfer if applicable.
/// </summary>
/// <value>
/// The audio information.
/// </value>
public TWAudioInfo AudioInfo { get; internal set; }
#endregion
} }
} }

379
NTwain/TwainSession.cs
View File

@ -663,168 +663,273 @@ namespace NTwain
} }
/// <summary> /// <summary>
/// Does the TWAIN transfer routine at state 6. /// Performs the TWAIN transfer routine at state 6.
/// </summary> /// </summary>
protected virtual void DoTransferRoutine() protected virtual void DoTransferRoutine()
{ {
TWPendingXfers pending = new TWPendingXfers(); // TODO: better way to determine what's being xfered?
if ((SourceId.DataGroup & DataGroups.Image) == DataGroups.Image)
{
DoImageXfer();
}
else if ((SourceId.DataGroup & DataGroups.Audio) == DataGroups.Audio)
{
DoAudioXfer();
}
else
{
// ??? just cancel it
var pending = new TWPendingXfers();
var rc = ReturnCode.Success;
do
{
rc = DGControl.PendingXfers.Reset(pending);
} while (rc == ReturnCode.Success && pending.Count != 0);
State = 5;
DisableSource();
}
}
#region audio xfers
private void DoAudioXfer()
{
var pending = new TWPendingXfers();
var rc = ReturnCode.Success; var rc = ReturnCode.Success;
do do
{ {
IList<FileFormat> formats = Enumerable.Empty<FileFormat>().ToList(); #region build pre xfer info
IList<Compression> compressions = Enumerable.Empty<Compression>().ToList(); TWAudioInfo audInfo;
bool canDoFileXfer = this.CapGetImageXferMech().Contains(XferMech.File); DGAudio.AudioInfo.Get(out audInfo);
var curFormat = this.GetCurrentCap<FileFormat>(CapabilityId.ICapImageFileFormat);
var curComp = this.GetCurrentCap<Compression>(CapabilityId.ICapCompression); // ask consumer for xfer details
TWImageInfo imgInfo; var preXferArgs = new TransferReadyEventArgs
bool skip = false;
if (DGImage.ImageInfo.Get(out imgInfo) != ReturnCode.Success)
{ {
// bad! AudioInfo = audInfo,
skip = true; PendingTransferCount = pending.Count,
} EndOfJob = pending.EndOfJob == 0
};
try OnTransferReady(preXferArgs);
{
formats = this.CapGetImageFileFormat();
}
catch { }
try
{
compressions = this.CapGetCompression();
}
catch { }
// ask consumer for cancel in case of non-ui multi-page transfers #endregion
TransferReadyEventArgs args = new TransferReadyEventArgs(pending, formats, curFormat, compressions,
curComp, canDoFileXfer, imgInfo);
args.CancelCurrent = skip;
OnTransferReady(args); if (preXferArgs.CancelAll)
if (!args.CancelAll && !args.CancelCurrent)
{
Values.XferMech mech = this.GetCurrentCap<XferMech>(CapabilityId.ICapXferMech);
if (args.CanDoFileXfer && !string.IsNullOrEmpty(args.OutputFile))
{
var setXferRC = DGControl.SetupFileXfer.Set(new TWSetupFileXfer
{
FileName = args.OutputFile,
Format = args.ImageFormat
});
if (setXferRC == ReturnCode.Success)
{
mech = XferMech.File;
}
}
// I don't know how this is supposed to work so it probably doesn't
//this.CapSetImageFormat(args.ImageFormat);
//this.CapSetImageCompression(args.ImageCompression);
#region do xfer
// TODO: expose all swallowed exceptions somehow later
IntPtr dataPtr = IntPtr.Zero;
IntPtr lockedPtr = IntPtr.Zero;
string file = null;
try
{
ReturnCode xrc = ReturnCode.Cancel;
switch (mech)
{
case Values.XferMech.Native:
xrc = DGImage.ImageNativeXfer.Get(ref dataPtr);
break;
case Values.XferMech.File:
xrc = DGImage.ImageFileXfer.Get();
if (File.Exists(args.OutputFile))
{
file = args.OutputFile;
}
break;
case Values.XferMech.MemFile:
// not supported yet
//TWImageMemXfer memxfer = new TWImageMemXfer();
//xrc = DGImage.ImageMemXfer.Get(memxfer);
break;
}
if (xrc == ReturnCode.XferDone)
{
State = 7;
if (dataPtr != IntPtr.Zero)
{
lockedPtr = MemoryManager.Instance.Lock(dataPtr);
}
OnDataTransferred(new DataTransferredEventArgs(lockedPtr, file));
}
//}
//else if (group == DataGroups.Audio)
//{
// var xrc = DGAudio.AudioNativeXfer.Get(ref dataPtr);
// if (xrc == ReturnCode.XferDone)
// {
// State = 7;
// try
// {
// var dtHand = DataTransferred;
// if (dtHand != null)
// {
// lockedPtr = MemoryManager.Instance.MemLock(dataPtr);
// dtHand(this, new DataTransferredEventArgs(lockedPtr));
// }
// }
// catch { }
// }
//}
}
finally
{
State = 6;
// data here is allocated by source so needs to use shared mem calls
if (lockedPtr != IntPtr.Zero)
{
MemoryManager.Instance.Unlock(lockedPtr);
lockedPtr = IntPtr.Zero;
}
if (dataPtr != IntPtr.Zero)
{
MemoryManager.Instance.Free(dataPtr);
dataPtr = IntPtr.Zero;
}
}
#endregion
}
if (args.CancelAll)
{ {
rc = DGControl.PendingXfers.Reset(pending); rc = DGControl.PendingXfers.Reset(pending);
if (rc == ReturnCode.Success) if (rc == ReturnCode.Success)
{ {
// if audio exit here // TODO: verify if audio exit directly?
//if (group == DataGroups.Audio) return;
//{
// //???
// return;
//}
} }
} }
else else if (!preXferArgs.CancelCurrent)
{ {
rc = DGControl.PendingXfers.EndXfer(pending); var mech = this.GetCurrentCap<XferMech>(CapabilityId.ACapXferMech);
switch (mech)
{
case XferMech.Native:
DoAudioNativeXfer();
break;
case XferMech.File:
DoAudioFileXfer();
break;
}
} }
rc = DGControl.PendingXfers.EndXfer(pending);
} while (rc == ReturnCode.Success && pending.Count != 0); } while (rc == ReturnCode.Success && pending.Count != 0);
State = 5; State = 5;
DisableSource(); DisableSource();
} }
private void DoAudioNativeXfer()
{
IntPtr dataPtr = IntPtr.Zero;
IntPtr lockedPtr = IntPtr.Zero;
try
{
var xrc = DGAudio.AudioNativeXfer.Get(ref dataPtr);
if (xrc == ReturnCode.XferDone)
{
State = 7;
if (dataPtr != IntPtr.Zero)
{
lockedPtr = MemoryManager.Instance.Lock(dataPtr);
}
OnDataTransferred(new DataTransferredEventArgs(lockedPtr, null));
}
}
finally
{
State = 6;
// data here is allocated by source so needs to use shared mem calls
if (lockedPtr != IntPtr.Zero)
{
MemoryManager.Instance.Unlock(lockedPtr);
lockedPtr = IntPtr.Zero;
}
if (dataPtr != IntPtr.Zero)
{
MemoryManager.Instance.Free(dataPtr);
dataPtr = IntPtr.Zero;
}
}
}
private void DoAudioFileXfer()
{
throw new NotImplementedException();
}
#endregion
#region image xfers
private void DoImageXfer()
{
var pending = new TWPendingXfers();
var rc = ReturnCode.Success;
do
{
#region build pre xfer info
TWImageInfo imgInfo;
DGImage.ImageInfo.Get(out imgInfo);
//IList<FileFormat> formats = Enumerable.Empty<FileFormat>().ToList();
//IList<Compression> compressions = Enumerable.Empty<Compression>().ToList();
//var curFormat = this.GetCurrentCap<FileFormat>(CapabilityId.ICapImageFileFormat);
//var curComp = this.GetCurrentCap<Compression>(CapabilityId.ICapCompression);
//try
//{
// formats = this.CapGetImageFileFormat();
//}
//catch { }
//try
//{
// compressions = this.CapGetCompression();
//}
//catch { }
// ask consumer for xfer details
var preXferArgs = new TransferReadyEventArgs
{
PendingImageInfo = imgInfo,
PendingTransferCount = pending.Count,
EndOfJob = pending.EndOfJob == 0
};
OnTransferReady(preXferArgs);
#endregion
if (preXferArgs.CancelAll)
{
rc = DGControl.PendingXfers.Reset(pending);
}
else if (!preXferArgs.CancelCurrent)
{
var mech = this.GetCurrentCap<XferMech>(CapabilityId.ICapXferMech);
switch (mech)
{
case XferMech.Native:
DoImageNativeXfer();
break;
case XferMech.Memory:
DoImageMemoryXfer();
break;
case XferMech.File:
DoImageFileXfer();
break;
case XferMech.MemFile:
DoImageMemoryFileXfer();
break;
}
}
rc = DGControl.PendingXfers.EndXfer(pending);
} while (rc == ReturnCode.Success && pending.Count != 0);
State = 5;
DisableSource();
}
private void DoImageNativeXfer()
{
IntPtr dataPtr = IntPtr.Zero;
IntPtr lockedPtr = IntPtr.Zero;
try
{
ReturnCode xrc = DGImage.ImageNativeXfer.Get(ref dataPtr);
if (xrc == ReturnCode.XferDone)
{
State = 7;
if (dataPtr != IntPtr.Zero)
{
lockedPtr = MemoryManager.Instance.Lock(dataPtr);
}
OnDataTransferred(new DataTransferredEventArgs(lockedPtr, null));
}
}
finally
{
State = 6;
// data here is allocated by source so needs to use shared mem calls
if (lockedPtr != IntPtr.Zero)
{
MemoryManager.Instance.Unlock(lockedPtr);
lockedPtr = IntPtr.Zero;
}
if (dataPtr != IntPtr.Zero)
{
MemoryManager.Instance.Free(dataPtr);
dataPtr = IntPtr.Zero;
}
}
}
private void DoImageMemoryFileXfer()
{
throw new NotImplementedException();
}
private void DoImageFileXfer()
{
throw new NotImplementedException();
//if (preXferArgs.CanDoFileXfer && !string.IsNullOrEmpty(preXferArgs.OutputFile))
//{
// var setXferRC = DGControl.SetupFileXfer.Set(new TWSetupFileXfer
// {
// FileName = preXferArgs.OutputFile,
// Format = preXferArgs.ImageFormat
// });
// if (setXferRC == ReturnCode.Success)
// {
// mech = XferMech.File;
// }
//}
//xrc = DGImage.ImageFileXfer.Get();
//if (File.Exists(preXferArgs.OutputFile))
//{
// file = preXferArgs.OutputFile;
//}
}
private void DoImageMemoryXfer()
{
throw new NotImplementedException();
}
#endregion
#endregion #endregion

74
NTwain/TwainSessionOld.cs
View File

@ -36,11 +36,11 @@ namespace NTwain
do do
{ {
IList<FileFormat> formats = Enumerable.Empty<FileFormat>().ToList(); //IList<FileFormat> formats = Enumerable.Empty<FileFormat>().ToList();
IList<Compression> compressions = Enumerable.Empty<Compression>().ToList(); //IList<Compression> compressions = Enumerable.Empty<Compression>().ToList();
bool canDoFileXfer = this.CapGetImageXferMech().Contains(XferMech.File); //bool canDoFileXfer = this.CapGetImageXferMech().Contains(XferMech.File);
var curFormat = this.GetCurrentCap<FileFormat>(CapabilityId.ICapImageFileFormat); //var curFormat = this.GetCurrentCap<FileFormat>(CapabilityId.ICapImageFileFormat);
var curComp = this.GetCurrentCap<Compression>(CapabilityId.ICapCompression); //var curComp = this.GetCurrentCap<Compression>(CapabilityId.ICapCompression);
TWImageInfo imgInfo; TWImageInfo imgInfo;
bool skip = false; bool skip = false;
if (DGImage.ImageInfo.Get(out imgInfo) != ReturnCode.Success) if (DGImage.ImageInfo.Get(out imgInfo) != ReturnCode.Success)
@ -49,20 +49,26 @@ namespace NTwain
skip = true; skip = true;
} }
try //try
{ //{
formats = this.CapGetImageFileFormat(); // formats = this.CapGetImageFileFormat();
} //}
catch { } //catch { }
try //try
{ //{
compressions = this.CapGetCompression(); // compressions = this.CapGetCompression();
} //}
catch { } //catch { }
// ask consumer for cancel in case of non-ui multi-page transfers // ask consumer for cancel in case of non-ui multi-page transfers
TransferReadyEventArgs args = new TransferReadyEventArgs(pending, formats, curFormat, compressions, //TransferReadyEventArgs args = new TransferReadyEventArgs(pending, formats, curFormat, compressions,
curComp, canDoFileXfer, imgInfo); // curComp, canDoFileXfer, imgInfo);
var args = new TransferReadyEventArgs
{
PendingImageInfo = imgInfo,
PendingTransferCount = pending.Count,
EndOfJob = pending.EndOfJob == 0
};
args.CancelCurrent = skip; args.CancelCurrent = skip;
OnTransferReady(args); OnTransferReady(args);
@ -72,18 +78,18 @@ namespace NTwain
{ {
Values.XferMech mech = this.GetCurrentCap<XferMech>(CapabilityId.ICapXferMech); Values.XferMech mech = this.GetCurrentCap<XferMech>(CapabilityId.ICapXferMech);
if (args.CanDoFileXfer && !string.IsNullOrEmpty(args.OutputFile)) //if (args.CanDoFileXfer && !string.IsNullOrEmpty(args.OutputFile))
{ //{
var setXferRC = DGControl.SetupFileXfer.Set(new TWSetupFileXfer // var setXferRC = DGControl.SetupFileXfer.Set(new TWSetupFileXfer
{ // {
FileName = args.OutputFile, // FileName = args.OutputFile,
Format = args.ImageFormat // Format = args.ImageFormat
}); // });
if (setXferRC == ReturnCode.Success) // if (setXferRC == ReturnCode.Success)
{ // {
mech = XferMech.File; // mech = XferMech.File;
} // }
} //}
// I don't know how this is supposed to work so it probably doesn't // I don't know how this is supposed to work so it probably doesn't
//this.CapSetImageFormat(args.ImageFormat); //this.CapSetImageFormat(args.ImageFormat);
@ -105,11 +111,11 @@ namespace NTwain
xrc = DGImage.ImageNativeXfer.Get(ref dataPtr); xrc = DGImage.ImageNativeXfer.Get(ref dataPtr);
break; break;
case Values.XferMech.File: case Values.XferMech.File:
xrc = DGImage.ImageFileXfer.Get(); //xrc = DGImage.ImageFileXfer.Get();
if (File.Exists(args.OutputFile)) //if (File.Exists(args.OutputFile))
{ //{
file = args.OutputFile; // file = args.OutputFile;
} //}
break; break;
case Values.XferMech.MemFile: case Values.XferMech.MemFile:
// not supported yet // not supported yet

22
Tests/NTwain.Tests/TransferReadyEventArgsTests.cs
View File

@ -11,28 +11,6 @@ namespace NTwain.Tests
[TestClass] [TestClass]
public class TransferReadyEventArgsTests public class TransferReadyEventArgsTests
{ {
[TestMethod]
public void Constructor_Sets_Correct_Properties()
{
// just some non-default values to test
TWPendingXfers pending = new TWPendingXfers();
List<FileFormat> formats = new List<FileFormat> { FileFormat.Bmp, FileFormat.Tiff };
FileFormat curFormat = FileFormat.Tiff;
List<Compression> compressions = new List<Compression> { Compression.None, Compression.Group4 };
Compression curCompress = Compression.None;
bool fileXfer = true;
TWImageInfo info = new TWImageInfo();
TransferReadyEventArgs target = new TransferReadyEventArgs(pending, formats, curFormat, compressions, curCompress, fileXfer, info);
Assert.AreEqual(pending.Count, target.PendingCount, "PendingCount mismatch.");
Assert.AreEqual(formats, target.SupportedFormats, "SupportedFormats mismatch.");
Assert.AreEqual(curFormat, target.ImageFormat, "ImageFormat mismatch.");
Assert.AreEqual(compressions, target.SupportedCompressions, "SupportedCompressions mismatch.");
Assert.AreEqual(curCompress, target.ImageCompression, "ImageCompression mismatch.");
Assert.AreEqual(fileXfer, target.CanDoFileXfer, "CanDoFileXfer mismatch.");
Assert.AreEqual(info, target.ImageInfo, "ImageInfo mismatch.");
}
} }
} }