JuniorHighClient/SmartEvaluationLogic/twain/TwainString.cpp

/***************************************************************************
* Copyright ?2007 TWAIN Working Group:  
*   Adobe Systems Incorporated, AnyDoc Software Inc., Eastman Kodak Company, 
*   Fujitsu Computer Products of America, JFL Peripheral Solutions Inc., 
*   Ricoh Corporation, and Xerox Corporation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*     * Redistributions of source code must retain the above copyright
*       notice, this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above copyright
*       notice, this list of conditions and the following disclaimer in the
*       documentation and/or other materials provided with the distribution.
*     * Neither the name of the TWAIN Working Group nor the
*       names of its contributors may be used to endorse or promote products
*       derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY TWAIN Working Group ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL TWAIN Working Group BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
***************************************************************************/

/**
 * @file TwainString.cpp
 * Convert TWAIN Constants to Strings
 * @author JFL Peripheral Solutions Inc.
 * @date Dec 2008
 */

#include "TwainString.h"

extern TW_HANDLE _DSM_Alloc(TW_UINT32 _size);
extern void _DSM_Free(TW_HANDLE _hMemory);
extern TW_MEMREF _DSM_LockMemory(TW_HANDLE _hMemory);
extern void _DSM_UnlockMemory(TW_HANDLE _hMemory);

/** the size of the temp buffer */
#define TEMPBUFSIZE 1024

/**
* return a temp buffer from an array.  Rotating through the queue.
* @return pointer to the buffer to use.
*/
char * nextTempBuffer()
{
  static char szTempBuffer[3][TEMPBUFSIZE];
  static int  nTempBuffer = 0;

  if(++nTempBuffer >= 3)
  {
    nTempBuffer = 0;
  }
  szTempBuffer[nTempBuffer][0] = '\0';
  return szTempBuffer[nTempBuffer];
}


//////////////////////////////////////////////////////////////////////////////
const char* convertCAP_Item_toString(const TW_UINT16 _unCap, const TW_UINT32 _unItem, const TW_UINT16 _unType)
{
  const char* pszString = "Unknown capability";

  switch(_unCap)
  {
    case CAP_ALARMS:
      pszString = convertCAP_ALARMS_toString((TW_UINT16)_unItem);
      break;

    case ICAP_AUTOSIZE:
      pszString = convertICAP_AUTOSIZE_toString((TW_UINT16)_unItem);
      break;

    case ICAP_COMPRESSION:
      pszString = convertICAP_COMPRESSION_toString((TW_UINT16)_unItem);
      break;

    case ICAP_BARCODESEARCHMODE:
      pszString = convertICAP_BARCODESEARCHMODE_toString((TW_UINT16)_unItem);
      break;

    case ICAP_BITORDER:
      pszString = convertICAP_BITORDER_toString((TW_UINT16)_unItem);
      break;

    case ICAP_AUTODISCARDBLANKPAGES:
      pszString = convertICAP_AUTODISCARDBLANKPAGES_toString((TW_UINT16)_unItem);
      break;

    case ICAP_BITDEPTH:
      {
      char *buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%u", _unItem);
      pszString = buff;
      }
      break;

    case ICAP_BITDEPTHREDUCTION:
      pszString = convertICAP_BITDEPTHREDUCTION_toString((TW_UINT16)_unItem);
      break;

    case ICAP_SUPPORTEDBARCODETYPES:
      pszString = convertICAP_SUPPORTEDBARCODETYPES_toString((TW_UINT16)_unItem);
      break;

    case CAP_CAMERASIDE:
      pszString = convertCAP_CAMERASIDE_toString((TW_UINT16)_unItem);
      break;

    case CAP_CLEARBUFFERS:
      pszString = convertCAP_CLEARBUFFERS_toString((TW_UINT16)_unItem);
      break;

    case CAP_DEVICEEVENT:
      pszString = convertCAP_DEVICEEVENT_toString((TW_UINT16)_unItem);
      break;

    case CAP_DUPLEX:
      pszString = convertCAP_DUPLEX_toString((TW_UINT16)_unItem);
      break;

    case CAP_EXTENDEDCAPS:
      pszString = convertCAP_toString((TW_UINT16)_unItem);
      break;

    case CAP_FEEDERALIGNMENT:
      pszString = convertCAP_FEEDERALIGNMENT_toString((TW_UINT16)_unItem);
      break;

    case ICAP_FEEDERTYPE:
      pszString = convertICAP_FEEDERTYPE_toString((TW_UINT16)_unItem);
      break;

    case ICAP_IMAGEFILEFORMAT:
      pszString = convertICAP_IMAGEFILEFORMAT_toString((TW_UINT16)_unItem);
      break;

    case ICAP_FLASHUSED2:
      pszString = convertICAP_FLASHUSED2_toString((TW_UINT16)_unItem);
      break;

    case CAP_FEEDERORDER:
      pszString = convertCAP_FEEDERORDER_toString((TW_UINT16)_unItem);
      break;

    case CAP_FEEDERPOCKET:
      pszString = convertCAP_FEEDERPOCKET_toString((TW_UINT16)_unItem);
      break;

    case ICAP_FLIPROTATION:
      pszString = convertICAP_FLIPROTATION_toString((TW_UINT16)_unItem);
      break;

    case ICAP_FILTER:
      pszString = convertICAP_FILTER_toString((TW_UINT16)_unItem);
      break;

    case ICAP_ICCPROFILE:
      pszString = convertICAP_ICCPROFILE_toString((TW_UINT16)_unItem);
      break;

    case ICAP_IMAGEFILTER:
      pszString = convertICAP_IMAGEFILTER_toString((TW_UINT16)_unItem);
      break;

    case ICAP_IMAGEMERGE:
      pszString = convertICAP_IMAGEMERGE_toString((TW_UINT16)_unItem);
      break;

    case CAP_JOBCONTROL:
      pszString = convertCAP_JOBCONTROL_toString((TW_UINT16)_unItem);
      break;

    case ICAP_JPEGQUALITY:
      pszString = convertICAP_JPEGQUALITY_toString((TW_UINT16)_unItem);
      break;

    case ICAP_LIGHTPATH:
      pszString = convertICAP_LIGHTPATH_toString((TW_UINT16)_unItem);
      break;

    case ICAP_LIGHTSOURCE:
      pszString = convertICAP_LIGHTSOURCE_toString((TW_UINT16)_unItem);
      break;

    case ICAP_NOISEFILTER:
      pszString = convertICAP_NOISEFILTER_toString((TW_UINT16)_unItem);
      break;

    case ICAP_ORIENTATION:
      pszString = convertICAP_ORIENTATION_toString((TW_UINT16)_unItem);
      break;

    case ICAP_OVERSCAN:
      pszString = convertICAP_OVERSCAN_toString((TW_UINT16)_unItem);
      break;

    case ICAP_PLANARCHUNKY:
      pszString = convertICAP_PLANARCHUNKY_toString((TW_UINT16)_unItem);
      break;

    case ICAP_PIXELFLAVOR:
      pszString = convertICAP_PIXELFLAVOR_toString((TW_UINT16)_unItem);
      break;

    case CAP_PRINTERMODE:
      pszString = convertCAP_PRINTERMODE_toString((TW_UINT16)_unItem);
      break;

    case CAP_PRINTER:
      pszString = convertCAP_PRINTER_toString((TW_UINT16)_unItem);
      break;

    case CAP_POWERSUPPLY:
      pszString = convertCAP_POWERSUPPLY_toString((TW_UINT16)_unItem);
      break;

    case ICAP_PIXELTYPE:
      pszString = convertICAP_PIXELTYPE_toString((TW_UINT16)_unItem);
      break;

    case CAP_SEGMENTED:
      pszString = convertCAP_SEGMENTED_toString((TW_UINT16)_unItem);
      break;

    case ICAP_SUPPORTEDEXTIMAGEINFO:
      pszString = convertExtImageInfoName_toString((TW_UINT16)_unItem);
      break;

    case ICAP_SUPPORTEDSIZES:
      pszString = convertICAP_SUPPORTEDSIZES_toString((TW_UINT16)_unItem);
      break;

    case ICAP_XFERMECH:
      pszString = convertICAP_XFERMECH_toString((TW_UINT16)_unItem);
      break;

    case ICAP_UNITS:
      pszString = convertICAP_UNITS_toString((TW_UINT16)_unItem);
      break;

    default:
      {
      char *buff = nextTempBuffer();
      switch(_unType)
      {
        case TWTY_UINT8:
        case TWTY_UINT16:
        case TWTY_UINT32:
          SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%u [0x%x]", _unItem, _unItem);
          break;

        case TWTY_INT8:
        case TWTY_INT16:
        case TWTY_INT32:
          SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%d", _unItem);
          break;

        case TWTY_BOOL:
          SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%s", (TW_BOOL)_unItem? "True" : "False");
          break;
      }
      pszString = buff;
      }
      break;
  }

  return pszString;
}

//////////////////////////////////////////////////////////////////////////////
const char* convertEI_Item_toString(const TW_UINT16 _unEI, const TW_UINT32 _unItem)
{
  const char* pszString = NULL;
  TW_UINT16 twItem = (TW_UINT16)_unItem;
  switch(_unEI)
  {
    case TWEI_BARCODEROTATION:
      pszString = convertTWEI_BARCODEROTATION_toString((TW_UINT16)_unItem);
      break;

    case TWEI_BARCODETYPE:
      pszString = CapabilityValueToString(ICAP_SUPPORTEDBARCODETYPES, TWTY_UINT16, &twItem);//convertICAP_SUPPORTEDBARCODETYPES_toString((TW_UINT16)_unItem);
      break;

    case TWEI_PAGESIDE: //CAP_CAMERASIDE
      pszString = CapabilityValueToString(CAP_CAMERASIDE, TWTY_UINT16, &twItem);//convertTWEI_PAGESIDE_toString((TW_UINT16)_unItem);
      break;

    case TWEI_DESKEWSTATUS:
      pszString = convertTWEI_DESKEWSTATUS_toString((TW_UINT16)_unItem);
      break;

    case TWEI_FILESYSTEMSOURCE:
      pszString = convertFileType_toString((TW_UINT16)_unItem);
      break;

    case TWEI_PIXELFLAVOR:
      pszString = CapabilityValueToString(ICAP_PIXELFLAVOR, TWTY_UINT16, &twItem);//convertICAP_PIXELFLAVOR_toString((TW_UINT16)_unItem);
      break;

    case TWEI_MAGTYPE:
      pszString = convertTWEI_MAGTYPE_toString((TW_UINT16)_unItem);
      break;

    case TWEI_PATCHCODE:
      pszString = convertTWEI_PATCHCODE_toString((TW_UINT16)_unItem);
      break;
  }

  return pszString;
}


//////////////////////////////////////////////////////////////////////////////
const char* convertCAP_toString(const TW_UINT16 _unCap)
{
  const char* text;

  switch(_unCap)
  {
  case ICAP_AUTODISCARDBLANKPAGES:
    text = "ICAP_AUTODISCARDBLANKPAGES";
    break;
  case CAP_CUSTOMBASE:
    text = "CAP_CUSTOMBASE";
    break;

  case CAP_XFERCOUNT:
    text = "CAP_XFERCOUNT";
    break;

  case ICAP_COMPRESSION:
    text = "ICAP_COMPRESSION";
    break;

  case ICAP_PIXELTYPE:
    text = "ICAP_PIXELTYPE";
    break;

  case ICAP_UNITS:
    text = "ICAP_UNITS";
    break;

  case ICAP_XFERMECH:
    text = "ICAP_XFERMECH";
    break;

  case CAP_AUTHOR:
    text = "CAP_AUTHOR";
    break;

  case CAP_CAPTION:
    text = "CAP_CAPTION";
    break;

  case CAP_FEEDERENABLED:
    text = "CAP_FEEDERENABLED";
    break;

  case CAP_FEEDERLOADED:
    text = "CAP_FEEDERLOADED";
    break;

  case CAP_TIMEDATE:
    text = "CAP_TIMEDATE";
    break;

  case CAP_SUPPORTEDCAPS:
    text = "CAP_SUPPORTEDCAPS";
    break;

  case CAP_EXTENDEDCAPS:
    text = "CAP_EXTENDEDCAPS";
    break;

  case CAP_AUTOFEED:
    text = "CAP_AUTOFEED";
    break;

  case CAP_CLEARPAGE:
    text = "CAP_CLEARPAGE";
    break;

  case CAP_FEEDPAGE:
    text = "CAP_FEEDPAGE";
    break;

  case CAP_REWINDPAGE:
    text = "CAP_REWINDPAGE";
    break;

  case CAP_INDICATORS:
    text = "CAP_INDICATORS";
    break;

  case CAP_SUPPORTEDCAPSEXT:
    text = "CAP_SUPPORTEDCAPSEXT";
    break;

  case CAP_PAPERDETECTABLE:
    text = "CAP_PAPERDETECTABLE";
    break;

  case CAP_UICONTROLLABLE:
    text = "CAP_UICONTROLLABLE";
    break;

  case CAP_DEVICEONLINE:
    text = "CAP_DEVICEONLINE";
    break;

  case CAP_AUTOSCAN:
    text = "CAP_AUTOSCAN";
    break;

  case CAP_THUMBNAILSENABLED:
    text = "CAP_THUMBNAILSENABLED";
    break;

  case CAP_DUPLEX:
    text = "CAP_DUPLEX";
    break;

  case CAP_DUPLEXENABLED:
    text = "CAP_DUPLEXENABLED";
    break;

  case CAP_ENABLEDSUIONLY:
    text = "CAP_ENABLEDSUIONLY";
    break;

  case CAP_CUSTOMDSDATA:
    text = "CAP_CUSTOMDSDATA";
    break;

  case CAP_ENDORSER:
    text = "CAP_ENDORSER";
    break;

  case CAP_JOBCONTROL:
    text = "CAP_JOBCONTROL";
    break;

  case CAP_ALARMS:
    text = "CAP_ALARMS";
    break;

  case CAP_ALARMVOLUME:
    text = "CAP_ALARMVOLUME";
    break;

  case CAP_AUTOMATICCAPTURE:
    text = "CAP_AUTOMATICCAPTURE";
    break;

  case CAP_TIMEBEFOREFIRSTCAPTURE:
    text = "CAP_TIMEBEFOREFIRSTCAPTURE";
    break;

  case CAP_TIMEBETWEENCAPTURES:
    text = "CAP_TIMEBETWEENCAPTURES";
    break;

  case CAP_CLEARBUFFERS:
    text = "CAP_CLEARBUFFERS";
    break;

  case CAP_MAXBATCHBUFFERS:
    text = "CAP_MAXBATCHBUFFERS";
    break;

  case CAP_DEVICETIMEDATE:
    text = "CAP_DEVICETIMEDATE";
    break;

  case CAP_POWERSUPPLY:
    text = "CAP_POWERSUPPLY";
    break;

  case CAP_CAMERAPREVIEWUI:
    text = "CAP_CAMERAPREVIEWUI";
    break;

  case CAP_DEVICEEVENT:
    text = "CAP_DEVICEEVENT";
    break;

  case CAP_SERIALNUMBER:
    text = "CAP_SERIALNUMBER";
    break;

  case CAP_PRINTER:
    text = "CAP_PRINTER";
    break;

  case CAP_PRINTERENABLED:
    text = "CAP_PRINTERENABLED";
    break;

  case CAP_PRINTERINDEX:
    text = "CAP_PRINTERINDEX";
    break;

  case CAP_PRINTERMODE:
    text = "CAP_PRINTERMODE";
    break;

  case CAP_PRINTERSTRING:
    text = "CAP_PRINTERSTRING";
    break;

  case CAP_PRINTERSUFFIX:
    text = "CAP_PRINTERSUFFIX";
    break;

  case CAP_LANGUAGE:
    text = "CAP_LANGUAGE";
    break;

  case CAP_FEEDERALIGNMENT:
    text = "CAP_FEEDERALIGNMENT";
    break;

  case CAP_FEEDERORDER:
    text = "CAP_FEEDERORDER";
    break;

  case CAP_REACQUIREALLOWED:
    text = "CAP_REACQUIREALLOWED";
    break;

  case CAP_BATTERYMINUTES:
    text = "CAP_BATTERYMINUTES";
    break;

  case CAP_BATTERYPERCENTAGE:
    text = "CAP_BATTERYPERCENTAGE";
    break;

  case CAP_CAMERASIDE:
    text = "CAP_CAMERASIDE";
    break;

  case CAP_SEGMENTED:
    text = "CAP_SEGMENTED";
    break;

  case CAP_CAMERAENABLED:
    text = "CAP_CAMERAENABLED";
    break;

  case CAP_CAMERAORDER:
    text = "CAP_CAMERAORDER";
    break;

  case CAP_MICRENABLED:
    text = "CAP_MICRENABLED";
    break;

  case CAP_FEEDERPREP:
    text = "CAP_FEEDERPREP";
    break;

  case CAP_FEEDERPOCKET:
    text = "CAP_FEEDERPOCKET";
    break;

  case CAP_AUTOMATICSENSEMEDIUM:
    text = "CAP_AUTOMATICSENSEMEDIUM";
    break;

  case CAP_CUSTOMINTERFACEGUID:
    text = "CAP_CUSTOMINTERFACEGUID";
    break;

  case ICAP_AUTOBRIGHT:
    text = "ICAP_AUTOBRIGHT";
    break;

  case ICAP_BRIGHTNESS:
    text = "ICAP_BRIGHTNESS";
    break;

  case ICAP_CONTRAST:
    text = "ICAP_CONTRAST";
    break;

  case ICAP_CUSTHALFTONE:
    text = "ICAP_CUSTHALFTONE";
    break;

  case ICAP_EXPOSURETIME:
    text = "ICAP_EXPOSURETIME";
    break;

  case ICAP_FILTER:
    text = "ICAP_FILTER";
    break;

  case ICAP_FLASHUSED:
    text = "ICAP_FLASHUSED";
    break;

  case ICAP_GAMMA:
    text = "ICAP_GAMMA";
    break;

  case ICAP_HALFTONES:
    text = "ICAP_HALFTONES";
    break;

  case ICAP_HIGHLIGHT:
    text = "ICAP_HIGHLIGHT";
    break;

  case ICAP_IMAGEFILEFORMAT:
    text = "ICAP_IMAGEFILEFORMAT";
    break;

  case ICAP_LAMPSTATE:
    text = "ICAP_LAMPSTATE";
    break;

  case ICAP_LIGHTSOURCE:
    text = "ICAP_LIGHTSOURCE";
    break;

  case ICAP_ORIENTATION:
    text = "ICAP_ORIENTATION";
    break;

  case ICAP_PHYSICALWIDTH:
    text = "ICAP_PHYSICALWIDTH";
    break;

  case ICAP_PHYSICALHEIGHT:
    text = "ICAP_PHYSICALHEIGHT";
    break;

  case ICAP_SHADOW:
    text = "ICAP_SHADOW";
    break;

  case ICAP_FRAMES:
    text = "ICAP_FRAMES";
    break;

  case ICAP_XNATIVERESOLUTION:
    text = "ICAP_XNATIVERESOLUTION";
    break;

  case ICAP_YNATIVERESOLUTION:
    text = "ICAP_YNATIVERESOLUTION";
    break;

  case ICAP_XRESOLUTION:
    text = "ICAP_XRESOLUTION";
    break;

  case ICAP_YRESOLUTION:
    text = "ICAP_YRESOLUTION";
    break;

  case ICAP_MAXFRAMES:
    text = "ICAP_MAXFRAMES";
    break;

  case ICAP_TILES:
    text = "ICAP_TILES";
    break;

  case ICAP_BITORDER:
    text = "ICAP_BITORDER";
    break;

  case ICAP_CCITTKFACTOR:
    text = "ICAP_CCITTKFACTOR";
    break;

  case ICAP_LIGHTPATH:
    text = "ICAP_LIGHTPATH";
    break;

  case ICAP_PIXELFLAVOR:
    text = "ICAP_PIXELFLAVOR";
    break;

  case ICAP_PLANARCHUNKY:
    text = "ICAP_PLANARCHUNKY";
    break;

  case ICAP_ROTATION:
    text = "ICAP_ROTATION";
    break;

  case ICAP_SUPPORTEDSIZES:
    text = "ICAP_SUPPORTEDSIZES";
    break;

  case ICAP_THRESHOLD:
    text = "ICAP_THRESHOLD";
    break;

  case ICAP_XSCALING:
    text = "ICAP_XSCALING";
    break;

  case ICAP_YSCALING:
    text = "ICAP_YSCALING";
    break;

  case ICAP_BITORDERCODES:
    text = "ICAP_BITORDERCODES";
    break;

  case ICAP_PIXELFLAVORCODES:
    text = "ICAP_PIXELFLAVORCODES";
    break;

  case ICAP_JPEGPIXELTYPE:
    text = "ICAP_JPEGPIXELTYPE";
    break;

  case ICAP_TIMEFILL:
    text = "ICAP_TIMEFILL";
    break;

  case ICAP_BITDEPTH:
    text = "ICAP_BITDEPTH";
    break;

  case ICAP_BITDEPTHREDUCTION:
    text = "ICAP_BITDEPTHREDUCTION";
    break;

  case ICAP_UNDEFINEDIMAGESIZE:
    text = "ICAP_UNDEFINEDIMAGESIZE";
    break;

  case ICAP_IMAGEDATASET:
    text = "ICAP_IMAGEDATASET";
    break;

  case ICAP_EXTIMAGEINFO:
    text = "ICAP_EXTIMAGEINFO";
    break;

  case ICAP_MINIMUMHEIGHT:
    text = "ICAP_MINIMUMHEIGHT";
    break;

  case ICAP_MINIMUMWIDTH:
    text = "ICAP_MINIMUMWIDTH";
    break;

  case ICAP_FLIPROTATION:
    text = "ICAP_FLIPROTATION";
    break;

  case ICAP_BARCODEDETECTIONENABLED:
    text = "ICAP_BARCODEDETECTIONENABLED";
    break;

  case ICAP_SUPPORTEDBARCODETYPES:
    text = "ICAP_SUPPORTEDBARCODETYPES";
    break;

  case ICAP_BARCODEMAXSEARCHPRIORITIES:
    text = "ICAP_BARCODEMAXSEARCHPRIORITIES";
    break;

  case ICAP_BARCODESEARCHPRIORITIES:
    text = "ICAP_BARCODESEARCHPRIORITIES";
    break;

  case ICAP_BARCODESEARCHMODE:
    text = "ICAP_BARCODESEARCHMODE";
    break;

  case ICAP_BARCODEMAXRETRIES:
    text = "ICAP_BARCODEMAXRETRIES";
    break;

  case ICAP_BARCODETIMEOUT:
    text = "ICAP_BARCODETIMEOUT";
    break;

  case ICAP_ZOOMFACTOR:
    text = "ICAP_ZOOMFACTOR";
    break;

  case ICAP_PATCHCODEDETECTIONENABLED:
    text = "ICAP_PATCHCODEDETECTIONENABLED";
    break;

  case ICAP_SUPPORTEDPATCHCODETYPES:
    text = "ICAP_SUPPORTEDPATCHCODETYPES";
    break;

  case ICAP_PATCHCODEMAXSEARCHPRIORITIES:
    text = "ICAP_PATCHCODEMAXSEARCHPRIORITIES";
    break;

  case ICAP_PATCHCODESEARCHPRIORITIES:
    text = "ICAP_PATCHCODESEARCHPRIORITIES";
    break;

  case ICAP_PATCHCODESEARCHMODE:
    text = "ICAP_PATCHCODESEARCHMODE";
    break;

  case ICAP_PATCHCODEMAXRETRIES:
    text = "ICAP_PATCHCODEMAXRETRIES";
    break;

  case ICAP_PATCHCODETIMEOUT:
    text = "ICAP_PATCHCODETIMEOUT";
    break;

  case ICAP_FLASHUSED2:
    text = "ICAP_FLASHUSED2";
    break;

  case ICAP_IMAGEFILTER:
    text = "ICAP_IMAGEFILTER";
    break;

  case ICAP_NOISEFILTER:
    text = "ICAP_NOISEFILTER";
    break;

  case ICAP_OVERSCAN:
    text = "ICAP_OVERSCAN";
    break;

  case ICAP_AUTOMATICBORDERDETECTION:
    text = "ICAP_AUTOMATICBORDERDETECTION";
    break;

  case ICAP_AUTOMATICDESKEW:
    text = "ICAP_AUTOMATICDESKEW";
    break;

  case ICAP_AUTOMATICROTATE:
    text = "ICAP_AUTOMATICROTATE";
    break;

  case ICAP_JPEGQUALITY:
    text = "ICAP_JPEGQUALITY";
    break;

  case ICAP_FEEDERTYPE:
    text = "ICAP_FEEDERTYPE";
    break;

  case ICAP_ICCPROFILE:
    text = "ICAP_ICCPROFILE";
    break;

  case ICAP_AUTOSIZE:
    text = "ICAP_AUTOSIZE";
    break;

    case ICAP_AUTOMATICCROPUSESFRAME:
    text = "ICAP_AUTOMATICCROPUSESFRAME";
    break;

  case ICAP_AUTOMATICLENGTHDETECTION:
    text = "ICAP_AUTOMATICLENGTHDETECTION";
    break;

  case ICAP_AUTOMATICCOLORENABLED:
    text = "ICAP_AUTOMATICCOLORENABLED";
    break;

  case ICAP_AUTOMATICCOLORNONCOLORPIXELTYPE:
    text = "ICAP_AUTOMATICCOLORNONCOLORPIXELTYPE";
    break;

  case ICAP_COLORMANAGEMENTENABLED:
    text = "ICAP_COLORMANAGEMENTENABLED";
    break;

  case ICAP_IMAGEMERGE:
    text = "ICAP_IMAGEMERGE";
    break;

  case ICAP_IMAGEMERGEHEIGHTTHRESHOLD:
    text = "ICAP_IMAGEMERGEHEIGHTTHRESHOLD";
    break;

  case ICAP_SUPPORTEDEXTIMAGEINFO:
    text = "ICAP_SUPPORTEDEXTIMAGEINFO";
    break;

  case ACAP_AUDIOFILEFORMAT:
    text = "ACAP_AUDIOFILEFORMAT";
    break;

  case ACAP_XFERMECH:
    text = "ACAP_XFERMECH";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      if(_unCap < CAP_CUSTOMBASE)
      {
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown CAP 0x:%04X", _unCap);
      }
      else if (_unCap > CAP_CUSTOMBASE)
      {
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Custom CAP 0x:%04X", _unCap);
      }
      else // == CAP_CUSTOMBASE
      {
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Invalid CAP 0x:%04X", _unCap);
      }
      text = buff;
    }
    break;
  }

  return text;
}



