From 9bd155d419250696415dc56ed20f72056a730ba7 Mon Sep 17 00:00:00 2001 From: Eugene Wang <8755753+soukoku@users.noreply.github.com> Date: Thu, 22 Apr 2021 07:46:02 -0400 Subject: [PATCH] Moved static csv conversions to own file. --- NTwain/TWAINWorkingGroup/CsvSerializer.cs | 1850 +++++++++++++++++++ NTwain/TWAINWorkingGroup/TWAIN.cs | 1958 +-------------------- NTwain/TwainSession.cs | 4 +- 3 files changed, 1932 insertions(+), 1880 deletions(-) create mode 100644 NTwain/TWAINWorkingGroup/CsvSerializer.cs diff --git a/NTwain/TWAINWorkingGroup/CsvSerializer.cs b/NTwain/TWAINWorkingGroup/CsvSerializer.cs new file mode 100644 index 0000000..127be13 --- /dev/null +++ b/NTwain/TWAINWorkingGroup/CsvSerializer.cs @@ -0,0 +1,1850 @@ +/////////////////////////////////////////////////////////////////////////////////////// +// +// TwainWorkingGroup.TWAIN +// +// These are the definitions for TWAIN. They're essentially the C/C++ +// TWAIN.H file contents translated to C#, with modifications that +// recognize the differences between Windows, Linux and Mac OS X. +// +/////////////////////////////////////////////////////////////////////////////////////// +// Author Date TWAIN Comment +// M.McLaughlin 13-Mar-2019 2.4.0.3 Add language code page support for strings +// M.McLaughlin 13-Nov-2015 2.4.0.0 Updated to latest spec +// M.McLaughlin 13-Sep-2015 2.3.1.2 DsmMem bug fixes +// M.McLaughlin 26-Aug-2015 2.3.1.1 Log fix and sync with TWAIN Direct +// M.McLaughlin 13-Mar-2015 2.3.1.0 Numerous fixes +// M.McLaughlin 13-Oct-2014 2.3.0.4 Added logging +// M.McLaughlin 24-Jun-2014 2.3.0.3 Stability fixes +// M.McLaughlin 21-May-2014 2.3.0.2 64-Bit Linux +// M.McLaughlin 27-Feb-2014 2.3.0.1 AnyCPU support +// M.McLaughlin 21-Oct-2013 2.3.0.0 Initial Release +/////////////////////////////////////////////////////////////////////////////////////// +// Copyright (C) 2013-2020 Kodak Alaris Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the "Software"), +// to deal in the Software without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////////////////////////////////////////////////// + +using System; +using System.Globalization; + +namespace TWAINWorkingGroup +{ + public static class CsvSerializer + { + /// + /// Convert the contents of an audio info to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string AudioinfoToCsv(TW_AUDIOINFO a_twaudioinfo) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twaudioinfo.Name.Get()); + csv.Add(a_twaudioinfo.Reserved.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a callback to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string CallbackToCsv(TW_CALLBACK a_twcallback) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twcallback.CallBackProc.ToString()); + csv.Add(a_twcallback.RefCon.ToString()); + csv.Add(a_twcallback.Message.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to an callback structure... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToCallback(ref TW_CALLBACK a_twcallback, string a_szCallback) + { + // Init stuff... + a_twcallback = default(TW_CALLBACK); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szCallback); + + // Grab the values... + a_twcallback.CallBackProc = (IntPtr)UInt64.Parse(asz[0]); + a_twcallback.RefCon = uint.Parse(asz[1]); + a_twcallback.Message = ushort.Parse(asz[2]); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of a callback2 to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string Callback2ToCsv(TW_CALLBACK2 a_twcallback2) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twcallback2.CallBackProc.ToString()); + csv.Add(a_twcallback2.RefCon.ToString()); + csv.Add(a_twcallback2.Message.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to an callback2 structure... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToCallback2(ref TW_CALLBACK2 a_twcallback2, string a_szCallback2) + { + // Init stuff... + a_twcallback2 = default(TW_CALLBACK2); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szCallback2); + + // Grab the values... + a_twcallback2.CallBackProc = (IntPtr)UInt64.Parse(asz[0]); + a_twcallback2.RefCon = (UIntPtr)UInt64.Parse(asz[1]); + a_twcallback2.Message = ushort.Parse(asz[2]); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + + /// + /// Convert the contents of a device event to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string DeviceeventToCsv(TW_DEVICEEVENT a_twdeviceevent) + { + try + { + CSV csv = new CSV(); + csv.Add(((TWDE)a_twdeviceevent.Event).ToString()); + csv.Add(a_twdeviceevent.DeviceName.Get()); + csv.Add(a_twdeviceevent.BatteryMinutes.ToString()); + csv.Add(a_twdeviceevent.BatteryPercentage.ToString()); + csv.Add(a_twdeviceevent.PowerSupply.ToString()); + csv.Add(((double)a_twdeviceevent.XResolution.Whole + ((double)a_twdeviceevent.XResolution.Frac / 65536.0)).ToString()); + csv.Add(((double)a_twdeviceevent.YResolution.Whole + ((double)a_twdeviceevent.YResolution.Frac / 65536.0)).ToString()); + csv.Add(a_twdeviceevent.FlashUsed2.ToString()); + csv.Add(a_twdeviceevent.AutomaticCapture.ToString()); + csv.Add(a_twdeviceevent.TimeBeforeFirstCapture.ToString()); + csv.Add(a_twdeviceevent.TimeBetweenCaptures.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of an entry point to a string that + /// we can show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string EntrypointToCsv(TW_ENTRYPOINT a_twentrypoint) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twentrypoint.Size.ToString()); + csv.Add("0x" + ((a_twentrypoint.DSM_Entry == null) ? "0" : a_twentrypoint.DSM_Entry.ToString("X"))); + csv.Add("0x" + ((a_twentrypoint.DSM_MemAllocate == null) ? "0" : a_twentrypoint.DSM_MemAllocate.ToString("X"))); + csv.Add("0x" + ((a_twentrypoint.DSM_MemFree == null) ? "0" : a_twentrypoint.DSM_MemFree.ToString("X"))); + csv.Add("0x" + ((a_twentrypoint.DSM_MemLock == null) ? "0" : a_twentrypoint.DSM_MemLock.ToString("X"))); + csv.Add("0x" + ((a_twentrypoint.DSM_MemUnlock == null) ? "0" : a_twentrypoint.DSM_MemUnlock.ToString("X"))); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of an event to a string that + /// we can show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string EventToCsv(TW_EVENT a_twevent) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twevent.pEvent.ToString()); + csv.Add(a_twevent.TWMessage.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of an extimageinfo to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string ExtimageinfoToCsv(TW_EXTIMAGEINFO a_twextimageinfo) + { + try + { + uint uTwinfo = 0; + CSV csv = new CSV(); + csv.Add(a_twextimageinfo.NumInfos.ToString()); + for (int ii = 0; (ii < a_twextimageinfo.NumInfos) && (ii < 200); ii++) + { + TWEI twei; + TWTY twty; + STS sts; + TW_INFO twinfo = default(TW_INFO); + a_twextimageinfo.Get(uTwinfo, ref twinfo); + twei = (TWEI)twinfo.InfoId; + if (twei.ToString() != twinfo.InfoId.ToString()) + { + csv.Add("TWEI_" + twei.ToString()); + } + else + { + csv.Add(string.Format("0x{0:X}", twinfo.InfoId)); + } + twty = (TWTY)twinfo.ItemType; + if (twty.ToString() != twinfo.ItemType.ToString()) + { + csv.Add("TWTY_" + twty.ToString()); + } + else + { + csv.Add(string.Format("0x{0:X}", twinfo.ItemType)); + } + csv.Add(twinfo.NumItems.ToString()); + sts = (STS)twinfo.ReturnCode; + if (sts.ToString() != twinfo.ReturnCode.ToString()) + { + csv.Add("TWRC_" + sts.ToString()); + } + else + { + csv.Add(string.Format("0x{0:X}", twinfo.ReturnCode)); + } + csv.Add(twinfo.ReturnCode.ToString()); + csv.Add(twinfo.Item.ToString()); + uTwinfo += 1; + } + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to an extimageinfo structure, + /// note that we don't have to worry about containers going in this + /// direction... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToExtimageinfo(ref TW_EXTIMAGEINFO a_twextimageinfo, string a_szExtimageinfo) + { + // Init stuff... + a_twextimageinfo = default(TW_EXTIMAGEINFO); + + // Build the string... + try + { + int iField; + uint uTwinfo; + string[] asz = CSV.Parse(a_szExtimageinfo); + + // Set the number of entries (this is the easy bit)... + uint.TryParse(asz[0], out a_twextimageinfo.NumInfos); + if (a_twextimageinfo.NumInfos > 200) + { + Log.Error("***error*** - we're limited to 200 entries, if this is a problem, just add more, and fix this code..."); + return (false); + } + + // Okay, walk all the entries in steps of TW_INFO... + uTwinfo = 0; + for (iField = 1; iField < asz.Length; iField += 5) + { + UInt64 u64; + TWEI twei; + TW_INFO twinfo = default(TW_INFO); + if ((iField + 5) > asz.Length) + { + Log.Error("***error*** - badly constructed list, should be: num,(twinfo),(twinfo)..."); + return (false); + } + if (TWEI.TryParse(asz[iField + 0].Replace("TWEI_", ""), out twei)) + { + twinfo.InfoId = (ushort)twei; + } + else + { + if (asz[iField + 0].ToLowerInvariant().StartsWith("0x")) + { + ushort.TryParse(asz[iField + 0].Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out twinfo.InfoId); + } + else + { + ushort.TryParse(asz[iField + 0], out twinfo.InfoId); + } + } + // We really don't care about these... + ushort.TryParse(asz[iField + 1], out twinfo.ItemType); + ushort.TryParse(asz[iField + 2], out twinfo.NumItems); + ushort.TryParse(asz[iField + 3], out twinfo.ReturnCode); + UInt64.TryParse(asz[iField + 4], out u64); + twinfo.Item = (UIntPtr)u64; + a_twextimageinfo.Set(uTwinfo, ref twinfo); + uTwinfo += 1; + } + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of a filesystem to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string FilesystemToCsv(TW_FILESYSTEM a_twfilesystem) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twfilesystem.InputName.Get()); + csv.Add(a_twfilesystem.OutputName.Get()); + csv.Add(a_twfilesystem.Context.ToString()); + csv.Add(a_twfilesystem.Recursive.ToString()); + csv.Add(a_twfilesystem.FileType.ToString()); + csv.Add(a_twfilesystem.Size.ToString()); + csv.Add(a_twfilesystem.CreateTimeDate.Get()); + csv.Add(a_twfilesystem.ModifiedTimeDate.Get()); + csv.Add(a_twfilesystem.FreeSpace.ToString()); + csv.Add(a_twfilesystem.NewImageSize.ToString()); + csv.Add(a_twfilesystem.NumberOfFiles.ToString()); + csv.Add(a_twfilesystem.NumberOfSnippets.ToString()); + csv.Add(a_twfilesystem.DeviceGroupMask.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to a filesystem structure... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToFilesystem(ref TW_FILESYSTEM a_twfilesystem, string a_szFilesystem) + { + // Init stuff... + a_twfilesystem = default(TW_FILESYSTEM); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szFilesystem); + + // Grab the values... + a_twfilesystem.InputName.Set(asz[0]); + a_twfilesystem.OutputName.Set(asz[1]); + a_twfilesystem.Context = (IntPtr)UInt64.Parse(asz[2]); + a_twfilesystem.Recursive = int.Parse(asz[3]); + a_twfilesystem.FileType = int.Parse(asz[4]); + a_twfilesystem.Size = uint.Parse(asz[5]); + a_twfilesystem.CreateTimeDate.Set(asz[6]); + a_twfilesystem.ModifiedTimeDate.Set(asz[7]); + a_twfilesystem.FreeSpace = (uint)UInt64.Parse(asz[8]); + a_twfilesystem.NewImageSize = (uint)UInt64.Parse(asz[9]); + a_twfilesystem.NumberOfFiles = (uint)UInt64.Parse(asz[10]); + a_twfilesystem.NumberOfSnippets = (uint)UInt64.Parse(asz[11]); + a_twfilesystem.DeviceGroupMask = (uint)UInt64.Parse(asz[12]); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of an iccprofile to a string that we can + /// show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string IccprofileToCsv(TW_MEMORY a_twmemory) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twmemory.Flags.ToString()); + csv.Add(a_twmemory.Length.ToString()); + csv.Add(a_twmemory.TheMem.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of an identity to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string IdentityToCsv(TW_IDENTITY a_twidentity) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twidentity.Id.ToString()); + csv.Add(a_twidentity.Version.MajorNum.ToString()); + csv.Add(a_twidentity.Version.MinorNum.ToString()); + csv.Add(a_twidentity.Version.Language.ToString()); + csv.Add(a_twidentity.Version.Country.ToString()); + csv.Add(a_twidentity.Version.Info.Get()); + csv.Add(a_twidentity.ProtocolMajor.ToString()); + csv.Add(a_twidentity.ProtocolMinor.ToString()); + csv.Add("0x" + a_twidentity.SupportedGroups.ToString("X")); + csv.Add(a_twidentity.Manufacturer.Get()); + csv.Add(a_twidentity.ProductFamily.Get()); + csv.Add(a_twidentity.ProductName.Get()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to an identity structure... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToIdentity(ref TW_IDENTITY a_twidentity, string a_szIdentity) + { + // Init stuff... + a_twidentity = default(TW_IDENTITY); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szIdentity); + + // Grab the values... + a_twidentity.Id = ulong.Parse(asz[0]); + a_twidentity.Version.MajorNum = ushort.Parse(asz[1]); + a_twidentity.Version.MinorNum = ushort.Parse(asz[2]); + if (asz[3] != "0") a_twidentity.Version.Language = (TWLG)Enum.Parse(typeof(TWLG), asz[3]); + if (asz[4] != "0") a_twidentity.Version.Country = (TWCY)Enum.Parse(typeof(TWCY), asz[4]); + a_twidentity.Version.Info.Set(asz[5]); + a_twidentity.ProtocolMajor = ushort.Parse(asz[6]); + a_twidentity.ProtocolMinor = ushort.Parse(asz[7]); + a_twidentity.SupportedGroups = asz[8].ToLower().StartsWith("0x") ? Convert.ToUInt32(asz[8].Remove(0, 2), 16) : Convert.ToUInt32(asz[8], 16); + a_twidentity.Manufacturer.Set(asz[9]); + a_twidentity.ProductFamily.Set(asz[10]); + a_twidentity.ProductName.Set(asz[11]); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of a image info to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string ImageinfoToCsv(TW_IMAGEINFO a_twimageinfo) + { + try + { + CSV csv = new CSV(); + csv.Add(((double)a_twimageinfo.XResolution.Whole + ((double)a_twimageinfo.XResolution.Frac / 65536.0)).ToString()); + csv.Add(((double)a_twimageinfo.YResolution.Whole + ((double)a_twimageinfo.YResolution.Frac / 65536.0)).ToString()); + csv.Add(a_twimageinfo.ImageWidth.ToString()); + csv.Add(a_twimageinfo.ImageLength.ToString()); + csv.Add(a_twimageinfo.SamplesPerPixel.ToString()); + csv.Add(a_twimageinfo.BitsPerSample_0.ToString()); + csv.Add(a_twimageinfo.BitsPerSample_1.ToString()); + csv.Add(a_twimageinfo.BitsPerSample_2.ToString()); + csv.Add(a_twimageinfo.BitsPerSample_3.ToString()); + csv.Add(a_twimageinfo.BitsPerSample_4.ToString()); + csv.Add(a_twimageinfo.BitsPerSample_5.ToString()); + csv.Add(a_twimageinfo.BitsPerSample_6.ToString()); + csv.Add(a_twimageinfo.BitsPerSample_7.ToString()); + csv.Add(a_twimageinfo.Planar.ToString()); + csv.Add("TWPT_" + (TWPT)a_twimageinfo.PixelType); + csv.Add("TWCP_" + (TWCP)a_twimageinfo.Compression); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to an callback structure... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToImageinfo(ref TW_IMAGEINFO a_twimageinfo, string a_szImageinfo) + { + // Init stuff... + a_twimageinfo = default(TW_IMAGEINFO); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szImageinfo); + + // Grab the values... + a_twimageinfo.XResolution.Whole = (short)double.Parse(asz[0]); + a_twimageinfo.XResolution.Frac = (ushort)((double.Parse(asz[0]) - (double)a_twimageinfo.XResolution.Whole) * 65536.0); + a_twimageinfo.YResolution.Whole = (short)double.Parse(asz[1]); + a_twimageinfo.YResolution.Frac = (ushort)((double.Parse(asz[1]) - (double)a_twimageinfo.YResolution.Whole) * 65536.0); + a_twimageinfo.ImageWidth = (short)double.Parse(asz[2]); + a_twimageinfo.ImageLength = int.Parse(asz[3]); + a_twimageinfo.SamplesPerPixel = short.Parse(asz[4]); + a_twimageinfo.BitsPerSample_0 = short.Parse(asz[5]); + a_twimageinfo.BitsPerSample_1 = short.Parse(asz[6]); + a_twimageinfo.BitsPerSample_2 = short.Parse(asz[7]); + a_twimageinfo.BitsPerSample_3 = short.Parse(asz[8]); + a_twimageinfo.BitsPerSample_4 = short.Parse(asz[9]); + a_twimageinfo.BitsPerSample_5 = short.Parse(asz[10]); + a_twimageinfo.BitsPerSample_6 = short.Parse(asz[11]); + a_twimageinfo.BitsPerSample_7 = short.Parse(asz[12]); + a_twimageinfo.Planar = ushort.Parse(CvtCapValueFromEnum(CAP.ICAP_PLANARCHUNKY, asz[13])); + a_twimageinfo.PixelType = (TWPT)ushort.Parse(CvtCapValueFromEnum(CAP.ICAP_PIXELTYPE, asz[14])); + a_twimageinfo.Compression = (TWCP)ushort.Parse(CvtCapValueFromEnum(CAP.ICAP_COMPRESSION, asz[15])); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of a image layout to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string ImagelayoutToCsv(TW_IMAGELAYOUT a_twimagelayout) + { + try + { + CSV csv = new CSV(); + csv.Add(((double)a_twimagelayout.Frame.Left.Whole + ((double)a_twimagelayout.Frame.Left.Frac / 65536.0)).ToString()); + csv.Add(((double)a_twimagelayout.Frame.Top.Whole + ((double)a_twimagelayout.Frame.Top.Frac / 65536.0)).ToString()); + csv.Add(((double)a_twimagelayout.Frame.Right.Whole + ((double)a_twimagelayout.Frame.Right.Frac / 65536.0)).ToString()); + csv.Add(((double)a_twimagelayout.Frame.Bottom.Whole + ((double)a_twimagelayout.Frame.Bottom.Frac / 65536.0)).ToString()); + csv.Add(a_twimagelayout.DocumentNumber.ToString()); + csv.Add(a_twimagelayout.PageNumber.ToString()); + csv.Add(a_twimagelayout.FrameNumber.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to an image layout structure... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToImagelayout(ref TW_IMAGELAYOUT a_twimagelayout, string a_szImagelayout) + { + // Init stuff... + a_twimagelayout = default(TW_IMAGELAYOUT); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szImagelayout); + + // Sort out the frame... + a_twimagelayout.Frame.Left.Whole = (short)double.Parse(asz[0]); + a_twimagelayout.Frame.Left.Frac = (ushort)((double.Parse(asz[0]) - (double)a_twimagelayout.Frame.Left.Whole) * 65536.0); + a_twimagelayout.Frame.Top.Whole = (short)double.Parse(asz[1]); + a_twimagelayout.Frame.Top.Frac = (ushort)((double.Parse(asz[1]) - (double)a_twimagelayout.Frame.Top.Whole) * 65536.0); + a_twimagelayout.Frame.Right.Whole = (short)double.Parse(asz[2]); + a_twimagelayout.Frame.Right.Frac = (ushort)((double.Parse(asz[2]) - (double)a_twimagelayout.Frame.Right.Whole) * 65536.0); + a_twimagelayout.Frame.Bottom.Whole = (short)double.Parse(asz[3]); + a_twimagelayout.Frame.Bottom.Frac = (ushort)((double.Parse(asz[3]) - (double)a_twimagelayout.Frame.Bottom.Whole) * 65536.0); + + // And now the counters... + a_twimagelayout.DocumentNumber = (uint)int.Parse(asz[4]); + a_twimagelayout.PageNumber = (uint)int.Parse(asz[5]); + a_twimagelayout.FrameNumber = (uint)int.Parse(asz[6]); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of an image mem xfer structure to a string that + /// we can show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string ImagememxferToCsv(TW_IMAGEMEMXFER a_twimagememxfer) + { + try + { + CSV csv = new CSV(); + csv.Add("TWCP_" + (TWCP)a_twimagememxfer.Compression); + csv.Add(a_twimagememxfer.BytesPerRow.ToString()); + csv.Add(a_twimagememxfer.Columns.ToString()); + csv.Add(a_twimagememxfer.Rows.ToString()); + csv.Add(a_twimagememxfer.XOffset.ToString()); + csv.Add(a_twimagememxfer.YOffset.ToString()); + csv.Add(a_twimagememxfer.BytesWritten.ToString()); + csv.Add(a_twimagememxfer.Memory.Flags.ToString()); + csv.Add(a_twimagememxfer.Memory.Length.ToString()); + csv.Add(a_twimagememxfer.Memory.TheMem.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to an image mem xfer structure... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToImagememxfer(ref TW_IMAGEMEMXFER a_twimagememxfer, string a_szImagememxfer) + { + // Init stuff... + a_twimagememxfer = default(TW_IMAGEMEMXFER); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szImagememxfer); + + // Sort out the structure... + a_twimagememxfer.Compression = ushort.Parse(CvtCapValueFromEnum(CAP.ICAP_COMPRESSION, asz[0])); + a_twimagememxfer.BytesPerRow = uint.Parse(asz[1]); + a_twimagememxfer.Columns = uint.Parse(asz[2]); + a_twimagememxfer.Rows = uint.Parse(asz[3]); + a_twimagememxfer.XOffset = uint.Parse(asz[4]); + a_twimagememxfer.YOffset = uint.Parse(asz[5]); + a_twimagememxfer.BytesWritten = uint.Parse(asz[6]); + a_twimagememxfer.Memory.Flags = ushort.Parse(asz[7]); + a_twimagememxfer.Memory.Length = uint.Parse(asz[8]); + a_twimagememxfer.Memory.TheMem = (IntPtr)ulong.Parse(asz[9]); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of a metrics structure to a string that + /// we can show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string MetricsToCsv(TW_METRICS a_twmetrics) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twmetrics.SizeOf.ToString()); + csv.Add(a_twmetrics.ImageCount.ToString()); + csv.Add(a_twmetrics.SheetCount.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a patthru structure to a string that + /// we can show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string PassthruToCsv(TW_PASSTHRU a_twpassthru) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twpassthru.pCommand.ToString()); + csv.Add(a_twpassthru.CommandBytes.ToString()); + csv.Add(a_twpassthru.Direction.ToString()); + csv.Add(a_twpassthru.pData.ToString()); + csv.Add(a_twpassthru.DataBytes.ToString()); + csv.Add(a_twpassthru.DataBytesXfered.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to a passthru structure... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToPassthru(ref TW_PASSTHRU a_twpassthru, string a_szPassthru) + { + // Init stuff... + a_twpassthru = default(TW_PASSTHRU); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szPassthru); + + // Sort out the frame... + a_twpassthru.pCommand = (IntPtr)UInt64.Parse(asz[0]); + a_twpassthru.CommandBytes = uint.Parse(asz[1]); + a_twpassthru.Direction = int.Parse(asz[2]); + a_twpassthru.pData = (IntPtr)UInt64.Parse(asz[3]); + a_twpassthru.DataBytes = uint.Parse(asz[4]); + a_twpassthru.DataBytesXfered = uint.Parse(asz[5]); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of a pending xfers structure to a string that + /// we can show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string PendingxfersToCsv(TW_PENDINGXFERS a_twpendingxfers) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twpendingxfers.Count.ToString()); + csv.Add(a_twpendingxfers.EOJ.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to a pendingxfers structure... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToPendingXfers(ref TW_PENDINGXFERS a_twpendingxfers, string a_szPendingxfers) + { + // Init stuff... + a_twpendingxfers = default(TW_PENDINGXFERS); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szPendingxfers); + + // Sort out the frame... + a_twpendingxfers.Count = ushort.Parse(asz[0]); + a_twpendingxfers.EOJ = uint.Parse(asz[1]); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of a setup file xfer structure to a string that + /// we can show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string SetupfilexferToCsv(TW_SETUPFILEXFER a_twsetupfilexfer) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twsetupfilexfer.FileName.Get()); + csv.Add("TWFF_" + a_twsetupfilexfer.Format); + csv.Add(a_twsetupfilexfer.VRefNum.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert a string to a setupfilexfer... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToSetupfilexfer(ref TW_SETUPFILEXFER a_twsetupfilexfer, string a_szSetupfilexfer) + { + // Init stuff... + a_twsetupfilexfer = default(TW_SETUPFILEXFER); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szSetupfilexfer); + + // Sort out the values... + a_twsetupfilexfer.FileName.Set(asz[0]); + a_twsetupfilexfer.Format = (TWFF)ushort.Parse(CvtCapValueFromEnum(CAP.ICAP_IMAGEFILEFORMAT, asz[1])); + a_twsetupfilexfer.VRefNum = short.Parse(asz[2]); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of a setup mem xfer structure to a string that + /// we can show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string SetupmemxferToCsv(TW_SETUPMEMXFER a_twsetupmemxfer) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twsetupmemxfer.MinBufSize.ToString()); + csv.Add(a_twsetupmemxfer.MaxBufSize.ToString()); + csv.Add(a_twsetupmemxfer.Preferred.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert a string to a setupmemxfer... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToSetupmemxfer(ref TW_SETUPMEMXFER a_twsetupmemxfer, string a_szSetupmemxfer) + { + // Init stuff... + a_twsetupmemxfer = default(TW_SETUPMEMXFER); + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szSetupmemxfer); + + // Sort out the values... + a_twsetupmemxfer.MinBufSize = uint.Parse(asz[0]); + a_twsetupmemxfer.MaxBufSize = uint.Parse(asz[1]); + a_twsetupmemxfer.Preferred = uint.Parse(asz[2]); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of a status structure to a string that + /// we can show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string StatusToCsv(TW_STATUS a_twstatus) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twstatus.ConditionCode.ToString()); + csv.Add(a_twstatus.Data.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert a string to a twaindirect... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToTwaindirect(ref TW_TWAINDIRECT a_twtwaindirect, string a_szTwaindirect) + { + // Init stuff... + a_twtwaindirect = default(TW_TWAINDIRECT); + + // Build the string... + try + { + long lTmp; + string[] asz = CSV.Parse(a_szTwaindirect); + + // Sort out the values... + if (!uint.TryParse(asz[0], out a_twtwaindirect.SizeOf)) + { + return (false); + } + if (!ushort.TryParse(asz[1], out a_twtwaindirect.CommunicationManager)) + { + return (false); + } + if (!long.TryParse(asz[2], out lTmp)) + { + return (false); + } + a_twtwaindirect.Send = new IntPtr(lTmp); + if (!uint.TryParse(asz[3], out a_twtwaindirect.SendSize)) + { + return (false); + } + if (!long.TryParse(asz[4], out lTmp)) + { + return (false); + } + a_twtwaindirect.Receive = new IntPtr(lTmp); + if (!uint.TryParse(asz[5], out a_twtwaindirect.ReceiveSize)) + { + return (false); + } + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// Convert the contents of a twaindirect structure to a string that + /// we can show in our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string TwaindirectToCsv(TW_TWAINDIRECT a_twtwaindirect) + { + try + { + CSV csv = new CSV(); + csv.Add(a_twtwaindirect.SizeOf.ToString()); + csv.Add(a_twtwaindirect.CommunicationManager.ToString()); + csv.Add(a_twtwaindirect.Send.ToString()); + csv.Add(a_twtwaindirect.SendSize.ToString()); + csv.Add(a_twtwaindirect.Receive.ToString()); + csv.Add(a_twtwaindirect.ReceiveSize.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a userinterface to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string UserinterfaceToCsv(TW_USERINTERFACE a_twuserinterface) + { + try + { + CSV csv = new CSV(); + csv.Add(CvtCapValueToEnumHelper(a_twuserinterface.ShowUI.ToString())); + csv.Add(CvtCapValueToEnumHelper(a_twuserinterface.ModalUI.ToString())); + csv.Add(a_twuserinterface.hParent.ToString()); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a transfer group to a string that we can show in + /// our simple GUI... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + public static string XfergroupToCsv(UInt32 a_u32Xfergroup) + { + try + { + CSV csv = new CSV(); + csv.Add("0x" + a_u32Xfergroup.ToString("X")); + return (csv.Get()); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return ("***error***"); + } + } + + /// + /// Convert the contents of a string to a transfer group... + /// + /// A TWAIN structure + /// A CSV string of the TWAIN structure + /// True if the conversion is successful + public static bool CsvToXfergroup(ref UInt32 a_u32Xfergroup, string a_szXfergroup) + { + // Init stuff... + a_u32Xfergroup = 0; + + // Build the string... + try + { + string[] asz = CSV.Parse(a_szXfergroup); + + // Grab the values... + a_u32Xfergroup = asz[0].ToLower().StartsWith("0x") ? Convert.ToUInt32(asz[0].Remove(0, 2), 16) : Convert.ToUInt32(asz[0], 16); + } + catch (Exception exception) + { + Log.Error("***error*** - " + exception.Message); + return (false); + } + + // All done... + return (true); + } + + /// + /// This mess is what tries to turn numeric constants into something + /// a bit more readable... + /// + /// type for the conversion + /// value to convert + /// + private static string CvtCapValueToEnumHelper(string a_szValue) + { + T t; + Int32 i32 = 0; + UInt32 u32 = 0; + string szCvt = ""; + + // Adjust our value, as needed... + if (a_szValue.StartsWith(typeof(T).Name + "_")) + { + a_szValue = a_szValue.Substring((typeof(T).Name + "_").Length); + } + + // Handle enums with negative numbers... + if (a_szValue.StartsWith("-")) + { + if (Int32.TryParse(a_szValue, out i32)) + { + t = (T)Enum.Parse(typeof(T), a_szValue, true); + szCvt = t.ToString(); + if (szCvt != i32.ToString()) + { + return (typeof(T).ToString().Replace("TWAINWorkingGroup.TWAIN+", "") + "_" + szCvt); + } + } + } + + // Everybody else... + else if (UInt32.TryParse(a_szValue, out u32)) + { + // Handle bool... + if (typeof(T) == typeof(bool)) + { + if ((a_szValue == "1") || (a_szValue.ToLowerInvariant() == "true")) + { + return ("TRUE"); + } + return ("FALSE"); + } + + // Handle DAT (which is a weird one).. + else if (typeof(T) == typeof(DAT)) + { + UInt32 u32Dg = u32 >> 16; + UInt32 u32Dat = u32 & 0xFFFF; + string szDg = ((DG)u32Dg).ToString(); + string szDat = ((DAT)u32Dat).ToString(); + szDg = (szDg != u32Dg.ToString()) ? ("DG_" + szDg) : string.Format("0x{0:X}", u32Dg); + szDat = (szDat != u32Dat.ToString()) ? ("DAT_" + szDat) : string.Format("0x{0:X}", u32Dat); + return (szDg + "|" + szDat); + } + + // Everybody else is on their own... + else + { + // mono hurls on this, .net doesn't, so gonna help... + switch (a_szValue) + { + default: break; + case "65535": a_szValue = "-1"; break; + case "65534": a_szValue = "-2"; break; + case "65533": a_szValue = "-3"; break; + case "65532": a_szValue = "-4"; break; + } + t = (T)Enum.Parse(typeof(T), a_szValue, true); + } + + // Check to see if we changed anything... + szCvt = t.ToString(); + if (szCvt != u32.ToString()) + { + // CAP is in its final form... + if (typeof(T) == typeof(CAP)) + { + return (szCvt); + } + // Everybody else needs the name decoration removed... + else + { + return (typeof(T).ToString().Replace("TWAINWorkingGroup.TWAIN+", "") + "_" + szCvt); + } + } + + // We're probably a custom value... + else + { + return (string.Format("0x{0:X}", u32)); + } + } + + // We're a string... + return (a_szValue); + } + + /// + /// This mess is what tries to turn readable stuff into numeric constants... + /// + /// type for the conversion + /// value to convert + /// + internal static string CvtCapValueFromEnumHelper(string a_szValue) + { + // We can figure this one out on our own... + if ((typeof(T).Name == "bool") || (typeof(T).Name == "Boolean")) + { + return (((a_szValue.ToLowerInvariant() == "true") || (a_szValue == "1")) ? "1" : "0"); + } + + // Look for the enum prefix... + if (a_szValue.ToLowerInvariant().StartsWith(typeof(T).Name.ToLowerInvariant() + "_")) + { + return (a_szValue.Substring((typeof(T).Name + "_").Length)); + } + + // Er... + return (a_szValue); + } + + /// + /// This mess is what tries to turn readable stuff into numeric constants... + /// + /// type for the conversion + /// value to convert + /// + private static string CvtCapValueFromTwlg(string a_szValue) + { + // mono goes "hork", probably because the enum is wackadoodle, this + // does work on .net, but what'cha gonna do? + if (a_szValue.ToUpperInvariant().StartsWith("TWLG_")) + { + switch (a_szValue.ToUpperInvariant().Substring(5)) + { + default: break; + case "USERLOCALE": return ("65535"); // -1, kinda... + case "DAN": return ("0"); + case "DUT": return ("1"); + case "ENG": return ("2"); + case "FCF": return ("3"); + case "FIN": return ("4"); + case "FRN": return ("5"); + case "GER": return ("6"); + case "ICE": return ("7"); + case "ITN": return ("8"); + case "NOR": return ("9"); + case "POR": return ("10"); + case "SPA": return ("11"); + case "SWE": return ("12"); + case "USA": return ("13"); + case "AFRIKAANS": return ("14"); + case "ALBANIA": return ("15"); + case "ARABIC": return ("16"); + case "ARABIC_ALGERIA": return ("17"); + case "ARABIC_BAHRAIN": return ("18"); + case "ARABIC_EGYPT": return ("19"); + case "ARABIC_IRAQ": return ("20"); + case "ARABIC_JORDAN": return ("21"); + case "ARABIC_KUWAIT": return ("22"); + case "ARABIC_LEBANON": return ("23"); + case "ARABIC_LIBYA": return ("24"); + case "ARABIC_MOROCCO": return ("25"); + case "ARABIC_OMAN": return ("26"); + case "ARABIC_QATAR": return ("27"); + case "ARABIC_SAUDIARABIA": return ("28"); + case "ARABIC_SYRIA": return ("29"); + case "ARABIC_TUNISIA": return ("30"); + case "ARABIC_UAE": return ("31"); + case "ARABIC_YEMEN": return ("32"); + case "BASQUE": return ("33"); + case "BYELORUSSIAN": return ("34"); + case "BULGARIAN": return ("35"); + case "CATALAN": return ("36"); + case "CHINESE": return ("37"); + case "CHINESE_HONGKONG": return ("38"); + case "CHINESE_PRC": return ("39"); + case "CHINESE_SINGAPORE": return ("40"); + case "CHINESE_SIMPLIFIED": return ("41"); + case "CHINESE_TAIWAN": return ("42"); + case "CHINESE_TRADITIONAL": return ("43"); + case "CROATIA": return ("44"); + case "CZECH": return ("45"); + case "DANISH": return (((int)TWLG.DAN).ToString()); + case "DUTCH": return (((int)TWLG.DUT).ToString()); + case "DUTCH_BELGIAN": return ("46"); + case "ENGLISH": return (((int)TWLG.ENG).ToString()); + case "ENGLISH_AUSTRALIAN": return ("47"); + case "ENGLISH_CANADIAN": return ("48"); + case "ENGLISH_IRELAND": return ("49"); + case "ENGLISH_NEWZEALAND": return ("50"); + case "ENGLISH_SOUTHAFRICA": return ("51"); + case "ENGLISH_UK": return ("52"); + case "ENGLISH_USA": return (((int)TWLG.USA).ToString()); + case "ESTONIAN": return ("53"); + case "FAEROESE": return ("54"); + case "FARSI": return ("55"); + case "FINNISH": return (((int)TWLG.FIN).ToString()); + case "FRENCH": return (((int)TWLG.FRN).ToString()); + case "FRENCH_BELGIAN": return ("56"); + case "FRENCH_CANADIAN": return (((int)TWLG.FCF).ToString()); + case "FRENCH_LUXEMBOURG": return ("57"); + case "FRENCH_SWISS": return ("58"); + case "GERMAN": return (((int)TWLG.GER).ToString()); + case "GERMAN_AUSTRIAN": return ("59"); + case "GERMAN_LUXEMBOURG": return ("60"); + case "GERMAN_LIECHTENSTEIN": return ("61"); + case "GERMAN_SWISS": return ("62"); + case "GREEK": return ("63"); + case "HEBREW": return ("64"); + case "HUNGARIAN": return ("65"); + case "ICELANDIC": return (((int)TWLG.ICE).ToString()); + case "INDONESIAN": return ("66"); + case "ITALIAN": return (((int)TWLG.ITN).ToString()); + case "ITALIAN_SWISS": return ("67"); + case "JAPANESE": return ("68"); + case "KOREAN": return ("69"); + case "KOREAN_JOHAB": return ("70"); + case "LATVIAN": return ("71"); + case "LITHUANIAN": return ("72"); + case "NORWEGIAN": return (((int)TWLG.NOR).ToString()); + case "NORWEGIAN_BOKMAL": return ("73"); + case "NORWEGIAN_NYNORSK": return ("74"); + case "POLISH": return ("75"); + case "PORTUGUESE": return (((int)TWLG.POR).ToString()); + case "PORTUGUESE_BRAZIL": return ("76"); + case "ROMANIAN": return ("77"); + case "RUSSIAN": return ("78"); + case "SERBIAN_LATIN": return ("79"); + case "SLOVAK": return ("80"); + case "SLOVENIAN": return ("81"); + case "SPANISH": return (((int)TWLG.SPA).ToString()); + case "SPANISH_MEXICAN": return ("82"); + case "SPANISH_MODERN": return ("83"); + case "SWEDISH": return (((int)TWLG.SWE).ToString()); + case "THAI": return ("84"); + case "TURKISH": return ("85"); + case "UKRANIAN": return ("86"); + case "ASSAMESE": return ("87"); + case "BENGALI": return ("88"); + case "BIHARI": return ("89"); + case "BODO": return ("90"); + case "DOGRI": return ("91"); + case "GUJARATI": return ("92"); + case "HARYANVI": return ("93"); + case "HINDI": return ("94"); + case "KANNADA": return ("95"); + case "KASHMIRI": return ("96"); + case "MALAYALAM": return ("97"); + case "MARATHI": return ("98"); + case "MARWARI": return ("99"); + case "MEGHALAYAN": return ("100"); + case "MIZO": return ("101"); + case "NAGA": return ("102"); + case "ORISSI": return ("103"); + case "PUNJABI": return ("104"); + case "PUSHTU": return ("105"); + case "SERBIAN_CYRILLIC": return ("106"); + case "SIKKIMI": return ("107"); + case "SWEDISH_FINLAND": return ("108"); + case "TAMIL": return ("109"); + case "TELUGU": return ("110"); + case "TRIPURI": return ("111"); + case "URDU": return ("112"); + case "VIETNAMESE": return ("113"); + } + } + + // Er... + return (a_szValue); + } + + /// + /// Convert a value to the 'friendly' name, based on the capability... + /// + /// capability driving the conversion + /// value to convert + /// + public static string CvtCapValueToEnum(CAP a_cap, string a_szValue) + { + switch (a_cap) + { + default: return (a_szValue); + case CAP.ACAP_XFERMECH: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_ALARMS: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_ALARMVOLUME: return (a_szValue); + case CAP.CAP_AUTHOR: return (a_szValue); + case CAP.CAP_AUTOFEED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_AUTOMATICCAPTURE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_AUTOMATICSENSEMEDIUM: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_AUTOSCAN: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_BATTERYMINUTES: return (a_szValue); + case CAP.CAP_BATTERYPERCENTAGE: return (a_szValue); + case CAP.CAP_CAMERAENABLED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_CAMERAORDER: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_CAMERAPREVIEWUI: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_CAMERASIDE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_CAPTION: return (a_szValue); + case CAP.CAP_CLEARPAGE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_CUSTOMDSDATA: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_CUSTOMINTERFACEGUID: return (a_szValue); + case CAP.CAP_DEVICEEVENT: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_DEVICEONLINE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_DEVICETIMEDATE: return (a_szValue); + case CAP.CAP_DOUBLEFEEDDETECTION: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_DOUBLEFEEDDETECTIONLENGTH: return (a_szValue); + case CAP.CAP_DOUBLEFEEDDETECTIONRESPONSE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_DOUBLEFEEDDETECTIONSENSITIVITY: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_DUPLEX: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_DUPLEXENABLED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_ENABLEDSUIONLY: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_ENDORSER: return (a_szValue); + case CAP.CAP_EXTENDEDCAPS: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_FEEDERALIGNMENT: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_FEEDERENABLED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_FEEDERLOADED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_FEEDERORDER: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_FEEDERPOCKET: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_FEEDERPREP: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_FEEDPAGE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_INDICATORS: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_INDICATORSMODE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_JOBCONTROL: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_LANGUAGE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_MAXBATCHBUFFERS: return (a_szValue); + case CAP.CAP_MICRENABLED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_PAPERDETECTABLE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_PAPERHANDLING: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_POWERSAVETIME: return (a_szValue); + case CAP.CAP_POWERSUPPLY: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_PRINTER: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_PRINTERCHARROTATION: return (a_szValue); + case CAP.CAP_PRINTERENABLED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_PRINTERFONTSTYLE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_PRINTERINDEX: return (a_szValue); + case CAP.CAP_PRINTERINDEXLEADCHAR: return (a_szValue); + case CAP.CAP_PRINTERINDEXMAXVALUE: return (a_szValue); + case CAP.CAP_PRINTERINDEXNUMDIGITS: return (a_szValue); + case CAP.CAP_PRINTERINDEXSTEP: return (a_szValue); + case CAP.CAP_PRINTERINDEXTRIGGER: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_PRINTERMODE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_PRINTERSTRING: return (a_szValue); + case CAP.CAP_PRINTERSTRINGPREVIEW: return (a_szValue); + case CAP.CAP_PRINTERSUFFIX: return (a_szValue); + case CAP.CAP_PRINTERVERTICALOFFSET: return (a_szValue); + case CAP.CAP_REACQUIREALLOWED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_REWINDPAGE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_SEGMENTED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_SERIALNUMBER: return (a_szValue); + case CAP.CAP_SHEETCOUNT: return (a_szValue); + case CAP.CAP_SUPPORTEDCAPS: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_SUPPORTEDCAPSSEGMENTUNIQUE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_SUPPORTEDDATS: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_THUMBNAILSENABLED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_TIMEBEFOREFIRSTCAPTURE: return (a_szValue); + case CAP.CAP_TIMEBETWEENCAPTURES: return (a_szValue); + case CAP.CAP_TIMEDATE: return (a_szValue); + case CAP.CAP_UICONTROLLABLE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.CAP_XFERCOUNT: return (a_szValue); + case CAP.ICAP_AUTOBRIGHT: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_AUTODISCARDBLANKPAGES: return (a_szValue); + case CAP.ICAP_AUTOMATICBORDERDETECTION: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICCOLORENABLED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICCOLORNONCOLORPIXELTYPE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICCROPUSESFRAME: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICDESKEW: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICLENGTHDETECTION: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICROTATE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_AUTOSIZE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_BARCODEDETECTIONENABLED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_BARCODEMAXRETRIES: return (a_szValue); + case CAP.ICAP_BARCODEMAXSEARCHPRIORITIES: return (a_szValue); + case CAP.ICAP_BARCODESEARCHMODE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_BARCODESEARCHPRIORITIES: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_BARCODETIMEOUT: return (a_szValue); + case CAP.ICAP_BITDEPTH: return (a_szValue); + case CAP.ICAP_BITDEPTHREDUCTION: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_BITORDER: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_BITORDERCODES: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_BRIGHTNESS: return (a_szValue); + case CAP.ICAP_CCITTKFACTOR: return (a_szValue); + case CAP.ICAP_COLORMANAGEMENTENABLED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_COMPRESSION: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_CONTRAST: return (a_szValue); + case CAP.ICAP_CUSTHALFTONE: return (a_szValue); + case CAP.ICAP_EXPOSURETIME: return (a_szValue); + case CAP.ICAP_EXTIMAGEINFO: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_FEEDERTYPE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_FILMTYPE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_FILTER: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_FLASHUSED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_FLASHUSED2: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_FLIPROTATION: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_FRAMES: return (a_szValue); + case CAP.ICAP_GAMMA: return (a_szValue); + case CAP.ICAP_HALFTONES: return (a_szValue); + case CAP.ICAP_HIGHLIGHT: return (a_szValue); + case CAP.ICAP_ICCPROFILE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_IMAGEDATASET: return (a_szValue); + case CAP.ICAP_IMAGEFILEFORMAT: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_IMAGEFILTER: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_IMAGEMERGE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_IMAGEMERGEHEIGHTTHRESHOLD: return (a_szValue); + case CAP.ICAP_JPEGPIXELTYPE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_JPEGQUALITY: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_JPEGSUBSAMPLING: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_LAMPSTATE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_LIGHTPATH: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_LIGHTSOURCE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_MAXFRAMES: return (a_szValue); + case CAP.ICAP_MINIMUMHEIGHT: return (a_szValue); + case CAP.ICAP_MINIMUMWIDTH: return (a_szValue); + case CAP.ICAP_MIRROR: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_NOISEFILTER: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_ORIENTATION: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_OVERSCAN: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_PATCHCODEDETECTIONENABLED: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_PATCHCODEMAXRETRIES: return (a_szValue); + case CAP.ICAP_PATCHCODEMAXSEARCHPRIORITIES: return (a_szValue); + case CAP.ICAP_PATCHCODESEARCHMODE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_PATCHCODESEARCHPRIORITIES: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_PATCHCODETIMEOUT: return (a_szValue); + case CAP.ICAP_PHYSICALHEIGHT: return (a_szValue); + case CAP.ICAP_PHYSICALWIDTH: return (a_szValue); + case CAP.ICAP_PIXELFLAVOR: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_PIXELFLAVORCODES: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_PIXELTYPE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_PLANARCHUNKY: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_ROTATION: return (a_szValue); + case CAP.ICAP_SHADOW: return (a_szValue); + case CAP.ICAP_SUPPORTEDBARCODETYPES: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_SUPPORTEDEXTIMAGEINFO: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_SUPPORTEDPATCHCODETYPES: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_SUPPORTEDSIZES: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_THRESHOLD: return (a_szValue); + case CAP.ICAP_TILES: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_TIMEFILL: return (a_szValue); + case CAP.ICAP_UNDEFINEDIMAGESIZE: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_UNITS: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_XFERMECH: return (CvtCapValueToEnumHelper(a_szValue)); + case CAP.ICAP_XNATIVERESOLUTION: return (a_szValue); + case CAP.ICAP_XRESOLUTION: return (a_szValue); + case CAP.ICAP_XSCALING: return (a_szValue); + case CAP.ICAP_YNATIVERESOLUTION: return (a_szValue); + case CAP.ICAP_YRESOLUTION: return (a_szValue); + case CAP.ICAP_YSCALING: return (a_szValue); + case CAP.ICAP_ZOOMFACTOR: return (a_szValue); + } + } + + /// + /// Convert a 'friendly' name to a numeric value... + /// + /// capability driving the conversion + /// value to convert + /// + public static string CvtCapValueFromEnum(CAP a_cap, string a_szValue) + { + int ii; + + // Turn hex into a decimal... + if (a_szValue.ToLowerInvariant().StartsWith("0x")) + { + return (int.Parse(a_szValue.Substring(2), NumberStyles.HexNumber).ToString()); + } + + // Skip numbers... + if (int.TryParse(a_szValue, out ii)) + { + return (a_szValue); + } + + // Process text... + switch (a_cap) + { + default: return (a_szValue); + case CAP.ACAP_XFERMECH: { TWSX twsx; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twsx) ? ((int)twsx).ToString() : a_szValue); }; + case CAP.CAP_ALARMS: { TWAL twal; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twal) ? ((int)twal).ToString() : a_szValue); }; + case CAP.CAP_ALARMVOLUME: return (a_szValue); + case CAP.CAP_AUTHOR: return (a_szValue); + case CAP.CAP_AUTOFEED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_AUTOMATICCAPTURE: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_AUTOMATICSENSEMEDIUM: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_AUTOSCAN: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_BATTERYMINUTES: return (a_szValue); + case CAP.CAP_BATTERYPERCENTAGE: return (a_szValue); + case CAP.CAP_CAMERAENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_CAMERAORDER: { TWPT twpt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpt) ? ((int)twpt).ToString() : a_szValue); }; + case CAP.CAP_CAMERAPREVIEWUI: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_CAMERASIDE: { TWCS twcs; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twcs) ? ((int)twcs).ToString() : a_szValue); }; + case CAP.CAP_CAPTION: return (a_szValue); + case CAP.CAP_CLEARPAGE: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_CUSTOMDSDATA: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_CUSTOMINTERFACEGUID: return (a_szValue); + case CAP.CAP_DEVICEEVENT: { TWDE twde; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twde) ? ((int)twde).ToString() : a_szValue); }; + case CAP.CAP_DEVICEONLINE: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_DEVICETIMEDATE: return (a_szValue); + case CAP.CAP_DOUBLEFEEDDETECTION: { TWDF twdf; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twdf) ? ((int)twdf).ToString() : a_szValue); }; + case CAP.CAP_DOUBLEFEEDDETECTIONLENGTH: return (a_szValue); + case CAP.CAP_DOUBLEFEEDDETECTIONRESPONSE: { TWDP twdp; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twdp) ? ((int)twdp).ToString() : a_szValue); }; + case CAP.CAP_DOUBLEFEEDDETECTIONSENSITIVITY: { TWUS twus; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twus) ? ((int)twus).ToString() : a_szValue); }; + case CAP.CAP_DUPLEX: { TWDX twdx; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twdx) ? ((int)twdx).ToString() : a_szValue); }; + case CAP.CAP_DUPLEXENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_ENABLEDSUIONLY: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_ENDORSER: return (a_szValue); + case CAP.CAP_EXTENDEDCAPS: { CAP cap; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out cap) ? ((int)cap).ToString() : a_szValue); }; + case CAP.CAP_FEEDERALIGNMENT: { TWFA twfa; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfa) ? ((int)twfa).ToString() : a_szValue); }; + case CAP.CAP_FEEDERENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_FEEDERLOADED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_FEEDERORDER: { TWFO twfo; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfo) ? ((int)twfo).ToString() : a_szValue); }; + case CAP.CAP_FEEDERPOCKET: { TWFP twfp; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfp) ? ((int)twfp).ToString() : a_szValue); }; + case CAP.CAP_FEEDERPREP: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_FEEDPAGE: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_INDICATORS: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_INDICATORSMODE: { TWCI twci; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twci) ? ((int)twci).ToString() : a_szValue); }; + case CAP.CAP_JOBCONTROL: { TWJC twjc; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twjc) ? ((int)twjc).ToString() : a_szValue); }; + case CAP.CAP_LANGUAGE: return (CvtCapValueFromTwlg(a_szValue)); + case CAP.CAP_MAXBATCHBUFFERS: return (a_szValue); + case CAP.CAP_MICRENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_PAPERDETECTABLE: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_PAPERHANDLING: { TWPH twph; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twph) ? ((int)twph).ToString() : a_szValue); }; + case CAP.CAP_POWERSAVETIME: return (a_szValue); + case CAP.CAP_POWERSUPPLY: { TWPS twps; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twps) ? ((int)twps).ToString() : a_szValue); }; + case CAP.CAP_PRINTER: { TWPR twpr; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpr) ? ((int)twpr).ToString() : a_szValue); }; + case CAP.CAP_PRINTERCHARROTATION: return (a_szValue); + case CAP.CAP_PRINTERENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_PRINTERFONTSTYLE: { TWPF twpf; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpf) ? ((int)twpf).ToString() : a_szValue); }; + case CAP.CAP_PRINTERINDEX: return (a_szValue); + case CAP.CAP_PRINTERINDEXLEADCHAR: return (a_szValue); + case CAP.CAP_PRINTERINDEXMAXVALUE: return (a_szValue); + case CAP.CAP_PRINTERINDEXNUMDIGITS: return (a_szValue); + case CAP.CAP_PRINTERINDEXSTEP: return (a_szValue); + case CAP.CAP_PRINTERINDEXTRIGGER: { TWCT twct; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twct) ? ((int)twct).ToString() : a_szValue); }; + case CAP.CAP_PRINTERMODE: { TWPM twpm; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpm) ? ((int)twpm).ToString() : a_szValue); }; + case CAP.CAP_PRINTERSTRING: return (a_szValue); + case CAP.CAP_PRINTERSTRINGPREVIEW: return (a_szValue); + case CAP.CAP_PRINTERSUFFIX: return (a_szValue); + case CAP.CAP_PRINTERVERTICALOFFSET: return (a_szValue); + case CAP.CAP_REACQUIREALLOWED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_REWINDPAGE: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_SEGMENTED: { TWSG twsg; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twsg) ? ((int)twsg).ToString() : a_szValue); }; + case CAP.CAP_SERIALNUMBER: return (a_szValue); + case CAP.CAP_SHEETCOUNT: return (a_szValue); + case CAP.CAP_SUPPORTEDCAPS: { CAP cap; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out cap) ? ((int)cap).ToString() : a_szValue); }; + case CAP.CAP_SUPPORTEDCAPSSEGMENTUNIQUE: { CAP cap; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out cap) ? ((int)cap).ToString() : a_szValue); }; + case CAP.CAP_SUPPORTEDDATS: { DAT dat; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out dat) ? ((int)dat).ToString() : a_szValue); }; + case CAP.CAP_THUMBNAILSENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_TIMEBEFOREFIRSTCAPTURE: return (a_szValue); + case CAP.CAP_TIMEBETWEENCAPTURES: return (a_szValue); + case CAP.CAP_TIMEDATE: return (a_szValue); + case CAP.CAP_UICONTROLLABLE: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.CAP_XFERCOUNT: return (a_szValue); + case CAP.ICAP_AUTOBRIGHT: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_AUTODISCARDBLANKPAGES: { TWBP twbp; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbp) ? ((int)twbp).ToString() : a_szValue); }; + case CAP.ICAP_AUTOMATICBORDERDETECTION: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICCOLORENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICCOLORNONCOLORPIXELTYPE: { TWPT twpt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpt) ? ((int)twpt).ToString() : a_szValue); }; + case CAP.ICAP_AUTOMATICCROPUSESFRAME: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICDESKEW: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICLENGTHDETECTION: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_AUTOMATICROTATE: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_AUTOSIZE: { TWAS twas; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twas) ? ((int)twas).ToString() : a_szValue); }; + case CAP.ICAP_BARCODEDETECTIONENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_BARCODEMAXRETRIES: return (a_szValue); + case CAP.ICAP_BARCODEMAXSEARCHPRIORITIES: return (a_szValue); + case CAP.ICAP_BARCODESEARCHMODE: { TWBD twbd; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbd) ? ((int)twbd).ToString() : a_szValue); }; + case CAP.ICAP_BARCODESEARCHPRIORITIES: { TWBT twbt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbt) ? ((int)twbt).ToString() : a_szValue); }; + case CAP.ICAP_BARCODETIMEOUT: return (a_szValue); + case CAP.ICAP_BITDEPTH: return (a_szValue); + case CAP.ICAP_BITDEPTHREDUCTION: { TWBR twbr; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbr) ? ((int)twbr).ToString() : a_szValue); }; + case CAP.ICAP_BITORDER: { TWBO twbo; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbo) ? ((int)twbo).ToString() : a_szValue); }; + case CAP.ICAP_BITORDERCODES: { TWBO twbo; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbo) ? ((int)twbo).ToString() : a_szValue); }; + case CAP.ICAP_BRIGHTNESS: return (a_szValue); + case CAP.ICAP_CCITTKFACTOR: return (a_szValue); + case CAP.ICAP_COLORMANAGEMENTENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_COMPRESSION: { TWCP twcp; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twcp) ? ((int)twcp).ToString() : a_szValue); }; + case CAP.ICAP_CONTRAST: return (a_szValue); + case CAP.ICAP_CUSTHALFTONE: return (a_szValue); + case CAP.ICAP_EXPOSURETIME: return (a_szValue); + case CAP.ICAP_EXTIMAGEINFO: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_FEEDERTYPE: { TWFE twfe; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfe) ? ((int)twfe).ToString() : a_szValue); }; + case CAP.ICAP_FILMTYPE: { TWFM twfm; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfm) ? ((int)twfm).ToString() : a_szValue); }; + case CAP.ICAP_FILTER: { TWFT twft; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twft) ? ((int)twft).ToString() : a_szValue); }; + case CAP.ICAP_FLASHUSED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_FLASHUSED2: { TWFL twfl; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfl) ? ((int)twfl).ToString() : a_szValue); }; + case CAP.ICAP_FLIPROTATION: { TWFR twfr; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfr) ? ((int)twfr).ToString() : a_szValue); }; + case CAP.ICAP_FRAMES: return (a_szValue); + case CAP.ICAP_GAMMA: return (a_szValue); + case CAP.ICAP_HALFTONES: return (a_szValue); + case CAP.ICAP_HIGHLIGHT: return (a_szValue); + case CAP.ICAP_ICCPROFILE: { TWIC twic; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twic) ? ((int)twic).ToString() : a_szValue); }; + case CAP.ICAP_IMAGEDATASET: return (a_szValue); + case CAP.ICAP_IMAGEFILEFORMAT: { TWFF twff; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twff) ? ((int)twff).ToString() : a_szValue); }; + case CAP.ICAP_IMAGEFILTER: { TWIF twif; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twif) ? ((int)twif).ToString() : a_szValue); }; + case CAP.ICAP_IMAGEMERGE: { TWIM twim; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twim) ? ((int)twim).ToString() : a_szValue); }; + case CAP.ICAP_IMAGEMERGEHEIGHTTHRESHOLD: return (a_szValue); + case CAP.ICAP_JPEGPIXELTYPE: { TWPT twpt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpt) ? ((int)twpt).ToString() : a_szValue); }; + case CAP.ICAP_JPEGQUALITY: { TWJQ twjq; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twjq) ? ((int)twjq).ToString() : a_szValue); }; + case CAP.ICAP_JPEGSUBSAMPLING: { TWJS twjs; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twjs) ? ((int)twjs).ToString() : a_szValue); }; + case CAP.ICAP_LAMPSTATE: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_LIGHTPATH: { TWLP twlp; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twlp) ? ((int)twlp).ToString() : a_szValue); }; + case CAP.ICAP_LIGHTSOURCE: { TWLS twls; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twls) ? ((int)twls).ToString() : a_szValue); }; + case CAP.ICAP_MAXFRAMES: return (a_szValue); + case CAP.ICAP_MINIMUMHEIGHT: return (a_szValue); + case CAP.ICAP_MINIMUMWIDTH: return (a_szValue); + case CAP.ICAP_MIRROR: { TWMR twmr; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twmr) ? ((int)twmr).ToString() : a_szValue); }; + case CAP.ICAP_NOISEFILTER: { TWNF twnf; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twnf) ? ((int)twnf).ToString() : a_szValue); }; + case CAP.ICAP_ORIENTATION: { TWOR twor; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twor) ? ((int)twor).ToString() : a_szValue); }; + case CAP.ICAP_OVERSCAN: { TWOV twov; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twov) ? ((int)twov).ToString() : a_szValue); }; + case CAP.ICAP_PATCHCODEDETECTIONENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_PATCHCODEMAXRETRIES: return (a_szValue); + case CAP.ICAP_PATCHCODEMAXSEARCHPRIORITIES: return (a_szValue); + case CAP.ICAP_PATCHCODESEARCHMODE: { TWBD twbd; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbd) ? ((int)twbd).ToString() : a_szValue); }; + case CAP.ICAP_PATCHCODESEARCHPRIORITIES: { TWPCH twpch; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpch) ? ((int)twpch).ToString() : a_szValue); }; + case CAP.ICAP_PATCHCODETIMEOUT: return (a_szValue); + case CAP.ICAP_PHYSICALHEIGHT: return (a_szValue); + case CAP.ICAP_PHYSICALWIDTH: return (a_szValue); + case CAP.ICAP_PIXELFLAVOR: { TWPF twpf; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpf) ? ((int)twpf).ToString() : a_szValue); }; + case CAP.ICAP_PIXELFLAVORCODES: { TWPF twpf; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpf) ? ((int)twpf).ToString() : a_szValue); }; + case CAP.ICAP_PIXELTYPE: { TWPT twpt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpt) ? ((int)twpt).ToString() : a_szValue); }; + case CAP.ICAP_PLANARCHUNKY: { TWPC twpc; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpc) ? ((int)twpc).ToString() : a_szValue); }; + case CAP.ICAP_ROTATION: return (a_szValue); + case CAP.ICAP_SHADOW: return (a_szValue); + case CAP.ICAP_SUPPORTEDBARCODETYPES: { TWBT twbt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbt) ? ((int)twbt).ToString() : a_szValue); }; + case CAP.ICAP_SUPPORTEDEXTIMAGEINFO: { TWEI twei; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twei) ? ((int)twei).ToString() : a_szValue); }; + case CAP.ICAP_SUPPORTEDPATCHCODETYPES: { TWPCH twpch; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpch) ? ((int)twpch).ToString() : a_szValue); }; + case CAP.ICAP_SUPPORTEDSIZES: { TWSS twss; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twss) ? ((int)twss).ToString() : a_szValue); }; + case CAP.ICAP_THRESHOLD: return (a_szValue); + case CAP.ICAP_TILES: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_TIMEFILL: return (a_szValue); + case CAP.ICAP_UNDEFINEDIMAGESIZE: return (CvtCapValueFromEnumHelper(a_szValue)); + case CAP.ICAP_UNITS: { TWUN twun; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twun) ? ((int)twun).ToString() : a_szValue); }; + case CAP.ICAP_XFERMECH: { TWSX twsx; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twsx) ? ((int)twsx).ToString() : a_szValue); }; + case CAP.ICAP_XNATIVERESOLUTION: return (a_szValue); + case CAP.ICAP_XRESOLUTION: return (a_szValue); + case CAP.ICAP_XSCALING: return (a_szValue); + case CAP.ICAP_YNATIVERESOLUTION: return (a_szValue); + case CAP.ICAP_YRESOLUTION: return (a_szValue); + case CAP.ICAP_YSCALING: return (a_szValue); + case CAP.ICAP_ZOOMFACTOR: return (a_szValue); + } + } + + } +} diff --git a/NTwain/TWAINWorkingGroup/TWAIN.cs b/NTwain/TWAINWorkingGroup/TWAIN.cs index d465979..40d985e 100644 --- a/NTwain/TWAINWorkingGroup/TWAIN.cs +++ b/NTwain/TWAINWorkingGroup/TWAIN.cs @@ -453,7 +453,7 @@ namespace TWAINWorkingGroup /// public string GetAppIdentity() { - return (IdentityToCsv(m_twidentityApp)); + return (CsvSerializer.IdentityToCsv(m_twidentityApp)); } /// @@ -464,9 +464,9 @@ namespace TWAINWorkingGroup { if (m_state < STATE.S4) { - return (IdentityToCsv(default(TW_IDENTITY))); + return (CsvSerializer.IdentityToCsv(default(TW_IDENTITY))); } - return (IdentityToCsv(m_twidentityDs)); + return (CsvSerializer.IdentityToCsv(m_twidentityDs)); } /// @@ -1098,7 +1098,7 @@ namespace TWAINWorkingGroup { TW_AUDIOINFO twaudioinfo = default(TW_AUDIOINFO); sts = DatAudioinfo((DG)iDg, (MSG)iMsg, ref twaudioinfo); - a_szTwmemref = AudioinfoToCsv(twaudioinfo); + a_szTwmemref = CsvSerializer.AudioinfoToCsv(twaudioinfo); } break; @@ -1115,9 +1115,9 @@ namespace TWAINWorkingGroup case (int)DAT.CALLBACK: { TW_CALLBACK twcallback = default(TW_CALLBACK); - CsvToCallback(ref twcallback, a_szTwmemref); + CsvSerializer.CsvToCallback(ref twcallback, a_szTwmemref); sts = DatCallback((DG)iDg, (MSG)iMsg, ref twcallback); - a_szTwmemref = CallbackToCsv(twcallback); + a_szTwmemref = CsvSerializer.CallbackToCsv(twcallback); } break; @@ -1125,9 +1125,9 @@ namespace TWAINWorkingGroup case (int)DAT.CALLBACK2: { TW_CALLBACK2 twcallback2 = default(TW_CALLBACK2); - CsvToCallback2(ref twcallback2, a_szTwmemref); + CsvSerializer.CsvToCallback2(ref twcallback2, a_szTwmemref); sts = DatCallback2((DG)iDg, (MSG)iMsg, ref twcallback2); - a_szTwmemref = Callback2ToCsv(twcallback2); + a_szTwmemref = CsvSerializer.Callback2ToCsv(twcallback2); } break; @@ -1185,7 +1185,7 @@ namespace TWAINWorkingGroup { TW_DEVICEEVENT twdeviceevent = default(TW_DEVICEEVENT); sts = DatDeviceevent((DG)iDg, (MSG)iMsg, ref twdeviceevent); - a_szTwmemref = DeviceeventToCsv(twdeviceevent); + a_szTwmemref = CsvSerializer.DeviceeventToCsv(twdeviceevent); } break; @@ -1195,7 +1195,7 @@ namespace TWAINWorkingGroup TW_ENTRYPOINT twentrypoint = default(TW_ENTRYPOINT); twentrypoint.Size = (uint)Marshal.SizeOf(twentrypoint); sts = DatEntrypoint((DG)iDg, (MSG)iMsg, ref twentrypoint); - a_szTwmemref = EntrypointToCsv(twentrypoint); + a_szTwmemref = CsvSerializer.EntrypointToCsv(twentrypoint); } break; @@ -1204,7 +1204,7 @@ namespace TWAINWorkingGroup { TW_EVENT twevent = default(TW_EVENT); sts = DatEvent((DG)iDg, (MSG)iMsg, ref twevent); - a_szTwmemref = EventToCsv(twevent); + a_szTwmemref = CsvSerializer.EventToCsv(twevent); } break; @@ -1212,9 +1212,9 @@ namespace TWAINWorkingGroup case (int)DAT.EXTIMAGEINFO: { TW_EXTIMAGEINFO twextimageinfo = default(TW_EXTIMAGEINFO); - CsvToExtimageinfo(ref twextimageinfo, a_szTwmemref); + CsvSerializer.CsvToExtimageinfo(ref twextimageinfo, a_szTwmemref); sts = DatExtimageinfo((DG)iDg, (MSG)iMsg, ref twextimageinfo); - a_szTwmemref = ExtimageinfoToCsv(twextimageinfo); + a_szTwmemref = CsvSerializer.ExtimageinfoToCsv(twextimageinfo); } break; @@ -1222,9 +1222,9 @@ namespace TWAINWorkingGroup case (int)DAT.FILESYSTEM: { TW_FILESYSTEM twfilesystem = default(TW_FILESYSTEM); - CsvToFilesystem(ref twfilesystem, a_szTwmemref); + CsvSerializer.CsvToFilesystem(ref twfilesystem, a_szTwmemref); sts = DatFilesystem((DG)iDg, (MSG)iMsg, ref twfilesystem); - a_szTwmemref = FilesystemToCsv(twfilesystem); + a_szTwmemref = CsvSerializer.FilesystemToCsv(twfilesystem); } break; @@ -1253,7 +1253,7 @@ namespace TWAINWorkingGroup { TW_MEMORY twmemory = default(TW_MEMORY); sts = DatIccprofile((DG)iDg, (MSG)iMsg, ref twmemory); - a_szTwmemref = IccprofileToCsv(twmemory); + a_szTwmemref = CsvSerializer.IccprofileToCsv(twmemory); } break; @@ -1267,11 +1267,11 @@ namespace TWAINWorkingGroup break; case (int)MSG.SET: case (int)MSG.OPENDS: - CsvToIdentity(ref twidentity, a_szTwmemref); + CsvSerializer.CsvToIdentity(ref twidentity, a_szTwmemref); break; } sts = DatIdentity((DG)iDg, (MSG)iMsg, ref twidentity); - a_szTwmemref = IdentityToCsv(twidentity); + a_szTwmemref = CsvSerializer.IdentityToCsv(twidentity); } break; @@ -1287,9 +1287,9 @@ namespace TWAINWorkingGroup case (int)DAT.IMAGEINFO: { TW_IMAGEINFO twimageinfo = default(TW_IMAGEINFO); - CsvToImageinfo(ref twimageinfo, a_szTwmemref); + CsvSerializer.CsvToImageinfo(ref twimageinfo, a_szTwmemref); sts = DatImageinfo((DG)iDg, (MSG)iMsg, ref twimageinfo); - a_szTwmemref = ImageinfoToCsv(twimageinfo); + a_szTwmemref = CsvSerializer.ImageinfoToCsv(twimageinfo); } break; @@ -1297,9 +1297,9 @@ namespace TWAINWorkingGroup case (int)DAT.IMAGELAYOUT: { TW_IMAGELAYOUT twimagelayout = default(TW_IMAGELAYOUT); - CsvToImagelayout(ref twimagelayout, a_szTwmemref); + CsvSerializer.CsvToImagelayout(ref twimagelayout, a_szTwmemref); sts = DatImagelayout((DG)iDg, (MSG)iMsg, ref twimagelayout); - a_szTwmemref = ImagelayoutToCsv(twimagelayout); + a_szTwmemref = CsvSerializer.ImagelayoutToCsv(twimagelayout); } break; @@ -1307,9 +1307,9 @@ namespace TWAINWorkingGroup case (int)DAT.IMAGEMEMFILEXFER: { TW_IMAGEMEMXFER twimagememxfer = default(TW_IMAGEMEMXFER); - CsvToImagememxfer(ref twimagememxfer, a_szTwmemref); + CsvSerializer.CsvToImagememxfer(ref twimagememxfer, a_szTwmemref); sts = DatImagememfilexfer((DG)iDg, (MSG)iMsg, ref twimagememxfer); - a_szTwmemref = ImagememxferToCsv(twimagememxfer); + a_szTwmemref = CsvSerializer.ImagememxferToCsv(twimagememxfer); } break; @@ -1317,9 +1317,9 @@ namespace TWAINWorkingGroup case (int)DAT.IMAGEMEMXFER: { TW_IMAGEMEMXFER twimagememxfer = default(TW_IMAGEMEMXFER); - CsvToImagememxfer(ref twimagememxfer, a_szTwmemref); + CsvSerializer.CsvToImagememxfer(ref twimagememxfer, a_szTwmemref); sts = DatImagememxfer((DG)iDg, (MSG)iMsg, ref twimagememxfer); - a_szTwmemref = ImagememxferToCsv(twimagememxfer); + a_szTwmemref = CsvSerializer.ImagememxferToCsv(twimagememxfer); } break; @@ -1348,7 +1348,7 @@ namespace TWAINWorkingGroup TW_METRICS twmetrics = default(TW_METRICS); twmetrics.SizeOf = (uint)Marshal.SizeOf(twmetrics); sts = DatMetrics((DG)iDg, (MSG)iMsg, ref twmetrics); - a_szTwmemref = MetricsToCsv(twmetrics); + a_szTwmemref = CsvSerializer.MetricsToCsv(twmetrics); } break; @@ -1374,9 +1374,9 @@ namespace TWAINWorkingGroup case (int)DAT.PASSTHRU: { TW_PASSTHRU twpassthru = default(TW_PASSTHRU); - CsvToPassthru(ref twpassthru, a_szTwmemref); + CsvSerializer.CsvToPassthru(ref twpassthru, a_szTwmemref); sts = DatPassthru((DG)iDg, (MSG)iMsg, ref twpassthru); - a_szTwmemref = PassthruToCsv(twpassthru); + a_szTwmemref = CsvSerializer.PassthruToCsv(twpassthru); } break; @@ -1385,7 +1385,7 @@ namespace TWAINWorkingGroup { TW_PENDINGXFERS twpendingxfers = default(TW_PENDINGXFERS); sts = DatPendingxfers((DG)iDg, (MSG)iMsg, ref twpendingxfers); - a_szTwmemref = PendingxfersToCsv(twpendingxfers); + a_szTwmemref = CsvSerializer.PendingxfersToCsv(twpendingxfers); } break; @@ -1403,9 +1403,9 @@ namespace TWAINWorkingGroup case (int)DAT.SETUPFILEXFER: { TW_SETUPFILEXFER twsetupfilexfer = default(TW_SETUPFILEXFER); - CsvToSetupfilexfer(ref twsetupfilexfer, a_szTwmemref); + CsvSerializer.CsvToSetupfilexfer(ref twsetupfilexfer, a_szTwmemref); sts = DatSetupfilexfer((DG)iDg, (MSG)iMsg, ref twsetupfilexfer); - a_szTwmemref = SetupfilexferToCsv(twsetupfilexfer); + a_szTwmemref = CsvSerializer.SetupfilexferToCsv(twsetupfilexfer); } break; @@ -1414,7 +1414,7 @@ namespace TWAINWorkingGroup { TW_SETUPMEMXFER twsetupmemxfer = default(TW_SETUPMEMXFER); sts = DatSetupmemxfer((DG)iDg, (MSG)iMsg, ref twsetupmemxfer); - a_szTwmemref = SetupmemxferToCsv(twsetupmemxfer); + a_szTwmemref = CsvSerializer.SetupmemxferToCsv(twsetupmemxfer); } break; @@ -1423,7 +1423,7 @@ namespace TWAINWorkingGroup { TW_STATUS twstatus = default(TW_STATUS); sts = DatStatus((DG)iDg, (MSG)iMsg, ref twstatus); - a_szTwmemref = StatusToCsv(twstatus); + a_szTwmemref = CsvSerializer.StatusToCsv(twstatus); } break; @@ -1440,9 +1440,9 @@ namespace TWAINWorkingGroup case (int)DAT.TWAINDIRECT: { TW_TWAINDIRECT twtwaindirect = default(TW_TWAINDIRECT); - CsvToTwaindirect(ref twtwaindirect, a_szTwmemref); + CsvSerializer.CsvToTwaindirect(ref twtwaindirect, a_szTwmemref); sts = DatTwaindirect((DG)iDg, (MSG)iMsg, ref twtwaindirect); - a_szTwmemref = TwaindirectToCsv(twtwaindirect); + a_szTwmemref = CsvSerializer.TwaindirectToCsv(twtwaindirect); } break; @@ -1452,7 +1452,7 @@ namespace TWAINWorkingGroup TW_USERINTERFACE twuserinterface = default(TW_USERINTERFACE); CsvToUserinterface(ref twuserinterface, a_szTwmemref); sts = DatUserinterface((DG)iDg, (MSG)iMsg, ref twuserinterface); - a_szTwmemref = UserinterfaceToCsv(twuserinterface); + a_szTwmemref = CsvSerializer.UserinterfaceToCsv(twuserinterface); } break; @@ -1595,136 +1595,6 @@ namespace TWAINWorkingGroup } } - /// - /// Convert the contents of an audio info to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string AudioinfoToCsv(TW_AUDIOINFO a_twaudioinfo) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twaudioinfo.Name.Get()); - csv.Add(a_twaudioinfo.Reserved.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a callback to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string CallbackToCsv(TW_CALLBACK a_twcallback) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twcallback.CallBackProc.ToString()); - csv.Add(a_twcallback.RefCon.ToString()); - csv.Add(a_twcallback.Message.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to an callback structure... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToCallback(ref TW_CALLBACK a_twcallback, string a_szCallback) - { - // Init stuff... - a_twcallback = default(TW_CALLBACK); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szCallback); - - // Grab the values... - a_twcallback.CallBackProc = (IntPtr)UInt64.Parse(asz[0]); - a_twcallback.RefCon = uint.Parse(asz[1]); - a_twcallback.Message = ushort.Parse(asz[2]); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of a callback2 to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string Callback2ToCsv(TW_CALLBACK2 a_twcallback2) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twcallback2.CallBackProc.ToString()); - csv.Add(a_twcallback2.RefCon.ToString()); - csv.Add(a_twcallback2.Message.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to an callback2 structure... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToCallback2(ref TW_CALLBACK2 a_twcallback2, string a_szCallback2) - { - // Init stuff... - a_twcallback2 = default(TW_CALLBACK2); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szCallback2); - - // Grab the values... - a_twcallback2.CallBackProc = (IntPtr)UInt64.Parse(asz[0]); - a_twcallback2.RefCon = (UIntPtr)UInt64.Parse(asz[1]); - a_twcallback2.Message = ushort.Parse(asz[2]); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - /// /// Convert the contents of a capability to a string that we can show in /// our simple GUI.... @@ -1783,7 +1653,7 @@ namespace TWAINWorkingGroup for (uu = 0; uu < NumItems; uu++) { string szItem = GetIndexedItem(a_twcapability, ItemType, intptr, (int)uu); - szValue = CvtCapValueToEnum(a_twcapability.Cap, szItem); + szValue = CsvSerializer.CvtCapValueToEnum(a_twcapability.Cap, szItem); csvArray.Add(szValue); } } @@ -1871,7 +1741,7 @@ namespace TWAINWorkingGroup for (uu = 0; uu < NumItems; uu++) { string szItem = GetIndexedItem(a_twcapability, ItemType, intptr, (int)uu); - szValue = CvtCapValueToEnum(a_twcapability.Cap, szItem); + szValue = CsvSerializer.CvtCapValueToEnum(a_twcapability.Cap, szItem); csvEnum.Add(szValue); } } @@ -1920,7 +1790,7 @@ namespace TWAINWorkingGroup { string szValue; string szItem = GetIndexedItem(a_twcapability, ItemType, intptr, 0); - szValue = CvtCapValueToEnum(a_twcapability.Cap, szItem); + szValue = CsvSerializer.CvtCapValueToEnum(a_twcapability.Cap, szItem); csvOnevalue.Add(szValue); } else @@ -2470,873 +2340,6 @@ namespace TWAINWorkingGroup return (true); } - /// - /// Convert the contents of a device event to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string DeviceeventToCsv(TW_DEVICEEVENT a_twdeviceevent) - { - try - { - CSV csv = new CSV(); - csv.Add(((TWDE)a_twdeviceevent.Event).ToString()); - csv.Add(a_twdeviceevent.DeviceName.Get()); - csv.Add(a_twdeviceevent.BatteryMinutes.ToString()); - csv.Add(a_twdeviceevent.BatteryPercentage.ToString()); - csv.Add(a_twdeviceevent.PowerSupply.ToString()); - csv.Add(((double)a_twdeviceevent.XResolution.Whole + ((double)a_twdeviceevent.XResolution.Frac / 65536.0)).ToString()); - csv.Add(((double)a_twdeviceevent.YResolution.Whole + ((double)a_twdeviceevent.YResolution.Frac / 65536.0)).ToString()); - csv.Add(a_twdeviceevent.FlashUsed2.ToString()); - csv.Add(a_twdeviceevent.AutomaticCapture.ToString()); - csv.Add(a_twdeviceevent.TimeBeforeFirstCapture.ToString()); - csv.Add(a_twdeviceevent.TimeBetweenCaptures.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of an entry point to a string that - /// we can show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string EntrypointToCsv(TW_ENTRYPOINT a_twentrypoint) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twentrypoint.Size.ToString()); - csv.Add("0x" + ((a_twentrypoint.DSM_Entry == null)?"0":a_twentrypoint.DSM_Entry.ToString("X"))); - csv.Add("0x" + ((a_twentrypoint.DSM_MemAllocate == null) ? "0" : a_twentrypoint.DSM_MemAllocate.ToString("X"))); - csv.Add("0x" + ((a_twentrypoint.DSM_MemFree == null) ? "0" : a_twentrypoint.DSM_MemFree.ToString("X"))); - csv.Add("0x" + ((a_twentrypoint.DSM_MemLock == null) ? "0" : a_twentrypoint.DSM_MemLock.ToString("X"))); - csv.Add("0x" + ((a_twentrypoint.DSM_MemUnlock == null) ? "0" : a_twentrypoint.DSM_MemUnlock.ToString("X"))); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of an event to a string that - /// we can show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string EventToCsv(TW_EVENT a_twevent) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twevent.pEvent.ToString()); - csv.Add(a_twevent.TWMessage.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of an extimageinfo to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string ExtimageinfoToCsv(TW_EXTIMAGEINFO a_twextimageinfo) - { - try - { - uint uTwinfo = 0; - CSV csv = new CSV(); - csv.Add(a_twextimageinfo.NumInfos.ToString()); - for (int ii = 0; (ii < a_twextimageinfo.NumInfos) && (ii < 200); ii++) - { - TWEI twei; - TWTY twty; - STS sts; - TW_INFO twinfo = default(TW_INFO); - a_twextimageinfo.Get(uTwinfo, ref twinfo); - twei = (TWEI)twinfo.InfoId; - if (twei.ToString() != twinfo.InfoId.ToString()) - { - csv.Add("TWEI_" + twei.ToString()); - } - else - { - csv.Add(string.Format("0x{0:X}", twinfo.InfoId)); - } - twty = (TWTY)twinfo.ItemType; - if (twty.ToString() != twinfo.ItemType.ToString()) - { - csv.Add("TWTY_" + twty.ToString()); - } - else - { - csv.Add(string.Format("0x{0:X}", twinfo.ItemType)); - } - csv.Add(twinfo.NumItems.ToString()); - sts = (STS)twinfo.ReturnCode; - if (sts.ToString() != twinfo.ReturnCode.ToString()) - { - csv.Add("TWRC_" + sts.ToString()); - } - else - { - csv.Add(string.Format("0x{0:X}", twinfo.ReturnCode)); - } - csv.Add(twinfo.ReturnCode.ToString()); - csv.Add(twinfo.Item.ToString()); - uTwinfo += 1; - } - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to an extimageinfo structure, - /// note that we don't have to worry about containers going in this - /// direction... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToExtimageinfo(ref TW_EXTIMAGEINFO a_twextimageinfo, string a_szExtimageinfo) - { - // Init stuff... - a_twextimageinfo = default(TW_EXTIMAGEINFO); - - // Build the string... - try - { - int iField; - uint uTwinfo; - string[] asz = CSV.Parse(a_szExtimageinfo); - - // Set the number of entries (this is the easy bit)... - uint.TryParse(asz[0], out a_twextimageinfo.NumInfos); - if (a_twextimageinfo.NumInfos > 200) - { - Log.Error("***error*** - we're limited to 200 entries, if this is a problem, just add more, and fix this code..."); - return (false); - } - - // Okay, walk all the entries in steps of TW_INFO... - uTwinfo = 0; - for (iField = 1; iField < asz.Length; iField += 5) - { - UInt64 u64; - TWEI twei; - TW_INFO twinfo = default(TW_INFO); - if ((iField + 5) > asz.Length) - { - Log.Error("***error*** - badly constructed list, should be: num,(twinfo),(twinfo)..."); - return (false); - } - if (TWEI.TryParse(asz[iField + 0].Replace("TWEI_", ""), out twei)) - { - twinfo.InfoId = (ushort)twei; - } - else - { - if (asz[iField + 0].ToLowerInvariant().StartsWith("0x")) - { - ushort.TryParse(asz[iField + 0].Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out twinfo.InfoId); - } - else - { - ushort.TryParse(asz[iField + 0], out twinfo.InfoId); - } - } - // We really don't care about these... - ushort.TryParse(asz[iField + 1], out twinfo.ItemType); - ushort.TryParse(asz[iField + 2], out twinfo.NumItems); - ushort.TryParse(asz[iField + 3], out twinfo.ReturnCode); - UInt64.TryParse(asz[iField + 4], out u64); - twinfo.Item = (UIntPtr)u64; - a_twextimageinfo.Set(uTwinfo, ref twinfo); - uTwinfo += 1; - } - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of a filesystem to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string FilesystemToCsv(TW_FILESYSTEM a_twfilesystem) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twfilesystem.InputName.Get()); - csv.Add(a_twfilesystem.OutputName.Get()); - csv.Add(a_twfilesystem.Context.ToString()); - csv.Add(a_twfilesystem.Recursive.ToString()); - csv.Add(a_twfilesystem.FileType.ToString()); - csv.Add(a_twfilesystem.Size.ToString()); - csv.Add(a_twfilesystem.CreateTimeDate.Get()); - csv.Add(a_twfilesystem.ModifiedTimeDate.Get()); - csv.Add(a_twfilesystem.FreeSpace.ToString()); - csv.Add(a_twfilesystem.NewImageSize.ToString()); - csv.Add(a_twfilesystem.NumberOfFiles.ToString()); - csv.Add(a_twfilesystem.NumberOfSnippets.ToString()); - csv.Add(a_twfilesystem.DeviceGroupMask.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to a filesystem structure... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToFilesystem(ref TW_FILESYSTEM a_twfilesystem, string a_szFilesystem) - { - // Init stuff... - a_twfilesystem = default(TW_FILESYSTEM); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szFilesystem); - - // Grab the values... - a_twfilesystem.InputName.Set(asz[0]); - a_twfilesystem.OutputName.Set(asz[1]); - a_twfilesystem.Context = (IntPtr)UInt64.Parse(asz[2]); - a_twfilesystem.Recursive = int.Parse(asz[3]); - a_twfilesystem.FileType = int.Parse(asz[4]); - a_twfilesystem.Size = uint.Parse(asz[5]); - a_twfilesystem.CreateTimeDate.Set(asz[6]); - a_twfilesystem.ModifiedTimeDate.Set(asz[7]); - a_twfilesystem.FreeSpace = (uint)UInt64.Parse(asz[8]); - a_twfilesystem.NewImageSize = (uint)UInt64.Parse(asz[9]); - a_twfilesystem.NumberOfFiles = (uint)UInt64.Parse(asz[10]); - a_twfilesystem.NumberOfSnippets = (uint)UInt64.Parse(asz[11]); - a_twfilesystem.DeviceGroupMask = (uint)UInt64.Parse(asz[12]); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of an iccprofile to a string that we can - /// show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string IccprofileToCsv(TW_MEMORY a_twmemory) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twmemory.Flags.ToString()); - csv.Add(a_twmemory.Length.ToString()); - csv.Add(a_twmemory.TheMem.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of an identity to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string IdentityToCsv(TW_IDENTITY a_twidentity) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twidentity.Id.ToString()); - csv.Add(a_twidentity.Version.MajorNum.ToString()); - csv.Add(a_twidentity.Version.MinorNum.ToString()); - csv.Add(a_twidentity.Version.Language.ToString()); - csv.Add(a_twidentity.Version.Country.ToString()); - csv.Add(a_twidentity.Version.Info.Get()); - csv.Add(a_twidentity.ProtocolMajor.ToString()); - csv.Add(a_twidentity.ProtocolMinor.ToString()); - csv.Add("0x" + a_twidentity.SupportedGroups.ToString("X")); - csv.Add(a_twidentity.Manufacturer.Get()); - csv.Add(a_twidentity.ProductFamily.Get()); - csv.Add(a_twidentity.ProductName.Get()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to an identity structure... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToIdentity(ref TW_IDENTITY a_twidentity, string a_szIdentity) - { - // Init stuff... - a_twidentity = default(TW_IDENTITY); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szIdentity); - - // Grab the values... - a_twidentity.Id = ulong.Parse(asz[0]); - a_twidentity.Version.MajorNum = ushort.Parse(asz[1]); - a_twidentity.Version.MinorNum = ushort.Parse(asz[2]); - if (asz[3] != "0") a_twidentity.Version.Language = (TWLG)Enum.Parse(typeof(TWLG), asz[3]); - if (asz[4] != "0") a_twidentity.Version.Country = (TWCY)Enum.Parse(typeof(TWCY), asz[4]); - a_twidentity.Version.Info.Set(asz[5]); - a_twidentity.ProtocolMajor = ushort.Parse(asz[6]); - a_twidentity.ProtocolMinor = ushort.Parse(asz[7]); - a_twidentity.SupportedGroups = asz[8].ToLower().StartsWith("0x") ? Convert.ToUInt32(asz[8].Remove(0, 2), 16) : Convert.ToUInt32(asz[8], 16); - a_twidentity.Manufacturer.Set(asz[9]); - a_twidentity.ProductFamily.Set(asz[10]); - a_twidentity.ProductName.Set(asz[11]); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of a image info to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string ImageinfoToCsv(TW_IMAGEINFO a_twimageinfo) - { - try - { - CSV csv = new CSV(); - csv.Add(((double)a_twimageinfo.XResolution.Whole + ((double)a_twimageinfo.XResolution.Frac / 65536.0)).ToString()); - csv.Add(((double)a_twimageinfo.YResolution.Whole + ((double)a_twimageinfo.YResolution.Frac / 65536.0)).ToString()); - csv.Add(a_twimageinfo.ImageWidth.ToString()); - csv.Add(a_twimageinfo.ImageLength.ToString()); - csv.Add(a_twimageinfo.SamplesPerPixel.ToString()); - csv.Add(a_twimageinfo.BitsPerSample_0.ToString()); - csv.Add(a_twimageinfo.BitsPerSample_1.ToString()); - csv.Add(a_twimageinfo.BitsPerSample_2.ToString()); - csv.Add(a_twimageinfo.BitsPerSample_3.ToString()); - csv.Add(a_twimageinfo.BitsPerSample_4.ToString()); - csv.Add(a_twimageinfo.BitsPerSample_5.ToString()); - csv.Add(a_twimageinfo.BitsPerSample_6.ToString()); - csv.Add(a_twimageinfo.BitsPerSample_7.ToString()); - csv.Add(a_twimageinfo.Planar.ToString()); - csv.Add("TWPT_" + (TWPT)a_twimageinfo.PixelType); - csv.Add("TWCP_" + (TWCP)a_twimageinfo.Compression); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to an callback structure... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToImageinfo(ref TW_IMAGEINFO a_twimageinfo, string a_szImageinfo) - { - // Init stuff... - a_twimageinfo = default(TW_IMAGEINFO); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szImageinfo); - - // Grab the values... - a_twimageinfo.XResolution.Whole = (short)double.Parse(asz[0]); - a_twimageinfo.XResolution.Frac = (ushort)((double.Parse(asz[0]) - (double)a_twimageinfo.XResolution.Whole) * 65536.0); - a_twimageinfo.YResolution.Whole = (short)double.Parse(asz[1]); - a_twimageinfo.YResolution.Frac = (ushort)((double.Parse(asz[1]) - (double)a_twimageinfo.YResolution.Whole) * 65536.0); - a_twimageinfo.ImageWidth = (short)double.Parse(asz[2]); - a_twimageinfo.ImageLength = int.Parse(asz[3]); - a_twimageinfo.SamplesPerPixel = short.Parse(asz[4]); - a_twimageinfo.BitsPerSample_0 = short.Parse(asz[5]); - a_twimageinfo.BitsPerSample_1 = short.Parse(asz[6]); - a_twimageinfo.BitsPerSample_2 = short.Parse(asz[7]); - a_twimageinfo.BitsPerSample_3 = short.Parse(asz[8]); - a_twimageinfo.BitsPerSample_4 = short.Parse(asz[9]); - a_twimageinfo.BitsPerSample_5 = short.Parse(asz[10]); - a_twimageinfo.BitsPerSample_6 = short.Parse(asz[11]); - a_twimageinfo.BitsPerSample_7 = short.Parse(asz[12]); - a_twimageinfo.Planar = ushort.Parse(CvtCapValueFromEnum(CAP.ICAP_PLANARCHUNKY, asz[13])); - a_twimageinfo.PixelType = (TWPT)ushort.Parse(CvtCapValueFromEnum(CAP.ICAP_PIXELTYPE, asz[14])); - a_twimageinfo.Compression = (TWCP)ushort.Parse(CvtCapValueFromEnum(CAP.ICAP_COMPRESSION, asz[15])); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of a image layout to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string ImagelayoutToCsv(TW_IMAGELAYOUT a_twimagelayout) - { - try - { - CSV csv = new CSV(); - csv.Add(((double)a_twimagelayout.Frame.Left.Whole + ((double)a_twimagelayout.Frame.Left.Frac / 65536.0)).ToString()); - csv.Add(((double)a_twimagelayout.Frame.Top.Whole + ((double)a_twimagelayout.Frame.Top.Frac / 65536.0)).ToString()); - csv.Add(((double)a_twimagelayout.Frame.Right.Whole + ((double)a_twimagelayout.Frame.Right.Frac / 65536.0)).ToString()); - csv.Add(((double)a_twimagelayout.Frame.Bottom.Whole + ((double)a_twimagelayout.Frame.Bottom.Frac / 65536.0)).ToString()); - csv.Add(a_twimagelayout.DocumentNumber.ToString()); - csv.Add(a_twimagelayout.PageNumber.ToString()); - csv.Add(a_twimagelayout.FrameNumber.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to an image layout structure... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToImagelayout(ref TW_IMAGELAYOUT a_twimagelayout, string a_szImagelayout) - { - // Init stuff... - a_twimagelayout = default(TW_IMAGELAYOUT); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szImagelayout); - - // Sort out the frame... - a_twimagelayout.Frame.Left.Whole = (short)double.Parse(asz[0]); - a_twimagelayout.Frame.Left.Frac = (ushort)((double.Parse(asz[0]) - (double)a_twimagelayout.Frame.Left.Whole) * 65536.0); - a_twimagelayout.Frame.Top.Whole = (short)double.Parse(asz[1]); - a_twimagelayout.Frame.Top.Frac = (ushort)((double.Parse(asz[1]) - (double)a_twimagelayout.Frame.Top.Whole) * 65536.0); - a_twimagelayout.Frame.Right.Whole = (short)double.Parse(asz[2]); - a_twimagelayout.Frame.Right.Frac = (ushort)((double.Parse(asz[2]) - (double)a_twimagelayout.Frame.Right.Whole) * 65536.0); - a_twimagelayout.Frame.Bottom.Whole = (short)double.Parse(asz[3]); - a_twimagelayout.Frame.Bottom.Frac = (ushort)((double.Parse(asz[3]) - (double)a_twimagelayout.Frame.Bottom.Whole) * 65536.0); - - // And now the counters... - a_twimagelayout.DocumentNumber = (uint)int.Parse(asz[4]); - a_twimagelayout.PageNumber = (uint)int.Parse(asz[5]); - a_twimagelayout.FrameNumber = (uint)int.Parse(asz[6]); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of an image mem xfer structure to a string that - /// we can show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string ImagememxferToCsv(TW_IMAGEMEMXFER a_twimagememxfer) - { - try - { - CSV csv = new CSV(); - csv.Add("TWCP_" + (TWCP)a_twimagememxfer.Compression); - csv.Add(a_twimagememxfer.BytesPerRow.ToString()); - csv.Add(a_twimagememxfer.Columns.ToString()); - csv.Add(a_twimagememxfer.Rows.ToString()); - csv.Add(a_twimagememxfer.XOffset.ToString()); - csv.Add(a_twimagememxfer.YOffset.ToString()); - csv.Add(a_twimagememxfer.BytesWritten.ToString()); - csv.Add(a_twimagememxfer.Memory.Flags.ToString()); - csv.Add(a_twimagememxfer.Memory.Length.ToString()); - csv.Add(a_twimagememxfer.Memory.TheMem.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to an image mem xfer structure... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToImagememxfer(ref TW_IMAGEMEMXFER a_twimagememxfer, string a_szImagememxfer) - { - // Init stuff... - a_twimagememxfer = default(TW_IMAGEMEMXFER); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szImagememxfer); - - // Sort out the structure... - a_twimagememxfer.Compression = ushort.Parse(CvtCapValueFromEnum(CAP.ICAP_COMPRESSION, asz[0])); - a_twimagememxfer.BytesPerRow = uint.Parse(asz[1]); - a_twimagememxfer.Columns = uint.Parse(asz[2]); - a_twimagememxfer.Rows = uint.Parse(asz[3]); - a_twimagememxfer.XOffset = uint.Parse(asz[4]); - a_twimagememxfer.YOffset = uint.Parse(asz[5]); - a_twimagememxfer.BytesWritten = uint.Parse(asz[6]); - a_twimagememxfer.Memory.Flags = ushort.Parse(asz[7]); - a_twimagememxfer.Memory.Length = uint.Parse(asz[8]); - a_twimagememxfer.Memory.TheMem = (IntPtr)ulong.Parse(asz[9]); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of a metrics structure to a string that - /// we can show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string MetricsToCsv(TW_METRICS a_twmetrics) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twmetrics.SizeOf.ToString()); - csv.Add(a_twmetrics.ImageCount.ToString()); - csv.Add(a_twmetrics.SheetCount.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a patthru structure to a string that - /// we can show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string PassthruToCsv(TW_PASSTHRU a_twpassthru) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twpassthru.pCommand.ToString()); - csv.Add(a_twpassthru.CommandBytes.ToString()); - csv.Add(a_twpassthru.Direction.ToString()); - csv.Add(a_twpassthru.pData.ToString()); - csv.Add(a_twpassthru.DataBytes.ToString()); - csv.Add(a_twpassthru.DataBytesXfered.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to a passthru structure... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToPassthru(ref TW_PASSTHRU a_twpassthru, string a_szPassthru) - { - // Init stuff... - a_twpassthru = default(TW_PASSTHRU); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szPassthru); - - // Sort out the frame... - a_twpassthru.pCommand = (IntPtr)UInt64.Parse(asz[0]); - a_twpassthru.CommandBytes = uint.Parse(asz[1]); - a_twpassthru.Direction = int.Parse(asz[2]); - a_twpassthru.pData = (IntPtr)UInt64.Parse(asz[3]); - a_twpassthru.DataBytes = uint.Parse(asz[4]); - a_twpassthru.DataBytesXfered = uint.Parse(asz[5]); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of a pending xfers structure to a string that - /// we can show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string PendingxfersToCsv(TW_PENDINGXFERS a_twpendingxfers) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twpendingxfers.Count.ToString()); - csv.Add(a_twpendingxfers.EOJ.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to a pendingxfers structure... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToPendingXfers(ref TW_PENDINGXFERS a_twpendingxfers, string a_szPendingxfers) - { - // Init stuff... - a_twpendingxfers = default(TW_PENDINGXFERS); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szPendingxfers); - - // Sort out the frame... - a_twpendingxfers.Count = ushort.Parse(asz[0]); - a_twpendingxfers.EOJ = uint.Parse(asz[1]); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of a setup file xfer structure to a string that - /// we can show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string SetupfilexferToCsv(TW_SETUPFILEXFER a_twsetupfilexfer) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twsetupfilexfer.FileName.Get()); - csv.Add("TWFF_" + a_twsetupfilexfer.Format); - csv.Add(a_twsetupfilexfer.VRefNum.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert a string to a setupfilexfer... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToSetupfilexfer(ref TW_SETUPFILEXFER a_twsetupfilexfer, string a_szSetupfilexfer) - { - // Init stuff... - a_twsetupfilexfer = default(TW_SETUPFILEXFER); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szSetupfilexfer); - - // Sort out the values... - a_twsetupfilexfer.FileName.Set(asz[0]); - a_twsetupfilexfer.Format = (TWFF)ushort.Parse(CvtCapValueFromEnum(CAP.ICAP_IMAGEFILEFORMAT, asz[1])); - a_twsetupfilexfer.VRefNum = short.Parse(asz[2]); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of a setup mem xfer structure to a string that - /// we can show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string SetupmemxferToCsv(TW_SETUPMEMXFER a_twsetupmemxfer) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twsetupmemxfer.MinBufSize.ToString()); - csv.Add(a_twsetupmemxfer.MaxBufSize.ToString()); - csv.Add(a_twsetupmemxfer.Preferred.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert a string to a setupmemxfer... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToSetupmemxfer(ref TW_SETUPMEMXFER a_twsetupmemxfer, string a_szSetupmemxfer) - { - // Init stuff... - a_twsetupmemxfer = default(TW_SETUPMEMXFER); - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szSetupmemxfer); - - // Sort out the values... - a_twsetupmemxfer.MinBufSize = uint.Parse(asz[0]); - a_twsetupmemxfer.MaxBufSize = uint.Parse(asz[1]); - a_twsetupmemxfer.Preferred = uint.Parse(asz[2]); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of a status structure to a string that - /// we can show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string StatusToCsv(TW_STATUS a_twstatus) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twstatus.ConditionCode.ToString()); - csv.Add(a_twstatus.Data.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - /// /// Convert the contents of a statusutf8 structure to a string that /// we can show in our simple GUI... @@ -3362,110 +2365,6 @@ namespace TWAINWorkingGroup } } - /// - /// Convert a string to a twaindirect... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToTwaindirect(ref TW_TWAINDIRECT a_twtwaindirect, string a_szTwaindirect) - { - // Init stuff... - a_twtwaindirect = default(TW_TWAINDIRECT); - - // Build the string... - try - { - long lTmp; - string[] asz = CSV.Parse(a_szTwaindirect); - - // Sort out the values... - if (!uint.TryParse(asz[0], out a_twtwaindirect.SizeOf)) - { - return (false); - } - if (!ushort.TryParse(asz[1], out a_twtwaindirect.CommunicationManager)) - { - return (false); - } - if (!long.TryParse(asz[2], out lTmp)) - { - return (false); - } - a_twtwaindirect.Send = new IntPtr(lTmp); - if (!uint.TryParse(asz[3], out a_twtwaindirect.SendSize)) - { - return (false); - } - if (!long.TryParse(asz[4], out lTmp)) - { - return (false); - } - a_twtwaindirect.Receive = new IntPtr(lTmp); - if (!uint.TryParse(asz[5], out a_twtwaindirect.ReceiveSize)) - { - return (false); - } - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// Convert the contents of a twaindirect structure to a string that - /// we can show in our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string TwaindirectToCsv(TW_TWAINDIRECT a_twtwaindirect) - { - try - { - CSV csv = new CSV(); - csv.Add(a_twtwaindirect.SizeOf.ToString()); - csv.Add(a_twtwaindirect.CommunicationManager.ToString()); - csv.Add(a_twtwaindirect.Send.ToString()); - csv.Add(a_twtwaindirect.SendSize.ToString()); - csv.Add(a_twtwaindirect.Receive.ToString()); - csv.Add(a_twtwaindirect.ReceiveSize.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a userinterface to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string UserinterfaceToCsv(TW_USERINTERFACE a_twuserinterface) - { - try - { - CSV csv = new CSV(); - csv.Add(CvtCapValueToEnumHelper(a_twuserinterface.ShowUI.ToString())); - csv.Add(CvtCapValueToEnumHelper(a_twuserinterface.ModalUI.ToString())); - csv.Add(a_twuserinterface.hParent.ToString()); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - /// /// Convert a string to a userinterface... /// @@ -3488,8 +2387,8 @@ namespace TWAINWorkingGroup a_twuserinterface.hParent = IntPtr.Zero; // Sort out the values... - ushort.TryParse(CvtCapValueFromEnumHelper(asz[0]), out a_twuserinterface.ShowUI); - ushort.TryParse(CvtCapValueFromEnumHelper(asz[1]), out a_twuserinterface.ModalUI); + ushort.TryParse(CsvSerializer.CvtCapValueFromEnumHelper(asz[0]), out a_twuserinterface.ShowUI); + ushort.TryParse(CsvSerializer.CvtCapValueFromEnumHelper(asz[1]), out a_twuserinterface.ModalUI); // Really shouldn't have this test, but I'll probably break things if I remove it... if (asz.Length >= 3) @@ -3518,703 +2417,6 @@ namespace TWAINWorkingGroup return (true); } - /// - /// Convert the contents of a transfer group to a string that we can show in - /// our simple GUI... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - public static string XfergroupToCsv(UInt32 a_u32Xfergroup) - { - try - { - CSV csv = new CSV(); - csv.Add("0x" + a_u32Xfergroup.ToString("X")); - return (csv.Get()); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return ("***error***"); - } - } - - /// - /// Convert the contents of a string to a transfer group... - /// - /// A TWAIN structure - /// A CSV string of the TWAIN structure - /// True if the conversion is successful - public static bool CsvToXfergroup(ref UInt32 a_u32Xfergroup, string a_szXfergroup) - { - // Init stuff... - a_u32Xfergroup = 0; - - // Build the string... - try - { - string[] asz = CSV.Parse(a_szXfergroup); - - // Grab the values... - a_u32Xfergroup = asz[0].ToLower().StartsWith("0x") ? Convert.ToUInt32(asz[0].Remove(0, 2), 16) : Convert.ToUInt32(asz[0], 16); - } - catch (Exception exception) - { - Log.Error("***error*** - " + exception.Message); - return (false); - } - - // All done... - return (true); - } - - /// - /// This mess is what tries to turn numeric constants into something - /// a bit more readable... - /// - /// type for the conversion - /// value to convert - /// - private static string CvtCapValueToEnumHelper(string a_szValue) - { - T t; - Int32 i32 = 0; - UInt32 u32 = 0; - string szCvt = ""; - - // Adjust our value, as needed... - if (a_szValue.StartsWith(typeof(T).Name + "_")) - { - a_szValue = a_szValue.Substring((typeof(T).Name + "_").Length); - } - - // Handle enums with negative numbers... - if (a_szValue.StartsWith("-")) - { - if (Int32.TryParse(a_szValue, out i32)) - { - t = (T)Enum.Parse(typeof(T), a_szValue, true); - szCvt = t.ToString(); - if (szCvt != i32.ToString()) - { - return (typeof(T).ToString().Replace("TWAINWorkingGroup.TWAIN+", "") + "_" + szCvt); - } - } - } - - // Everybody else... - else if (UInt32.TryParse(a_szValue, out u32)) - { - // Handle bool... - if (typeof(T) == typeof(bool)) - { - if ((a_szValue == "1") || (a_szValue.ToLowerInvariant() == "true")) - { - return ("TRUE"); - } - return ("FALSE"); - } - - // Handle DAT (which is a weird one).. - else if (typeof(T) == typeof(DAT)) - { - UInt32 u32Dg = u32 >> 16; - UInt32 u32Dat = u32 & 0xFFFF; - string szDg = ((DG)u32Dg).ToString(); - string szDat = ((DAT)u32Dat).ToString(); - szDg = (szDg != u32Dg.ToString()) ? ("DG_" + szDg) : string.Format("0x{0:X}", u32Dg); - szDat = (szDat != u32Dat.ToString()) ? ("DAT_" + szDat) : string.Format("0x{0:X}", u32Dat); - return (szDg + "|" + szDat); - } - - // Everybody else is on their own... - else - { - // mono hurls on this, .net doesn't, so gonna help... - switch (a_szValue) - { - default: break; - case "65535": a_szValue = "-1"; break; - case "65534": a_szValue = "-2"; break; - case "65533": a_szValue = "-3"; break; - case "65532": a_szValue = "-4"; break; - } - t = (T)Enum.Parse(typeof(T), a_szValue, true); - } - - // Check to see if we changed anything... - szCvt = t.ToString(); - if (szCvt != u32.ToString()) - { - // CAP is in its final form... - if (typeof(T) == typeof(CAP)) - { - return (szCvt); - } - // Everybody else needs the name decoration removed... - else - { - return (typeof(T).ToString().Replace("TWAINWorkingGroup.TWAIN+", "") + "_" + szCvt); - } - } - - // We're probably a custom value... - else - { - return (string.Format("0x{0:X}", u32)); - } - } - - // We're a string... - return (a_szValue); - } - - /// - /// This mess is what tries to turn readable stuff into numeric constants... - /// - /// type for the conversion - /// value to convert - /// - private static string CvtCapValueFromEnumHelper(string a_szValue) - { - // We can figure this one out on our own... - if ((typeof(T).Name == "bool") || (typeof(T).Name == "Boolean")) - { - return (((a_szValue.ToLowerInvariant() == "true") || (a_szValue == "1")) ? "1" : "0"); - } - - // Look for the enum prefix... - if (a_szValue.ToLowerInvariant().StartsWith(typeof(T).Name.ToLowerInvariant() + "_")) - { - return (a_szValue.Substring((typeof(T).Name + "_").Length)); - } - - // Er... - return (a_szValue); - } - - /// - /// This mess is what tries to turn readable stuff into numeric constants... - /// - /// type for the conversion - /// value to convert - /// - private static string CvtCapValueFromTwlg(string a_szValue) - { - // mono goes "hork", probably because the enum is wackadoodle, this - // does work on .net, but what'cha gonna do? - if (a_szValue.ToUpperInvariant().StartsWith("TWLG_")) - { - switch (a_szValue.ToUpperInvariant().Substring(5)) - { - default: break; - case "USERLOCALE": return ("65535"); // -1, kinda... - case "DAN": return ("0"); - case "DUT": return ("1"); - case "ENG": return ("2"); - case "FCF": return ("3"); - case "FIN": return ("4"); - case "FRN": return ("5"); - case "GER": return ("6"); - case "ICE": return ("7"); - case "ITN": return ("8"); - case "NOR": return ("9"); - case "POR": return ("10"); - case "SPA": return ("11"); - case "SWE": return ("12"); - case "USA": return ("13"); - case "AFRIKAANS": return ("14"); - case "ALBANIA": return ("15"); - case "ARABIC": return ("16"); - case "ARABIC_ALGERIA": return ("17"); - case "ARABIC_BAHRAIN": return ("18"); - case "ARABIC_EGYPT": return ("19"); - case "ARABIC_IRAQ": return ("20"); - case "ARABIC_JORDAN": return ("21"); - case "ARABIC_KUWAIT": return ("22"); - case "ARABIC_LEBANON": return ("23"); - case "ARABIC_LIBYA": return ("24"); - case "ARABIC_MOROCCO": return ("25"); - case "ARABIC_OMAN": return ("26"); - case "ARABIC_QATAR": return ("27"); - case "ARABIC_SAUDIARABIA": return ("28"); - case "ARABIC_SYRIA": return ("29"); - case "ARABIC_TUNISIA": return ("30"); - case "ARABIC_UAE": return ("31"); - case "ARABIC_YEMEN": return ("32"); - case "BASQUE": return ("33"); - case "BYELORUSSIAN": return ("34"); - case "BULGARIAN": return ("35"); - case "CATALAN": return ("36"); - case "CHINESE": return ("37"); - case "CHINESE_HONGKONG": return ("38"); - case "CHINESE_PRC": return ("39"); - case "CHINESE_SINGAPORE": return ("40"); - case "CHINESE_SIMPLIFIED": return ("41"); - case "CHINESE_TAIWAN": return ("42"); - case "CHINESE_TRADITIONAL": return ("43"); - case "CROATIA": return ("44"); - case "CZECH": return ("45"); - case "DANISH": return (((int)TWLG.DAN).ToString()); - case "DUTCH": return (((int)TWLG.DUT).ToString()); - case "DUTCH_BELGIAN": return ("46"); - case "ENGLISH": return (((int)TWLG.ENG).ToString()); - case "ENGLISH_AUSTRALIAN": return ("47"); - case "ENGLISH_CANADIAN": return ("48"); - case "ENGLISH_IRELAND": return ("49"); - case "ENGLISH_NEWZEALAND": return ("50"); - case "ENGLISH_SOUTHAFRICA": return ("51"); - case "ENGLISH_UK": return ("52"); - case "ENGLISH_USA": return (((int)TWLG.USA).ToString()); - case "ESTONIAN": return ("53"); - case "FAEROESE": return ("54"); - case "FARSI": return ("55"); - case "FINNISH": return (((int)TWLG.FIN).ToString()); - case "FRENCH": return (((int)TWLG.FRN).ToString()); - case "FRENCH_BELGIAN": return ("56"); - case "FRENCH_CANADIAN": return (((int)TWLG.FCF).ToString()); - case "FRENCH_LUXEMBOURG": return ("57"); - case "FRENCH_SWISS": return ("58"); - case "GERMAN": return (((int)TWLG.GER).ToString()); - case "GERMAN_AUSTRIAN": return ("59"); - case "GERMAN_LUXEMBOURG": return ("60"); - case "GERMAN_LIECHTENSTEIN": return ("61"); - case "GERMAN_SWISS": return ("62"); - case "GREEK": return ("63"); - case "HEBREW": return ("64"); - case "HUNGARIAN": return ("65"); - case "ICELANDIC": return (((int)TWLG.ICE).ToString()); - case "INDONESIAN": return ("66"); - case "ITALIAN": return (((int)TWLG.ITN).ToString()); - case "ITALIAN_SWISS": return ("67"); - case "JAPANESE": return ("68"); - case "KOREAN": return ("69"); - case "KOREAN_JOHAB": return ("70"); - case "LATVIAN": return ("71"); - case "LITHUANIAN": return ("72"); - case "NORWEGIAN": return (((int)TWLG.NOR).ToString()); - case "NORWEGIAN_BOKMAL": return ("73"); - case "NORWEGIAN_NYNORSK": return ("74"); - case "POLISH": return ("75"); - case "PORTUGUESE": return (((int)TWLG.POR).ToString()); - case "PORTUGUESE_BRAZIL": return ("76"); - case "ROMANIAN": return ("77"); - case "RUSSIAN": return ("78"); - case "SERBIAN_LATIN": return ("79"); - case "SLOVAK": return ("80"); - case "SLOVENIAN": return ("81"); - case "SPANISH": return (((int)TWLG.SPA).ToString()); - case "SPANISH_MEXICAN": return ("82"); - case "SPANISH_MODERN": return ("83"); - case "SWEDISH": return (((int)TWLG.SWE).ToString()); - case "THAI": return ("84"); - case "TURKISH": return ("85"); - case "UKRANIAN": return ("86"); - case "ASSAMESE": return ("87"); - case "BENGALI": return ("88"); - case "BIHARI": return ("89"); - case "BODO": return ("90"); - case "DOGRI": return ("91"); - case "GUJARATI": return ("92"); - case "HARYANVI": return ("93"); - case "HINDI": return ("94"); - case "KANNADA": return ("95"); - case "KASHMIRI": return ("96"); - case "MALAYALAM": return ("97"); - case "MARATHI": return ("98"); - case "MARWARI": return ("99"); - case "MEGHALAYAN": return ("100"); - case "MIZO": return ("101"); - case "NAGA": return ("102"); - case "ORISSI": return ("103"); - case "PUNJABI": return ("104"); - case "PUSHTU": return ("105"); - case "SERBIAN_CYRILLIC": return ("106"); - case "SIKKIMI": return ("107"); - case "SWEDISH_FINLAND": return ("108"); - case "TAMIL": return ("109"); - case "TELUGU": return ("110"); - case "TRIPURI": return ("111"); - case "URDU": return ("112"); - case "VIETNAMESE": return ("113"); - } - } - - // Er... - return (a_szValue); - } - - /// - /// Convert a value to the 'friendly' name, based on the capability... - /// - /// capability driving the conversion - /// value to convert - /// - public static string CvtCapValueToEnum(CAP a_cap, string a_szValue) - { - switch (a_cap) - { - default: return (a_szValue); - case CAP.ACAP_XFERMECH: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_ALARMS: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_ALARMVOLUME: return (a_szValue); - case CAP.CAP_AUTHOR: return (a_szValue); - case CAP.CAP_AUTOFEED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_AUTOMATICCAPTURE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_AUTOMATICSENSEMEDIUM: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_AUTOSCAN: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_BATTERYMINUTES: return (a_szValue); - case CAP.CAP_BATTERYPERCENTAGE: return (a_szValue); - case CAP.CAP_CAMERAENABLED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_CAMERAORDER: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_CAMERAPREVIEWUI: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_CAMERASIDE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_CAPTION: return (a_szValue); - case CAP.CAP_CLEARPAGE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_CUSTOMDSDATA: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_CUSTOMINTERFACEGUID: return (a_szValue); - case CAP.CAP_DEVICEEVENT: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_DEVICEONLINE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_DEVICETIMEDATE: return (a_szValue); - case CAP.CAP_DOUBLEFEEDDETECTION: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_DOUBLEFEEDDETECTIONLENGTH: return (a_szValue); - case CAP.CAP_DOUBLEFEEDDETECTIONRESPONSE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_DOUBLEFEEDDETECTIONSENSITIVITY: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_DUPLEX: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_DUPLEXENABLED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_ENABLEDSUIONLY: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_ENDORSER: return (a_szValue); - case CAP.CAP_EXTENDEDCAPS: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_FEEDERALIGNMENT: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_FEEDERENABLED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_FEEDERLOADED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_FEEDERORDER: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_FEEDERPOCKET: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_FEEDERPREP: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_FEEDPAGE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_INDICATORS: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_INDICATORSMODE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_JOBCONTROL: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_LANGUAGE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_MAXBATCHBUFFERS: return (a_szValue); - case CAP.CAP_MICRENABLED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_PAPERDETECTABLE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_PAPERHANDLING: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_POWERSAVETIME: return (a_szValue); - case CAP.CAP_POWERSUPPLY: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_PRINTER: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_PRINTERCHARROTATION: return (a_szValue); - case CAP.CAP_PRINTERENABLED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_PRINTERFONTSTYLE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_PRINTERINDEX: return (a_szValue); - case CAP.CAP_PRINTERINDEXLEADCHAR: return (a_szValue); - case CAP.CAP_PRINTERINDEXMAXVALUE: return (a_szValue); - case CAP.CAP_PRINTERINDEXNUMDIGITS: return (a_szValue); - case CAP.CAP_PRINTERINDEXSTEP: return (a_szValue); - case CAP.CAP_PRINTERINDEXTRIGGER: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_PRINTERMODE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_PRINTERSTRING: return (a_szValue); - case CAP.CAP_PRINTERSTRINGPREVIEW: return (a_szValue); - case CAP.CAP_PRINTERSUFFIX: return (a_szValue); - case CAP.CAP_PRINTERVERTICALOFFSET: return (a_szValue); - case CAP.CAP_REACQUIREALLOWED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_REWINDPAGE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_SEGMENTED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_SERIALNUMBER: return (a_szValue); - case CAP.CAP_SHEETCOUNT: return (a_szValue); - case CAP.CAP_SUPPORTEDCAPS: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_SUPPORTEDCAPSSEGMENTUNIQUE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_SUPPORTEDDATS: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_THUMBNAILSENABLED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_TIMEBEFOREFIRSTCAPTURE: return (a_szValue); - case CAP.CAP_TIMEBETWEENCAPTURES: return (a_szValue); - case CAP.CAP_TIMEDATE: return (a_szValue); - case CAP.CAP_UICONTROLLABLE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.CAP_XFERCOUNT: return (a_szValue); - case CAP.ICAP_AUTOBRIGHT: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_AUTODISCARDBLANKPAGES: return (a_szValue); - case CAP.ICAP_AUTOMATICBORDERDETECTION: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICCOLORENABLED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICCOLORNONCOLORPIXELTYPE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICCROPUSESFRAME: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICDESKEW: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICLENGTHDETECTION: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICROTATE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_AUTOSIZE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_BARCODEDETECTIONENABLED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_BARCODEMAXRETRIES: return (a_szValue); - case CAP.ICAP_BARCODEMAXSEARCHPRIORITIES: return (a_szValue); - case CAP.ICAP_BARCODESEARCHMODE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_BARCODESEARCHPRIORITIES: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_BARCODETIMEOUT: return (a_szValue); - case CAP.ICAP_BITDEPTH: return (a_szValue); - case CAP.ICAP_BITDEPTHREDUCTION: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_BITORDER: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_BITORDERCODES: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_BRIGHTNESS: return (a_szValue); - case CAP.ICAP_CCITTKFACTOR: return (a_szValue); - case CAP.ICAP_COLORMANAGEMENTENABLED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_COMPRESSION: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_CONTRAST: return (a_szValue); - case CAP.ICAP_CUSTHALFTONE: return (a_szValue); - case CAP.ICAP_EXPOSURETIME: return (a_szValue); - case CAP.ICAP_EXTIMAGEINFO: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_FEEDERTYPE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_FILMTYPE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_FILTER: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_FLASHUSED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_FLASHUSED2: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_FLIPROTATION: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_FRAMES: return (a_szValue); - case CAP.ICAP_GAMMA: return (a_szValue); - case CAP.ICAP_HALFTONES: return (a_szValue); - case CAP.ICAP_HIGHLIGHT: return (a_szValue); - case CAP.ICAP_ICCPROFILE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_IMAGEDATASET: return (a_szValue); - case CAP.ICAP_IMAGEFILEFORMAT: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_IMAGEFILTER: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_IMAGEMERGE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_IMAGEMERGEHEIGHTTHRESHOLD: return (a_szValue); - case CAP.ICAP_JPEGPIXELTYPE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_JPEGQUALITY: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_JPEGSUBSAMPLING: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_LAMPSTATE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_LIGHTPATH: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_LIGHTSOURCE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_MAXFRAMES: return (a_szValue); - case CAP.ICAP_MINIMUMHEIGHT: return (a_szValue); - case CAP.ICAP_MINIMUMWIDTH: return (a_szValue); - case CAP.ICAP_MIRROR: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_NOISEFILTER: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_ORIENTATION: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_OVERSCAN: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_PATCHCODEDETECTIONENABLED: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_PATCHCODEMAXRETRIES: return (a_szValue); - case CAP.ICAP_PATCHCODEMAXSEARCHPRIORITIES: return (a_szValue); - case CAP.ICAP_PATCHCODESEARCHMODE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_PATCHCODESEARCHPRIORITIES: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_PATCHCODETIMEOUT: return (a_szValue); - case CAP.ICAP_PHYSICALHEIGHT: return (a_szValue); - case CAP.ICAP_PHYSICALWIDTH: return (a_szValue); - case CAP.ICAP_PIXELFLAVOR: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_PIXELFLAVORCODES: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_PIXELTYPE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_PLANARCHUNKY: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_ROTATION: return (a_szValue); - case CAP.ICAP_SHADOW: return (a_szValue); - case CAP.ICAP_SUPPORTEDBARCODETYPES: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_SUPPORTEDEXTIMAGEINFO: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_SUPPORTEDPATCHCODETYPES: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_SUPPORTEDSIZES: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_THRESHOLD: return (a_szValue); - case CAP.ICAP_TILES: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_TIMEFILL: return (a_szValue); - case CAP.ICAP_UNDEFINEDIMAGESIZE: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_UNITS: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_XFERMECH: return (CvtCapValueToEnumHelper(a_szValue)); - case CAP.ICAP_XNATIVERESOLUTION: return (a_szValue); - case CAP.ICAP_XRESOLUTION: return (a_szValue); - case CAP.ICAP_XSCALING: return (a_szValue); - case CAP.ICAP_YNATIVERESOLUTION: return (a_szValue); - case CAP.ICAP_YRESOLUTION: return (a_szValue); - case CAP.ICAP_YSCALING: return (a_szValue); - case CAP.ICAP_ZOOMFACTOR: return (a_szValue); - } - } - - /// - /// Convert a 'friendly' name to a numeric value... - /// - /// capability driving the conversion - /// value to convert - /// - public static string CvtCapValueFromEnum(CAP a_cap, string a_szValue) - { - int ii; - - // Turn hex into a decimal... - if (a_szValue.ToLowerInvariant().StartsWith("0x")) - { - return (int.Parse(a_szValue.Substring(2), NumberStyles.HexNumber).ToString()); - } - - // Skip numbers... - if (int.TryParse(a_szValue, out ii)) - { - return (a_szValue); - } - - // Process text... - switch (a_cap) - { - default: return (a_szValue); - case CAP.ACAP_XFERMECH: { TWSX twsx; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twsx) ? ((int)twsx).ToString() : a_szValue); }; - case CAP.CAP_ALARMS: { TWAL twal; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twal) ? ((int)twal).ToString() : a_szValue); }; - case CAP.CAP_ALARMVOLUME: return (a_szValue); - case CAP.CAP_AUTHOR: return (a_szValue); - case CAP.CAP_AUTOFEED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_AUTOMATICCAPTURE: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_AUTOMATICSENSEMEDIUM: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_AUTOSCAN: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_BATTERYMINUTES: return (a_szValue); - case CAP.CAP_BATTERYPERCENTAGE: return (a_szValue); - case CAP.CAP_CAMERAENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_CAMERAORDER: { TWPT twpt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpt) ? ((int)twpt).ToString() : a_szValue); }; - case CAP.CAP_CAMERAPREVIEWUI: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_CAMERASIDE: { TWCS twcs; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twcs) ? ((int)twcs).ToString() : a_szValue); }; - case CAP.CAP_CAPTION: return (a_szValue); - case CAP.CAP_CLEARPAGE: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_CUSTOMDSDATA: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_CUSTOMINTERFACEGUID: return (a_szValue); - case CAP.CAP_DEVICEEVENT: { TWDE twde; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twde) ? ((int)twde).ToString() : a_szValue); }; - case CAP.CAP_DEVICEONLINE: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_DEVICETIMEDATE: return (a_szValue); - case CAP.CAP_DOUBLEFEEDDETECTION: { TWDF twdf; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twdf) ? ((int)twdf).ToString() : a_szValue); }; - case CAP.CAP_DOUBLEFEEDDETECTIONLENGTH: return (a_szValue); - case CAP.CAP_DOUBLEFEEDDETECTIONRESPONSE: { TWDP twdp; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twdp) ? ((int)twdp).ToString() : a_szValue); }; - case CAP.CAP_DOUBLEFEEDDETECTIONSENSITIVITY: { TWUS twus; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twus) ? ((int)twus).ToString() : a_szValue); }; - case CAP.CAP_DUPLEX: { TWDX twdx; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twdx) ? ((int)twdx).ToString() : a_szValue); }; - case CAP.CAP_DUPLEXENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_ENABLEDSUIONLY: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_ENDORSER: return (a_szValue); - case CAP.CAP_EXTENDEDCAPS: { CAP cap; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out cap) ? ((int)cap).ToString() : a_szValue); }; - case CAP.CAP_FEEDERALIGNMENT: { TWFA twfa; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfa) ? ((int)twfa).ToString() : a_szValue); }; - case CAP.CAP_FEEDERENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_FEEDERLOADED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_FEEDERORDER: { TWFO twfo; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfo) ? ((int)twfo).ToString() : a_szValue); }; - case CAP.CAP_FEEDERPOCKET: { TWFP twfp; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfp) ? ((int)twfp).ToString() : a_szValue); }; - case CAP.CAP_FEEDERPREP: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_FEEDPAGE: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_INDICATORS: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_INDICATORSMODE: { TWCI twci; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twci) ? ((int)twci).ToString() : a_szValue); }; - case CAP.CAP_JOBCONTROL: { TWJC twjc; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twjc) ? ((int)twjc).ToString() : a_szValue); }; - case CAP.CAP_LANGUAGE: return(CvtCapValueFromTwlg(a_szValue)); - case CAP.CAP_MAXBATCHBUFFERS: return (a_szValue); - case CAP.CAP_MICRENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_PAPERDETECTABLE: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_PAPERHANDLING: { TWPH twph; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twph) ? ((int)twph).ToString() : a_szValue); }; - case CAP.CAP_POWERSAVETIME: return (a_szValue); - case CAP.CAP_POWERSUPPLY: { TWPS twps; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twps) ? ((int)twps).ToString() : a_szValue); }; - case CAP.CAP_PRINTER: { TWPR twpr; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpr) ? ((int)twpr).ToString() : a_szValue); }; - case CAP.CAP_PRINTERCHARROTATION: return (a_szValue); - case CAP.CAP_PRINTERENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_PRINTERFONTSTYLE: { TWPF twpf; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpf) ? ((int)twpf).ToString() : a_szValue); }; - case CAP.CAP_PRINTERINDEX: return (a_szValue); - case CAP.CAP_PRINTERINDEXLEADCHAR: return (a_szValue); - case CAP.CAP_PRINTERINDEXMAXVALUE: return (a_szValue); - case CAP.CAP_PRINTERINDEXNUMDIGITS: return (a_szValue); - case CAP.CAP_PRINTERINDEXSTEP: return (a_szValue); - case CAP.CAP_PRINTERINDEXTRIGGER: { TWCT twct; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twct) ? ((int)twct).ToString() : a_szValue); }; - case CAP.CAP_PRINTERMODE: { TWPM twpm; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpm) ? ((int)twpm).ToString() : a_szValue); }; - case CAP.CAP_PRINTERSTRING: return (a_szValue); - case CAP.CAP_PRINTERSTRINGPREVIEW: return (a_szValue); - case CAP.CAP_PRINTERSUFFIX: return (a_szValue); - case CAP.CAP_PRINTERVERTICALOFFSET: return (a_szValue); - case CAP.CAP_REACQUIREALLOWED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_REWINDPAGE: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_SEGMENTED: { TWSG twsg; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twsg) ? ((int)twsg).ToString() : a_szValue); }; - case CAP.CAP_SERIALNUMBER: return (a_szValue); - case CAP.CAP_SHEETCOUNT: return (a_szValue); - case CAP.CAP_SUPPORTEDCAPS: { CAP cap; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out cap) ? ((int)cap).ToString() : a_szValue); }; - case CAP.CAP_SUPPORTEDCAPSSEGMENTUNIQUE: { CAP cap; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out cap) ? ((int)cap).ToString() : a_szValue); }; - case CAP.CAP_SUPPORTEDDATS: { DAT dat; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out dat) ? ((int)dat).ToString() : a_szValue); }; - case CAP.CAP_THUMBNAILSENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_TIMEBEFOREFIRSTCAPTURE: return (a_szValue); - case CAP.CAP_TIMEBETWEENCAPTURES: return (a_szValue); - case CAP.CAP_TIMEDATE: return (a_szValue); - case CAP.CAP_UICONTROLLABLE: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.CAP_XFERCOUNT: return (a_szValue); - case CAP.ICAP_AUTOBRIGHT: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_AUTODISCARDBLANKPAGES: { TWBP twbp; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbp) ? ((int)twbp).ToString() : a_szValue); }; - case CAP.ICAP_AUTOMATICBORDERDETECTION: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICCOLORENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICCOLORNONCOLORPIXELTYPE: { TWPT twpt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpt) ? ((int)twpt).ToString() : a_szValue); }; - case CAP.ICAP_AUTOMATICCROPUSESFRAME: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICDESKEW: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICLENGTHDETECTION: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_AUTOMATICROTATE: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_AUTOSIZE: { TWAS twas; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twas) ? ((int)twas).ToString() : a_szValue); }; - case CAP.ICAP_BARCODEDETECTIONENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_BARCODEMAXRETRIES: return (a_szValue); - case CAP.ICAP_BARCODEMAXSEARCHPRIORITIES: return (a_szValue); - case CAP.ICAP_BARCODESEARCHMODE: { TWBD twbd; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbd) ? ((int)twbd).ToString() : a_szValue); }; - case CAP.ICAP_BARCODESEARCHPRIORITIES: { TWBT twbt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbt) ? ((int)twbt).ToString() : a_szValue); }; - case CAP.ICAP_BARCODETIMEOUT: return (a_szValue); - case CAP.ICAP_BITDEPTH: return (a_szValue); - case CAP.ICAP_BITDEPTHREDUCTION: { TWBR twbr; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbr) ? ((int)twbr).ToString() : a_szValue); }; - case CAP.ICAP_BITORDER: { TWBO twbo; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbo) ? ((int)twbo).ToString() : a_szValue); }; - case CAP.ICAP_BITORDERCODES: { TWBO twbo; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbo) ? ((int)twbo).ToString() : a_szValue); }; - case CAP.ICAP_BRIGHTNESS: return (a_szValue); - case CAP.ICAP_CCITTKFACTOR: return (a_szValue); - case CAP.ICAP_COLORMANAGEMENTENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_COMPRESSION: { TWCP twcp; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twcp) ? ((int)twcp).ToString() : a_szValue); }; - case CAP.ICAP_CONTRAST: return (a_szValue); - case CAP.ICAP_CUSTHALFTONE: return (a_szValue); - case CAP.ICAP_EXPOSURETIME: return (a_szValue); - case CAP.ICAP_EXTIMAGEINFO: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_FEEDERTYPE: { TWFE twfe; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfe) ? ((int)twfe).ToString() : a_szValue); }; - case CAP.ICAP_FILMTYPE: { TWFM twfm; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfm) ? ((int)twfm).ToString() : a_szValue); }; - case CAP.ICAP_FILTER: { TWFT twft; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twft) ? ((int)twft).ToString() : a_szValue); }; - case CAP.ICAP_FLASHUSED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_FLASHUSED2: { TWFL twfl; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfl) ? ((int)twfl).ToString() : a_szValue); }; - case CAP.ICAP_FLIPROTATION: { TWFR twfr; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twfr) ? ((int)twfr).ToString() : a_szValue); }; - case CAP.ICAP_FRAMES: return (a_szValue); - case CAP.ICAP_GAMMA: return (a_szValue); - case CAP.ICAP_HALFTONES: return (a_szValue); - case CAP.ICAP_HIGHLIGHT: return (a_szValue); - case CAP.ICAP_ICCPROFILE: { TWIC twic; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twic) ? ((int)twic).ToString() : a_szValue); }; - case CAP.ICAP_IMAGEDATASET: return (a_szValue); - case CAP.ICAP_IMAGEFILEFORMAT: { TWFF twff; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twff) ? ((int)twff).ToString() : a_szValue); }; - case CAP.ICAP_IMAGEFILTER: { TWIF twif; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twif) ? ((int)twif).ToString() : a_szValue); }; - case CAP.ICAP_IMAGEMERGE: { TWIM twim; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twim) ? ((int)twim).ToString() : a_szValue); }; - case CAP.ICAP_IMAGEMERGEHEIGHTTHRESHOLD: return (a_szValue); - case CAP.ICAP_JPEGPIXELTYPE: { TWPT twpt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpt) ? ((int)twpt).ToString() : a_szValue); }; - case CAP.ICAP_JPEGQUALITY: { TWJQ twjq; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twjq) ? ((int)twjq).ToString() : a_szValue); }; - case CAP.ICAP_JPEGSUBSAMPLING: { TWJS twjs; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twjs) ? ((int)twjs).ToString() : a_szValue); }; - case CAP.ICAP_LAMPSTATE: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_LIGHTPATH: { TWLP twlp; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twlp) ? ((int)twlp).ToString() : a_szValue); }; - case CAP.ICAP_LIGHTSOURCE: { TWLS twls; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twls) ? ((int)twls).ToString() : a_szValue); }; - case CAP.ICAP_MAXFRAMES: return (a_szValue); - case CAP.ICAP_MINIMUMHEIGHT: return (a_szValue); - case CAP.ICAP_MINIMUMWIDTH: return (a_szValue); - case CAP.ICAP_MIRROR: { TWMR twmr; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twmr) ? ((int)twmr).ToString() : a_szValue); }; - case CAP.ICAP_NOISEFILTER: { TWNF twnf; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twnf) ? ((int)twnf).ToString() : a_szValue); }; - case CAP.ICAP_ORIENTATION: { TWOR twor; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twor) ? ((int)twor).ToString() : a_szValue); }; - case CAP.ICAP_OVERSCAN: { TWOV twov; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twov) ? ((int)twov).ToString() : a_szValue); }; - case CAP.ICAP_PATCHCODEDETECTIONENABLED: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_PATCHCODEMAXRETRIES: return (a_szValue); - case CAP.ICAP_PATCHCODEMAXSEARCHPRIORITIES: return (a_szValue); - case CAP.ICAP_PATCHCODESEARCHMODE: { TWBD twbd; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbd) ? ((int)twbd).ToString() : a_szValue); }; - case CAP.ICAP_PATCHCODESEARCHPRIORITIES: { TWPCH twpch; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpch) ? ((int)twpch).ToString() : a_szValue); }; - case CAP.ICAP_PATCHCODETIMEOUT: return (a_szValue); - case CAP.ICAP_PHYSICALHEIGHT: return (a_szValue); - case CAP.ICAP_PHYSICALWIDTH: return (a_szValue); - case CAP.ICAP_PIXELFLAVOR: { TWPF twpf; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpf) ? ((int)twpf).ToString() : a_szValue); }; - case CAP.ICAP_PIXELFLAVORCODES: { TWPF twpf; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpf) ? ((int)twpf).ToString() : a_szValue); }; - case CAP.ICAP_PIXELTYPE: { TWPT twpt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpt) ? ((int)twpt).ToString() : a_szValue); }; - case CAP.ICAP_PLANARCHUNKY: { TWPC twpc; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpc) ? ((int)twpc).ToString() : a_szValue); }; - case CAP.ICAP_ROTATION: return (a_szValue); - case CAP.ICAP_SHADOW: return (a_szValue); - case CAP.ICAP_SUPPORTEDBARCODETYPES: { TWBT twbt; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twbt) ? ((int)twbt).ToString() : a_szValue); }; - case CAP.ICAP_SUPPORTEDEXTIMAGEINFO: { TWEI twei; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twei) ? ((int)twei).ToString() : a_szValue); }; - case CAP.ICAP_SUPPORTEDPATCHCODETYPES: { TWPCH twpch; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twpch) ? ((int)twpch).ToString() : a_szValue); }; - case CAP.ICAP_SUPPORTEDSIZES: { TWSS twss; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twss) ? ((int)twss).ToString() : a_szValue); }; - case CAP.ICAP_THRESHOLD: return (a_szValue); - case CAP.ICAP_TILES: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_TIMEFILL: return (a_szValue); - case CAP.ICAP_UNDEFINEDIMAGESIZE: return (CvtCapValueFromEnumHelper(a_szValue)); - case CAP.ICAP_UNITS: { TWUN twun; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twun) ? ((int)twun).ToString() : a_szValue); }; - case CAP.ICAP_XFERMECH: { TWSX twsx; return (Enum.TryParse(CvtCapValueFromEnumHelper(a_szValue), out twsx) ? ((int)twsx).ToString() : a_szValue); }; - case CAP.ICAP_XNATIVERESOLUTION: return (a_szValue); - case CAP.ICAP_XRESOLUTION: return (a_szValue); - case CAP.ICAP_XSCALING: return (a_szValue); - case CAP.ICAP_YNATIVERESOLUTION: return (a_szValue); - case CAP.ICAP_YRESOLUTION: return (a_szValue); - case CAP.ICAP_YSCALING: return (a_szValue); - case CAP.ICAP_ZOOMFACTOR: return (a_szValue); - } - } - #endregion @@ -5138,7 +3340,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.CALLBACK.ToString(), a_msg.ToString(), CallbackToCsv(a_twcallback)); + Log.LogSendBefore(a_dg.ToString(), DAT.CALLBACK.ToString(), a_msg.ToString(), CsvSerializer.CallbackToCsv(a_twcallback)); } // Windows... @@ -5235,7 +3437,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, CallbackToCsv(a_twcallback)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.CallbackToCsv(a_twcallback)); } // All done... @@ -5283,7 +3485,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.CALLBACK2.ToString(), a_msg.ToString(), Callback2ToCsv(a_twcallback2)); + Log.LogSendBefore(a_dg.ToString(), DAT.CALLBACK2.ToString(), a_msg.ToString(), CsvSerializer.Callback2ToCsv(a_twcallback2)); } // Windows... @@ -5380,7 +3582,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, Callback2ToCsv(a_twcallback2)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.Callback2ToCsv(a_twcallback2)); } // All done... @@ -6117,7 +4319,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, DeviceeventToCsv(a_twdeviceevent)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.DeviceeventToCsv(a_twdeviceevent)); } // All done... @@ -6166,7 +4368,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.ENTRYPOINT.ToString(), a_msg.ToString(), EntrypointToCsv(a_twentrypoint)); + Log.LogSendBefore(a_dg.ToString(), DAT.ENTRYPOINT.ToString(), a_msg.ToString(), CsvSerializer.EntrypointToCsv(a_twentrypoint)); } // Windows... @@ -6309,7 +4511,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, EntrypointToCsv(a_twentrypoint)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.EntrypointToCsv(a_twentrypoint)); } // All done... @@ -6761,7 +4963,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.FILESYSTEM.ToString(), a_msg.ToString(), FilesystemToCsv(a_twfilesystem)); + Log.LogSendBefore(a_dg.ToString(), DAT.FILESYSTEM.ToString(), a_msg.ToString(), CsvSerializer.FilesystemToCsv(a_twfilesystem)); } // Windows... @@ -6858,7 +5060,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, FilesystemToCsv(a_twfilesystem)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.FilesystemToCsv(a_twfilesystem)); } // All done... @@ -7390,7 +5592,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.IDENTITY.ToString(), a_msg.ToString(), ((a_msg == MSG.OPENDS) ? IdentityToCsv(a_twidentity) : "")); + Log.LogSendBefore(a_dg.ToString(), DAT.IDENTITY.ToString(), a_msg.ToString(), ((a_msg == MSG.OPENDS) ? CsvSerializer.IdentityToCsv(a_twidentity) : "")); } // Windows... @@ -7738,7 +5940,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, IdentityToCsv(a_twidentity)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.IdentityToCsv(a_twidentity)); } // If we opened, go to state 4... @@ -7767,7 +5969,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.CALLBACK.ToString(), a_msg.ToString(), CallbackToCsv(twcallback)); + Log.LogSendBefore(a_dg.ToString(), DAT.CALLBACK.ToString(), a_msg.ToString(), CsvSerializer.CallbackToCsv(twcallback)); } // Issue the command... try @@ -7804,7 +6006,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.CALLBACK.ToString(), MSG.REGISTER_CALLBACK.ToString(), CallbackToCsv(twcallback)); + Log.LogSendBefore(a_dg.ToString(), DAT.CALLBACK.ToString(), MSG.REGISTER_CALLBACK.ToString(), CsvSerializer.CallbackToCsv(twcallback)); } // Issue the command... try @@ -7850,7 +6052,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.CALLBACK.ToString(), a_msg.ToString(), CallbackToCsv(twcallback)); + Log.LogSendBefore(a_dg.ToString(), DAT.CALLBACK.ToString(), a_msg.ToString(), CsvSerializer.CallbackToCsv(twcallback)); } // Issue the command... try @@ -8118,7 +6320,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, ImageinfoToCsv(a_twimageinfo)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.ImageinfoToCsv(a_twimageinfo)); } // All done... @@ -8197,7 +6399,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.IMAGELAYOUT.ToString(), a_msg.ToString(), ImagelayoutToCsv(a_twimagelayout)); + Log.LogSendBefore(a_dg.ToString(), DAT.IMAGELAYOUT.ToString(), a_msg.ToString(), CsvSerializer.ImagelayoutToCsv(a_twimagelayout)); } // Windows... @@ -8332,7 +6534,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, ImagelayoutToCsv(a_twimagelayout)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.ImagelayoutToCsv(a_twimagelayout)); } // All done... @@ -8624,7 +6826,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.IMAGEMEMFILEXFER.ToString(), a_msg.ToString(), ImagememxferToCsv(a_twimagememxfer)); + Log.LogSendBefore(a_dg.ToString(), DAT.IMAGEMEMFILEXFER.ToString(), a_msg.ToString(), CsvSerializer.ImagememxferToCsv(a_twimagememxfer)); } // Windows... @@ -8801,7 +7003,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, ImagememxferToCsv(a_twimagememxfer)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.ImagememxferToCsv(a_twimagememxfer)); } // If we had a successful transfer, then change state... @@ -8886,7 +7088,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.IMAGEMEMXFER.ToString(), a_msg.ToString(), ImagememxferToCsv(a_twimagememxfer)); + Log.LogSendBefore(a_dg.ToString(), DAT.IMAGEMEMXFER.ToString(), a_msg.ToString(), CsvSerializer.ImagememxferToCsv(a_twimagememxfer)); } // Windows... @@ -9063,7 +7265,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, ImagememxferToCsv(a_twimagememxfer)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.ImagememxferToCsv(a_twimagememxfer)); } // If we had a successful transfer, then change state... @@ -10382,7 +8584,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, PendingxfersToCsv(a_twpendingxfers)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.PendingxfersToCsv(a_twpendingxfers)); } // If we endxfer, go to state 5 or 6... @@ -10635,7 +8837,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.SETUPFILEXFER.ToString(), a_msg.ToString(), SetupfilexferToCsv(a_twsetupfilexfer)); + Log.LogSendBefore(a_dg.ToString(), DAT.SETUPFILEXFER.ToString(), a_msg.ToString(), CsvSerializer.SetupfilexferToCsv(a_twsetupfilexfer)); } // Windows... @@ -10770,7 +8972,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, SetupfilexferToCsv(a_twsetupfilexfer)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.SetupfilexferToCsv(a_twsetupfilexfer)); } // All done... @@ -10984,7 +9186,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, SetupmemxferToCsv(a_twsetupmemxfer)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.SetupmemxferToCsv(a_twsetupmemxfer)); } // All done... @@ -11568,7 +9770,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.USERINTERFACE.ToString(), a_msg.ToString(), UserinterfaceToCsv(a_twuserinterface)); + Log.LogSendBefore(a_dg.ToString(), DAT.USERINTERFACE.ToString(), a_msg.ToString(), CsvSerializer.UserinterfaceToCsv(a_twuserinterface)); } // We need this to handle data sources that return MSG_XFERREADY in @@ -11785,7 +9987,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendBefore(a_dg.ToString(), DAT.XFERGROUP.ToString(), a_msg.ToString(), XfergroupToCsv(a_twuint32)); + Log.LogSendBefore(a_dg.ToString(), DAT.XFERGROUP.ToString(), a_msg.ToString(), CsvSerializer.XfergroupToCsv(a_twuint32)); } // Windows... @@ -11882,7 +10084,7 @@ namespace TWAINWorkingGroup // Log it... if (Log.GetLevel() > 0) { - Log.LogSendAfter(stsRcOrCc, XfergroupToCsv(a_twuint32)); + Log.LogSendAfter(stsRcOrCc, CsvSerializer.XfergroupToCsv(a_twuint32)); } // All done... @@ -13115,14 +11317,14 @@ namespace TWAINWorkingGroup // We do this to make sure the entire Item value is overwritten... if (a_twcapability.ConType == TWON.ONEVALUE) { - int i32Value = sbyte.Parse(CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); + int i32Value = sbyte.Parse(CsvSerializer.CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); Marshal.StructureToPtr(i32Value, a_intptr, true); return (""); } // These items have to be packed on the type sizes... else { - sbyte i8Value = sbyte.Parse(CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); + sbyte i8Value = sbyte.Parse(CsvSerializer.CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); intptr = (IntPtr)((ulong)a_intptr + (ulong)(1 * a_iIndex)); Marshal.StructureToPtr(i8Value, intptr, true); return (""); @@ -13134,14 +11336,14 @@ namespace TWAINWorkingGroup // We use i32Value to make sure the entire Item value is overwritten... if (a_twcapability.ConType == TWON.ONEVALUE) { - int i32Value = short.Parse(CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); + int i32Value = short.Parse(CsvSerializer.CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); Marshal.StructureToPtr(i32Value, a_intptr, true); return (""); } // These items have to be packed on the type sizes... else { - short i16Value = short.Parse(CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); + short i16Value = short.Parse(CsvSerializer.CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); intptr = (IntPtr)((ulong)a_intptr + (ulong)(2 * a_iIndex)); Marshal.StructureToPtr(i16Value, intptr, true); return (""); @@ -13151,7 +11353,7 @@ namespace TWAINWorkingGroup case TWTY.INT32: { // Entire value will always be overwritten, so we don't have to get fancy... - int i32Value = int.Parse(CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); + int i32Value = int.Parse(CsvSerializer.CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); intptr = (IntPtr)((ulong)a_intptr + (ulong)(4 * a_iIndex)); Marshal.StructureToPtr(i32Value, intptr, true); return (""); @@ -13162,14 +11364,14 @@ namespace TWAINWorkingGroup // We use u32Value to make sure the entire Item value is overwritten... if (a_twcapability.ConType == TWON.ONEVALUE) { - uint u32Value = byte.Parse(CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); + uint u32Value = byte.Parse(CsvSerializer.CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); Marshal.StructureToPtr(u32Value, a_intptr, true); return (""); } // These items have to be packed on the type sizes... else { - byte u8Value = byte.Parse(CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); + byte u8Value = byte.Parse(CsvSerializer.CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); intptr = (IntPtr)((ulong)a_intptr + (ulong)(1 * a_iIndex)); Marshal.StructureToPtr(u8Value, intptr, true); return (""); @@ -13182,13 +11384,13 @@ namespace TWAINWorkingGroup // We use u32Value to make sure the entire Item value is overwritten... if (a_twcapability.ConType == TWON.ONEVALUE) { - uint u32Value = ushort.Parse(CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); + uint u32Value = ushort.Parse(CsvSerializer.CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); Marshal.StructureToPtr(u32Value, a_intptr, true); return (""); } else { - ushort u16Value = ushort.Parse(CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); + ushort u16Value = ushort.Parse(CsvSerializer.CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); intptr = (IntPtr)((ulong)a_intptr + (ulong)(2 * a_iIndex)); Marshal.StructureToPtr(u16Value, intptr, true); return (""); @@ -13198,7 +11400,7 @@ namespace TWAINWorkingGroup case TWTY.UINT32: { // Entire value will always be overwritten, so we don't have to get fancy... - uint u32Value = uint.Parse(CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); + uint u32Value = uint.Parse(CsvSerializer.CvtCapValueFromEnum(a_twcapability.Cap, a_szValue)); intptr = (IntPtr)((ulong)a_intptr + (ulong)(4 * a_iIndex)); Marshal.StructureToPtr(u32Value, intptr, true); return (""); diff --git a/NTwain/TwainSession.cs b/NTwain/TwainSession.cs index b308b85..90d0621 100644 --- a/NTwain/TwainSession.cs +++ b/NTwain/TwainSession.cs @@ -216,7 +216,7 @@ namespace NTwain if (State > STATE.S3) { TW_IDENTITY twidentity = default; - if (TWAIN.CsvToIdentity(ref twidentity, _twain.GetDsIdentity())) + if (CsvSerializer.CsvToIdentity(ref twidentity, _twain.GetDsIdentity())) { return twidentity; } @@ -274,7 +274,7 @@ namespace NTwain if ((_twain.GetState() == STATE.S4) && (state < STATE.S4)) { TW_IDENTITY twidentity = default; - TWAIN.CsvToIdentity(ref twidentity, _twain.GetDsIdentity()); + CsvSerializer.CsvToIdentity(ref twidentity, _twain.GetDsIdentity()); _twain.DatIdentity(DG.CONTROL, MSG.CLOSEDS, ref twidentity); }