//////////////////////////////////////////////////////////////////////////////
const char* convertTWTY_toString(const TW_UINT16 _unItem)
{
  const char* text;

  switch(_unItem)
  {
  case TWTY_INT8:
    text = "TWTY_INT8";
    break;

  case TWTY_INT16:
    text = "TWTY_INT16";
    break;

  case TWTY_INT32:
    text = "TWTY_INT32";
    break;

  case TWTY_UINT8:
    text = "TWTY_UINT8";
    break;

  case TWTY_UINT16:
    text = "TWTY_UINT16";
    break;

  case TWTY_UINT32:
    text = "TWTY_UINT32";
    break;

  case TWTY_BOOL:
    text = "TWTY_BOOL";
    break;

  case TWTY_FIX32:
    text = "TWTY_FIX32";
    break;

  case TWTY_FRAME:
    text = "TWTY_FRAME";
    break;

  case TWTY_STR32:
    text = "TWTY_STR32";
    break;

  case TWTY_STR64:
    text = "TWTY_STR64";
    break;

  case TWTY_STR128:
    text = "TWTY_STR128";
    break;

  case TWTY_STR255:
    text = "TWTY_STR255";
    break;

  case TWTY_STR1024:
    text = "TWTY_STR1024";
    break;

  case TWTY_UNI512:
    text = "TWTY_UNI512";
    break;

  case TWTY_HANDLE:
    text = "TWTY_HANDLE";
    break;    

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWTY 0x:%04X", _unItem);
      text = buff;
    }
    break;
  }

  return text;
}



//////////////////////////////////////////////////////////////////////////////
// Convert Extended Image Info Attributes to String

const char* convertExtImageInfoName_toString(int InfoID)
{
  const char* text;

  switch(InfoID)
  {
  case TWEI_BARCODEX:
    text = "TWEI_BARCODEX";
    break;

  case TWEI_BARCODEY:
    text = "TWEI_BARCODEY";
    break;

	case TWEI_BARCODETEXT:
    text = "TWEI_BARCODETEXT";
    break;

	case TWEI_BARCODETYPE:
    text = "TWEI_BARCODETYPE";
    break;

	case TWEI_DESHADETOP:
    text = "TWEI_DESHADETOP";
    break;

	case TWEI_DESHADELEFT:
    text = "TWEI_DESHADELEFT";
    break;

	case TWEI_DESHADEHEIGHT:
    text = "TWEI_DESHADEHEIGHT";
    break;

	case TWEI_DESHADEWIDTH:
    text = "TWEI_DESHADEWIDTH";
    break;

	case TWEI_DESHADESIZE:
    text = "TWEI_DESHADESIZE";
    break;

	case TWEI_SPECKLESREMOVED:
    text = "TWEI_SPECKLESREMOVED";
    break;

	case TWEI_HORZLINEXCOORD:
    text = "TWEI_HORZLINEXCOORD";
    break;

	case TWEI_HORZLINEYCOORD:
    text = "TWEI_HORZLINEYCOORD";
    break;

	case TWEI_HORZLINELENGTH:
    text = "TWEI_HORZLINELENGTH";
    break;

	case TWEI_HORZLINETHICKNESS:
    text = "TWEI_HORZLINETHICKNESS";
    break;

	case TWEI_VERTLINEXCOORD:
    text = "TWEI_VERTLINEXCOORD";
    break;

	case TWEI_VERTLINEYCOORD:
    text = "TWEI_VERTLINEYCOORD";
    break;

	case TWEI_VERTLINELENGTH:
    text = "TWEI_VERTLINELENGTH";
    break;

	case TWEI_VERTLINETHICKNESS:
    text = "TWEI_VERTLINETHICKNESS";
    break;

	case TWEI_PATCHCODE:
    text = "TWEI_PATCHCODE";
    break;

	case TWEI_ENDORSEDTEXT:
    text = "TWEI_ENDORSEDTEXT";
    break;

	case TWEI_FORMCONFIDENCE:
    text = "TWEI_FORMCONFIDENCE";
    break;

	case TWEI_FORMTEMPLATEMATCH:
    text = "TWEI_FORMTEMPLATEMATCH";
    break;

	case TWEI_FORMTEMPLATEPAGEMATCH:
    text = "TWEI_FORMTEMPLATEPAGEMATCH";
    break;

	case TWEI_FORMHORZDOCOFFSET:
    text = "TWEI_FORMHORZDOCOFFSET";
    break;

	case TWEI_FORMVERTDOCOFFSET:
    text = "TWEI_FORMVERTDOCOFFSET";
    break;

	case TWEI_BARCODECOUNT:
    text = "TWEI_BARCODECOUNT";
    break;

	case TWEI_BARCODECONFIDENCE:
    text = "TWEI_BARCODECONFIDENCE";
    break;

	case TWEI_BARCODEROTATION:
    text = "TWEI_BARCODEROTATION";
    break;

	case TWEI_BARCODETEXTLENGTH:
    text = "TWEI_BARCODETEXTLENGTH";
    break;

	case TWEI_DESHADECOUNT:
    text = "TWEI_DESHADECOUNT";
    break;

	case TWEI_DESHADEBLACKCOUNTOLD:
    text = "TWEI_DESHADEBLACKCOUNTOLD";
    break;

	case TWEI_DESHADEBLACKCOUNTNEW:
    text = "TWEI_DESHADEBLACKCOUNTNEW";
    break;

	case TWEI_DESHADEBLACKRLMIN:
    text = "TWEI_DESHADEBLACKRLMIN";
    break;

	case TWEI_DESHADEBLACKRLMAX:
    text = "TWEI_DESHADEBLACKRLMAX";
    break;

	case TWEI_DESHADEWHITECOUNTOLD:
    text = "TWEI_DESHADEWHITECOUNTOLD";
    break;

	case TWEI_DESHADEWHITECOUNTNEW:
    text = "TWEI_DESHADEWHITECOUNTNEW";
    break;

	case TWEI_DESHADEWHITERLMIN:
    text = "TWEI_DESHADEWHITERLMIN";
    break;

	case TWEI_DESHADEWHITERLAVE:
    text = "TWEI_DESHADEWHITERLAVE";
    break;

	case TWEI_DESHADEWHITERLMAX:
    text = "TWEI_DESHADEWHITERLMAX";
    break;

	case TWEI_BLACKSPECKLESREMOVED:
    text = "TWEI_BLACKSPECKLESREMOVED";
    break;

	case TWEI_WHITESPECKLESREMOVED:
    text = "TWEI_WHITESPECKLESREMOVED";
    break;

	case TWEI_HORZLINECOUNT:
    text = "TWEI_HORZLINECOUNT";
    break;

	case TWEI_VERTLINECOUNT:
    text = "TWEI_VERTLINECOUNT";
    break;

	case TWEI_DESKEWSTATUS:
    text = "TWEI_DESKEWSTATUS";
    break;

	case TWEI_SKEWORIGINALANGLE:
    text = "TWEI_SKEWORIGINALANGLE";
    break;

	case TWEI_SKEWFINALANGLE:
    text = "TWEI_SKEWFINALANGLE";
    break;

	case TWEI_SKEWCONFIDENCE:
    text = "TWEI_SKEWCONFIDENCE";
    break;

	case TWEI_SKEWWINDOWX1:
    text = "TWEI_SKEWWINDOWX1";
    break;

	case TWEI_SKEWWINDOWY1:
    text = "TWEI_SKEWWINDOWY1";
    break;

	case TWEI_SKEWWINDOWX2:
    text = "TWEI_SKEWWINDOWX2";
    break;

	case TWEI_SKEWWINDOWY2:
    text = "TWEI_SKEWWINDOWY2";
    break;

	case TWEI_SKEWWINDOWX3:
    text = "TWEI_SKEWWINDOWX3";
    break;

	case TWEI_SKEWWINDOWY3:
    text = "TWEI_SKEWWINDOWY3";
    break;

	case TWEI_SKEWWINDOWX4:
    text = "TWEI_SKEWWINDOWX4";
    break;

	case TWEI_SKEWWINDOWY4:
    text = "TWEI_SKEWWINDOWY4";
    break;

	case TWEI_BOOKNAME:
    text = "TWEI_BOOKNAME";
    break;

	case TWEI_CHAPTERNUMBER:
    text = "TWEI_CHAPTERNUMBER";
    break;

	case TWEI_DOCUMENTNUMBER:
    text = "TWEI_DOCUMENTNUMBER";
    break;

	case TWEI_PAGENUMBER:
    text = "TWEI_PAGENUMBER";
    break;

	case TWEI_CAMERA:
    text = "TWEI_CAMERA";
    break;

	case TWEI_FRAMENUMBER:
    text = "TWEI_FRAMENUMBER";
    break;

	case TWEI_FRAME:
    text = "TWEI_FRAME";
    break;

	case TWEI_PIXELFLAVOR:
    text = "TWEI_PIXELFLAVOR";
    break;

	case TWEI_PAGESIDE:
    text = "TWEI_PAGESIDE";
    break;

	case TWEI_MAGDATA:
    text = "TWEI_MAGDATA";
    break;

	case TWEI_MAGTYPE:
    text = "TWEI_MAGTYPE";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "ExtImageInfo ID 0x:%04X",InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_ALARMS values to String
const char* convertCAP_ALARMS_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWAL_ALARM:
    text = "Alarm";
    break;

	case TWAL_FEEDERERROR:
    text = "Feeder Error";
    break;

	case TWAL_FEEDERWARNING:
    text = "Feeder Warning";
    break;

	case TWAL_BARCODE:
    text = "Barcode";
    break;

	case TWAL_DOUBLEFEED:
    text = "Double Feed";
    break;

	case TWAL_JAM:
    text = "Paper Jam";
    break;

	case TWAL_PATCHCODE:
    text = "Patch Code";
    break;

	case TWAL_POWER:
    text = "Power";
    break;

	case TWAL_SKEW:
    text = "Skew";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWAL 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_AUTOSIZE values to String
const char* convertICAP_AUTOSIZE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWAS_NONE:
    text = "None";
    break;

	case TWAS_AUTO:
    text = "Auto";
    break;

	case TWAS_CURRENT:
    text = "Current";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWAS 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert TWEI_BARCODEROTATION values to String
const char* convertTWEI_BARCODEROTATION_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWBCOR_ROT0:
    text = "TWBCOR_ROT0";
    break;

	case TWBCOR_ROT90:
    text = "TWBCOR_ROT90";
    break;

	case TWBCOR_ROT180:
    text = "TWBCOR_ROT180";
    break;

	case TWBCOR_ROT270:
    text = "TWBCOR_ROT270";
    break;

	case TWBCOR_ROTX:
    text = "TWBCOR_ROTX";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWBCOR 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_BARCODESEARCHMODE values to String
const char* convertICAP_BARCODESEARCHMODE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWBD_HORZ:
    text = "Horizontal";
    break;

	case TWBD_VERT:
    text = "Vertical";
    break;

	case TWBD_HORZVERT:
    text = "Horz Vert";
    break;

	case TWBD_VERTHORZ:
    text = "Vert Horz";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWBD 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_BITORDER values to String
const char* convertICAP_BITORDER_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWBO_LSBFIRST:
    text = "LSB first";
    break;

	case TWBO_MSBFIRST:
    text = "MSB first";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWBO 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_AUTODISCARDBLANKPAGES values to String
const char* convertICAP_AUTODISCARDBLANKPAGES_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWBP_DISABLE:
    text = "Disable";
    break;

	case TWBP_AUTO:
    text = "Auto";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWBP 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_BITDEPTHREDUCTION values to String
const char* convertICAP_BITDEPTHREDUCTION_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWBR_THRESHOLD:
    text = "Threshold";
    break;

	case TWBR_HALFTONE:
    text = "Halftone";
    break;

	case TWBR_CUSTHALFTONE:
    text = "Custom Halftone";
    break;

	case TWBR_DIFFUSION:
    text = "Diffusion";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWBR 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_SUPPORTEDBARCODETYPES and TWEI_BARCODETYPE values to String
const char* convertICAP_SUPPORTEDBARCODETYPES_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWBT_3OF9:
    text = "3of9";
    break;

	case TWBT_2OF5INTERLEAVED:
    text = "2of5 interleaved";
    break;

	case TWBT_2OF5NONINTERLEAVED:
    text = "2of5 noninterleaved";
    break;

	case TWBT_CODE93:
    text = "code93";
    break;

	case TWBT_CODE128:
    text = "code128";
    break;

	case TWBT_UCC128:
    text = "UCC128";
    break;

	case TWBT_CODABAR:
    text = "Codebar";
    break;

	case TWBT_UPCA:
    text = "UPCA";
    break;

	case TWBT_UPCE:
    text = "UPCE";
    break;

	case TWBT_EAN8:
    text = "EAN8";
    break;

	case TWBT_EAN13:
    text = "EAN13";
    break;

	case TWBT_POSTNET:
    text = "POSTNET";
    break;

	case TWBT_PDF417:
    text = "PDF417";
    break;

	case TWBT_2OF5INDUSTRIAL:
    text = "2of5 industrial";
    break;

	case TWBT_2OF5MATRIX:
    text = "2of5 matrix";
    break;

	case TWBT_2OF5DATALOGIC:
    text = "2of5 datalogic";
    break;

	case TWBT_2OF5IATA:
    text = "2of5 IATA";
    break;

	case TWBT_3OF9FULLASCII:
    text = "3of9 fullASCII";
    break;

	case TWBT_CODABARWITHSTARTSTOP:
    text = "Codabar with start stop";
    break;

	case TWBT_MAXICODE:
    text = "MAXICODE";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWBT 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_COMPRESSION values to String
const char* convertICAP_COMPRESSION_toString(const TW_UINT16 _unItem)
{
  const char* text;

  switch(_unItem)
  {
  case TWCP_NONE:
    text = "None";
    break;

  case TWCP_PACKBITS:
    text = "PACKBITS";
    break;

  case TWCP_GROUP31D:
    text = "GROUP31D";
    break;

  case TWCP_GROUP31DEOL:
    text = "GROUP31DEOL";
    break;

  case TWCP_GROUP32D:
    text = "GROUP32D";
    break;

  case TWCP_GROUP4:
    text = "GROUP4";
    break;

  case TWCP_JPEG:
    text = "JPEG";
    break;

  case TWCP_LZW:
    text = "LZW";
    break;

  case TWCP_JBIG:
    text = "JBIG";
    break;

  case TWCP_PNG:
    text = "PNG";
    break;

  case TWCP_RLE4:
    text = "RLE4";
    break;

  case TWCP_RLE8:
    text = "RLE8";
    break;

  case TWCP_BITFIELDS:
    text = "BITFIELDS";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWCP 0x:%04X", _unItem);
      text = buff;
    }
    break;
  }

  return text;
}


//////////////////////////////////////////////////////////////////////////////
// Convert CAP_CAMERASIDE values to String
const char* convertCAP_CAMERASIDE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWCS_BOTH:
    text = "Both";
    break;

	case TWCS_TOP:
    text = "Top";
    break;

	case TWCS_BOTTOM:
    text = "Bottom";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWCS 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert TWEI_PAGESIDE values to String
const char* convertTWEI_PAGESIDE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWCS_TOP:
    text = "TWCS_TOP";
    break;

	case TWCS_BOTTOM:
    text = "TWCS_BOTTOM";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWCS 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_CLEARBUFFERS values to String
const char* convertCAP_CLEARBUFFERS_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWCB_AUTO:
    text = "Auto";
    break;

	case TWCB_CLEAR:
    text = "Clear";
    break;

	case TWCB_NOCLEAR:
    text = "No Clear";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWCB 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_DEVICEEVENT values to String
const char* convertCAP_DEVICEEVENT_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWDE_CUSTOMEVENTS:
    text = "Custom Events";
    break;

	case TWDE_CHECKAUTOMATICCAPTURE:
    text = "Check Automatic Capture";
    break;

	case TWDE_CHECKBATTERY:
    text = "Check Battery";
    break;

	case TWDE_CHECKDEVICEONLINE:
    text = "Check Device Online";
    break;

	case TWDE_CHECKFLASH:
    text = "Check Flash";
    break;

	case TWDE_CHECKPOWERSUPPLY:
    text = "Check Power Supply";
    break;

	case TWDE_CHECKRESOLUTION:
    text = "Check Resolution";
    break;

	case TWDE_DEVICEADDED:
    text = "Device Added";
    break;

	case TWDE_DEVICEOFFLINE:
    text = "Device Offline";
    break;

	case TWDE_DEVICEREADY:
    text = "Device Ready";
    break;

	case TWDE_DEVICEREMOVED:
    text = "Device Removed";
    break;

	case TWDE_IMAGECAPTURED:
    text = "Image Captured";
    break;

	case TWDE_IMAGEDELETED:
    text = "Image Deleted";
    break;

	case TWDE_PAPERDOUBLEFEED:
    text = "Paper Doublefeed";
    break;

	case TWDE_PAPERJAM:
    text = "Paperjam";
    break;

	case TWDE_LAMPFAILURE:
    text = "Lamp Failure";
    break;

	case TWDE_POWERSAVE:
    text = "Power Save";
    break;

	case TWDE_POWERSAVENOTIFY:
    text = "Power Save Notify";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWDE 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert TWEI_DESKEWSTATUS values to String
const char* convertTWEI_DESKEWSTATUS_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWDSK_SUCCESS:
    text = "TWDSK_SUCCESS";
    break;

	case TWDSK_REPORTONLY:
    text = "TWDSK_REPORTONLY";
    break;

	case TWDSK_FAIL:
    text = "TWDSK_FAIL";
    break;

	case TWDSK_DISABLED:
    text = "TWDSK_DISABLED";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWDSK 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_DUPLEX values to String
const char* convertCAP_DUPLEX_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWDX_NONE:
    text = "None";
    break;

	case TWDX_1PASSDUPLEX:
    text = "1 Pass Duplex";
    break;

	case TWDX_2PASSDUPLEX:
    text = "2 Pass Duplex";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWDX 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_FEEDERALIGNMENT values to String
const char* convertCAP_FEEDERALIGNMENT_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWFA_NONE:
    text = "None";
    break;

	case TWFA_LEFT:
    text = "Left";
    break;

	case TWFA_CENTER:
    text = "Center";
    break;

	case TWFA_RIGHT:
    text = "Right";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWFA 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_FEEDERTYPE values to String
const char* convertICAP_FEEDERTYPE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWFE_GENERAL:
    text = "General";
    break;

	case TWFE_PHOTO:
    text = "Photo";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWFE 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Cover ICAP_IMAGEFILEFORMAT values to String
const char* convertICAP_IMAGEFILEFORMAT_toString(const TW_UINT16 _unItem)
{
  const char* text;

  switch(_unItem)
  {
  case TWFF_TIFF:
    text = "tiff";
    break;

  case TWFF_PICT:
    text = "pict";
    break;

  case TWFF_BMP:
    text = "bmp";
    break;

  case TWFF_XBM:
    text = "xbm";
    break;

  case TWFF_JFIF:
    text = "jpeg";
    break;

  case TWFF_FPX:
    text = "fpx";
    break;

  case TWFF_TIFFMULTI:
    text = "multi image tiff";
    break;

  case TWFF_PNG:
    text = "png";
    break;

  case TWFF_SPIFF:
    text = "spiff";
    break;

  case TWFF_EXIF:
    text = "exif";
    break;

  case TWFF_PDF:
    text = "PDF";
    break;

  case TWFF_JP2:
    text = "JP2";
    break;

  case TWFF_JPN:
    text = "JPN";
    break;

  case TWFF_JPX:
    text = "JPX";
    break;

  case TWFF_DEJAVU:
    text = "DEJAVU";
    break;

  case TWFF_PDFA:
    text = "PDF-A1";/* 2.0 Adobe PDF/A, Version 1*/
    break;

  case TWFF_PDFA2:
    text = "PDF-A2";/* 2.1 Adobe PDF/A, Version 2*/
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWFF 0x:%04X", _unItem);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Cover ICAP_IMAGEFILEFORMAT values to String
const char* convertICAP_IMAGEFILEFORMAT_toExt(const TW_UINT16 _unItem)
{
  const char* text;

  switch(_unItem)
  {
  case TWFF_PICT:
    text = ".pict";
    break;

  case TWFF_BMP:
    text = ".bmp";
    break;

  case TWFF_XBM:
    text = ".xbm";
    break;

  case TWFF_JFIF:
    text = ".jpeg";
    break;

  case TWFF_FPX:
    text = ".fpx";
    break;

  case TWFF_TIFF:
  case TWFF_TIFFMULTI:
    text = ".tiff";
    break;

  case TWFF_PNG:
    text = ".png";
    break;

  case TWFF_SPIFF:
    text = ".spiff";
    break;

  case TWFF_EXIF:
    text = ".exif";
    break;

  case TWFF_JP2:
    text = ".jp2";
    break;

  case TWFF_JPN:
    text = ".jpn";
    break;

  case TWFF_JPX:
    text = ".jpx";
    break;

  case TWFF_DEJAVU:
    text = ".dejavu";
    break;

  case TWFF_PDF:
  case TWFF_PDFA:
  case TWFF_PDFA2:
    text = ".pdf";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, ".0x:%04X", _unItem);//Unknown TWFF 
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_FLASHUSED2 values to String
const char* convertICAP_FLASHUSED2_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWFL_NONE:
    text = "None";
    break;

	case TWFL_OFF:
    text = "Off";
    break;

	case TWFL_ON:
    text = "On";
    break;

	case TWFL_AUTO:
    text = "Auto";
    break;

	case TWFL_REDEYE:
    text = "Redeye";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWFL 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_FEEDERORDER values to String
const char* convertCAP_FEEDERORDER_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWFO_FIRSTPAGEFIRST:
    text = "First Page First";
    break;

	case TWFO_LASTPAGEFIRST:
    text = "Last Page First";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWFO 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_FEEDERPOCKET values to String
const char* convertCAP_FEEDERPOCKET_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWFP_POCKETERROR:
    text = "Pocket Error";
    break;

	case TWFP_POCKET1:
    text = "Pocket 1";
    break;

	case TWFP_POCKET2:
    text = "Pocket 2";
    break;

	case TWFP_POCKET3:
    text = "Pocket 3";
    break;

	case TWFP_POCKET4:
    text = "Pocket 4";
    break;

	case TWFP_POCKET5:
    text = "Pocket 5";
    break;

	case TWFP_POCKET6:
    text = "Pocket 6";
    break;

	case TWFP_POCKET7:
    text = "Pocket 7";
    break;

	case TWFP_POCKET8:
    text = "Pocket 8";
    break;

	case TWFP_POCKET9:
    text = "Pocket 9";
    break;

	case TWFP_POCKET10:
    text = "Pocket 10";
    break;

	case TWFP_POCKET11:
    text = "Pocket 11";
    break;

	case TWFP_POCKET12:
    text = "Pocket 12";
    break;

	case TWFP_POCKET13:
    text = "Pocket 13";
    break;

	case TWFP_POCKET14:
    text = "Pocket 14";
    break;

	case TWFP_POCKET15:
    text = "Pocket 15";
    break;

	case TWFP_POCKET16:
    text = "Pocket 16";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWFP 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_FLIPROTATION values to String
const char* convertICAP_FLIPROTATION_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWFR_BOOK:
    text = "Book";
    break;

	case TWFR_FANFOLD:
    text = "Fanfold";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWFR 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_FILTER values to String
const char* convertICAP_FILTER_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWFT_RED:
    text = "Red";
    break;

	case TWFT_GREEN:
    text = "Green";
    break;

	case TWFT_BLUE:
    text = "Blue";
    break;

	case TWFT_NONE:
    text = "None";
    break;

	case TWFT_WHITE:
    text = "White";
    break;

	case TWFT_CYAN:
    text = "Cyan";
    break;

	case TWFT_MAGENTA:
    text = "Magenta";
    break;

	case TWFT_YELLOW:
    text = "Yellow";
    break;

	case TWFT_BLACK:
    text = "Black";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWFT 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert TW_FILESYSTEM values to String
const char* convertTWEI_FILESYSTEM_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWFY_CAMERA:
    text = "Camera";
    break;

	case TWFY_CAMERATOP:
    text = "Camera Top";
    break;

	case TWFY_CAMERABOTTOM:
    text = "Camera Bottom";
    break;

	case TWFY_CAMERAPREVIEW:
    text = "Camera Preview";
    break;

	case TWFY_DOMAIN:
    text = "Domain";
    break;

	case TWFY_HOST:
    text = "Host";
    break;

	case TWFY_DIRECTORY:
    text = "Directory";
    break;

	case TWFY_IMAGE:
    text = "Image";
    break;

	case TWFY_UNKNOWN:
    text = "Unknown";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWFY 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_ICCPROFILE values to String
const char* convertICAP_ICCPROFILE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWIC_NONE:
    text = "None";
    break;

	case TWIC_LINK:
    text = "Link";
    break;

	case TWIC_EMBED:
    text = "Embed";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWIC 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_IMAGEFILTER values to String
const char* convertICAP_IMAGEFILTER_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWIF_NONE:
    text = "None";
    break;

	case TWIF_AUTO:
    text = "Auto";
    break;

	case TWIF_LOWPASS:
    text = "Low Pass";
    break;

	case TWIF_BANDPASS:
    text = "Band Pass";
    break;

	case TWIF_HIGHPASS:
    text = "High Pass";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWIF 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_IMAGEMERGE values to String
const char* convertICAP_IMAGEMERGE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWIM_NONE:
    text = "None";
    break;

	case TWIM_FRONTONTOP:
    text = "Front on Top";
    break;

	case TWIM_FRONTONBOTTOM:
    text = "Front on Bottom";
    break;

	case TWIM_FRONTONLEFT:
    text = "Front on Left";
    break;

	case TWIM_FRONTONRIGHT:
    text = "Front on Right";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWIM 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_JOBCONTROL values to String
const char* convertCAP_JOBCONTROL_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWJC_NONE:
    text = "None";
    break;

	case TWJC_JSIC:
    text = "JSIC";
    break;

	case TWJC_JSIS:
    text = "JSIS";
    break;

	case TWJC_JSXC:
    text = "JSXC";
    break;

	case TWJC_JSXS:
    text = "JSXS";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWJC 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_JPEGQUALITY values to String
const char* convertICAP_JPEGQUALITY_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWJQ_UNKNOWN:
    text = "Unknown";
    break;

	case TWJQ_LOW:
    text = "Low";
    break;

	case TWJQ_MEDIUM:
    text = "Medium";
    break;

	case TWJQ_HIGH:
    text = "High";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%d", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_LIGHTPATH values to String
const char* convertICAP_LIGHTPATH_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWLP_REFLECTIVE:
    text = "Reflective";
    break;

	case TWLP_TRANSMISSIVE:
    text = "Transmissive";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWLP 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_LIGHTSOURCE values to String
const char* convertICAP_LIGHTSOURCE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWLS_RED:
    text = "Red";
    break;

	case TWLS_GREEN:
    text = "Green";
    break;

	case TWLS_BLUE:
    text = "Blue";
    break;

	case TWLS_NONE:
    text = "None";
    break;

	case TWLS_WHITE:
    text = "White";
    break;

	case TWLS_UV:
    text = "UV";
    break;

	case TWLS_IR:
    text = "IR";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWLS 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert TWEI_MAGTYPE values to String
const char* convertTWEI_MAGTYPE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWMD_MICR:
    text = "TWMD_MICR";
    break;

	case TWMD_RAW:
    text = "TWMD_RAW";
    break;

	case TWMD_INVALID:
    text = "TWMD_INVALID";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWMD 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_NOISEFILTER values to String
const char* convertICAP_NOISEFILTER_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWNF_NONE:
    text = "None";
    break;

	case TWNF_AUTO:
    text = "Auto";
    break;

	case TWNF_LONEPIXEL:
    text = "Low Pixel";
    break;

	case TWNF_MAJORITYRULE:
    text = "Majoriry Rule";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWNF 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_ORIENTATION values to String
const char* convertICAP_ORIENTATION_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
//	case TWOR_ROT0:
//    text = "";
//    break;

	case TWOR_ROT90:
    text = "Orientation 90";
    break;

	case TWOR_ROT180:
    text = "Orientation 180";
    break;

//	case TWOR_ROT270:
//    text = "";
//    break;

	case TWOR_PORTRAIT:
    text = "Portrait";
    break;

	case TWOR_LANDSCAPE:
    text = "Landscape";
    break;

	case TWOR_AUTO:
    text = "Auto";
    break;

	case TWOR_AUTOTEXT:
    text = "Auto Text";
    break;

	case TWOR_AUTOPICTURE:
    text = "Auto Picture";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWOR 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_OVERSCAN values to String
const char* convertICAP_OVERSCAN_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWOV_NONE:
    text = "None";
    break;

	case TWOV_AUTO:
    text = "Auto";
    break;

	case TWOV_TOPBOTTOM:
    text = "Top Bottom";
    break;

	case TWOV_LEFTRIGHT:
    text = "Left Right";
    break;

	case TWOV_ALL:
    text = "All";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWOV 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_PLANARCHUNKY values to String
const char* convertICAP_PLANARCHUNKY_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWPC_CHUNKY:
    text = "Chunky";
    break;

	case TWPC_PLANAR:
    text = "Planar";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWPC 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert TWEI_PATCHCODE values to String
const char* convertTWEI_PATCHCODE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWPCH_PATCH1:
    text = "TWPCH_PATCH1";
    break;

	case TWPCH_PATCH2:
    text = "TWPCH_PATCH2";
    break;

	case TWPCH_PATCH3:
    text = "TWPCH_PATCH3";
    break;

	case TWPCH_PATCH4:
    text = "TWPCH_PATCH4";
    break;

	case TWPCH_PATCH6:
    text = "TWPCH_PATCH6";
    break;

	case TWPCH_PATCHT:
    text = "TWPCH_PATCHT";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWPCH 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_PIXELFLAVOR values to String
const char* convertICAP_PIXELFLAVOR_toString(const TW_UINT16 _unItem)
{
  const char* text;

  switch(_unItem)
  {
  case TWPF_CHOCOLATE:
    text = "Chocolate";
    break;

  case TWPF_VANILLA:
    text = "Vanilla";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWPF 0x:%04X", _unItem);
      text = buff;
    }
    break;
  }

  return text;
}


//////////////////////////////////////////////////////////////////////////////
// Convert CAP_PRINTERMODE values to String
const char* convertCAP_PRINTERMODE_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWPM_SINGLESTRING:
    text = "Single String";
    break;

	case TWPM_MULTISTRING:
    text = "Multi String";
    break;

	case TWPM_COMPOUNDSTRING:
    text = "Compound String";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWPM 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_PRINTER values to String
const char* convertCAP_PRINTER_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWPR_IMPRINTERTOPBEFORE:
    text = "Imprinter Top Before";
    break;

	case TWPR_IMPRINTERTOPAFTER:
    text = "Imprinter Top After";
    break;

	case TWPR_IMPRINTERBOTTOMBEFORE:
    text = "Imprinter Bottom Before";
    break;

	case TWPR_IMPRINTERBOTTOMAFTER:
    text = "Imprinter Bottom After";
    break;

	case TWPR_ENDORSERTOPBEFORE:
    text = "Endorser Top Before";
    break;

	case TWPR_ENDORSERTOPAFTER:
    text = "Endorser Top After";
    break;

	case TWPR_ENDORSERBOTTOMBEFORE:
    text = "Endorser Bottom Before";
    break;

	case TWPR_ENDORSERBOTTOMAFTER:
    text = "Endorser Bottom After";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWPR 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_POWERSUPPLY values to String
const char* convertCAP_POWERSUPPLY_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWPS_EXTERNAL:
    text = "External";
    break;

	case TWPS_BATTERY:
    text = "Battery";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWPS 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_PIXELTYPE values to String
const char* convertICAP_PIXELTYPE_toString(const TW_UINT16 _unItem)
{
  const char* text;

  switch(_unItem)
  {
  case TWPT_BW:
    text = "BW";
    break;

  case TWPT_GRAY:
    text = "GRAY";
    break;

  case TWPT_RGB:
    text = "RGB";
    break;

  case TWPT_PALETTE:
    text = "PALETTE";
    break;

  case TWPT_CMY:
    text = "CMY";
    break;

  case TWPT_CMYK:
    text = "CMYK";
    break;

  case TWPT_YUV:
    text = "YUV";
    break;

  case TWPT_YUVK:
    text = "YUVK";
    break;

  case TWPT_CIEXYZ:
    text = "CIEXYZ";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWPT 0x:%04X", _unItem);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert CAP_SEGMENTED values to String
const char* convertCAP_SEGMENTED_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWSG_NONE:
    text = "None";
    break;

	case TWSG_AUTO:
    text = "Auto";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWSG 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Convert ICAP_SUPPORTEDSIZES values to String
const char* convertICAP_SUPPORTEDSIZES_toString(const TW_UINT16 InfoID)
{
  const char* text;

  switch(InfoID)
  {
	case TWSS_NONE:
    text = "None";
    break;

	case TWSS_A4:
    text = "A4";
    break;

	case TWSS_JISB5:
    text = "JIS B5";
    break;

	case TWSS_USLETTER:
    text = "US Letter";
    break;

	case TWSS_USLEGAL:
    text = "US Legal";
    break;

	case TWSS_A5:
    text = "A5";
    break;

	case TWSS_ISOB4:
    text = "ISO B4";
    break;

	case TWSS_ISOB6:
    text = "ISO B6";
    break;

	case TWSS_USLEDGER:
    text = "US Ledger";
    break;

	case TWSS_USEXECUTIVE:
    text = "US Executive";
    break;

	case TWSS_A3:
    text = "A3";
    break;

	case TWSS_ISOB3:
    text = "ISO B3";
    break;

	case TWSS_A6:
    text = "A6";
    break;

	case TWSS_C4:
    text = "C4";
    break;

	case TWSS_C5:
    text = "C5";
    break;

	case TWSS_C6:
    text = "C6";
    break;

	case TWSS_4A0:
    text = "4A0";
    break;

	case TWSS_2A0:
    text = "2A0";
    break;

	case TWSS_A0:
    text = "A0";
    break;

	case TWSS_A1:
    text = "A1";
    break;

	case TWSS_A2:
    text = "A2";
    break;

	case TWSS_A7:
    text = "A7";
    break;

	case TWSS_A8:
    text = "A8";
    break;

	case TWSS_A9:
    text = "A9";
    break;

	case TWSS_A10:
    text = "A10";
    break;

	case TWSS_ISOB0:
    text = "ISO B0";
    break;

	case TWSS_ISOB1:
    text = "ISO B1";
    break;

	case TWSS_ISOB2:
    text = "ISO B2";
    break;

	case TWSS_ISOB5:
    text = "ISO B5";
    break;

	case TWSS_ISOB7:
    text = "ISO B7";
    break;

	case TWSS_ISOB8:
    text = "ISO B8";
    break;

	case TWSS_ISOB9:
    text = "ISO B9";
    break;

	case TWSS_ISOB10:
    text = "ISO B10";
    break;

	case TWSS_JISB0:
    text = "JIS B0";
    break;

	case TWSS_JISB1:
    text = "JIS B1";
    break;

	case TWSS_JISB2:
    text = "JIS B2";
    break;

	case TWSS_JISB3:
    text = "JIS B3";
    break;

	case TWSS_JISB4:
    text = "JIS B4";
    break;

	case TWSS_JISB6:
    text = "JIS B6";
    break;

	case TWSS_JISB7:
    text = "JIS B7";
    break;

	case TWSS_JISB8:
    text = "JIS B8";
    break;

	case TWSS_JISB9:
    text = "JIS B9";
    break;

	case TWSS_JISB10:
    text = "JIS B10";
    break;

	case TWSS_C0:
    text = "C0";
    break;

	case TWSS_C1:
    text = "C1";
    break;

	case TWSS_C2:
    text = "C2";
    break;

	case TWSS_C3:
    text = "C3";
    break;

	case TWSS_C7:
    text = "C7";
    break;

	case TWSS_C8:
    text = "C8";
    break;

	case TWSS_C9:
    text = "C9";
    break;

	case TWSS_C10:
    text = "C10";
    break;

	case TWSS_USSTATEMENT:
    text = "US Statement";
    break;

	case TWSS_BUSINESSCARD:
    text = "Business Card";
    break;

	case TWSS_MAXSIZE:
    text = "MAX size";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWSS 0x:%04X", InfoID);
      text = buff;
    }
    break;
  }

  return text;
}

//////////////////////////////////////////////////////////////////////////////
// Covert ICAP_XFERMECH values to String
const char* convertICAP_XFERMECH_toString(const TW_UINT16 _unItem)
{
  const char* text;

  switch(_unItem)
  {
  case TWSX_NATIVE:
    text = "Native";
    break;

  case TWSX_FILE:
    text = "File";
    break;

  case TWSX_MEMORY:
    text = "Memory";
    break;

  case TWSX_MEMFILE:
    text = "Memory of File";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWSX 0x:%04X", _unItem);
      text = buff;
    }
    break;
  }

  return text;
}


//////////////////////////////////////////////////////////////////////////////
// Covert ICAP_UNITS values to String
const char* convertICAP_UNITS_toString(const TW_UINT16 _unItem)
{
  const char* text;

  switch(_unItem)
  {
  case TWUN_INCHES:
    text = "Inches";
    break;

  case TWUN_CENTIMETERS:
    text = "Centimeters";
    break;

  case TWUN_PICAS:
    text = "Picas";
    break;

  case TWUN_POINTS:
    text = "Points";
    break;

  case TWUN_TWIPS:
    text = "Twips";
    break;

  case TWUN_PIXELS:
    text = "Pixels";
    break;

  case TWUN_MILLIMETERS:
    text = "Millimeters";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unknown TWUN 0x:%04X", _unItem);
      text = buff;
    }
    break;
  }

  return text;
}


const char* convertExtImageInfoItem_toString(const TW_INFO &ImgInfo)
{
   char * buff = nextTempBuffer();

   if(TWRC_SUCCESS == ImgInfo.ReturnCode)
   {
      switch(ImgInfo.ItemType)
      {
       case TWTY_INT8:
       case TWTY_INT16:
       case TWTY_INT32:
       case TWTY_UINT8:
       case TWTY_UINT32:
       case TWTY_UINT16:
       case TWTY_BOOL:
         // If the size of the data is larger than 4 bytes (regardless of 32bit or 64bit OS) then the data
         // is no longer an array of data but a handle to the data.
         // If the data does fit inside then it is possible to have an array of data.
         if(getTWTYsize(ImgInfo.ItemType)*ImgInfo.NumItems <= sizeof(TW_UINT32))
         {
            char        *pTemp    = buff;
            const char  *pItem    = NULL;
            int          TempSize = TEMPBUFSIZE;

            for( int nItem=0; nItem<ImgInfo.NumItems; nItem++)
            {
               switch(ImgInfo.ItemType)
               {
                case TWTY_INT8:
                  SSNPRINTF(pTemp, TempSize, TempSize, "%d ", ((TW_INT8*)&ImgInfo.Item)[nItem]);
                  break;

                case TWTY_INT16:
                  SSNPRINTF(pTemp, TempSize, TempSize, "%d ", ((TW_INT16*)&ImgInfo.Item)[nItem]);
                  break;

                case TWTY_INT32:
                  SSNPRINTF(pTemp, TempSize, TempSize, "%d ", ((TW_INT32*)&ImgInfo.Item)[nItem]);
                  break;

                case TWTY_UINT8:
                  SSNPRINTF(pTemp, TempSize, TempSize, "%u ", ((TW_UINT8*)&ImgInfo.Item)[nItem]);
                  break;

                case TWTY_UINT32:
                  pItem = convertEI_Item_toString(ImgInfo.InfoID, ((TW_UINT32*)&ImgInfo.Item)[nItem]);
                  if(pItem)
                  {
                    SSNPRINTF(pTemp, TempSize, TempSize, "%s ", pItem);
                  }
                  else
                  {
                    SSNPRINTF(pTemp, TempSize, TempSize, "%u ", ((TW_UINT32*)&ImgInfo.Item)[nItem]);
                  }
                  break;

                case TWTY_UINT16:
                  pItem = convertEI_Item_toString(ImgInfo.InfoID, ((TW_UINT16*)&ImgInfo.Item)[nItem]);
                  if(pItem)
                  {
                    SSNPRINTF(pTemp, TempSize, TempSize, "%s ", pItem);
                  }
                  else
                  {
                    SSNPRINTF(pTemp, TempSize, TempSize, "%u ", ((TW_UINT16*)&ImgInfo.Item)[nItem]);
                  }
                  break;

                case TWTY_BOOL:
                  SSNPRINTF(pTemp, TempSize, TempSize, "%s ", ((TW_BOOL*)&ImgInfo.Item)[nItem]? "True" : "False");
                  break;
               }
               TempSize -= (int)strlen(pTemp);
               pTemp += strlen(pTemp);
               if(TempSize <= 0)
               {
                  break;
               }
            }
         }
         else
         {
            //Did not fit into the INT32
            char        *pTemp    = buff;
            const char  *pItem    = NULL;
            int          TempSize = TEMPBUFSIZE;

            BYTE * pBData = (BYTE *)_DSM_LockMemory((TW_HANDLE)ImgInfo.Item);

            for( int nItem=0; nItem<ImgInfo.NumItems; nItem++)
            {
               switch(ImgInfo.ItemType)
               {
                case TWTY_INT8:
                  SSNPRINTF(pTemp, TempSize, TempSize, "%d ", ((TW_INT8*)pBData)[nItem]);
                  break;

                case TWTY_INT16:
                  SSNPRINTF(pTemp, TempSize, TempSize, "%d ", ((TW_INT16*)pBData)[nItem]);
                  break;

                case TWTY_INT32:
                  SSNPRINTF(pTemp, TempSize, TempSize, "%d ", ((TW_INT32*)pBData)[nItem]);
                  break;

                case TWTY_UINT8:
                  SSNPRINTF(pTemp, TempSize, TempSize, "%u ", ((TW_UINT8*)pBData)[nItem]);
                  break;

                case TWTY_UINT32:
                  pItem = convertEI_Item_toString(ImgInfo.InfoID, ((TW_UINT32*)pBData)[nItem]);
                  if(pItem)
                  {
                    SSNPRINTF(pTemp, TempSize, TempSize, "%s ", pItem);
                  }
                  else
                  {
                    SSNPRINTF(pTemp, TempSize, TempSize, "%u ", ((TW_UINT32*)pBData)[nItem]);
                  }
                  break;

                case TWTY_UINT16:
                  pItem = convertEI_Item_toString(ImgInfo.InfoID, ((TW_UINT16*)pBData)[nItem]);
                  if(pItem)
                  {
                    SSNPRINTF(pTemp, TempSize, TempSize, "%s ", pItem);
                  }
                  else
                  {
                    SSNPRINTF(pTemp, TempSize, TempSize, "%u ", ((TW_UINT16*)pBData)[nItem]);
                  }
                  break;

                case TWTY_BOOL:
                  SSNPRINTF(pTemp, TempSize, TempSize, "%s ", ((TW_BOOL*)pBData)[nItem]? "True" : "False");
                  break;
               }
               TempSize -= (int)strlen(pTemp);
               pTemp += strlen(pTemp);
               if(TempSize <= 0)
               {
                  break;
               }
            }

             _DSM_UnlockMemory((TW_HANDLE)ImgInfo.Item);
         }
         break;

       case TWTY_STR32:
       case TWTY_STR64:
       case TWTY_STR128:
       case TWTY_STR255:
       case TWTY_STR1024:
         {
         char *chTest = (char *)_DSM_LockMemory((TW_HANDLE)ImgInfo.Item);

         SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%.*s", getTWTYsize(ImgInfo.ItemType), chTest);

         _DSM_UnlockMemory((TW_HANDLE)ImgInfo.Item);
         }
         break;

       case TWTY_HANDLE:
         {
         // Need to look at the item to know how to handle :) this 
         // It might be a handle to a string or a handle to a chunk of memory
         SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Handle 0x:%8X", (TW_HANDLE)ImgInfo.Item);
         }
         break;

       case TWTY_FRAME:
         {
         TW_FRAME *pFrame = (TW_FRAME *)_DSM_LockMemory((TW_HANDLE)ImgInfo.Item);

         SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%0.2f  %.2f  %.2f  %.2f",
                   FIX32ToFloat(pFrame->Left), FIX32ToFloat(pFrame->Top),
                   FIX32ToFloat(pFrame->Right), FIX32ToFloat(pFrame->Bottom));

         _DSM_UnlockMemory((TW_HANDLE)ImgInfo.Item);
         }
         break;

       default:
          SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unsupporetd Type 0x:%04X", ImgInfo.ItemType);
         break;
      }
   }
   else if(TWRC_INFONOTSUPPORTED == ImgInfo.CondCode)
   {
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Unsupporetd");
   }
   else if(TWRC_DATANOTAVAILABLE == ImgInfo.CondCode)
   {
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Data Not Available");
   }
   else
   {
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "unknown failure %d", ImgInfo.CondCode);
   }

   return buff;
}

const char* convertReturnCode_toString(const TW_UINT16 _unItem)
{
  const char* text;

  switch(_unItem)
  {
  case TWRC_SUCCESS:
    text = "TWRC_SUCCESS";
    break;

  case TWRC_FAILURE:
    text = "TWRC_FAILURE";
    break;

  case TWRC_CHECKSTATUS:
    text = "TWRC_CHECKSTATUS";
    break;

  case TWRC_CANCEL:
    text = "TWRC_CANCEL";
    break;

  case TWRC_DSEVENT:
    text = "TWRC_DSEVENT";
    break;

  case TWRC_NOTDSEVENT:
    text = "TWRC_NOTDSEVENT";
    break;

  case TWRC_XFERDONE:
    text = "TWRC_XFERDONE";
    break;

  case TWRC_ENDOFLIST:
    text = "TWRC_ENDOFLIST";
    break;

  case TWRC_INFONOTSUPPORTED:
    text = "TWRC_INFONOTSUPPORTED";
    break;

  case TWRC_DATANOTAVAILABLE:
    text = "TWRC_DATANOTAVAILABLE";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "ReturnCode 0x:%04X",_unItem);
      text = buff;
    }
    break;
  }

  return text;
}

const char* convertConditionCode_toString(const TW_UINT16 _unItem)
{
  const char* text;

  switch(_unItem)
  {
  case TWCC_SUCCESS:
    text = "TWCC_SUCCESS";
    break;

  case TWCC_BUMMER:
    text = "TWCC_BUMMER";
    break;

  case TWCC_LOWMEMORY:
    text = "TWCC_LOWMEMORY";
    break;

  case TWCC_NODS:
    text = "TWCC_NODS";
    break;

  case TWCC_MAXCONNECTIONS:
    text = "TWCC_MAXCONNECTIONS";
    break;

  case TWCC_OPERATIONERROR:
    text = "TWCC_OPERATIONERROR";
    break;

  case TWCC_BADCAP:
    text = "TWCC_BADCAP";
    break;

  case TWCC_BADPROTOCOL:
    text = "TWCC_BADPROTOCOL";
    break;

  case TWCC_BADVALUE:
    text = "TWCC_BADVALUE";
    break;

  case TWCC_SEQERROR:
    text = "TWCC_SEQERROR";
    break;

  case TWCC_BADDEST:
    text = "TWCC_BADDEST";
    break;

  case TWCC_CAPUNSUPPORTED:
    text = "TWCC_CAPUNSUPPORTED";
    break;

  case TWCC_CAPBADOPERATION:
    text = "TWCC_CAPBADOPERATION";
    break;

  case TWCC_CAPSEQERROR:
    text = "TWCC_CAPSEQERROR";
    break;

  case TWCC_DENIED:
    text = "TWCC_DENIED";
    break;

  case TWCC_FILEEXISTS:
    text = "TWCC_FILEEXISTS";
    break;

  case TWCC_FILENOTFOUND:
    text = "TWCC_FILENOTFOUND";
    break;

  case TWCC_NOTEMPTY:
    text = "TWCC_NOTEMPTY";
    break;

  case TWCC_PAPERJAM:
    text = "TWCC_PAPERJAM";
    break;

  case TWCC_PAPERDOUBLEFEED:
    text = "TWCC_PAPERDOUBLEFEED";
    break;

  case TWCC_FILEWRITEERROR:
    text = "TWCC_FILEWRITEERROR";
    break;

  case TWCC_CHECKDEVICEONLINE:
    text = "TWCC_CHECKDEVICEONLINE";
    break;

  case TWCC_INTERLOCK:
    text = "TWCC_INTERLOCK";
    break;

  case TWCC_DAMAGEDCORNER:
    text = "TWCC_DAMAGEDCORNER";
    break;

  case TWCC_FOCUSERROR:
    text = "TWCC_FOCUSERROR";
    break;

  case TWCC_DOCTOOLIGHT:
    text = "TWCC_DOCTOOLIGHT";
    break;

  case TWCC_DOCTOODARK:
    text = "TWCC_DOCTOODARK";
    break;

  case TWCC_NOMEDIA:
    text = "TWCC_NOMEDIA";
    break;

  default:
    {
      char * buff = nextTempBuffer();
      SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "ConditionCode 0x:%04X",_unItem);
      text = buff;
    }
    break;
  }

  return text;
}

const char* convertMessage_toString(const TW_UINT16 _unItem)
{
  const char* strRet;
  switch(_unItem)
  {
    case MSG_GET:
      strRet = "MSG_GET";
      break;
    case MSG_GETCURRENT:
      strRet = "MSG_GETCURRENT";
      break;
    case MSG_GETDEFAULT:
      strRet = "MSG_GETDEFAULT";
      break;
    case MSG_GETFIRST:
      strRet = "MSG_GETFIRST";
      break;
    case MSG_GETNEXT:
      strRet = "MSG_GETNEXT";
      break;
    case MSG_SET:
      strRet = "MSG_SET";
      break;
    case MSG_RESET:
      strRet = "MSG_RESET";
      break;
    case MSG_QUERYSUPPORT:
      strRet = "MSG_QUERYSUPPORT";
      break;
    case MSG_GETHELP:
      strRet = "MSG_GETHELP";
      break;
    case MSG_GETLABEL:
      strRet = "MSG_GETLABEL";
      break;
    case MSG_GETLABELENUM:
      strRet = "MSG_GETLABELENUM";
      break;
    case MSG_XFERREADY:
      strRet = "MSG_XFERREADY";
      break;
    case MSG_CLOSEDSREQ:
      strRet = "MSG_CLOSEDSREQ";
      break;
    case MSG_CLOSEDSOK:
      strRet = "MSG_CLOSEDSOK";
      break;
    case MSG_DEVICEEVENT:
      strRet = "MSG_DEVICEEVENT";
      break;
    case MSG_OPENDSM:
      strRet = "MSG_OPENDSM";
      break;
    case MSG_CLOSEDSM:
      strRet = "MSG_CLOSEDSM";
      break;
    case MSG_OPENDS:
      strRet = "MSG_OPENDS";
      break;
    case MSG_CLOSEDS:
      strRet = "MSG_CLOSEDS";
      break;
    case MSG_USERSELECT:
      strRet = "MSG_USERSELECT";
      break;
    case MSG_DISABLEDS:
      strRet = "MSG_DISABLEDS";
      break;
    case MSG_ENABLEDS:
      strRet = "MSG_ENABLEDS";
      break;
    case MSG_ENABLEDSUIONLY:
      strRet = "MSG_ENABLEDSUIONLY";
      break;
    case MSG_PROCESSEVENT:
      strRet = "MSG_PROCESSEVENT";
      break;
    case MSG_ENDXFER:
      strRet = "MSG_ENDXFER";
      break;
    case MSG_STOPFEEDER:
      strRet = "MSG_STOPFEEDER";
      break;
    case MSG_CHANGEDIRECTORY:
      strRet = "MSG_CHANGEDIRECTORY";
      break;
    case MSG_CREATEDIRECTORY:
      strRet = "MSG_CREATEDIRECTORY";
      break;
    case MSG_DELETE:
      strRet = "MSG_DELETE";
      break;
    case MSG_FORMATMEDIA:
      strRet = "MSG_FORMATMEDIA";
      break;
    case MSG_GETCLOSE:
      strRet = "MSG_GETCLOSE";
      break;
    case MSG_GETFIRSTFILE:
      strRet = "MSG_GETFIRSTFILE";
      break;
    case MSG_GETINFO:
      strRet = "MSG_GETINFO";
      break;
    case MSG_GETNEXTFILE:
      strRet = "MSG_GETNEXTFILE";
      break;
    case MSG_RENAME:
      strRet = "MSG_RENAME";
      break;
    case MSG_COPY:
      strRet = "MSG_COPY";
      break;
    case MSG_AUTOMATICCAPTUREDIRECTORY:
      strRet = "MSG_AUTOMATICCAPTUREDIRECTORY";
      break;
    case MSG_PASSTHRU:
      strRet = "MSG_PASSTHRU";
      break;
    case MSG_REGISTER_CALLBACK:
      strRet = "MSG_REGISTER_CALLBACK";
      break;
    case MSG_RESETALL:
      strRet = "MSG_RESETALL";
      break;
    default:
      {
        char * buff = nextTempBuffer();
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Message 0x:%04X",_unItem);
        strRet = buff;
      }
      break;
  }
  return strRet;
}

const char* convertDataGroup_toString(const TW_UINT16 _unItem)
{
  const char* strRet;
  switch(_unItem)
  {
        case DG_CONTROL:
          strRet = "DG_CONTROL";
          break;
        case DG_IMAGE:
          strRet = "DG_IMAGE";
          break;
        case DG_AUDIO:
          strRet = "DG_AUDIO";
          break;
    default:
      {
        char * buff = nextTempBuffer();
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "DataGroup 0x:%04X",_unItem);
        strRet = buff;
      }
      break;
  }
  return strRet;
}

const char* convertDataArgType_toString(const TW_UINT16 _unItem)
{
  const char* strRet;
  switch(_unItem)
  {
    case DAT_NULL:
      strRet = "DAT_NULL";
      break;
    case DAT_CAPABILITY:
      strRet = "DAT_CAPABILITY";
      break;
    case DAT_EVENT:
      strRet = "DAT_EVENT";
      break;
    case DAT_IDENTITY:
      strRet = "DAT_IDENTITY";
      break;
    case DAT_PARENT:
      strRet = "DAT_PARENT";
      break;
    case DAT_PENDINGXFERS:
      strRet = "DAT_PENDINGXFERS";
      break;
    case DAT_SETUPMEMXFER:
      strRet = "DAT_SETUPMEMXFER";
      break;
    case DAT_SETUPFILEXFER:
      strRet = "DAT_SETUPFILEXFER";
      break;
    case DAT_STATUS:
      strRet = "DAT_STATUS";
      break;
    case DAT_USERINTERFACE:
      strRet = "DAT_USERINTERFACE";
      break;
    case DAT_XFERGROUP:
      strRet = "DAT_XFERGROUP";
      break;
    case DAT_CUSTOMDSDATA:
      strRet = "DAT_CUSTOMDSDATA";
      break;
    case DAT_DEVICEEVENT:
      strRet = "DAT_DEVICEEVENT";
      break;
    case DAT_FILESYSTEM:
      strRet = "DAT_FILESYSTEM";
      break;
    case DAT_PASSTHRU:
      strRet = "DAT_PASSTHRU";
      break;
    case DAT_CALLBACK:
      strRet = "DAT_CALLBACK";
      break;
    case DAT_STATUSUTF8:
      strRet = "DAT_STATUSUTF8";
      break;
    case DAT_IMAGEINFO:
      strRet = "DAT_IMAGEINFO";
      break;
    case DAT_IMAGELAYOUT:
      strRet = "DAT_IMAGELAYOUT";
      break;
    case DAT_IMAGEMEMXFER:
      strRet = "DAT_IMAGEMEMXFER";
      break;
    case DAT_IMAGENATIVEXFER:
      strRet = "DAT_IMAGENATIVEXFER";
      break;
    case DAT_IMAGEFILEXFER:
      strRet = "DAT_IMAGEFILEXFER";
      break;
    case DAT_CIECOLOR:
      strRet = "DAT_CIECOLOR";
      break;
    case DAT_GRAYRESPONSE:
      strRet = "DAT_GRAYRESPONSE";
      break;
    case DAT_RGBRESPONSE:
      strRet = "DAT_RGBRESPONSE";
      break;
    case DAT_JPEGCOMPRESSION:
      strRet = "DAT_JPEGCOMPRESSION";
      break;
    case DAT_PALETTE8:
      strRet = "DAT_PALETTE8";
      break;
    case DAT_EXTIMAGEINFO:
      strRet = "DAT_EXTIMAGEINFO";
      break;
    case DAT_AUDIOFILEXFER:
      strRet = "DAT_AUDIOFILEXFER";
      break;
    case DAT_AUDIOINFO:
      strRet = "DAT_AUDIOINFO";
      break;
    case DAT_AUDIONATIVEXFER:
      strRet = "DAT_AUDIONATIVEXFER";
      break;
    case DAT_ICCPROFILE:
      strRet = "DAT_ICCPROFILE";
      break;
    case DAT_IMAGEMEMFILEXFER:
      strRet = "DAT_IMAGEMEMFILEXFER";
      break;
    case DAT_ENTRYPOINT:
      strRet = "DAT_ENTRYPOINT";
      break;
    default:
      {
        char * buff = nextTempBuffer();
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "DataArgumentType 0x:%04X",_unItem);
        strRet = buff;
      }
      break;
  }
  return strRet;
}

const char* convertContainerType_toString(const TW_UINT16 _unItem)
{
  const char* strRet;
  switch(_unItem)
  {
    case TWON_ARRAY:
      strRet = "TWON_ARRAY";
      break;
    case TWON_ENUMERATION:
      strRet = "TWON_ENUMERATION";
      break;
    case TWON_ONEVALUE:
      strRet = "TWON_ONEVALUE";
      break;
    case TWON_RANGE:
      strRet = "TWON_RANGE";
      break;
    default:
      {
        char * buff = nextTempBuffer();
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "DataArgumentType 0x:%04X",_unItem);
        strRet = buff;
      }
      break;
  }
  return strRet;
}

const char* convertQuerySupport_toString(const TW_UINT32 _unItem)
{
  const char* strRet = NULL;
  string strVal;
  if(_unItem&TWQC_GET)
  {
    strVal+="TWQC_GET";
  }
  if(_unItem&TWQC_SET)
  {
    if(strVal.length())
    {
      strVal+="|";
    }
    strVal+="TWQC_SET";
  }
  if(_unItem&TWQC_GETDEFAULT)
  {
    if(strVal.length())
    {
      strVal+="|";
    }
    strVal+="TWQC_GETDEFAULT";
  }
  if(_unItem&TWQC_GETCURRENT)
  {
    if(strVal.length())
    {
      strVal+="|";
    }
    strVal+="TWQC_GETCURRENT";
  }
  if(_unItem&TWQC_RESET)
  {
    if(strVal.length())
    {
      strVal+="|";
    }
    strVal+="TWQC_RESET";
  }

  if(strVal.length())
  {
    char * buff = nextTempBuffer();
    SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%s",strVal.c_str());
    strRet = buff;
  }
  if(NULL==strRet)
  {
    strRet = "NONE";
  }
  return strRet;
}

const char* convertFileFmt_toExtension(const TW_UINT16 _unItem)
{
  const char* strRet = NULL;
  switch(_unItem)
  {
    case TWFF_PICT:
      strRet = "pct";
      break;
    case TWFF_BMP:
      strRet = "bmp";
      break;
    case TWFF_XBM:
      strRet = "xbm";
      break;
    case TWFF_JFIF:
      strRet = "jpg";
      break;
    case TWFF_FPX:
      strRet = "fpx";
      break;
    case TWFF_TIFF:
    case TWFF_TIFFMULTI:
      strRet = "tif";
      break;
    case TWFF_PNG:
      strRet = "png";
      break;
    case TWFF_SPIFF:
      strRet = "spf";
      break;
    case TWFF_EXIF:
      strRet = "xif";
      break;
    case TWFF_JP2:
      strRet = "jp2";
      break;
    case TWFF_JPX:
      strRet = "jpx";
      break;
    case TWFF_DEJAVU:
      strRet = "djv";
      break;
    case TWFF_PDF:
    case TWFF_PDFA:
    case TWFF_PDFA2:
      strRet = "pdf";
      break;
    default:
      strRet = "bin";
      break;
  }
  return strRet;
}

const char *CapabilityValueToString(TW_UINT16 twCapId, TW_UINT16 twItemType, const void *pValue)
{
  const char *strRet = NULL;

  //Setup various pointers for later
  const TW_FRAME *pFrame = static_cast<const TW_FRAME *>(pValue);
  const TW_FIX32 *pFix32 = static_cast<const TW_FIX32 *>(pValue);
  const TW_UINT16 *pUint16 = static_cast<const TW_UINT16 *>(pValue);
  const TW_UINT32 *pUint32 = static_cast<const TW_UINT32 *>(pValue);
  const TW_INT16 *pInt16 = static_cast<const TW_INT16 *>(pValue);
  const TW_BOOL *pBool = static_cast<const TW_BOOL *>(pValue);
  const char *pStr = static_cast<const char *>(pValue);

  //knock-out some standards first
  switch(twItemType)
  {
    case TWTY_INT16:
      {
        char * buff = nextTempBuffer();
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%d", *pInt16);
        strRet = buff;
      }
      break;
    case TWTY_BOOL:
      strRet = *pBool?"TRUE":"FALSE";
      break;
    case TWTY_FIX32:
      {
        char * buff = nextTempBuffer();
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%.2f", FIX32ToFloat(*pFix32));
        strRet = buff;
      }
      break;
    case TWTY_FRAME:
      {
        char * buff = nextTempBuffer();
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%.2f,%.2f,%.2f,%.2f", 
          FIX32ToFloat(pFrame->Left), FIX32ToFloat(pFrame->Top), FIX32ToFloat(pFrame->Right), FIX32ToFloat(pFrame->Bottom));
        strRet = buff;
      }
      break;
    case TWTY_STR32:
    case TWTY_STR64:
    case TWTY_STR128:
    case TWTY_STR255:
      {
        char * buff = nextTempBuffer();
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%s", pStr);
        strRet = buff;
      }
      break;
  }

  if(NULL==strRet)
  {
    switch(twCapId)
    {
#if 0
      case CAP_CUSTOMDSDATA:
      case CAP_FEEDERENABLED:
      case CAP_FEEDERLOADED:
      case CAP_AUTOFEED:
      case CAP_CLEARPAGE:
      case CAP_FEEDPAGE:
      case CAP_REWINDPAGE:
      case CAP_INDICATORS:
      case CAP_PAPERDETECTABLE:
      case CAP_UICONTROLLABLE:
      case CAP_DEVICEONLINE:
      case CAP_AUTOSCAN:
      case CAP_THUMBNAILSENABLED:
      case CAP_DUPLEXENABLED:
      case CAP_ENABLEDSUIONLY:
        strRet = *pBool?"TRUE":"FALSE";
        break;
#endif //#if 0
      case CAP_EXTENDEDCAPS:
      case CAP_SUPPORTEDCAPS:
        switch(*pUint16)
        {
          case CAP_XFERCOUNT :
            strRet = "CAP_XFERCOUNT";
            break;
          case ICAP_COMPRESSION:
            strRet = "ICAP_COMPRESSION";
            break;
          case ICAP_PIXELTYPE:
            strRet = "ICAP_PIXELTYPE";
            break;
          case ICAP_UNITS:
            strRet = "ICAP_UNITS";
            break;
          case ICAP_XFERMECH:
            strRet = "ICAP_XFERMECH";
            break;
          case CAP_AUTHOR:
            strRet = "CAP_AUTHOR";
            break;
          case CAP_CAPTION:
            strRet = "CAP_CAPTION";
            break;
          case CAP_FEEDERENABLED:
            strRet = "CAP_FEEDERENABLED";
            break;
          case CAP_FEEDERLOADED:
            strRet = "CAP_FEEDERLOADED";
            break;
          case CAP_TIMEDATE:
            strRet = "CAP_TIMEDATE";
            break;
          case CAP_SUPPORTEDCAPS:
            strRet = "CAP_SUPPORTEDCAPS";
            break;
          case CAP_EXTENDEDCAPS:
            strRet = "CAP_EXTENDEDCAPS";
            break;
          case CAP_AUTOFEED:
            strRet = "CAP_AUTOFEED";
            break;
          case CAP_CLEARPAGE:
            strRet = "CAP_CLEARPAGE";
            break;
          case CAP_FEEDPAGE:
            strRet = "CAP_FEEDPAGE";
            break;
          case CAP_REWINDPAGE:
            strRet = "CAP_REWINDPAGE";
            break;
          case CAP_INDICATORS:
            strRet = "CAP_INDICATORS";
            break;
          case CAP_SUPPORTEDCAPSEXT:
            strRet = "CAP_SUPPORTEDCAPSEXT";
            break;
          case CAP_PAPERDETECTABLE:
            strRet = "CAP_PAPERDETECTABLE";
            break;
          case CAP_UICONTROLLABLE:
            strRet = "CAP_UICONTROLLABLE";
            break;
          case CAP_DEVICEONLINE:
            strRet = "CAP_DEVICEONLINE";
            break;
          case CAP_AUTOSCAN:
            strRet = "CAP_AUTOSCAN";
            break;
          case CAP_THUMBNAILSENABLED:
            strRet = "CAP_THUMBNAILSENABLED";
            break;
          case CAP_DUPLEX:
            strRet = "CAP_DUPLEX";
            break;
          case CAP_DUPLEXENABLED:
            strRet = "CAP_DUPLEXENABLED";
            break;
          case CAP_ENABLEDSUIONLY:
            strRet = "CAP_ENABLEDSUIONLY";
            break;
          case CAP_CUSTOMDSDATA:
            strRet = "CAP_CUSTOMDSDATA";
            break;
          case CAP_ENDORSER:
            strRet = "CAP_ENDORSER";
            break;
          case CAP_JOBCONTROL:
            strRet = "CAP_JOBCONTROL";
            break;
          case CAP_ALARMS:
            strRet = "CAP_ALARMS";
            break;
          case CAP_ALARMVOLUME:
            strRet = "CAP_ALARMVOLUME";
            break;
          case CAP_AUTOMATICCAPTURE:
            strRet = "CAP_AUTOMATICCAPTURE";
            break;
          case CAP_TIMEBEFOREFIRSTCAPTURE:
            strRet = "CAP_TIMEBEFOREFIRSTCAPTURE";
            break;
          case CAP_TIMEBETWEENCAPTURES:
            strRet = "CAP_TIMEBETWEENCAPTURES";
            break;
          case CAP_CLEARBUFFERS:
            strRet = "CAP_CLEARBUFFERS";
            break;
          case CAP_MAXBATCHBUFFERS:
            strRet = "CAP_MAXBATCHBUFFERS";
            break;
          case CAP_DEVICETIMEDATE:
            strRet = "CAP_DEVICETIMEDATE";
            break;
          case CAP_POWERSUPPLY:
            strRet = "CAP_POWERSUPPLY";
            break;
          case CAP_CAMERAPREVIEWUI:
            strRet = "CAP_CAMERAPREVIEWUI";
            break;
          case CAP_DEVICEEVENT:
            strRet = "CAP_DEVICEEVENT";
            break;
          case CAP_SERIALNUMBER:
            strRet = "CAP_SERIALNUMBER";
            break;
          case CAP_PRINTER:
            strRet = "CAP_PRINTER";
            break;
          case CAP_PRINTERENABLED:
            strRet = "CAP_PRINTERENABLED";
            break;
          case CAP_PRINTERINDEX:
            strRet = "CAP_PRINTERINDEX";
            break;
          case CAP_PRINTERMODE:
            strRet = "CAP_PRINTERMODE";
            break;
          case CAP_PRINTERSTRING:
            strRet = "CAP_PRINTERSTRING";
            break;
          case CAP_PRINTERSUFFIX:
            strRet = "CAP_PRINTERSUFFIX";
            break;
          case CAP_LANGUAGE:
            strRet = "CAP_LANGUAGE";
            break;
          case CAP_FEEDERALIGNMENT:
            strRet = "CAP_FEEDERALIGNMENT";
            break;
          case CAP_FEEDERORDER:
            strRet = "CAP_FEEDERORDER";
            break;
          case CAP_REACQUIREALLOWED:
            strRet = "CAP_REACQUIREALLOWED";
            break;
          case CAP_BATTERYMINUTES:
            strRet = "CAP_BATTERYMINUTES";
            break;
          case CAP_BATTERYPERCENTAGE:
            strRet = "CAP_BATTERYPERCENTAGE";
            break;
          case CAP_CAMERASIDE:
            strRet = "CAP_CAMERASIDE";
            break;
          case CAP_SEGMENTED:
            strRet = "CAP_SEGMENTED";
            break;
          case CAP_CAMERAENABLED:
            strRet = "CAP_CAMERAENABLED";
            break;
          case CAP_CAMERAORDER:
            strRet = "CAP_CAMERAORDER";
            break;
          case CAP_MICRENABLED:
            strRet = "CAP_MICRENABLED";
            break;
          case CAP_FEEDERPREP:
            strRet = "CAP_FEEDERPREP";
            break;
          case CAP_FEEDERPOCKET:
            strRet = "CAP_FEEDERPOCKET";
            break;
          case CAP_AUTOMATICSENSEMEDIUM:
            strRet = "CAP_AUTOMATICSENSEMEDIUM";
            break;
          case CAP_CUSTOMINTERFACEGUID:
            strRet = "CAP_CUSTOMINTERFACEGUID";
            break;
          case ICAP_AUTOBRIGHT:
            strRet = "ICAP_AUTOBRIGHT";
            break;
          case ICAP_BRIGHTNESS:
            strRet = "ICAP_BRIGHTNESS";
            break;
          case ICAP_CONTRAST:
            strRet = "ICAP_CONTRAST";
            break;
          case ICAP_CUSTHALFTONE:
            strRet = "ICAP_CUSTHALFTONE";
            break;
          case ICAP_EXPOSURETIME:
            strRet = "ICAP_EXPOSURETIME";
            break;
          case ICAP_FILTER:
            strRet = "ICAP_FILTER";
            break;
          case ICAP_FLASHUSED:
            strRet = "ICAP_FLASHUSED";
            break;
          case ICAP_GAMMA:
            strRet = "ICAP_GAMMA";
            break;
          case ICAP_HALFTONES:
            strRet = "ICAP_HALFTONES";
            break;
          case ICAP_HIGHLIGHT:
            strRet = "ICAP_HIGHLIGHT";
            break;
          case ICAP_IMAGEFILEFORMAT:
            strRet = "ICAP_IMAGEFILEFORMAT";
            break;
          case ICAP_LAMPSTATE:
            strRet = "ICAP_LAMPSTATE";
            break;
          case ICAP_LIGHTSOURCE:
            strRet = "ICAP_LIGHTSOURCE";
            break;
          case ICAP_ORIENTATION:
            strRet = "ICAP_ORIENTATION";
            break;
          case ICAP_PHYSICALWIDTH:
            strRet = "ICAP_PHYSICALWIDTH";
            break;
          case ICAP_PHYSICALHEIGHT:
            strRet = "ICAP_PHYSICALHEIGHT";
            break;
          case ICAP_SHADOW:
            strRet = "ICAP_SHADOW";
            break;
          case ICAP_FRAMES:
            strRet = "ICAP_FRAMES";
            break;
          case ICAP_XNATIVERESOLUTION:
            strRet = "ICAP_XNATIVERESOLUTION";
            break;
          case ICAP_YNATIVERESOLUTION:
            strRet = "ICAP_YNATIVERESOLUTION";
            break;
          case ICAP_XRESOLUTION:
            strRet = "ICAP_XRESOLUTION";
            break;
          case ICAP_YRESOLUTION:
            strRet = "ICAP_YRESOLUTION";
            break;
          case ICAP_MAXFRAMES:
            strRet = "ICAP_MAXFRAMES";
            break;
          case ICAP_TILES:
            strRet = "ICAP_TILES";
            break;
          case ICAP_BITORDER:
            strRet = "ICAP_BITORDER";
            break;
          case ICAP_CCITTKFACTOR:
            strRet = "ICAP_CCITTKFACTOR";
            break;
          case ICAP_LIGHTPATH:
            strRet = "ICAP_LIGHTPATH";
            break;
          case ICAP_PIXELFLAVOR:
            strRet = "ICAP_PIXELFLAVOR";
            break;
          case ICAP_PLANARCHUNKY:
            strRet = "ICAP_PLANARCHUNKY";
            break;
          case ICAP_ROTATION:
            strRet = "ICAP_ROTATION";
            break;
          case ICAP_SUPPORTEDSIZES:
            strRet = "ICAP_SUPPORTEDSIZES";
            break;
          case ICAP_THRESHOLD:
            strRet = "ICAP_THRESHOLD";
            break;
          case ICAP_XSCALING:
            strRet = "ICAP_XSCALING";
            break;
          case ICAP_YSCALING:
            strRet = "ICAP_YSCALING";
            break;
          case ICAP_BITORDERCODES:
            strRet = "ICAP_BITORDERCODES";
            break;
          case ICAP_PIXELFLAVORCODES:
            strRet = "ICAP_PIXELFLAVORCODES";
            break;
          case ICAP_JPEGPIXELTYPE:
            strRet = "ICAP_JPEGPIXELTYPE";
            break;
          case ICAP_TIMEFILL:
            strRet = "ICAP_TIMEFILL";
            break;
          case ICAP_BITDEPTH:
            strRet = "ICAP_BITDEPTH";
            break;
          case ICAP_BITDEPTHREDUCTION:
            strRet = "ICAP_BITDEPTHREDUCTION";
            break;
          case ICAP_UNDEFINEDIMAGESIZE:
            strRet = "ICAP_UNDEFINEDIMAGESIZE";
            break;
          case ICAP_IMAGEDATASET:
            strRet = "ICAP_IMAGEDATASET";
            break;
          case ICAP_EXTIMAGEINFO:
            strRet = "ICAP_EXTIMAGEINFO";
            break;
          case ICAP_MINIMUMHEIGHT:
            strRet = "ICAP_MINIMUMHEIGHT";
            break;
          case ICAP_MINIMUMWIDTH:
            strRet = "ICAP_MINIMUMWIDTH";
            break;
          case ICAP_AUTODISCARDBLANKPAGES:
            strRet = "ICAP_AUTODISCARDBLANKPAGES";
            break;
          case ICAP_FLIPROTATION:
            strRet = "ICAP_FLIPROTATION";
            break;
          case ICAP_BARCODEDETECTIONENABLED:
            strRet = "ICAP_BARCODEDETECTIONENABLED";
            break;
          case ICAP_SUPPORTEDBARCODETYPES:
            strRet = "ICAP_SUPPORTEDBARCODETYPES";
            break;
          case ICAP_BARCODEMAXSEARCHPRIORITIES:
            strRet = "ICAP_BARCODEMAXSEARCHPRIORITIES";
            break;
          case ICAP_BARCODESEARCHPRIORITIES:
            strRet = "ICAP_BARCODESEARCHPRIORITIES";
            break;
          case ICAP_BARCODESEARCHMODE:
            strRet = "ICAP_BARCODESEARCHMODE";
            break;
          case ICAP_BARCODEMAXRETRIES:
            strRet = "ICAP_BARCODEMAXRETRIES";
            break;
          case ICAP_BARCODETIMEOUT:
            strRet = "ICAP_BARCODETIMEOUT";
            break;
          case ICAP_ZOOMFACTOR:
            strRet = "ICAP_ZOOMFACTOR";
            break;
          case ICAP_PATCHCODEDETECTIONENABLED:
            strRet = "ICAP_PATCHCODEDETECTIONENABLED";
            break;
          case ICAP_SUPPORTEDPATCHCODETYPES:
            strRet = "ICAP_SUPPORTEDPATCHCODETYPES";
            break;
          case ICAP_PATCHCODEMAXSEARCHPRIORITIES:
            strRet = "ICAP_PATCHCODEMAXSEARCHPRIORITIES";
            break;
          case ICAP_PATCHCODESEARCHPRIORITIES:
            strRet = "ICAP_PATCHCODESEARCHPRIORITIES";
            break;
          case ICAP_PATCHCODESEARCHMODE:
            strRet = "ICAP_PATCHCODESEARCHMODE";
            break;
          case ICAP_PATCHCODEMAXRETRIES:
            strRet = "ICAP_PATCHCODEMAXRETRIES";
            break;
          case ICAP_PATCHCODETIMEOUT:
            strRet = "ICAP_PATCHCODETIMEOUT";
            break;
          case ICAP_FLASHUSED2:
            strRet = "ICAP_FLASHUSED2";
            break;
          case ICAP_IMAGEFILTER:
            strRet = "ICAP_IMAGEFILTER";
            break;
          case ICAP_NOISEFILTER:
            strRet = "ICAP_NOISEFILTER";
            break;
          case ICAP_OVERSCAN:
            strRet = "ICAP_OVERSCAN";
            break;
          case ICAP_AUTOMATICBORDERDETECTION:
            strRet = "ICAP_AUTOMATICBORDERDETECTION";
            break;
          case ICAP_AUTOMATICDESKEW:
            strRet = "ICAP_AUTOMATICDESKEW";
            break;
          case ICAP_AUTOMATICROTATE:
            strRet = "ICAP_AUTOMATICROTATE";
            break;
          case ICAP_JPEGQUALITY:
            strRet = "ICAP_JPEGQUALITY";
            break;
          case ICAP_FEEDERTYPE:
            strRet = "ICAP_FEEDERTYPE";
            break;
          case ICAP_ICCPROFILE:
            strRet = "ICAP_ICCPROFILE";
            break;
          case ICAP_AUTOSIZE:
            strRet = "ICAP_AUTOSIZE";
            break;
          case ICAP_AUTOMATICCROPUSESFRAME:
            strRet = "ICAP_AUTOMATICCROPUSESFRAME";
            break;
          case ICAP_AUTOMATICLENGTHDETECTION:
            strRet = "ICAP_AUTOMATICLENGTHDETECTION";
            break;
          case ICAP_AUTOMATICCOLORENABLED:
            strRet = "ICAP_AUTOMATICCOLORENABLED";
            break;
          case ICAP_AUTOMATICCOLORNONCOLORPIXELTYPE:
            strRet = "ICAP_AUTOMATICCOLORNONCOLORPIXELTYPE";
            break;
          case ICAP_COLORMANAGEMENTENABLED:
            strRet = "ICAP_COLORMANAGEMENTENABLED";
            break;
          case ICAP_IMAGEMERGE:
            strRet = "ICAP_IMAGEMERGE";
            break;
          case ICAP_IMAGEMERGEHEIGHTTHRESHOLD:
            strRet = "ICAP_IMAGEMERGEHEIGHTTHRESHOLD";
            break;
          case ICAP_SUPPORTEDEXTIMAGEINFO:
            strRet = "ICAP_SUPPORTEDEXTIMAGEINFO";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_SUPPORTEDEXTIMAGEINFO:
        switch(*pUint16)
        {
          case TWEI_BARCODEX:
            strRet = "TWEI_BARCODEX";
            break;
          case TWEI_BARCODEY:
            strRet = "TWEI_BARCODEY";
            break;
          case TWEI_BARCODETEXT:
            strRet = "TWEI_BARCODETEXT";
            break;
          case TWEI_BARCODETYPE:
            strRet = "TWEI_BARCODETYPE";
            break;
          case TWEI_DESHADETOP:
            strRet = "TWEI_DESHADETOP";
            break;
          case TWEI_DESHADELEFT:
            strRet = "TWEI_DESHADELEFT";
            break;
          case TWEI_DESHADEHEIGHT:
            strRet = "TWEI_DESHADEHEIGHT";
            break;
          case TWEI_DESHADEWIDTH:
            strRet = "TWEI_DESHADEWIDTH";
            break;
          case TWEI_DESHADESIZE:
            strRet = "TWEI_DESHADESIZE";
            break;
          case TWEI_SPECKLESREMOVED:
            strRet = "TWEI_SPECKLESREMOVED";
            break;
          case TWEI_HORZLINEXCOORD:
            strRet = "TWEI_HORZLINEXCOORD";
            break;
          case TWEI_HORZLINEYCOORD:
            strRet = "TWEI_HORZLINEYCOORD";
            break;
          case TWEI_HORZLINELENGTH:
            strRet = "TWEI_HORZLINELENGTH";
            break;
          case TWEI_HORZLINETHICKNESS:
            strRet = "TWEI_HORZLINETHICKNESS";
            break;
          case TWEI_VERTLINEXCOORD:
            strRet = "TWEI_VERTLINEXCOORD";
            break;
          case TWEI_VERTLINEYCOORD:
            strRet = "TWEI_VERTLINEYCOORD";
            break;
          case TWEI_VERTLINELENGTH:
            strRet = "TWEI_VERTLINELENGTH";
            break;
          case TWEI_VERTLINETHICKNESS:
            strRet = "TWEI_VERTLINETHICKNESS";
            break;
          case TWEI_PATCHCODE:
            strRet = "TWEI_PATCHCODE";
            break;
          case TWEI_ENDORSEDTEXT:
            strRet = "TWEI_ENDORSEDTEXT";
            break;
          case TWEI_FORMCONFIDENCE:
            strRet = "TWEI_FORMCONFIDENCE";
            break;
          case TWEI_FORMTEMPLATEMATCH:
            strRet = "TWEI_FORMTEMPLATEMATCH";
            break;
          case TWEI_FORMTEMPLATEPAGEMATCH:
            strRet = "TWEI_FORMTEMPLATEPAGEMATCH";
            break;
          case TWEI_FORMHORZDOCOFFSET:
            strRet = "TWEI_FORMHORZDOCOFFSET";
            break;
          case TWEI_FORMVERTDOCOFFSET:
            strRet = "TWEI_FORMVERTDOCOFFSET";
            break;
          case TWEI_BARCODECOUNT:
            strRet = "TWEI_BARCODECOUNT";
            break;
          case TWEI_BARCODECONFIDENCE:
            strRet = "TWEI_BARCODECONFIDENCE";
            break;
          case TWEI_BARCODEROTATION:
            strRet = "TWEI_BARCODEROTATION";
            break;
          case TWEI_BARCODETEXTLENGTH:
            strRet = "TWEI_BARCODETEXTLENGTH";
            break;
          case TWEI_DESHADECOUNT:
            strRet = "TWEI_DESHADECOUNT";
            break;
          case TWEI_DESHADEBLACKCOUNTOLD:
            strRet = "TWEI_DESHADEBLACKCOUNTOLD";
            break;
          case TWEI_DESHADEBLACKCOUNTNEW:
            strRet = "TWEI_DESHADEBLACKCOUNTNEW";
            break;
          case TWEI_DESHADEBLACKRLMIN:
            strRet = "TWEI_DESHADEBLACKRLMIN";
            break;
          case TWEI_DESHADEBLACKRLMAX:
            strRet = "TWEI_DESHADEBLACKRLMAX";
            break;
          case TWEI_DESHADEWHITECOUNTOLD:
            strRet = "TWEI_DESHADEWHITECOUNTOLD";
            break;
          case TWEI_DESHADEWHITECOUNTNEW:
            strRet = "TWEI_DESHADEWHITECOUNTNEW";
            break;
          case TWEI_DESHADEWHITERLMIN:
            strRet = "TWEI_DESHADEWHITERLMIN";
            break;
          case TWEI_DESHADEWHITERLAVE:
            strRet = "TWEI_DESHADEWHITERLAVE";
            break;
          case TWEI_DESHADEWHITERLMAX:
            strRet = "TWEI_DESHADEWHITERLMAX";
            break;
          case TWEI_BLACKSPECKLESREMOVED:
            strRet = "TWEI_BLACKSPECKLESREMOVED";
            break;
          case TWEI_WHITESPECKLESREMOVED:
            strRet = "TWEI_WHITESPECKLESREMOVED";
            break;
          case TWEI_HORZLINECOUNT:
            strRet = "TWEI_HORZLINECOUNT";
            break;
          case TWEI_VERTLINECOUNT:
            strRet = "TWEI_VERTLINECOUNT";
            break;
          case TWEI_DESKEWSTATUS:
            strRet = "TWEI_DESKEWSTATUS";
            break;
          case TWEI_SKEWORIGINALANGLE:
            strRet = "TWEI_SKEWORIGINALANGLE";
            break;
          case TWEI_SKEWFINALANGLE:
            strRet = "TWEI_SKEWFINALANGLE";
            break;
          case TWEI_SKEWCONFIDENCE:
            strRet = "TWEI_SKEWCONFIDENCE";
            break;
          case TWEI_SKEWWINDOWX1:
            strRet = "TWEI_SKEWWINDOWX1";
            break;
          case TWEI_SKEWWINDOWY1:
            strRet = "TWEI_SKEWWINDOWY1";
            break;
          case TWEI_SKEWWINDOWX2:
            strRet = "TWEI_SKEWWINDOWX2";
            break;
          case TWEI_SKEWWINDOWY2:
            strRet = "TWEI_SKEWWINDOWY2";
            break;
          case TWEI_SKEWWINDOWX3:
            strRet = "TWEI_SKEWWINDOWX3";
            break;
          case TWEI_SKEWWINDOWY3:
            strRet = "TWEI_SKEWWINDOWY3";
            break;
          case TWEI_SKEWWINDOWX4:
            strRet = "TWEI_SKEWWINDOWX4";
            break;
          case TWEI_SKEWWINDOWY4:
            strRet = "TWEI_SKEWWINDOWY4";
            break;
          case TWEI_BOOKNAME:
            strRet = "TWEI_BOOKNAME";
            break;
          case TWEI_CHAPTERNUMBER:
            strRet = "TWEI_CHAPTERNUMBER";
            break;
          case TWEI_DOCUMENTNUMBER:
            strRet = "TWEI_DOCUMENTNUMBER";
            break;
          case TWEI_PAGENUMBER:
            strRet = "TWEI_PAGENUMBER";
            break;
          case TWEI_CAMERA:
            strRet = "TWEI_CAMERA";
            break;
          case TWEI_FRAMENUMBER:
            strRet = "TWEI_FRAMENUMBER";
            break;
          case TWEI_FRAME:
            strRet = "TWEI_FRAME";
            break;
          case TWEI_PIXELFLAVOR:
            strRet = "TWEI_PIXELFLAVOR";
            break;
          case TWEI_ICCPROFILE:
            strRet = "TWEI_ICCPROFILE";
            break;
          case TWEI_LASTSEGMENT:
            strRet = "TWEI_LASTSEGMENT";
            break;
          case TWEI_SEGMENTNUMBER:
            strRet = "TWEI_SEGMENTNUMBER";
            break;
          case TWEI_MAGDATA:
            strRet = "TWEI_MAGDATA";
            break;
          case TWEI_MAGTYPE:
            strRet = "TWEI_MAGTYPE";
            break;
          case TWEI_PAGESIDE:
            strRet = "TWEI_PAGESIDE";
            break;
          case TWEI_FILESYSTEMSOURCE:
            strRet = "TWEI_FILESYSTEMSOURCE";
            break;
          case TWEI_IMAGEMERGED:
            strRet = "TWEI_IMAGEMERGED";
            break;
          case TWEI_MAGDATALENGTH:
            strRet = "TWEI_MAGDATALENGTH";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
#if 0
      case ICAP_FRAMES:
        {
          char * buff = nextTempBuffer();
          SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%.2f,%.2f,%.2f,%.2f", 
            FIX32ToFloat(pFrame->Left), FIX32ToFloat(pFrame->Top), FIX32ToFloat(pFrame->Right), FIX32ToFloat(pFrame->Bottom));
          strRet = buff;
        }
        break;
#endif //#if 0
      case ICAP_MAXFRAMES:
      case ICAP_BITDEPTH:
        {
          char * buff = nextTempBuffer();
          SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%d", *pUint16);
          strRet = buff;
        }
        break;
#if 0
      case CAP_XFERCOUNT:
        {
          char * buff = nextTempBuffer();
          SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%d", *pInt16);
          strRet = buff;
        }
        break;
#endif //#if 0
#if 0
      case ICAP_GAMMA:
      case ICAP_XRESOLUTION:
      case ICAP_YRESOLUTION:
      case ICAP_BRIGHTNESS:
      case ICAP_CONTRAST:
      case ICAP_THRESHOLD:
      case ICAP_PHYSICALWIDTH:
      case ICAP_PHYSICALHEIGHT:
      case ICAP_MINIMUMHEIGHT:
      case ICAP_MINIMUMWIDTH:
        {
          char * buff = nextTempBuffer();
          SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%.2f", FIX32ToFloat(*pFix32));
          strRet = buff;
        }
        break;
#endif //#if 0
      case CAP_CUSTOMINTERFACEGUID:
      case ICAP_HALFTONES:
      case CAP_AUTHOR:
      case CAP_CAPTION:
      case CAP_TIMEDATE:
        {
          char * buff = nextTempBuffer();
          SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "%s", pStr);
          strRet = buff;
        }
        break;
      case CAP_ALARMS:
        switch(*pUint16)
        {
          case TWAL_ALARM:
            strRet = "TWAL_ALARM";
            break;
          case TWAL_FEEDERERROR:
            strRet = "TWAL_FEEDERERROR";
            break;
          case TWAL_FEEDERWARNING:
            strRet = "TWAL_FEEDERWARNING";
            break;
          case TWAL_BARCODE:
            strRet = "TWAL_BARCODE";
            break;
          case TWAL_DOUBLEFEED:
            strRet = "TWAL_DOUBLEFEED";
            break;
          case TWAL_JAM:
            strRet = "TWAL_JAM";
            break;
          case TWAL_PATCHCODE:
            strRet = "TWAL_PATCHCODE";
            break;
          case TWAL_POWER:
            strRet = "TWAL_POWER";
            break;
          case TWAL_SKEW:
            strRet = "TWAL_SKEW";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_AUTOSIZE:
        switch(*pUint16)
        {
          case TWAS_NONE:
            strRet = "TWAS_NONE";
            break;
          case TWAS_AUTO:
            strRet = "TWAS_AUTO";
            break;
          case TWAS_CURRENT:
            strRet = "TWAS_CURRENT";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_BARCODESEARCHMODE:
        switch(*pUint16)
        {
          case TWBD_HORZ:
            strRet = "TWBD_HORZ";
            break;
          case TWBD_VERT:
            strRet = "TWBD_VERT";
            break;
          case TWBD_HORZVERT:
            strRet = "TWBD_HORZVERT";
            break;
          case TWBD_VERTHORZ:
            strRet = "TWBD_VERTHORZ";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_BITORDER:
        switch(*pUint16)
        {
          case TWBO_LSBFIRST:
            strRet = "TWBO_LSBFIRST";
            break;
          case TWBO_MSBFIRST:
            strRet = "TWBO_MSBFIRST";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_AUTODISCARDBLANKPAGES:
        switch(*pUint16)
        {
          case TWBP_DISABLE:
            strRet = "TWBP_DISABLE";
            break;
          case TWBP_AUTO:
            strRet = "TWBP_AUTO";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_BITDEPTHREDUCTION:
        switch(*pUint16)
        {
          case TWBR_THRESHOLD:
            strRet = "TWBR_THRESHOLD";
            break;
          case TWBR_HALFTONE:
            strRet = "TWBR_HALFTONE";
            break;
          case TWBR_CUSTHALFTONE:
            strRet = "TWBR_CUSTHALFTONE";
            break;
          case TWBR_DIFFUSION:
            strRet = "TWBR_DIFFUSION";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_SUPPORTEDBARCODETYPES: /*and TWEI_BARCODETYPE values Added 1.7 */
        switch(*pUint16)
        {
          case TWBT_3OF9:
            strRet = "TWBT_3OF9";
            break;
          case TWBT_2OF5INTERLEAVED:
            strRet = "TWBT_2OF5INTERLEAVED";
            break;
          case TWBT_2OF5NONINTERLEAVED:
            strRet = "TWBT_2OF5NONINTERLEAVED";
            break;
          case TWBT_CODE93:
            strRet = "TWBT_CODE93";
            break;
          case TWBT_CODE128:
            strRet = "TWBT_CODE128";
            break;
          case TWBT_UCC128:
            strRet = "TWBT_UCC128";
            break;
          case TWBT_CODABAR:
            strRet = "TWBT_CODABAR";
            break;
          case TWBT_UPCA:
            strRet = "TWBT_UPCA";
            break;
          case TWBT_UPCE:
            strRet = "TWBT_UPCE";
            break;
          case TWBT_EAN8:
            strRet = "TWBT_EAN8";
            break;
          case TWBT_EAN13:
            strRet = "TWBT_EAN13";
            break;
          case TWBT_POSTNET:
            strRet = "TWBT_POSTNET";
            break;
          case TWBT_PDF417:
            strRet = "TWBT_PDF417";
            break;
          case TWBT_2OF5INDUSTRIAL:
            strRet = "TWBT_2OF5INDUSTRIAL";
            break;
          case TWBT_2OF5MATRIX:
            strRet = "TWBT_2OF5MATRIX";
            break;
          case TWBT_2OF5DATALOGIC:
            strRet = "TWBT_2OF5DATALOGIC";
            break;
          case TWBT_2OF5IATA:
            strRet = "TWBT_2OF5IATA";
            break;
          case TWBT_3OF9FULLASCII:
            strRet = "TWBT_3OF9FULLASCII";
            break;
          case TWBT_CODABARWITHSTARTSTOP:
            strRet = "TWBT_CODABARWITHSTARTSTOP";
            break;
          case TWBT_MAXICODE:
            strRet = "TWBT_MAXICODE";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_COMPRESSION:
        switch(*pUint16)
        {
          case TWCP_NONE:
            strRet = "TWCP_NONE";
            break;
          case TWCP_PACKBITS:
            strRet = "TWCP_PACKBITS";
            break;
          case TWCP_GROUP31D:
            strRet = "TWCP_GROUP31D";
            break;
          case TWCP_GROUP31DEOL:
            strRet = "TWCP_GROUP31DEOL";
            break;
          case TWCP_GROUP32D:
            strRet = "TWCP_GROUP32D";
            break;
          case TWCP_GROUP4:
            strRet = "TWCP_GROUP4";
            break;
          case TWCP_JPEG:
            strRet = "TWCP_JPEG";
            break;
          case TWCP_LZW:
            strRet = "TWCP_LZW";
            break;
          case TWCP_JBIG:
            strRet = "TWCP_JBIG";
            break;
          case TWCP_PNG:
            strRet = "TWCP_PNG";
            break;
          case TWCP_RLE4:
            strRet = "TWCP_RLE4";
            break;
          case TWCP_RLE8:
            strRet = "TWCP_RLE8";
            break;
          case TWCP_BITFIELDS:
            strRet = "TWCP_BITFIELDS";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_CAMERASIDE: /* and TWEI_PAGESIDE values (CS_ means camera side) Added 1.91 */
        switch(*pUint16)
        {
          case TWCS_BOTH:
            strRet = "TWCS_BOTH";
            break;
          case TWCS_TOP:
            strRet = "TWCS_TOP";
            break;
          case TWCS_BOTTOM:
            strRet = "TWCS_BOTTOM";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_CLEARBUFFERS:
        switch(*pUint16)
        {
          case TWCB_AUTO:
            strRet = "TWCB_AUTO";
            break;
          case TWCB_CLEAR:
            strRet = "TWCB_CLEAR";
            break;
          case TWCB_NOCLEAR:
            strRet = "TWCB_NOCLEAR";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_DEVICEEVENT:
        switch(*pUint16)
        {
          case TWDE_CUSTOMEVENTS:
            strRet = "TWDE_CUSTOMEVENTS";
            break;
          case TWDE_CHECKAUTOMATICCAPTURE:
            strRet = "TWDE_CHECKAUTOMATICCAPTURE";
            break;
          case TWDE_CHECKBATTERY:
            strRet = "TWDE_CHECKBATTERY";
            break;
          case TWDE_CHECKDEVICEONLINE:
            strRet = "TWDE_CHECKDEVICEONLINE";
            break;
          case TWDE_CHECKFLASH:
            strRet = "TWDE_CHECKFLASH";
            break;
          case TWDE_CHECKPOWERSUPPLY:
            strRet = "TWDE_CHECKPOWERSUPPLY";
            break;
          case TWDE_CHECKRESOLUTION:
            strRet = "TWDE_CHECKRESOLUTION";
            break;
          case TWDE_DEVICEADDED:
            strRet = "TWDE_DEVICEADDED";
            break;
          case TWDE_DEVICEOFFLINE:
            strRet = "TWDE_DEVICEOFFLINE";
            break;
          case TWDE_DEVICEREADY:
            strRet = "TWDE_DEVICEREADY";
            break;
          case TWDE_DEVICEREMOVED:
            strRet = "TWDE_DEVICEREMOVED";
            break;
          case TWDE_IMAGECAPTURED:
            strRet = "TWDE_IMAGECAPTURED";
            break;
          case TWDE_IMAGEDELETED:
            strRet = "TWDE_IMAGEDELETED";
            break;
          case TWDE_PAPERDOUBLEFEED:
            strRet = "TWDE_PAPERDOUBLEFEED";
            break;
          case TWDE_PAPERJAM:
            strRet = "TWDE_PAPERJAM";
            break;
          case TWDE_LAMPFAILURE:
            strRet = "TWDE_LAMPFAILURE";
            break;
          case TWDE_POWERSAVE:
            strRet = "TWDE_POWERSAVE";
            break;
          case TWDE_POWERSAVENOTIFY:
            strRet = "TWDE_POWERSAVENOTIFY";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_DUPLEX:
        switch(*pUint16)
        {
          case TWDX_NONE:
            strRet = "TWDX_NONE";
            break;
          case TWDX_1PASSDUPLEX:
            strRet = "TWDX_1PASSDUPLEX";
            break;
          case TWDX_2PASSDUPLEX:
            strRet = "TWDX_2PASSDUPLEX";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_FEEDERALIGNMENT:
        switch(*pUint16)
        {
          case TWFA_NONE:
            strRet = "TWFA_NONE";
            break;
          case TWFA_LEFT:
            strRet = "TWFA_LEFT";
            break;
          case TWFA_CENTER:
            strRet = "TWFA_CENTER";
            break;
          case TWFA_RIGHT:
            strRet = "TWFA_RIGHT";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_FEEDERTYPE:
        switch(*pUint16)
        {
          case TWFE_GENERAL:
            strRet = "TWFE_GENERAL";
            break;
          case TWFE_PHOTO:
            strRet = "TWFE_PHOTO";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_IMAGEFILEFORMAT:
        switch(*pUint16)
        {
          case TWFF_TIFF:
            strRet = "TWFF_TIFF";
            break;
          case TWFF_PICT:
            strRet = "TWFF_PICT";
            break;
          case TWFF_BMP:
            strRet = "TWFF_BMP";
            break;
          case TWFF_XBM:
            strRet = "TWFF_XBM";
            break;
          case TWFF_JFIF:
            strRet = "TWFF_JFIF";
            break;
          case TWFF_FPX:
            strRet = "TWFF_FPX";
            break;
          case TWFF_TIFFMULTI:
            strRet = "TWFF_TIFFMULTI";
            break;
          case TWFF_PNG:
            strRet = "TWFF_PNG";
            break;
          case TWFF_SPIFF:
            strRet = "TWFF_SPIFF";
            break;
          case TWFF_EXIF:
            strRet = "TWFF_EXIF";
            break;
          case TWFF_PDF:
            strRet = "TWFF_PDF";
            break;
          case TWFF_JP2:
            strRet = "TWFF_JP2";
            break;
          case TWFF_JPN:
            strRet = "TWFF_JPN";
            break;
          case TWFF_JPX:
            strRet = "TWFF_JPX";
            break;
          case TWFF_DEJAVU:
            strRet = "TWFF_DEJAVU";
            break;
          case TWFF_PDFA:
            strRet = "TWFF_PDFA";
            break;
          case TWFF_PDFA2:
            strRet = "TWFF_PDFA2";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_FLASHUSED2:
        switch(*pUint16)
        {
          case TWFL_NONE:
            strRet = "TWFL_NONE";
            break;
          case TWFL_OFF:
            strRet = "TWFL_OFF";
            break;
          case TWFL_ON:
            strRet = "TWFL_ON";
            break;
          case TWFL_AUTO:
            strRet = "TWFL_AUTO";
            break;
          case TWFL_REDEYE:
            strRet = "TWFL_REDEYE";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_FEEDERORDER:
        switch(*pUint16)
        {
          case TWFO_FIRSTPAGEFIRST:
            strRet = "TWFO_FIRSTPAGEFIRST";
            break;
          case TWFO_LASTPAGEFIRST:
            strRet = "TWFO_LASTPAGEFIRST";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_FEEDERPOCKET:
        switch(*pUint16)
        {
          case TWFP_POCKETERROR:
            strRet = "TWFP_POCKETERROR";
            break;
          case TWFP_POCKET1:
            strRet = "TWFP_POCKET1";
            break;
          case TWFP_POCKET2:
            strRet = "TWFP_POCKET2";
            break;
          case TWFP_POCKET3:
            strRet = "TWFP_POCKET3";
            break;
          case TWFP_POCKET4:
            strRet = "TWFP_POCKET4";
            break;
          case TWFP_POCKET5:
            strRet = "TWFP_POCKET5";
            break;
          case TWFP_POCKET6:
            strRet = "TWFP_POCKET6";
            break;
          case TWFP_POCKET7:
            strRet = "TWFP_POCKET7";
            break;
          case TWFP_POCKET8:
            strRet = "TWFP_POCKET8";
            break;
          case TWFP_POCKET9:
            strRet = "TWFP_POCKET9";
            break;
          case TWFP_POCKET10:
            strRet = "TWFP_POCKET10";
            break;
          case TWFP_POCKET11:
            strRet = "TWFP_POCKET11";
            break;
          case TWFP_POCKET12:
            strRet = "TWFP_POCKET12";
            break;
          case TWFP_POCKET13:
            strRet = "TWFP_POCKET13";
            break;
          case TWFP_POCKET14:
            strRet = "TWFP_POCKET14";
            break;
          case TWFP_POCKET15:
            strRet = "TWFP_POCKET15";
            break;
          case TWFP_POCKET16:
            strRet = "TWFP_POCKET16";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_FLIPROTATION:
        switch(*pUint16)
        {
          case TWFR_BOOK:
            strRet = "TWFR_BOOK";
            break;
          case TWFR_FANFOLD:
            strRet = "TWFR_FANFOLD";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_FILTER:
        switch(*pUint16)
        {
          case TWFT_RED:
            strRet = "TWFT_RED";
            break;
          case TWFT_GREEN:
            strRet = "TWFT_GREEN";
            break;
          case TWFT_BLUE:
            strRet = "TWFT_BLUE";
            break;
          case TWFT_NONE:
            strRet = "TWFT_NONE";
            break;
          case TWFT_WHITE:
            strRet = "TWFT_WHITE";
            break;
          case TWFT_CYAN:
            strRet = "TWFT_CYAN";
            break;
          case TWFT_MAGENTA:
            strRet = "TWFT_MAGENTA";
            break;
          case TWFT_YELLOW:
            strRet = "TWFT_YELLOW";
            break;
          case TWFT_BLACK:
            strRet = "TWFT_BLACK";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_ICCPROFILE:
        switch(*pUint16)
        {
          case TWIC_NONE:
            strRet = "TWIC_NONE";
            break;
          case TWIC_LINK:
            strRet = "TWIC_LINK";
            break;
          case TWIC_EMBED:
            strRet = "TWIC_EMBED";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_IMAGEFILTER:
        switch(*pUint16)
        {
          case TWIF_NONE:
            strRet = "TWIF_NONE";
            break;
          case TWIF_AUTO:
            strRet = "TWIF_AUTO";
            break;
          case TWIF_LOWPASS:
            strRet = "TWIF_LOWPASS";
            break;
          case TWIF_BANDPASS:
            strRet = "TWIF_BANDPASS";
            break;
          case TWIF_HIGHPASS:
            strRet = "TWIF_HIGHPASS";
            break;
  //        case TWIF_TEXT:
  //          strRet = "TWIF_TEXT";
  //          break;
  //        case TWIF_FINELINE:
  //          strRet = "TWIF_FINELINE";
  //          break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_IMAGEMERGE:
        switch(*pUint16)
        {
          case TWIM_NONE:
            strRet = "TWIM_NONE";
            break;
          case TWIM_FRONTONTOP:
            strRet = "TWIM_FRONTONTOP";
            break;
          case TWIM_FRONTONBOTTOM:
            strRet = "TWIM_FRONTONBOTTOM";
            break;
          case TWIM_FRONTONLEFT:
            strRet = "TWIM_FRONTONLEFT";
            break;
          case TWIM_FRONTONRIGHT:
            strRet = "TWIM_FRONTONRIGHT";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_JOBCONTROL:
        switch(*pUint16)
        {
          case TWJC_NONE:
            strRet = "TWJC_NONE";
            break;
          case TWJC_JSIC:
            strRet = "TWJC_JSIC";
            break;
          case TWJC_JSIS:
            strRet = "TWJC_JSIS";
            break;
          case TWJC_JSXC:
            strRet = "TWJC_JSXC";
            break;
          case TWJC_JSXS:
            strRet = "TWJC_JSXS";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_JPEGQUALITY:
        switch(*pUint16)
        {
          case TWJQ_UNKNOWN:
            strRet = "TWJQ_UNKNOWN";
            break;
          case TWJQ_LOW:
            strRet = "TWJQ_LOW";
            break;
          case TWJQ_MEDIUM:
            strRet = "TWJQ_MEDIUM";
            break;
          case TWJQ_HIGH:
            strRet = "TWJQ_HIGH";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_LIGHTPATH:
        switch(*pUint16)
        {
          case TWLP_REFLECTIVE:
            strRet = "TWLP_REFLECTIVE";
            break;
          case TWLP_TRANSMISSIVE:
            strRet = "TWLP_TRANSMISSIVE";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_LIGHTSOURCE:
        switch(*pUint16)
        {
          case TWLS_RED:
            strRet = "TWLS_RED";
            break;
          case TWLS_GREEN:
            strRet = "TWLS_GREEN";
            break;
          case TWLS_BLUE:
            strRet = "TWLS_BLUE";
            break;
          case TWLS_NONE:
            strRet = "TWLS_NONE";
            break;
          case TWLS_WHITE:
            strRet = "TWLS_WHITE";
            break;
          case TWLS_UV:
            strRet = "TWLS_UV";
            break;
          case TWLS_IR:
            strRet = "TWLS_IR";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_NOISEFILTER:
        switch(*pUint16)
        {
          case TWNF_NONE:
            strRet = "TWNF_NONE";
            break;
          case TWNF_AUTO:
            strRet = "TWNF_AUTO";
            break;
          case TWNF_LONEPIXEL:
            strRet = "TWNF_LONEPIXEL";
            break;
          case TWNF_MAJORITYRULE:
            strRet = "TWNF_MAJORITYRULE";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_ORIENTATION:
        switch(*pUint16)
        {
  //        case TWOR_ROT0:
  //          strRet = "TWOR_ROT0";
  //          break;
          case TWOR_ROT90:
            strRet = "TWOR_ROT90";
            break;
          case TWOR_ROT180:
            strRet = "TWOR_ROT180";
            break;
  //        case TWOR_ROT270:
  //          strRet = "TWOR_ROT270";
  //          break;
          case TWOR_PORTRAIT:
            strRet = "TWOR_PORTRAIT";
            break;
          case TWOR_LANDSCAPE:
            strRet = "TWOR_LANDSCAPE";
            break;
          case TWOR_AUTO:
            strRet = "TWOR_AUTO";
            break;
          case TWOR_AUTOTEXT:
            strRet = "TWOR_AUTOTEXT";
            break;
          case TWOR_AUTOPICTURE:
            strRet = "TWOR_AUTOPICTURE";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_OVERSCAN:
        switch(*pUint16)
        {
          case TWOV_NONE:
            strRet = "TWOV_NONE";
            break;
          case TWOV_AUTO:
            strRet = "TWOV_AUTO";
            break;
          case TWOV_TOPBOTTOM:
            strRet = "TWOV_TOPBOTTOM";
            break;
          case TWOV_LEFTRIGHT:
            strRet = "TWOV_LEFTRIGHT";
            break;
          case TWOV_ALL:
            strRet = "TWOV_ALL";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_PLANARCHUNKY:
        switch(*pUint16)
        {
          case TWPC_CHUNKY:
            strRet = "TWPC_CHUNKY";
            break;
          case TWPC_PLANAR:
            strRet = "TWPC_PLANAR";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_PIXELFLAVOR:
        switch(*pUint16)
        {
          case TWPF_CHOCOLATE:
            strRet = "TWPF_CHOCOLATE";
            break;
          case TWPF_VANILLA:
            strRet = "TWPF_VANILLA";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_PRINTERMODE:
        switch(*pUint16)
        {
          case TWPM_SINGLESTRING:
            strRet = "TWPM_SINGLESTRING";
            break;
          case TWPM_MULTISTRING:
            strRet = "TWPM_MULTISTRING";
            break;
          case TWPM_COMPOUNDSTRING:
            strRet = "TWPM_COMPOUNDSTRING";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_PRINTER:
        switch(*pUint16)
        {
          case TWPR_IMPRINTERTOPBEFORE:
            strRet = "TWPR_IMPRINTERTOPBEFORE";
            break;
          case TWPR_IMPRINTERTOPAFTER:
            strRet = "TWPR_IMPRINTERTOPAFTER";
            break;
          case TWPR_IMPRINTERBOTTOMBEFORE:
            strRet = "TWPR_IMPRINTERBOTTOMBEFORE";
            break;
          case TWPR_IMPRINTERBOTTOMAFTER:
            strRet = "TWPR_IMPRINTERBOTTOMAFTER";
            break;
          case TWPR_ENDORSERTOPBEFORE:
            strRet = "TWPR_ENDORSERTOPBEFORE";
            break;
          case TWPR_ENDORSERTOPAFTER:
            strRet = "TWPR_ENDORSERTOPAFTER";
            break;
          case TWPR_ENDORSERBOTTOMBEFORE:
            strRet = "TWPR_ENDORSERBOTTOMBEFORE";
            break;
          case TWPR_ENDORSERBOTTOMAFTER:
            strRet = "TWPR_ENDORSERBOTTOMAFTER";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_POWERSUPPLY:
        switch(*pUint16)
        {
          case TWPS_EXTERNAL:
            strRet = "TWPS_EXTERNAL";
            break;
          case TWPS_BATTERY:
            strRet = "TWPS_BATTERY";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case ICAP_PIXELTYPE:
        switch(*pUint16)
        {
          case TWPT_BW:
            strRet = "TWPT_BW";
            break;
          case TWPT_GRAY:
            strRet = "TWPT_GRAY";
            break;
          case TWPT_RGB:
            strRet = "TWPT_RGB";
            break;
          case TWPT_PALETTE:
            strRet = "TWPT_PALETTE";
            break;
          case TWPT_CMY:
            strRet = "TWPT_CMY";
            break;
          case TWPT_CMYK:
            strRet = "TWPT_CMYK";
            break;
          case TWPT_YUV:
            strRet = "TWPT_YUV";
            break;
          case TWPT_YUVK:
            strRet = "TWPT_YUVK";
            break;
          case TWPT_CIEXYZ:
            strRet = "TWPT_CIEXYZ";
            break;
          case TWPT_LAB:
            strRet = "TWPT_LAB";
            break;
          case TWPT_SRGB:
            strRet = "TWPT_SRGB";
            break;
          case TWPT_SCRGB:
            strRet = "TWPT_SCRGB";
            break;
          case TWPT_INFRARED:
            strRet = "TWPT_INFRARED";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
    case CAP_SEGMENTED:
        switch(*pUint16)
        {
          case TWSG_NONE:
            strRet = "TWSG_NONE";
            break;
          case TWSG_AUTO:
            strRet = "TWSG_AUTO";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
    case ICAP_SUPPORTEDSIZES:
        switch(*pUint16)
        {
          case TWSS_NONE:
            strRet = "TWSS_NONE";
            break;
          case TWSS_A4:
            strRet = "TWSS_A4";
            break;
          case TWSS_JISB5:
            strRet = "TWSS_JISB5";
            break;
          case TWSS_USLETTER:
            strRet = "TWSS_USLETTER";
            break;
          case TWSS_USLEGAL:
            strRet = "TWSS_USLEGAL";
            break;
          case TWSS_A5:
            strRet = "TWSS_A5";
            break;
          case TWSS_ISOB4:
            strRet = "TWSS_ISOB4";
            break;
          case TWSS_ISOB6:
            strRet = "TWSS_ISOB6";
            break;
          case TWSS_USLEDGER:
            strRet = "TWSS_USLEDGER";
            break;
          case TWSS_USEXECUTIVE:
            strRet = "TWSS_USEXECUTIVE";
            break;
          case TWSS_A3:
            strRet = "TWSS_A3";
            break;
          case TWSS_ISOB3:
            strRet = "TWSS_ISOB3";
            break;
          case TWSS_A6:
            strRet = "TWSS_A6";
            break;
          case TWSS_C4:
            strRet = "TWSS_C4";
            break;
          case TWSS_C5:
            strRet = "TWSS_C5";
            break;
          case TWSS_C6:
            strRet = "TWSS_C6";
            break;
          case TWSS_4A0:
            strRet = "TWSS_4A0";
            break;
          case TWSS_2A0:
            strRet = "TWSS_2A0";
            break;
          case TWSS_A0:
            strRet = "TWSS_A0";
            break;
          case TWSS_A1:
            strRet = "TWSS_A1";
            break;
          case TWSS_A2:
            strRet = "TWSS_A2";
            break;
          case TWSS_A7:
            strRet = "TWSS_A7";
            break;
          case TWSS_A8:
            strRet = "TWSS_A8";
            break;
          case TWSS_A9:
            strRet = "TWSS_A9";
            break;
          case TWSS_A10:
            strRet = "TWSS_A10";
            break;
          case TWSS_ISOB0:
            strRet = "TWSS_ISOB0";
            break;
          case TWSS_ISOB1:
            strRet = "TWSS_ISOB1";
            break;
          case TWSS_ISOB2:
            strRet = "TWSS_ISOB2";
            break;
          case TWSS_ISOB5:
            strRet = "TWSS_ISOB5";
            break;
          case TWSS_ISOB7:
            strRet = "TWSS_ISOB7";
            break;
          case TWSS_ISOB8:
            strRet = "TWSS_ISOB8";
            break;
          case TWSS_ISOB9:
            strRet = "TWSS_ISOB9";
            break;
          case TWSS_ISOB10:
            strRet = "TWSS_ISOB10";
            break;
          case TWSS_JISB0:
            strRet = "TWSS_JISB0";
            break;
          case TWSS_JISB1:
            strRet = "TWSS_JISB1";
            break;
          case TWSS_JISB2:
            strRet = "TWSS_JISB2";
            break;
          case TWSS_JISB3:
            strRet = "TWSS_JISB3";
            break;
          case TWSS_JISB4:
            strRet = "TWSS_JISB4";
            break;
          case TWSS_JISB6:
            strRet = "TWSS_JISB6";
            break;
          case TWSS_JISB7:
            strRet = "TWSS_JISB7";
            break;
          case TWSS_JISB8:
            strRet = "TWSS_JISB8";
            break;
          case TWSS_JISB9:
            strRet = "TWSS_JISB9";
            break;
          case TWSS_JISB10:
            strRet = "TWSS_JISB10";
            break;
          case TWSS_C0:
            strRet = "TWSS_C0";
            break;
          case TWSS_C1:
            strRet = "TWSS_C1";
            break;
          case TWSS_C2:
            strRet = "TWSS_C2";
            break;
          case TWSS_C3:
            strRet = "TWSS_C3";
            break;
          case TWSS_C7:
            strRet = "TWSS_C7";
            break;
          case TWSS_C8:
            strRet = "TWSS_C8";
            break;
          case TWSS_C9:
            strRet = "TWSS_C9";
            break;
          case TWSS_C10:
            strRet = "TWSS_C10";
            break;
          case TWSS_USSTATEMENT:
            strRet = "TWSS_USSTATEMENT";
            break;
          case TWSS_BUSINESSCARD:
            strRet = "TWSS_BUSINESSCARD";
            break;
          case TWSS_MAXSIZE:
            strRet = "TWSS_MAXSIZE";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
    case ICAP_XFERMECH:
        switch(*pUint16)
        {
          case TWSX_NATIVE:
            strRet = "TWSX_NATIVE";
            break;
          case TWSX_FILE:
            strRet = "TWSX_FILE";
            break;
          case TWSX_MEMORY:
            strRet = "TWSX_MEMORY";
            break;
          case TWSX_MEMFILE:
            strRet = "TWSX_MEMFILE";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
    case ICAP_UNITS:
        switch(*pUint16)
        {
          case TWUN_INCHES:
            strRet = "TWUN_INCHES";
            break;
          case TWUN_CENTIMETERS:
            strRet = "TWUN_CENTIMETERS";
            break;
          case TWUN_PICAS:
            strRet = "TWUN_PICAS";
            break;
          case TWUN_POINTS:
            strRet = "TWUN_POINTS";
            break;
          case TWUN_TWIPS:
            strRet = "TWUN_TWIPS";
            break;
          case TWUN_PIXELS:
            strRet = "TWUN_PIXELS";
            break;
          case TWUN_MILLIMETERS:
            strRet = "TWUN_MILLIMETERS";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      case CAP_LANGUAGE:
        switch(*pUint16)
        {
          case TWLG_USERLOCALE:
            strRet = "TWLG_USERLOCALE";
            break;
          case TWLG_DANISH:
            strRet = "TWLG_DANISH";
            break;
          case TWLG_DUTCH:
            strRet = "TWLG_DUTCH";
            break;
          case TWLG_ENGLISH:
            strRet = "TWLG_ENGLISH";
            break;
          case TWLG_FRENCH_CANADIAN:
            strRet = "TWLG_FRENCH_CANADIAN";
            break;
          case TWLG_FINNISH:
            strRet = "TWLG_FINNISH";
            break;
          case TWLG_FRENCH:
            strRet = "TWLG_FRENCH";
            break;
          case TWLG_GERMAN:
            strRet = "TWLG_GERMAN";
            break;
          case TWLG_ICELANDIC:
            strRet = "TWLG_ICELANDIC";
            break;
          case TWLG_ITALIAN:
            strRet = "TWLG_ITALIAN";
            break;
          case TWLG_NORWEGIAN:
            strRet = "TWLG_NORWEGIAN";
            break;
          case TWLG_PORTUGUESE:
            strRet = "TWLG_PORTUGUESE";
            break;
          case TWLG_SPANISH:
            strRet = "TWLG_SPANISH";
            break;
          case TWLG_SWEDISH:
            strRet = "TWLG_SWEDISH";
            break;
          case TWLG_ENGLISH_USA:
            strRet = "TWLG_ENGLISH_USA";
            break;
          case TWLG_AFRIKAANS:
            strRet = "TWLG_AFRIKAANS";
            break;
          case TWLG_ALBANIA:
            strRet = "TWLG_ALBANIA";
            break;
          case TWLG_ARABIC:
            strRet = "TWLG_ARABIC";
            break;
          case TWLG_ARABIC_ALGERIA:
            strRet = "TWLG_ARABIC_ALGERIA";
            break;
          case TWLG_ARABIC_BAHRAIN:
            strRet = "TWLG_ARABIC_BAHRAIN";
            break;
          case TWLG_ARABIC_EGYPT:
            strRet = "TWLG_ARABIC_EGYPT";
            break;
          case TWLG_ARABIC_IRAQ:
            strRet = "TWLG_ARABIC_IRAQ";
            break;
          case TWLG_ARABIC_JORDAN:
            strRet = "TWLG_ARABIC_JORDAN";
            break;
          case TWLG_ARABIC_KUWAIT:
            strRet = "TWLG_ARABIC_KUWAIT";
            break;
          case TWLG_ARABIC_LEBANON:
            strRet = "TWLG_ARABIC_LEBANON";
            break;
          case TWLG_ARABIC_LIBYA:
            strRet = "TWLG_ARABIC_LIBYA";
            break;
          case TWLG_ARABIC_MOROCCO:
            strRet = "TWLG_ARABIC_MOROCCO";
            break;
          case TWLG_ARABIC_OMAN:
            strRet = "TWLG_ARABIC_OMAN";
            break;
          case TWLG_ARABIC_QATAR:
            strRet = "TWLG_ARABIC_QATAR";
            break;
          case TWLG_ARABIC_SAUDIARABIA:
            strRet = "TWLG_ARABIC_SAUDIARABIA";
            break;
          case TWLG_ARABIC_SYRIA:
            strRet = "TWLG_ARABIC_SYRIA";
            break;
          case TWLG_ARABIC_TUNISIA:
            strRet = "TWLG_ARABIC_TUNISIA";
            break;
          case TWLG_ARABIC_UAE:
            strRet = "TWLG_ARABIC_UAE";
            break;
          case TWLG_ARABIC_YEMEN:
            strRet = "TWLG_ARABIC_YEMEN";
            break;
          case TWLG_BASQUE:
            strRet = "TWLG_BASQUE";
            break;
          case TWLG_BYELORUSSIAN:
            strRet = "TWLG_BYELORUSSIAN";
            break;
          case TWLG_BULGARIAN:
            strRet = "TWLG_BULGARIAN";
            break;
          case TWLG_CATALAN:
            strRet = "TWLG_CATALAN";
            break;
          case TWLG_CHINESE:
            strRet = "TWLG_CHINESE";
            break;
          case TWLG_CHINESE_HONGKONG:
            strRet = "TWLG_CHINESE_HONGKONG";
            break;
          case TWLG_CHINESE_PRC:
            strRet = "TWLG_CHINESE_PRC";
            break;
          case TWLG_CHINESE_SINGAPORE:
            strRet = "TWLG_CHINESE_SINGAPORE";
            break;
          case TWLG_CHINESE_SIMPLIFIED:
            strRet = "TWLG_CHINESE_SIMPLIFIED";
            break;
          case TWLG_CHINESE_TAIWAN:
            strRet = "TWLG_CHINESE_TAIWAN";
            break;
          case TWLG_CHINESE_TRADITIONAL:
            strRet = "TWLG_CHINESE_TRADITIONAL";
            break;
          case TWLG_CROATIA:
            strRet = "TWLG_CROATIA";
            break;
          case TWLG_CZECH:
            strRet = "TWLG_CZECH";
            break;
          case TWLG_DUTCH_BELGIAN:
            strRet = "TWLG_DUTCH_BELGIAN";
            break;
          case TWLG_ENGLISH_AUSTRALIAN:
            strRet = "TWLG_ENGLISH_AUSTRALIAN";
            break;
          case TWLG_ENGLISH_CANADIAN:
            strRet = "TWLG_ENGLISH_CANADIAN";
            break;
          case TWLG_ENGLISH_IRELAND:
            strRet = "TWLG_ENGLISH_IRELAND";
            break;
          case TWLG_ENGLISH_NEWZEALAND:
            strRet = "TWLG_ENGLISH_NEWZEALAND";
            break;
          case TWLG_ENGLISH_SOUTHAFRICA:
            strRet = "TWLG_ENGLISH_SOUTHAFRICA";
            break;
          case TWLG_ENGLISH_UK:
            strRet = "TWLG_ENGLISH_UK";
            break;
          case TWLG_ESTONIAN:
            strRet = "TWLG_ESTONIAN";
            break;
          case TWLG_FAEROESE:
            strRet = "TWLG_FAEROESE";
            break;
          case TWLG_FARSI:
            strRet = "TWLG_FARSI";
            break;
          case TWLG_FRENCH_BELGIAN:
            strRet = "TWLG_FRENCH_BELGIAN";
            break;
          case TWLG_FRENCH_LUXEMBOURG:
            strRet = "TWLG_FRENCH_LUXEMBOURG";
            break;
          case TWLG_FRENCH_SWISS:
            strRet = "TWLG_FRENCH_SWISS";
            break;
          case TWLG_GERMAN_AUSTRIAN:
            strRet = "TWLG_GERMAN_AUSTRIAN";
            break;
          case TWLG_GERMAN_LUXEMBOURG:
            strRet = "TWLG_GERMAN_LUXEMBOURG";
            break;
          case TWLG_GERMAN_LIECHTENSTEIN:
            strRet = "TWLG_GERMAN_LIECHTENSTEIN";
            break;
          case TWLG_GERMAN_SWISS:
            strRet = "TWLG_GERMAN_SWISS";
            break;
          case TWLG_GREEK:
            strRet = "TWLG_GREEK";
            break;
          case TWLG_HEBREW:
            strRet = "TWLG_HEBREW";
            break;
          case TWLG_HUNGARIAN:
            strRet = "TWLG_HUNGARIAN";
            break;
          case TWLG_INDONESIAN:
            strRet = "TWLG_INDONESIAN";
            break;
          case TWLG_ITALIAN_SWISS:
            strRet = "TWLG_ITALIAN_SWISS";
            break;
          case TWLG_JAPANESE:
            strRet = "TWLG_JAPANESE";
            break;
          case TWLG_KOREAN:
            strRet = "TWLG_KOREAN";
            break;
          case TWLG_KOREAN_JOHAB:
            strRet = "TWLG_KOREAN_JOHAB";
            break;
          case TWLG_LATVIAN:
            strRet = "TWLG_LATVIAN";
            break;
          case TWLG_LITHUANIAN:
            strRet = "TWLG_LITHUANIAN";
            break;
          case TWLG_NORWEGIAN_BOKMAL:
            strRet = "TWLG_NORWEGIAN_BOKMAL";
            break;
          case TWLG_NORWEGIAN_NYNORSK:
            strRet = "TWLG_NORWEGIAN_NYNORSK";
            break;
          case TWLG_POLISH:
            strRet = "TWLG_POLISH";
            break;
          case TWLG_PORTUGUESE_BRAZIL:
            strRet = "TWLG_PORTUGUESE_BRAZIL";
            break;
          case TWLG_ROMANIAN:
            strRet = "TWLG_ROMANIAN";
            break;
          case TWLG_RUSSIAN:
            strRet = "TWLG_RUSSIAN";
            break;
          case TWLG_SERBIAN_LATIN:
            strRet = "TWLG_SERBIAN_LATIN";
            break;
          case TWLG_SLOVAK:
            strRet = "TWLG_SLOVAK";
            break;
          case TWLG_SLOVENIAN:
            strRet = "TWLG_SLOVENIAN";
            break;
          case TWLG_SPANISH_MEXICAN:
            strRet = "TWLG_SPANISH_MEXICAN";
            break;
          case TWLG_SPANISH_MODERN:
            strRet = "TWLG_SPANISH_MODERN";
            break;
          case TWLG_THAI:
            strRet = "TWLG_THAI";
            break;
          case TWLG_TURKISH:
            strRet = "TWLG_TURKISH";
            break;
          case TWLG_UKRANIAN:
            strRet = "TWLG_UKRANIAN";
            break;
          case TWLG_ASSAMESE:
            strRet = "TWLG_ASSAMESE";
            break;
          case TWLG_BENGALI:
            strRet = "TWLG_BENGALI";
            break;
          case TWLG_BIHARI:
            strRet = "TWLG_BIHARI";
            break;
          case TWLG_BODO:
            strRet = "TWLG_BODO";
            break;
          case TWLG_DOGRI:
            strRet = "TWLG_DOGRI";
            break;
          case TWLG_GUJARATI:
            strRet = "TWLG_GUJARATI";
            break;
          case TWLG_HARYANVI:
            strRet = "TWLG_HARYANVI";
            break;
          case TWLG_HINDI:
            strRet = "TWLG_HINDI";
            break;
          case TWLG_KANNADA:
            strRet = "TWLG_KANNADA";
            break;
          case TWLG_KASHMIRI:
            strRet = "TWLG_KASHMIRI";
            break;
          case TWLG_MALAYALAM:
            strRet = "TWLG_MALAYALAM";
            break;
          case TWLG_MARATHI:
            strRet = "TWLG_MARATHI";
            break;
          case TWLG_MARWARI:
            strRet = "TWLG_MARWARI";
            break;
          case TWLG_MEGHALAYAN:
            strRet = "TWLG_MEGHALAYAN";
            break;
          case TWLG_MIZO:
            strRet = "TWLG_MIZO";
            break;
          case TWLG_NAGA:
            strRet = "TWLG_NAGA";
            break;
          case TWLG_ORISSI:
            strRet = "TWLG_ORISSI";
            break;
          case TWLG_PUNJABI:
            strRet = "TWLG_PUNJABI";
            break;
          case TWLG_PUSHTU:
            strRet = "TWLG_PUSHTU";
            break;
          case TWLG_SERBIAN_CYRILLIC:
            strRet = "TWLG_SERBIAN_CYRILLIC";
            break;
          case TWLG_SIKKIMI:
            strRet = "TWLG_SIKKIMI";
            break;
          case TWLG_SWEDISH_FINLAND:
            strRet = "TWLG_SWEDISH_FINLAND";
            break;
          case TWLG_TAMIL:
            strRet = "TWLG_TAMIL";
            break;
          case TWLG_TELUGU:
            strRet = "TWLG_TELUGU";
            break;
          case TWLG_TRIPURI:
            strRet = "TWLG_TRIPURI";
            break;
          case TWLG_URDU:
            strRet = "TWLG_URDU";
            break;
          case TWLG_VIETNAMESE:
           strRet = "TWLG_VIETNAMESE";
            break;
          default:
            {
              char * buff = nextTempBuffer();
              SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "0x%04X", *pUint16);
              strRet = buff;
            }
            break;
        }
        break;
      default:
        {
          char * buff = nextTempBuffer();
          SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Un-recognized Capability 0x%04X", twCapId);
          strRet = buff;
        }
        break;
    }
  }
  return strRet;
}

const char *convertFileType_toString(const TW_UINT16 _nItem)
{
  const char *strRet = NULL;
  switch(_nItem)
  {
    case TWFY_CAMERA:
      strRet = "TWFY_CAMERA";
      break;
    case TWFY_CAMERATOP:
      strRet = "TWFY_CAMERATOP";
      break;
    case TWFY_CAMERABOTTOM:
      strRet = "TWFY_CAMERABOTTOM";
      break;
    case TWFY_CAMERAPREVIEW:
      strRet = "TWFY_CAMERAPREVIEW";
      break;
    case TWFY_DOMAIN:
      strRet = "TWFY_DOMAIN";
      break;
    case TWFY_HOST:
      strRet = "TWFY_HOST";
      break;
    case TWFY_DIRECTORY:
      strRet = "TWFY_DIRECTORY";
      break;
    case TWFY_IMAGE:
      strRet = "TWFY_IMAGE";
      break;
    case TWFY_UNKNOWN:
      strRet = "TWFY_UNKNOWN";
      break;
    default:
      {
        char * buff = nextTempBuffer();
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Un-recognized FileType 0x%04X", _nItem);
        strRet = buff;
      }
      break;
  }
  return strRet;
}

const char *convertFileFormat_toString(const TW_UINT16 _nItem)
{
  return CapabilityValueToString(ICAP_IMAGEFILEFORMAT, TWTY_UINT16, &_nItem);
}

const char *convertEOJ_toString(const TW_UINT16 _nItem)
{
  const char *strRet = NULL;
  switch(_nItem)
  {
    case TWEJ_NONE:
      strRet = "TWEJ_NONE";
      break;
    case TWEJ_MIDSEPARATOR:
      strRet = "TWEJ_MIDSEPARATOR";
      break;
    case TWEJ_PATCH1:
      strRet = "TWEJ_PATCH1";
      break;
    case TWEJ_PATCH2:
      strRet = "TWEJ_PATCH2";
      break;
    case TWEJ_PATCH3:
      strRet = "TWEJ_PATCH3";
      break;
    case TWEJ_PATCH4:
      strRet = "TWEJ_PATCH4";
      break;
    case TWEJ_PATCH6:
      strRet = "TWEJ_PATCH6";
      break;
    case TWEJ_PATCHT:
      strRet = "TWEJ_PATCHT";
      break;
    default:
      {
        char * buff = nextTempBuffer();
        SSNPRINTF(buff, TEMPBUFSIZE, TEMPBUFSIZE, "Un-recognized FileType 0x%04X", _nItem);
        strRet = buff;
      }
      break;
  }
  return strRet;
}