home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 March / Chip_2002-03_cd1.bin / zkuste / delphi / kompon / d5 / SGSCAN.ZIP / Eztwain.c next >
C/C++ Source or Header  |  1998-07-14  |  56KB  |  1,972 lines
  1. // EZTWAIN.C - Easy TWAIN DLL main module
  2. //
  3. //     05/11/94    spike    initial version
  4. // 1.00    06/17/94    spike
  5. // 1.01    07/27/94    spike - added XferCount negotiation
  6. // 1.02 10/26/94    spike - fixed bug in ModalEventLoop (thanks to Bill DeVoe of HP)
  7. //                            replaced random flags with state tracking
  8. // 1.03 02/06/95    spike - fixed gross omissions in WriteDibToFile
  9. // 1.04 04/05/95    spike - added WriteNativeToFile, WriteNativeToFilename, FreeNative
  10. //                            added Get/SetCurrentUnits, SetCurrentPixelType
  11. //                            added SetCurrentResolution, SetCapOneValue
  12. //                            corrected bug in SelectImageSource
  13. // 1.05 04/02/97    spike - 32-bit version.
  14. //                            Correction to MessageHook, for thunking DSM.
  15. //                            Bugfix: 32-bit version of TWAIN_WriteDibToFile
  16. // 1.06 08/21/97    spike
  17. //                            Yet another correction to MessageHook.
  18. //                            Figured out how to export names 'as is' in 32-bit version.
  19.  
  20. #define VERSION 106        // version number, times 100.
  21.  
  22. //------------ Includes
  23.  
  24. //#include <assert.h>
  25. //#include <memory.h>        // memset, memcpy
  26.  
  27. #include "windows.h"
  28. #include "commdlg.h"
  29.  
  30. #ifdef _WIN32
  31. #ifndef _INC_VFW
  32. #include <vfw.h>
  33. #endif
  34. #else
  35. #include "commdlg.h"
  36. #endif
  37.  
  38. #include "twain.h"
  39.  
  40. #ifdef _WIN32
  41.   #define EZTAPI WINAPI
  42. #else
  43.   #define EZTAPI __export FAR PASCAL
  44. #endif
  45.  
  46. #include "eztwain.h"
  47.  
  48. //------------ Constants and Macros
  49.  
  50. #define STATIC static
  51. #ifdef __BORLANDC__
  52. #define _WIN32
  53. #endif
  54.  
  55. #ifdef _WIN32
  56.   #define INT32 int
  57.   #define DATAGROUP unsigned
  58.   #define DSM_FILENAME "TWAIN_32.DLL"
  59.   #define DSM_ENTRYPOINT "DSM_Entry"
  60.   #define IsValidHandle(h) (h!=NULL)
  61.   #define HUGEWRITE(fh, pb, bc) ((INT32)_lwrite(fh, pb, bc))
  62.   #define FMEMSET(p, v, n) memset(p, v, n);
  63.   #define FMEMCPY(p, q, n) memcpy(p, q, n);
  64. #else
  65.   #define INT32 long
  66.   #define DATAGROUP unsigned long
  67.   #define DSM_FILENAME "TWAIN.DLL"
  68.   #define DSM_ENTRYPOINT "DSM_ENTRY"
  69.   #define VALID_HANDLE 32
  70.   #define IsValidHandle(h) ((h!=0) && ((h) >= 32))
  71.   #define HUGEWRITE(fh, pb, bc) _hwrite(fh, pb, bc)
  72.   #define FMEMSET(p, v, n) _fmemset(p, v, n);
  73.   #define FMEMCPY(p, q, n) _fmemcpy(p, q, n);
  74. #endif
  75.  
  76. #define MAX_IMAGES 999
  77. #define TW_CALLBACK_REGISTERED 0xf0f0f
  78.  
  79. typedef enum {
  80.     ED_NONE,
  81.     ED_START_TRIPLET_ERRS,
  82.     ED_CAP_GET,                // MSG_GET triplet on a capability failed
  83.     ED_CAP_SET,                // MSG_SET triplet on capability failed
  84.     ED_DSM_FAILURE,            // TWAIN DSM returned TWRC_FAILURE
  85.     ED_DS_FAILURE,            // source returned TWRC_FAILURE
  86.     ED_END_TRIPLET_ERRS,
  87.     ED_NOT_STATE_4,            // operation invoked in wrong state
  88.     ED_NULL_HCON,            // MSG_GET returned a null container handle
  89.     ED_BAD_HCON,            // MSG_GET returned an invalid/unlockable container handle
  90.     ED_BAD_CONTYPE,            // returned container ConType is not valid.
  91.     ED_BAD_ITEMTYPE,        // returned container ItemType is not valid.
  92.     ED_CAP_GET_EMPTY,        // returned container has 0 items.
  93.     ED_CAP_SET_EMPTY,        // trying to restrict a cap to empty set
  94. } ErrorDetail;
  95.  
  96. const char *pszErrDescrip[] =
  97.     {    "[no details available]",
  98.         "",
  99.         "DAT_CAPABILITY/MSG_GET failed",
  100.         "DAT_CAPABILITY/MSG_SET failed",
  101.         "Source Manager operation failed",
  102.         "DataSource operation failed",
  103.         "",
  104.         "TWAIN session not in State 4 (Source Open)",
  105.         "MSG_GET returned a NULL container handle",
  106.         "MSG_GET returned an invalid container handle",
  107.         "Returned container is not valid type",
  108.         "Returned container has invalid ItemType",
  109.         "Returned container is empty",
  110.         "App and source found NO values in common",
  111.     };
  112.  
  113. const char *pszRC[] = {
  114.     "TWRC_SUCCESS",
  115.     "TWRC_FAILURE",
  116.     "TWRC_CHECKSTATUS ('tried hard')",
  117.     "TWRC_CANCEL",
  118.     "TWRC_DSEVENT",
  119.     "TWRC_NOTDSEVENT",
  120.     "TWRC_XFERDONE",
  121.     "TWRC_ENDOFLIST",
  122. };
  123.  
  124. const char *pszCC[] = {
  125.     "TWCC_SUCCESS",
  126.     "TWCC_BUMMER (Failure due to unknown causes)",
  127.     "TWCC_LOWMEMORY",
  128.     "TWCC_NODS (No Data Source)",
  129.     "TWCC_MAXCONNECTIONS (DS is connected to max possible apps)",
  130.     "TWCC_OPERATIONERROR (DS or DSM reported error, app shouldn't)",
  131.     "TWCC_BADCAP (Unknown capability)",
  132.     "7 (undefined)",
  133.     "8 (undefined)",
  134.     "TWCC_BADPROTOCOL (Unrecognized triplet)",
  135.     "TWCC_BADVALUE (Data parameter out of range)",
  136.     "TWCC_SEQERROR (Triplet out of sequence)",
  137.     "TWCC_BADDEST (Unknown dest. App/Src in DSM_Entry)",
  138. };
  139.  
  140. //------------ Global variables
  141.  
  142. STATIC int            iAvailable;            // TWAIN available: 0:unknown, -1:No, 1:Yes
  143. STATIC int            nState = 1;            // TWAIN state (per the standard)
  144. STATIC int            nErrDetail;            // detailed error code
  145. STATIC unsigned        nErrRC, nErrCC;        // result code and condition code for last error
  146. STATIC char            szMsg[256];            // scratch buffer for messages
  147. STATIC DSMENTRYPROC    pDSM_Entry;            // entry point of Data Source Manager (TWAIN.DLL)
  148. STATIC HANDLE        hDSMLib;            // handle of DSM
  149. STATIC TW_IDENTITY    AppId = {            // application identity structure
  150.     0,                                    // Id, filled in by DSM
  151.     { 1, 0, TWLG_USA, TWCY_USA, "<?>"},    // Version
  152.      TWON_PROTOCOLMAJOR,
  153.      TWON_PROTOCOLMINOR,
  154.      DG_IMAGE | DG_CONTROL,
  155.      "<?>",                                // Mfg
  156.      "<?>",                                // Family
  157.      "<?>"                                // Product
  158.      };
  159. STATIC TW_IDENTITY    SourceId;            // source identity structure
  160. STATIC BOOL            bHideUI;            // allow source u/i to be hidden
  161. STATIC TW_USERINTERFACE twUI;
  162. STATIC TW_PENDINGXFERS pendingXfers;
  163. STATIC HANDLE        hDib;                // bitmap returned by native transfer
  164. STATIC TW_INT16        rc;                    // result code
  165. STATIC HINSTANCE    hinstLib;            // instance handle for this DLL
  166.  
  167. STATIC HANDLE hDibList[MAX_IMAGES];
  168. STATIC TW_INT32 nDibs;
  169. STATIC HDIBCALLBACKPROC lpfnDibCallback;
  170. STATIC int hDibCallback_registered = 0;
  171.  
  172. const char szInsuffMem[] = "Insufficient Memory";    // error message
  173. STATIC int bTrace = 0;  // debugging helper
  174.  
  175. //------------ Forward declarations
  176.  
  177. void TWAIN_NativeXferReady(LPMSG pmsg);
  178. HWND CreateProxyWindow(void);
  179. unsigned Intersect16(unsigned wMask, unsigned nItems, TW_UINT16 far *pItem);
  180. unsigned BitCount(unsigned W);
  181. void TWAIN_ErrorBox(const char *szMsg);
  182. int RecordError(ErrorDetail ed);
  183. void ClearError(void);
  184. void TWAIN_ReportLastError(LPSTR lpzGeneral);
  185. // TW_UINT32 ToFix32(double r);
  186. // double Fix32ToFloat(TW_FIX32 fix);
  187. // above functions implemented on the Delphi side to avoid need for floating
  188. // point library functions --DSN 7/98
  189. void assert(int);
  190.  
  191. //------------ Public functions
  192. // the two functions below are implemented by hand vs. the C RTL so that the
  193. // resultant OBJ can be neatly linked into a Delphi DCU.
  194. void assert(int a)
  195. {
  196.   if (a == 0)
  197.       MessageBox(NULL, "Assertion failed", "EZTWAIN", MB_OK);
  198. }
  199.  
  200. void *memset(void *s, int c, size_t n)
  201. {
  202.     size_t j;
  203.     char *p;
  204.     p = (char *) s;
  205.  
  206.     for (j = 0; j < n; j++)
  207.         p[j] = (char) c;
  208.  
  209.     return s;
  210. }
  211.  
  212. void *memcpy(void *dest, const void *src, size_t n)
  213. {
  214.     size_t j;
  215.     char *pdest, *psrc;
  216.     pdest = (char *) dest;
  217.     psrc = (char *)src;
  218.     for (j = 0; j < n; j++)
  219.         pdest[j] = psrc[j];
  220.  
  221.     return dest;
  222. }
  223.  
  224. #ifdef _WIN32
  225.  
  226. // Win32 DLL main
  227. /*BOOL WINAPI DllMain(HANDLE hModule,
  228.                           ULONG  ulEvent,
  229.                           LPVOID lpReserved)
  230. {
  231.     return 1;
  232. }*/
  233.  
  234. #else
  235.  
  236. // Win16 DLL initialization and termination routines
  237. int CALLBACK __export LibMain(HINSTANCE hinst, WORD wDataSeg, WORD cbHeapSize, LPSTR lpszCmdLine)
  238. {
  239.     wDataSeg = wDataSeg; cbHeapSize = cbHeapSize; lpszCmdLine = lpszCmdLine;
  240.  
  241.     hinstLib = hinst;
  242.     return 1;        // indicate success
  243. } // LibMain
  244.  
  245.  
  246. int FAR PASCAL __export _WEP(int x)
  247. {
  248.     x = x;                // suppress 'is never used' warning
  249.     return 1;
  250. } // _WEP
  251.  
  252.  
  253. #endif
  254.  
  255.  
  256. void EZTAPI TWAIN_RegisterApp(    // record application information
  257.     int        nMajorNum, int nMinorNum,    // major and incremental revision of application. E.g.
  258.                                         // for version 2.1, nMajorNum == 2 and nMinorNum == 1
  259.     int        nLanguage,                    // language of this version (use TWLG_xxx from TWAIN.H)
  260.     int        nCountry,                    // country of this version (use TWCY_xxx from TWAIN.H)
  261.     LPSTR    lpszVersion,                // version info string e.g. "1.0b3 Beta release"
  262.     LPSTR    lpszMfg,                    // name of manufacturer/developer e.g. "Crazbat Software"
  263.     LPSTR    lpszFamily,                    // product family e.g. "BitStomper"
  264.     LPSTR    lpszProduct)                // specific product e.g. "BitStomper Deluxe Pro"
  265. {
  266.      AppId.Id = 0;                        // init to 0, but Source Manager will assign real value
  267.     AppId.Version.MajorNum = nMajorNum;
  268.     AppId.Version.MinorNum = nMinorNum;
  269.     AppId.Version.Language = nLanguage;
  270.     AppId.Version.Country  = nCountry;
  271.     lstrcpy (AppId.Version.Info,  lpszVersion);
  272.  
  273.     AppId.ProtocolMajor =    TWON_PROTOCOLMAJOR;
  274.      AppId.ProtocolMinor =    TWON_PROTOCOLMINOR;
  275.      AppId.SupportedGroups =  DG_IMAGE | DG_CONTROL;
  276.     lstrcpy (AppId.Manufacturer,  lpszMfg);
  277.     lstrcpy (AppId.ProductFamily, lpszFamily);
  278.     lstrcpy (AppId.ProductName,   lpszProduct);
  279.  
  280. } // TWAIN_RegisterApp
  281.  
  282.  
  283. int EZTAPI TWAIN_SelectImageSource(HWND hwnd)
  284. {
  285.  
  286.     int fSuccess = FALSE;
  287.     int fProxyWindow = FALSE;
  288.  
  289.     if (!IsWindow(hwnd)) {
  290.         if (hwnd != NULL) {
  291.             TWAIN_ErrorBox("TWAIN_SelectImageSource: window handle is invalid");
  292.             return FALSE;
  293.         }
  294.         hwnd = CreateProxyWindow();
  295.         if (!IsWindow(hwnd)) {
  296.             TWAIN_ErrorBox("TWAIN_SelectImageSource: Unable to create proxy window");
  297.             return FALSE;
  298.         }
  299.         fProxyWindow = TRUE;
  300.     }
  301.     if (TWAIN_LoadSourceManager()) {
  302.         if (TWAIN_OpenSourceManager(hwnd)) {
  303.             TW_IDENTITY    NewSourceId;
  304. #ifdef _WIN32
  305.             FMEMSET(&NewSourceId, 0, sizeof NewSourceId);
  306. #else
  307.             // I will settle for the system default.  Shouldn't I get a highlight
  308.             // on system default without this call?
  309.             TWAIN_Mgr(DG_CONTROL, DAT_IDENTITY, MSG_GETDEFAULT, &NewSourceId);
  310. #endif
  311.             // Post the Select Source dialog
  312.             fSuccess = TWAIN_Mgr(DG_CONTROL, DAT_IDENTITY, MSG_USERSELECT, &NewSourceId);
  313.              TWAIN_CloseSourceManager(hwnd);
  314.          } else {
  315.             TWAIN_ErrorBox("Unable to open Source Manager (" DSM_FILENAME ")");
  316.          }
  317.          TWAIN_UnloadSourceManager();
  318.     } else {
  319.         TWAIN_ErrorBox("Unable to load Source Manager (" DSM_FILENAME ")");
  320.     }
  321.      if (fProxyWindow) DestroyWindow(hwnd);
  322.  
  323.     return fSuccess;
  324. } // TWAIN_SelectImageSource
  325.  
  326.  
  327. HANDLE EZTAPI TWAIN_AcquireNative(HWND hwnd, unsigned wPixTypes)
  328. {
  329.     int fProxyWindow = FALSE;
  330.     hDib = NULL;
  331.     ClearError();            // clear error detail
  332.     TWAIN_ClearDibList();
  333.  
  334.     if (!IsWindow(hwnd)) {
  335.         // hwnd isn't a valid window handle - most likely NULL
  336.         hwnd = CreateProxyWindow();
  337.         if (hwnd) fProxyWindow = TRUE;
  338.     }
  339.     if (!IsWindow(hwnd)) {
  340.         TWAIN_ErrorBox("Unable to create proxy window");
  341.     } else if (!TWAIN_LoadSourceManager()) {
  342.         TWAIN_ErrorBox("Unable to load Source Manager (" DSM_FILENAME ")");
  343.     } else if (!TWAIN_OpenSourceManager(hwnd)) {
  344.         TWAIN_ErrorBox("Unable to open Source Manager (" DSM_FILENAME ")");
  345.      } else if (!TWAIN_OpenDefaultSource()) {
  346.         TWAIN_ReportLastError("Unable to open default Data Source.");
  347.     } else if (!TWAIN_NegotiatePixelTypes(wPixTypes)) {
  348.         TWAIN_ReportLastError("Failed to negotiate Pixel Type.");
  349.     } else if (!TWAIN_EnableSource(hwnd)) {
  350.         TWAIN_ReportLastError("Failed to enable Data Source.");
  351.     } else {
  352.         EnableWindow(hwnd, FALSE);
  353.         // source is enabled, wait for transfer or source closed
  354.         TWAIN_ModalEventLoop();
  355.  
  356.         EnableWindow(hwnd, TRUE);
  357.     }
  358.  
  359.     // shut everything down in the right sequence
  360.     // these routines do nothing if the corresponding 'open' failed
  361.     TWAIN_DisableSource();
  362.     TWAIN_CloseSource();
  363.      TWAIN_CloseSourceManager(hwnd);
  364.      TWAIN_UnloadSourceManager();
  365.  
  366.      if (fProxyWindow) {
  367.         DestroyWindow(hwnd);
  368.      }
  369.  
  370.     return hDib;
  371. } // TWAIN_AcquireNative
  372.  
  373.  
  374. void EZTAPI TWAIN_FreeNative(HANDLE hdib)
  375. // Release the memory allocated to a native format image, as returned by TWAIN_AcquireNative.
  376. // (For those coding in C or C++, this is just a call to GlobalFree.)
  377. {
  378.     if (hdib) GlobalFree(hdib);
  379. } // TWAIN_FreeNative
  380.  
  381.  
  382.  
  383. int EZTAPI TWAIN_AcquireToClipboard(HWND hwndApp, unsigned wPixTypes)
  384. // Like AcquireNative, but puts the resulting image, if any, into the system clipboard.
  385. // Useful for environments like Visual Basic where it is hard to make direct use of a DIB handle.
  386. // A return value of 1 indicates success, 0 indicates failure.
  387. {
  388.     int fOk = FALSE;
  389.     HANDLE hDib = TWAIN_AcquireNative(hwndApp, wPixTypes);
  390.     if (hDib) {
  391.         if (OpenClipboard(hwndApp)) {
  392.             if (EmptyClipboard()) {
  393.                 SetClipboardData(CF_DIB, hDib);
  394.                 fOk = TRUE;
  395.                 hDib = NULL;
  396.             }
  397.             CloseClipboard();
  398.         }
  399.         if (hDib) {
  400.             // something went wrong, recycle the image
  401.             GlobalFree(hDib);
  402.         }
  403.     }
  404.     return fOk;        // failed
  405. } // TWAIN_AcquireToClipboard
  406.  
  407.  
  408. int EZTAPI TWAIN_AcquireToFilename(HWND hwndApp, char *pszFile)
  409. // Adapted from a routine by David D. Henseler (ddh) of SOLUTIONS GmbH
  410. {
  411.     int result = -1;
  412.     HANDLE    hDib = TWAIN_AcquireNative(hwndApp, TWAIN_ANYTYPE);
  413.     if (hDib) {
  414.         result = TWAIN_WriteNativeToFilename(hDib, pszFile);
  415.         TWAIN_FreeNative(hDib);
  416.     }
  417.     return result;
  418. } // TWAIN_AcquireToFile
  419.  
  420. //--------- Callback mechanism -------------
  421. // These routines, added by DSN 7/98, allow the user to specify an
  422. // optional callback function to be called each time a new image comes
  423. // in.  This can be a potentially powerful way to increase the primary
  424. // application's efficiency, because upon receipt of an hdib the app
  425. // could start a background thread to begin processing the images as
  426. // needed.  Why bother with this?  Because on my Pentium 150, the Windows
  427. // NT task monitor indicates that when I download images at 112kbps that
  428. // I'm only using 15% of the processor's power, and the remaining 85% of
  429. // the time it is idle!  It's silly to wait to begin processing because
  430. // there's so much untapped processing capacity here.
  431.  
  432. void EZTAPI TWAIN_RegisterCallback(HDIBCALLBACKPROC *fxn)
  433. {
  434.       lpfnDibCallback = fxn;
  435.       hDibCallback_registered = TW_CALLBACK_REGISTERED;  // our signature, because I don't trust
  436.                                                      // the supposed initialization to zero
  437.                                                      // by the compiler
  438. }
  439.  
  440. void EZTAPI TWAIN_UnRegisterCallback()
  441. {
  442.       lpfnDibCallback = NULL;
  443.       hDibCallback_registered = TW_CALLBACK_REGISTERED;
  444. }
  445.  
  446. ///////////////////////////////////////////////////////////////////////
  447. // DIB utilities
  448.  
  449. void EZTAPI TWAIN_ClearDibList()
  450. /// new; added by DSN
  451. /// note: user is responsible for calling TWAIN_FreeNative *before*
  452. /// calling this function!
  453.  
  454. {
  455.       int i;
  456.       for (i = 0; i < MAX_IMAGES; i++)
  457.              hDibList[i] = 0;
  458.       nDibs = 0;
  459. }
  460.  
  461. int EZTAPI TWAIN_GetNumDibs()
  462. {
  463.       return nDibs;
  464. }
  465.  
  466. HANDLE EZTAPI TWAIN_GetDib(int n)
  467. {
  468.       return hDibList[n];
  469. }
  470. int EZTAPI TWAIN_DibDepth(HANDLE hdib)
  471. {
  472.     LPBITMAPINFOHEADER pbi = (LPBITMAPINFOHEADER)GlobalLock(hdib);
  473.     int D = pbi->biBitCount;
  474.     GlobalUnlock(hdib);
  475.     return D;
  476. } // TWAIN_DibDepth
  477.  
  478. int EZTAPI TWAIN_DibWidth(HANDLE hdib)
  479. {
  480.     LPBITMAPINFOHEADER pbi = (LPBITMAPINFOHEADER)GlobalLock(hdib);
  481.     int W = (int)pbi->biWidth;
  482.     GlobalUnlock(hdib);
  483.     return W;
  484. } // TWAIN_DibWidth
  485.  
  486.  
  487. int EZTAPI TWAIN_DibHeight(HANDLE hdib)
  488. {
  489.     LPBITMAPINFOHEADER pbi = (LPBITMAPINFOHEADER)GlobalLock(hdib);
  490.     int H = (int)pbi->biHeight;
  491.     GlobalUnlock(hdib);
  492.     return H;
  493. } // TWAIN_DibHeight
  494.  
  495.  
  496. static int DibNumColors(VOID FAR *pv)
  497. {
  498.      LPBITMAPINFOHEADER    lpbi = ((LPBITMAPINFOHEADER)pv);
  499.      LPBITMAPCOREHEADER    lpbc = ((LPBITMAPCOREHEADER)pv);
  500.  
  501.     int nColors;
  502.  
  503.      if (lpbi->biSize == sizeof(BITMAPCOREHEADER)) {
  504.         nColors = 1 << lpbc->bcBitCount;
  505.      } else if (lpbi->biClrUsed == 0) {
  506.         nColors = 1 << lpbi->biBitCount;
  507.     } else {
  508.         nColors = (int)lpbi->biClrUsed;
  509.     }
  510.     if (nColors > 256) nColors = 0;
  511.     return nColors;
  512. } // DibNumColors
  513.  
  514.  
  515. int EZTAPI TWAIN_DibNumColors(HANDLE hdib)
  516. // given a DIB handle, return the number of palette entries: 0,2,16, or 256
  517. {
  518.     VOID FAR *pv = GlobalLock(hdib);
  519.     int nColors = DibNumColors(pv);
  520.     GlobalUnlock(hdib);
  521.     return nColors;
  522. }
  523.  
  524.  
  525. //---------------------------------------------------------------------------
  526.  
  527. const PALETTEENTRY peStock256[256] = {
  528.     // from 0 .. 9 are Windows fixed colors
  529.      0,   0,   0, 0,    // 000 always black
  530.    128,   0,   0, 0,    // 001 dark red
  531.      0, 128,   0, 0,    // 002 dark green
  532.    128, 128,   0, 0,    // 003 dark brown
  533.      0,   0, 128, 0,    // 004 dark blue
  534.     128,   0, 128, 0,    // 005 dark purple
  535.      0, 128, 128, 0,    // 006 dark teal
  536.    192, 192, 192, 0,    // 007 light gray
  537.     192, 220, 192, 0,    // 008 pale green
  538.    166, 202, 240, 0,    // 009 sky blue
  539.       4,   4,   4, 4,    // 010 dark gray ramp
  540.      8,   8,   8, 4,    // 011
  541.      12,  12,  12, 4,    // 012
  542.     17,  17,  17, 4,    // 013
  543.      22,  22,  22, 4,    // 014
  544.      28,  28,  28, 4,    // 015
  545.     34,  34,  34, 4,    // 016
  546.     41,  41,  41, 4,    // 017
  547.     85,  85,  85, 4,    // 018
  548.     77,  77,  77, 4,    // 019
  549.      66,  66,  66, 4,    // 020
  550.      57,  57,  57, 4,    // 021
  551.    255, 124, 128, 4,    // 022
  552.    255,  80,  80, 4,    // 023
  553.    214,   0, 147, 4,    // 024
  554.    204, 236, 255, 4,    // 025
  555.    239, 214, 198, 4,    // 026
  556.    231, 231, 214, 4,    // 027
  557.    173, 169, 144, 4,    // 028
  558.     51,   0,   0, 4,    // 029
  559.     102,   0,   0, 4,    // 030
  560.    153,   0,   0, 4,    // 031 
  561.    204,   0,   0, 4,    // 032
  562.      0,  51,   0, 4,    // 033
  563.     51,  51,   0, 4,    // 034
  564.    102,  51,   0, 4,    // 035
  565.    153,  51,   0, 4,    // 036
  566.    204,  51,   0, 4,    // 037
  567.    255,  51,   0, 4,    // 038
  568.       0, 102,   0, 4,    // 039
  569.     51, 102,   0, 4,    // 040
  570.    102, 102,   0, 4,    // 041
  571.     153, 102,   0, 4,    // 042
  572.     204, 102,   0, 4,    // 043
  573.     255, 102,   0, 4,    // 044
  574.      0, 153,   0, 4,    // 045     
  575.     51, 153,   0, 4,    // 046
  576.    102, 153,   0, 4,    // 047
  577.     153, 153,   0, 4,    // 048
  578.    204, 153,   0, 4,    // 049
  579.    255, 153,   0, 4,    // 050
  580.      0, 204,   0, 4,    // 051
  581.     51, 204,   0, 4,    // 052
  582.    102, 204,   0, 4,    // 053
  583.     153, 204,   0, 4,    // 054
  584.     204, 204,   0, 4,    // 055
  585.    255, 204,   0, 4,    // 056
  586.    102, 255,   0, 4,    // 057
  587.    153, 255,   0, 4,    // 058
  588.    204, 255,   0, 4,    // 059
  589.      0,   0,  51, 4,    // 060
  590.      51,   0,  51, 4,    // 061
  591.    102,   0,  51, 4,    // 062
  592.    153,   0,  51, 4,    // 063
  593.    204,   0,  51, 4,    // 064
  594.    255,   0,  51, 4,    // 065
  595.      0,  51,  51, 4,    // 066
  596.     51,  51,  51, 4,    // 067
  597.    102,  51,  51, 4,    // 068
  598.    153,  51,  51, 4,    // 069
  599.    204,  51,  51, 4,    // 070
  600.     255,  51,  51, 4,    // 071
  601.      0, 102,  51, 4,    // 072
  602.      51, 102,  51, 4,    // 073
  603.    102, 102,  51, 4,    // 074
  604.    153, 102,  51, 4,    // 075
  605.     204, 102,  51, 4,    // 076
  606.    255, 102,  51, 4,    // 077
  607.       0, 153,  51, 4,    // 078
  608.     51, 153,  51, 4,    // 079
  609.     102, 153,  51, 4,    // 080
  610.    153, 153,  51, 4,    // 081
  611.     204, 153,  51, 4,    // 082
  612.    255, 153,  51, 4,    // 083
  613.      0, 204,  51, 4,    // 084
  614.     51, 204,  51, 4,    // 085
  615.    102, 204,  51, 4,    // 086
  616.    153, 204,  51, 4,    // 087
  617.     204, 204,  51, 4,    // 088
  618.     255, 204,  51, 4,    // 089
  619.     51, 255,  51, 4,    // 090
  620.    102, 255,  51, 4,    // 091
  621.     153, 255,  51, 4,    // 092
  622.    204, 255,  51, 4,    // 093
  623.    255, 255,  51, 4,    // 094
  624.      0,   0, 102, 4,    // 095
  625.     51,   0, 102, 4,    // 096
  626.    102,   0, 102, 4,    // 097
  627.    153,   0, 102, 4,    // 098
  628.     204,   0, 102, 4,    // 099
  629.    255,   0, 102, 4,    // 100
  630.      0,  51, 102, 4,    // 101
  631.     51,  51, 102, 4,    // 102
  632.    102,  51, 102, 4,    // 103
  633.    153,  51, 102, 4,    // 104
  634.    204,  51, 102, 4,    // 105
  635.    255,  51, 102, 4,    // 106
  636.       0, 102, 102, 4,    // 107
  637.     51, 102, 102, 4,    // 108
  638.    102, 102, 102, 4,    // 109
  639.     153, 102, 102, 4,    // 110
  640.    204, 102, 102, 4,    // 111
  641.       0, 153, 102, 4,    // 112
  642.     51, 153, 102, 4,    // 113
  643.     102, 153, 102, 4,    // 114
  644.    153, 153, 102, 4,    // 115
  645.     204, 153, 102, 4,    // 116
  646.    255, 153, 102, 4,    // 117
  647.      0, 204, 102, 4,    // 118
  648.     51, 204, 102, 4,    // 119
  649.    153, 204, 102, 4,    // 120
  650.    204, 204, 102, 4,    // 121
  651.     255, 204, 102, 4,    // 122
  652.       0, 255, 102, 4,    // 123
  653.     51, 255, 102, 4,    // 124
  654.    153, 255, 102, 4,    // 125
  655.    204, 255, 102, 4,    // 126
  656.     255,   0, 204, 4,    // 127
  657.    204,   0, 255, 4,    // 128
  658.      0, 153, 153, 4,    // 129
  659.    153,  51, 153, 4,    // 130
  660.    153,   0, 153, 4,    // 131
  661.    204,   0, 153, 4,    // 132
  662.      0,   0, 153, 4,    // 133
  663.     51,  51, 153, 4,    // 134
  664.    102,   0, 153, 4,    // 135
  665.    204,  51, 153, 4,    // 136
  666.    255,   0, 153, 4,    // 137
  667.      0, 102, 153, 4,    // 138
  668.     51, 102, 153, 4,    // 139
  669.    102,  51, 153, 4,    // 140
  670.    153, 102, 153, 4,    // 141
  671.    204, 102, 153, 4,    // 142
  672.    255,  51, 153, 4,    // 143
  673.     51, 153, 153, 4,    // 144
  674.    102, 153, 153, 4,    // 145
  675.     153, 153, 153, 4,    // 146
  676.    204, 153, 153, 4,    // 147
  677.     255, 153, 153, 4,    // 148
  678.      0, 204, 153, 4,    // 149
  679.      51, 204, 153, 4,    // 150
  680.    102, 204, 102, 4,    // 151
  681.    153, 204, 153, 4,    // 152
  682.    204, 204, 153, 4,    // 153
  683.     255, 204, 153, 4,    // 154
  684.       0, 255, 153, 4,    // 155
  685.      51, 255, 153, 4,    // 156
  686.     102, 204, 153, 4,    // 157
  687.    153, 255, 153, 4,    // 158
  688.    204, 255, 153, 4,    // 159
  689.    255, 255, 153, 4,    // 160
  690.      0,   0, 204, 4,    // 161
  691.     51,   0, 153, 4,    // 162
  692.    102,   0, 204, 4,    // 163
  693.    153,   0, 204, 4,    // 164
  694.    204,   0, 204, 4,    // 165
  695.      0,  51, 153, 4,    // 166
  696.     51,  51, 204, 4,    // 167
  697.    102,  51, 204, 4,    // 168
  698.    153,  51, 204, 4,    // 169
  699.     204,  51, 204, 4,    // 170
  700.    255,  51, 204, 4,    // 171
  701.      0, 102, 204, 4,    // 172
  702.     51, 102, 204, 4,    // 173
  703.    102, 102, 153, 4,    // 174
  704.    153, 102, 204, 4,    // 175
  705.    204, 102, 204, 4,    // 176
  706.    255, 102, 153, 4,    // 177
  707.      0, 153, 204, 4,    // 178
  708.     51, 153, 204, 4,    // 179
  709.     102, 153, 204, 4,    // 180
  710.    153, 153, 204, 4,    // 181
  711.     204, 153, 204, 4,    // 182
  712.     255, 153, 204, 4,    // 183
  713.       0, 204, 204, 4,    // 184
  714.      51, 204, 204, 4,    // 185
  715.    102, 204, 204, 4,    // 186
  716.    153, 204, 204, 4,    // 187
  717.    204, 204, 204, 4,    // 188
  718.    255, 204, 204, 4,    // 189
  719.       0, 255, 204, 4,    // 190
  720.      51, 255, 204, 4,    // 191
  721.    102, 255, 153, 4,    // 192
  722.    153, 255, 204, 4,    // 193
  723.    204, 255, 204, 4,    // 194
  724.    255, 255, 204, 4,    // 195
  725.     51,   0, 204, 4,    // 196
  726.    102,   0, 255, 4,    // 197
  727.    153,   0, 255, 4,    // 198
  728.      0,  51, 204, 4,    // 199
  729.     51,  51, 255, 4,    // 200
  730.    102,  51, 255, 4,    // 201
  731.    153,  51, 255, 4,    // 202
  732.    204,  51, 255, 4,    // 203
  733.     255,  51, 255, 4,    // 204
  734.      0, 102, 255, 4,    // 205
  735.     51, 102, 255, 4,    // 206
  736.    102, 102, 204, 4,    // 207
  737.    153, 102, 255, 4,    // 208
  738.    204, 102, 255, 4,    // 209
  739.    255, 102, 204, 4,    // 210
  740.       0, 153, 255, 4,    // 211
  741.     51, 153, 255, 4,    // 212
  742.    102, 153, 255, 4,    // 213
  743.     153, 153, 255, 4,    // 214
  744.    204, 153, 255, 4,    // 215
  745.     255, 153, 255, 4,    // 216
  746.      0, 204, 255, 4,    // 217
  747.      51, 204, 255, 4,    // 218
  748.    102, 204, 255, 4,    // 219
  749.    153, 204, 255, 4,    // 220
  750.    204, 204, 255, 4,    // 221
  751.    255, 204, 255, 4,    // 222
  752.     51, 255, 255, 4,    // 223
  753.     102, 255, 204, 4,    // 224
  754.     153, 255, 255, 4,    // 225
  755.    204, 255, 255, 4,    // 226
  756.    255, 102, 102, 4,    // 227
  757.    102, 255, 102, 4,    // 228
  758.    255, 255, 102, 4,    // 229
  759.    102, 102, 255, 4,    // 230
  760.    255, 102, 255, 4,    // 231
  761.    102, 255, 255, 4,    // 232
  762.    165,   0,  33, 4,    // 233
  763.     95,  95,  95, 4,    // 234
  764.    119, 119, 119, 4,    // 235 
  765.    134, 134, 134, 4,    // 236
  766.    150, 150, 150, 4,    // 237
  767.     203, 203, 203, 4,    // 238
  768.     178, 178, 178, 4,    // 239
  769.    215, 215, 215, 4,    // 240
  770.    221, 221, 221, 4,    // 241
  771.    227, 227, 227, 4,    // 242
  772.    234, 234, 234, 4,    // 243
  773.    241, 241, 241, 4,    // 244
  774.    248, 248, 248, 4,    // 245
  775.    // 246 - 255 are Windows fixed colors    
  776.     255, 251, 240, 0,    // 246
  777.     160, 160, 164, 0,    // 247
  778.    128, 128, 128, 0,    // 248
  779.     255,   0,   0, 0,    // 249
  780.      0, 255,   0, 0,    // 250
  781.     255, 255,   0, 0,    // 251
  782.      0,   0, 255, 0,    // 252
  783.    255,   0, 255, 0,    // 253
  784.      0, 255, 255, 0,    // 254
  785.    255, 255, 255, 0,    // 255 always white 
  786. };
  787.  
  788. HPALETTE EZTAPI TWAIN_CreateDibPalette (HANDLE hdib)
  789. // given a pointer to a locked DIB, returns a handle to a plausible logical
  790. // palette to be used for rendering the DIB
  791. // For 24-bit dibs, returns a default palette.
  792. {
  793.     HPALETTE            hPalette = NULL;
  794.  
  795.     LPBITMAPINFOHEADER    lpbmi = (LPBITMAPINFOHEADER)GlobalLock(hdib);
  796.  
  797.     if (lpbmi) {
  798.         WORD nColors = TWAIN_DibNumColors(hdib);            // size of DIB palette
  799.         WORD nEntries = nColors ? nColors : 256;            // size of palette to create
  800.         // allocate logical palette structure
  801.          LOGPALETTE *pPal = (LOGPALETTE*)LocalAlloc(LPTR,
  802.                     sizeof(LOGPALETTE) + nEntries * sizeof(PALETTEENTRY));
  803.         if (pPal) {
  804.             // Fill in the palette entries
  805.             pPal->palNumEntries = nEntries;
  806.             pPal->palVersion    = 0x300;            // Windows 3.0 or later
  807.             if (nColors) {
  808.                 // from the DIB color table
  809.                 // Get a pointer to the color table
  810.                 RGBQUAD FAR *pRgb = (RGBQUAD FAR *)((LPSTR)lpbmi + (WORD)lpbmi->biSize);
  811.                  WORD i;
  812.                 // copy from DIB palette (triples, by the way) into the LOGPALETTE
  813.                 for (i = 0; i < nEntries; i++) {
  814.                     pPal->palPalEntry[i].peRed   = pRgb[i].rgbRed;
  815.                     pPal->palPalEntry[i].peGreen = pRgb[i].rgbGreen;
  816.                     pPal->palPalEntry[i].peBlue  = pRgb[i].rgbBlue;
  817.                     pPal->palPalEntry[i].peFlags = (BYTE)0;
  818.                 } // for
  819.             } else {
  820.                 // Deep Dib: Synthesize halftone palette
  821.                 memcpy(pPal->palPalEntry, peStock256, sizeof peStock256);
  822.             }
  823.     
  824.             // create a logical palette
  825.             hPalette = CreatePalette(pPal);
  826.             LocalFree((HANDLE)pPal);
  827.         }
  828.     
  829.         GlobalUnlock(hdib);
  830.     }
  831.     return hPalette;
  832. } // TWAIN_CreateDibPalette
  833.  
  834.  
  835. LPBYTE DibBits(LPBITMAPINFOHEADER lpdib)
  836. // Given a pointer to a locked DIB, return a pointer to the actual bits (pixels)
  837. {
  838.      DWORD dwColorTableSize = (DWORD)(DibNumColors(lpdib) * sizeof(RGBQUAD));
  839.     LPBYTE lpBits = (LPBYTE)lpdib + lpdib->biSize + dwColorTableSize;
  840.  
  841.     return lpBits;
  842. } // end DibBits
  843.  
  844.  
  845. void EZTAPI TWAIN_DrawDibToDC(HDC hDC, int dx, int dy, int w, int h,
  846.                                      HANDLE hdib, int sx, int sy)
  847. {
  848.     LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER)GlobalLock(hdib);
  849.     if (lpbmi) {
  850. /*#ifdef _WIN32
  851.         HDRAWDIB hdd = DrawDibOpen();
  852.         if (hdd) {
  853.             DrawDibDraw(hdd, hDC,
  854.                         dx, dy, w, h,
  855.                         lpbmi, DibBits(lpbmi),
  856.                         sx, sy, w, h,
  857.                         0
  858.                         );
  859.             DrawDibClose(hdd);
  860.         }
  861. #else*/
  862.         StretchDIBits(hDC,
  863.                     dx, dy,            // x,y destination
  864.                     w, h,            // pixel width & height in destination
  865.                     sx, sy,            // x,y source
  866.                     w, h,            // width & height in source
  867.                     DibBits(lpbmi), // pointer to 'bits' - the pixels
  868.                     (LPBITMAPINFO)lpbmi,
  869.                     DIB_RGB_COLORS,    // DIB palette is (presumably?) RGB entries
  870.                     SRCCOPY);        // raster operation (copy)
  871. //#endif
  872.         GlobalUnlock(hdib);
  873.     }
  874. } // TWAIN_DrawDibToDC
  875.  
  876.  
  877. ///////////////////////////////////////////////////////////////////////
  878. // TWAIN general
  879.  
  880.  
  881. int EZTAPI TWAIN_IsAvailable(void)
  882. // return 1 if TWAIN services are available, 0 if 'TWAIN-less' system
  883. {
  884.     if (pDSM_Entry) return TRUE;        // SM currently loaded
  885.  
  886.     if (iAvailable == 0) {
  887.         if (TWAIN_LoadSourceManager()) {
  888.             iAvailable = 1;
  889.             TWAIN_UnloadSourceManager();
  890.         } else {
  891.             iAvailable = -1;
  892.         }
  893.     }
  894.     return (iAvailable > 0);
  895. } // TWAIN_IsAvailable
  896.  
  897.  
  898. int EZTAPI TWAIN_EasyVersion(void)
  899. // Returns the version number of EZTWAIN.DLL, multiplied by 100.
  900. // So e.g. version 2.01 will return 201 from this call.
  901. {
  902.     return VERSION;
  903. } // TWAIN_EasyVersion
  904.  
  905.  
  906. int EZTAPI TWAIN_State(void)
  907. // Returns the TWAIN Protocol State per the spec.
  908. {
  909.     return nState;
  910. } 
  911.  
  912. int EZTAPI TWAIN_GetHideUI(void)
  913. {
  914.     return bHideUI;
  915. } // TWAIN_GetHideUI
  916.  
  917. void EZTAPI TWAIN_SetHideUI(int fHide)
  918. {
  919.     bHideUI = (fHide != 0);
  920. } // TWAIN_SetHideUI
  921.  
  922.  
  923. ///////////////////////////////////////////////////////////////////////
  924. // TWAIN State Changers
  925.  
  926. int EZTAPI TWAIN_LoadSourceManager(void)
  927. {
  928.     char        szSMDir[128];
  929.     int            cc;
  930.     OFSTRUCT    of;
  931.  
  932.     if (nState >= 2) return TRUE;            // DSM already loaded
  933.  
  934.     GetWindowsDirectory(szSMDir, sizeof(szSMDir));
  935.     cc = lstrlen(szSMDir);
  936.     if (cc && szSMDir[cc-1] != ':') {
  937.         lstrcat(szSMDir, "\\");
  938.     }
  939.     lstrcat(szSMDir, DSM_FILENAME);            // could crash!
  940.     if (OpenFile(szSMDir, &of, OF_EXIST) != -1) {
  941.         hDSMLib = LoadLibrary(szSMDir);
  942.     } else {
  943.         hDSMLib = NULL;
  944.     }
  945.     if (IsValidHandle(hDSMLib)) {
  946.         pDSM_Entry = (DSMENTRYPROC) GetProcAddress(hDSMLib, DSM_ENTRYPOINT);
  947.         if (pDSM_Entry) {
  948.             iAvailable = 1;
  949.             nState = 2;
  950.         } else {
  951.             FreeLibrary(hDSMLib);
  952.             hDSMLib = NULL;
  953.         }
  954.     } else {
  955.         pDSM_Entry = NULL;
  956.     }
  957.  
  958.     return (nState >= 2);
  959. } // TWAIN_LoadSourceManager
  960.  
  961.  
  962. static TW_INT32 hwnd32SM;
  963.  
  964. int EZTAPI TWAIN_OpenSourceManager(HWND hwnd)
  965. {
  966.     hwnd32SM = (TW_INT32)hwnd;
  967.  
  968.     if (TWAIN_LoadSourceManager() &&
  969.         TWAIN_Mgr(DG_CONTROL, DAT_PARENT, MSG_OPENDSM, &hwnd32SM)) {
  970.         nState = TWAIN_SM_OPEN;
  971.     }
  972.  
  973.     return (nState >= TWAIN_SM_OPEN);
  974. } // TWAIN_OpenSourceManager
  975.  
  976.  
  977. int EZTAPI TWAIN_OpenDefaultSource(void)
  978. {
  979.     if (nState != 3) return FALSE;
  980.     // open the system default source
  981.     SourceId.ProductName[0] = '\0';
  982.     SourceId.Id = 0;
  983.     if (TWAIN_Mgr(DG_CONTROL, DAT_IDENTITY, MSG_OPENDS, &SourceId)) {
  984.         nState = 4;
  985.     } else {
  986.         RecordError(ED_DSM_FAILURE);
  987.     }
  988.  
  989.     return (nState == 4);
  990. } // TWAIN_OpenDefaultSource
  991.  
  992.  
  993. int EZTAPI TWAIN_EnableSource(HWND hwnd)
  994. {
  995.     if (nState != 4) return FALSE;
  996.  
  997.     twUI.ShowUI = !bHideUI;
  998.     twUI.hParent = (TW_HANDLE)hwnd;
  999.     TWAIN_DS(DG_CONTROL, DAT_USERINTERFACE, MSG_ENABLEDS, &twUI);
  1000.     if (rc == TWRC_FAILURE) {
  1001.         RecordError(ED_DS_FAILURE);
  1002.     } else {
  1003.         // rc could be either SUCCESS or CHECKSTATUS
  1004.         nState = 5;
  1005.         // note, source will set twUI.ModalUI.
  1006.     }
  1007.     return (nState == 5);
  1008. } // TWAIN_EnableSource
  1009.  
  1010.  
  1011. int EZTAPI TWAIN_DisableSource(void)
  1012. {
  1013.     if (nState == 5 &&
  1014.         TWAIN_DS(DG_CONTROL, DAT_USERINTERFACE, MSG_DISABLEDS, &twUI)) {
  1015.         nState = 4;
  1016.     }
  1017.     return (nState <= 4);
  1018. } // TWAIN_DisableSource
  1019.  
  1020.  
  1021. int EZTAPI TWAIN_CloseSource(void)
  1022. {
  1023.     rc = TWRC_SUCCESS;
  1024.  
  1025.     if (nState == 5) TWAIN_DisableSource();
  1026.     if (nState == 4 &&
  1027.         TWAIN_Mgr(DG_CONTROL, DAT_IDENTITY, MSG_CLOSEDS, &SourceId)) {
  1028.         nState = 3;
  1029.     }
  1030.     return (nState <= 3);
  1031. } // TWAIN_CloseSource
  1032.  
  1033.  
  1034. int EZTAPI TWAIN_CloseSourceManager(HWND hwnd)
  1035. {
  1036.     TW_INT32 hwnd32 = (TW_INT32)hwnd;
  1037.  
  1038.     rc = TWRC_SUCCESS;
  1039.  
  1040.     if (TWAIN_CloseSource() &&
  1041.         TWAIN_Mgr(DG_CONTROL, DAT_PARENT, MSG_CLOSEDSM, &hwnd32)) {
  1042.         nState = 2;
  1043.     }
  1044.     return (nState <= 2);
  1045. } // TWAIN_CloseSourceManager
  1046.  
  1047.  
  1048. int EZTAPI TWAIN_UnloadSourceManager(void)
  1049. {
  1050.     if (nState == 2) {
  1051.  
  1052.         if (hDSMLib) {
  1053.             FreeLibrary(hDSMLib);
  1054.             hDSMLib = NULL;
  1055.         }
  1056.         pDSM_Entry = NULL;
  1057.         nState = 1;
  1058.     }
  1059.     return (nState == 1);
  1060. } // TWAIN_UnloadSourceManager
  1061.  
  1062.  
  1063.  
  1064. void EZTAPI TWAIN_ModalEventLoop(void)
  1065. {
  1066.     MSG msg;
  1067.  
  1068.     while ((nState >= 5) && !hDib && GetMessage((LPMSG)&msg, NULL, 0, 0)) {
  1069.         if (!TWAIN_MessageHook ((LPMSG)&msg)) {
  1070.             TranslateMessage ((LPMSG)&msg);
  1071.             DispatchMessage ((LPMSG)&msg);
  1072.         }
  1073.     } // while
  1074. } // TWAIN_ModalEventLoop
  1075.  
  1076.  
  1077. int EZTAPI TWAIN_MessageHook(LPMSG lpmsg)
  1078. // returns TRUE if msg processed by TWAIN (source)
  1079. {
  1080.     int   bProcessed = FALSE;
  1081.  
  1082.     if (nState >= 5) {
  1083.         // source enabled
  1084.         TW_EVENT    twEvent;
  1085.         twEvent.pEvent = (TW_MEMREF)lpmsg;
  1086.         twEvent.TWMessage = MSG_NULL;
  1087.         // see if source wants to process (eat) the message
  1088.         TWAIN_DS(DG_CONTROL, DAT_EVENT, MSG_PROCESSEVENT, &twEvent);
  1089.         bProcessed = (rc == TWRC_DSEVENT);
  1090.         switch (twEvent.TWMessage) {
  1091.             case MSG_XFERREADY:
  1092.                 nState = 6;
  1093.                 // TWAIN_NativeXferReady(lpmsg);  Spike's original code
  1094.                 TWAIN_NativeXferGetAll(lpmsg);  // replace with this -- DSN 07/98
  1095.                 break;
  1096.             case MSG_CLOSEDSREQ:
  1097.                 TWAIN_DisableSource();
  1098.                 break;
  1099.             case MSG_NULL:
  1100.                 // no message returned from DS
  1101.                 break;
  1102.         } // switch
  1103.      }
  1104.     return bProcessed;
  1105. } // TWAIN_MessageHook
  1106.  
  1107.  
  1108.  
  1109. void TWAIN_NativeXferReady(LPMSG pmsg)
  1110. // Spike's original code.  Note that it doesn't get called any more; instead,
  1111. // Message_Hook calls NativeXferGetAll, which supports multiple image
  1112. // acquisition. -- DSN 7/13/98
  1113. {
  1114.     TW_UINT32        hNative;
  1115.  
  1116.      pmsg = pmsg;        // suppress warning
  1117.  
  1118.     assert(nState == 6);
  1119.     TWAIN_DS(DG_IMAGE, DAT_IMAGENATIVEXFER, MSG_GET, &hNative);
  1120.  
  1121.     if (rc != TWRC_XFERDONE) hDib = NULL;
  1122.  
  1123.     switch (rc) {
  1124.         case TWRC_XFERDONE:
  1125.             // hNative contains a valid native image (handle)
  1126.             // application is responsible for de-allocating.
  1127.             nState = 7;
  1128.             // Need to acknowledge the end of the transfer
  1129.             hDib = (HANDLE)hNative;
  1130.             // above line added by DSN: add to list of hdibs and advance counter
  1131.             break;
  1132.  
  1133.         case TWRC_CANCEL:
  1134.             // user cancelled the transfer
  1135.             // hNative is invalid
  1136.             nState = 7;
  1137.             // acknowledge the end of the transfer
  1138.             break;
  1139.  
  1140.         case TWRC_FAILURE:
  1141.         default:
  1142.             // the transfer failed (e.g. insufficient memory)
  1143.             // hNative is invalid
  1144.             // check condition code for more info
  1145.             nState = 6;
  1146.             // state transition failed
  1147.             // image data is still pending
  1148.             break;
  1149.     } // switch
  1150.     assert(nState >= 6);
  1151.  
  1152.     TWAIN_AbortAllPendingXfers();    // state 7 or 6 -> state 5
  1153.  
  1154. } // TWAIN_NativeXferReady
  1155.  
  1156.  
  1157. int EZTAPI TWAIN_AbortAllPendingXfers(void)
  1158. // Not used any more because its only caller was TWAIN_NativeXferReady, which
  1159. // is now ignored in favor or TWAIN_NativeXferGetAll.  -- DSN 7/13/98
  1160. {
  1161.     if (nState == 7 &&
  1162.         TWAIN_DS(DG_CONTROL, DAT_PENDINGXFERS, MSG_ENDXFER, &pendingXfers)) {
  1163.         nState = pendingXfers.Count ? 6 : 5;
  1164.     }
  1165.     if (nState == 6 &&
  1166.         TWAIN_DS(DG_CONTROL, DAT_PENDINGXFERS, MSG_RESET, &pendingXfers)) {
  1167.         nState = 5;
  1168.     }
  1169.     return (nState <= 5);
  1170. } // TWAIN_AbortAllPendingXfers
  1171.  
  1172.  
  1173. void EZTAPI TWAIN_NativeXferGetAll(LPMSG pmsg)
  1174. // A modified version of Spike's original code that loops through until
  1175. // no more images are left. -- DSN 7/98
  1176. {
  1177.     TW_UINT32        hNative;
  1178.  
  1179.     pmsg = pmsg;        // suppress warning; (sic)  -- does this do anything?  DSN
  1180.     assert(nState == 6);
  1181.  
  1182.     do {
  1183.         TWAIN_DS(DG_IMAGE, DAT_IMAGENATIVEXFER, MSG_GET, &hNative);
  1184.  
  1185.         if (rc != TWRC_XFERDONE) hDib = NULL;
  1186.  
  1187.         switch (rc) {
  1188.             case TWRC_XFERDONE:
  1189.                 // hNative contains a valid native image (handle)
  1190.                 // application is responsible for de-allocating.
  1191.                 nState = 7;
  1192.                 // Need to acknowledge the end of the transfer
  1193.                 hDib = (HANDLE)hNative;  // thus hDib represents MOST RECENT image!
  1194.                 hDibList[nDibs] = hDib;
  1195.                 // added by DSN: add to list of hdibs and advance counter
  1196.                 if (hDibCallback_registered == TW_CALLBACK_REGISTERED)    // user may specify callback
  1197.                       (*lpfnDibCallback)(hDibList[nDibs], nDibs);   // great for multithreading!
  1198.                 nDibs++;
  1199.                 break;
  1200.  
  1201.             case TWRC_CANCEL:
  1202.                 // user cancelled the transfer
  1203.                 // hNative is invalid
  1204.                 nState = 7;
  1205.                 // acknowledge the end of the transfer
  1206.                 break;
  1207.  
  1208.             case TWRC_FAILURE:
  1209.                 default:
  1210.                 // the transfer failed (e.g. insufficient memory)
  1211.                 // hNative is invalid
  1212.                 // check condition code for more info
  1213.                 nState = 6;
  1214.                 // state transition failed
  1215.                 // image data is still pending
  1216.                 break;
  1217.         } // switch
  1218.         assert(nState >= 6);
  1219.         if (nState == 7 && TWAIN_DS(DG_CONTROL, DAT_PENDINGXFERS, MSG_ENDXFER, &pendingXfers))
  1220.             nState = pendingXfers.Count ? 6 : 5;
  1221.     } while (nState == 6);
  1222.  
  1223.     //    TWAIN_AbortAllPendingXfers();    // state 7 or 6 -> state 5
  1224.     // Commented out the above; we want to get all xfers!!
  1225.  
  1226. } // TWAIN_NativeXferReady
  1227. ///////////////////////////////////////////////////////////////////////
  1228. // DIB/BMP File I/O
  1229.  
  1230. int EZTAPI TWAIN_WriteNativeToFilename(HANDLE hdib, LPCSTR pszFile)
  1231. // Writes a DIB handle to a .BMP file
  1232. //
  1233. // hdib        = DIB handle, as returned by TWAIN_AcquireNative
  1234. // pszFile    = far pointer to NUL-terminated filename
  1235. // If pszFile is NULL or points to a null string, prompts the user
  1236. // for the filename with a standard file-save dialog.
  1237. //
  1238. // Return values:
  1239. //     0    success
  1240. //    -1    user cancelled File Save dialog
  1241. //    -2    file open error (invalid path or name, or access denied)
  1242. //    -3    (weird) unable to lock DIB - probably an invalid handle.
  1243. //    -4    writing BMP data failed, possibly output device is full
  1244. {
  1245.     int result;
  1246.     char szFile[256];
  1247.     HFILE fh;
  1248.     OFSTRUCT ofs;
  1249.  
  1250.     if (!pszFile || !*pszFile) {
  1251.         // prompt for filename
  1252.         OPENFILENAME ofn;
  1253.         int nExt;
  1254.  
  1255.         FMEMSET(&ofn, 0, sizeof ofn);
  1256.         szFile[0] = '\0';
  1257.         ofn.lStructSize = sizeof(OPENFILENAME);
  1258.         ofn.hwndOwner = NULL;
  1259.         ofn.lpstrFilter = "Windows Bitmap (*.bmp)\0*.bmp\0\0";
  1260.         ofn.lpstrFile= szFile;
  1261.         ofn.nMaxFile = sizeof(szFile) - 5;
  1262.         ofn.Flags = OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY |
  1263.                     OFN_NOREADONLYRETURN;
  1264.  
  1265.         if (!GetSaveFileName(&ofn)) {
  1266.             return -1;                    // user cancelled dialog
  1267.         }
  1268.         // supply default extension - GetSaveFileName doesn't seem to do it!
  1269.         nExt = ofn.nFileExtension;
  1270.         if (nExt && !szFile[nExt]) {
  1271.             // no extension
  1272.             lstrcat(szFile, ".bmp");
  1273.         }
  1274.         pszFile = szFile;
  1275.     }
  1276.  
  1277.     result = -2;
  1278.     fh = OpenFile(pszFile , &ofs, OF_CREATE | OF_WRITE | OF_SHARE_EXCLUSIVE);
  1279.     if (fh != HFILE_ERROR) {
  1280.         result = TWAIN_WriteNativeToFile(hdib, fh);
  1281.         _lclose(fh);
  1282.     }
  1283.     return result;
  1284. } // TWAIN_WriteNativeToFilename
  1285.  
  1286.  
  1287. int EZTAPI TWAIN_WriteNativeToFile(HANDLE hdib, HFILE fh)
  1288. // Writes a DIB to a file in .BMP format.
  1289. //
  1290. // hdib        = DIB handle, as returned by TWAIN_AcquireNative
  1291. // fh        = file handle, as returned by C _open or Windows _lopen or OpenFile
  1292. //
  1293. // Return value as for TWAIN_WriteNativeToFilename
  1294. {
  1295.     int result = -3;
  1296.     LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER)GlobalLock(hdib);
  1297.     if (lpbmi) {
  1298.         result = -4;
  1299.         if (TWAIN_WriteDibToFile(lpbmi, fh)) {
  1300.             result = 0;            // success
  1301.         }
  1302.         GlobalUnlock(hdib);
  1303.     }
  1304.     return result;
  1305. } //  TWAIN_WriteNativeToFile
  1306.  
  1307.  
  1308. int EZTAPI TWAIN_WriteDibToFile(LPBITMAPINFOHEADER lpDIB, HFILE fh)
  1309. {
  1310.     BITMAPFILEHEADER        bfh;
  1311.     int                        fOk = FALSE;
  1312.     int                        nBPP = lpDIB->biBitCount;
  1313.     int                        nColors = (int)lpDIB->biClrUsed;
  1314.  
  1315.     // figure out actual size of color table
  1316.     if (nColors == 0 && nBPP <= 8) {
  1317.         nColors = (1 << nBPP);
  1318.     }
  1319.     if (lpDIB->biCompression == BI_RGB) {
  1320.         // uncompressed bitmap, image size might not be set
  1321.         DWORD dwBytesPerRow = (((lpDIB->biWidth * nBPP) + 31) / 32) * 4;
  1322.         lpDIB->biSizeImage = dwBytesPerRow * lpDIB->biHeight;
  1323.     } else if (lpDIB->biSizeImage == 0) {
  1324.         // compressed bitmap, image size had damn well better be set!
  1325.         return FALSE;
  1326.         // This could be hacked around with something like this:
  1327.         //lpDIB->biSizeImage = GlobalSize((HANDLE)GlobalHandle(HIWORD(lpDIB)));
  1328.     }
  1329.  
  1330.     // Set up BMP header.
  1331.     bfh.bfType = 0x4d42;                // "BM"
  1332.     bfh.bfReserved1 = 0;
  1333.     bfh.bfReserved2 = 0;
  1334.     bfh.bfOffBits = sizeof(BITMAPFILEHEADER) +
  1335.                     sizeof(BITMAPINFOHEADER) +
  1336.                     sizeof(RGBQUAD) * nColors;
  1337.     bfh.bfSize = bfh.bfOffBits + lpDIB->biSizeImage;
  1338.  
  1339.     if (_lwrite(fh, (LPCSTR)&bfh, sizeof bfh) == sizeof bfh) {
  1340.  
  1341.         INT32 towrite = bfh.bfSize - (INT32)sizeof bfh;
  1342.  
  1343.         if (HUGEWRITE(fh, (LPCSTR)lpDIB, towrite) == towrite) {
  1344.             fOk = TRUE;
  1345.         }
  1346.     }
  1347.  
  1348.     return fOk;
  1349.  
  1350. } // TWAIN_WriteDibToFile
  1351.  
  1352.  
  1353. HANDLE EZTAPI TWAIN_LoadNativeFromFilename(LPCSTR pszFile)
  1354. // Load a .BMP file and return a DIB handle (as from AcquireNative.)
  1355. //
  1356. // pszFile    = far pointer to NUL-terminated filename
  1357. // If pszFile is NULL or points to a null string, prompts the user
  1358. // for the filename with a standard file-open dialog.
  1359. //
  1360. // Return value:
  1361. //    handle to a DIB if successful, otherwise NULL (0).
  1362. {
  1363.     HANDLE hdib = NULL;
  1364.     char szFile[256];
  1365.     HFILE fh;
  1366.     OFSTRUCT ofs;
  1367.  
  1368.     if (!pszFile || !*pszFile) {
  1369.         // prompt for filename
  1370.         OPENFILENAME ofn;
  1371.         int nExt;
  1372.  
  1373.         FMEMSET(&ofn, 0, sizeof ofn);
  1374.         szFile[0] = '\0';
  1375.         ofn.lStructSize = sizeof(OPENFILENAME);
  1376.         ofn.hwndOwner = NULL;
  1377.         ofn.lpstrFilter = "Windows Bitmaps (*.bmp)\0*.bmp\0\0";
  1378.         ofn.lpstrFile= szFile;
  1379.         ofn.nMaxFile = sizeof(szFile) - 5;
  1380.         ofn.Flags = OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY |
  1381.                     OFN_NOREADONLYRETURN;
  1382.  
  1383.         if (!GetOpenFileName(&ofn)) {
  1384.             return NULL;                    // user cancelled dialog
  1385.         }
  1386.         // supply default extension - GetOpenFileName doesn't seem to do it!
  1387.         nExt = ofn.nFileExtension;
  1388.         if (nExt && !szFile[nExt]) {
  1389.             // no extension
  1390.             lstrcat(szFile, ".bmp");
  1391.         }
  1392.         pszFile = szFile;
  1393.     }
  1394.  
  1395.     fh = OpenFile(pszFile, &ofs, OF_READ | OF_SHARE_DENY_WRITE);
  1396.     if (fh != HFILE_ERROR) {
  1397.         hdib = TWAIN_LoadNativeFromFile(fh);
  1398.         _lclose(fh);
  1399.     }
  1400.     return hdib;
  1401. } // TWAIN_LoadNativeFromFilename
  1402.  
  1403.  
  1404. HANDLE EZTAPI TWAIN_LoadNativeFromFile(HFILE fh)
  1405. // Like LoadNativeFromFilename, but takes an already open file handle.
  1406. {
  1407.     HANDLE hdib;
  1408.     LPBYTE pbi;
  1409.     BITMAPFILEHEADER bmh;
  1410.     INT32 dibSize;
  1411.     // Read BMP file header and validate
  1412.     if (_lread(fh, &bmh, sizeof bmh) != sizeof bmh ||
  1413.         bmh.bfType != 0x4d42) {
  1414.         return NULL;
  1415.     }
  1416.     // Allocate global block for DIB
  1417.     dibSize = bmh.bfSize - sizeof bmh;
  1418.     hdib = GlobalAlloc(0, dibSize);
  1419.     pbi = (LPBYTE)GlobalLock(hdib);
  1420.     if (!hdib || !pbi) {
  1421.         return NULL;
  1422.     }
  1423.  
  1424.     // Read DIB from file
  1425.     if (_hread(fh, pbi, dibSize) != dibSize) {
  1426.         GlobalUnlock(hdib);
  1427.         GlobalFree(hdib);
  1428.         return NULL;
  1429.     }
  1430.     GlobalUnlock(hdib);
  1431.     return hdib;
  1432. } // TWAIN_LoadNativeFromFile
  1433.  
  1434. ///////////////////////////////////////////////////////////////////////
  1435. // TWAIN State 4 Negotiation Functions
  1436.  
  1437. int EZTAPI TWAIN_NegotiateXferCount(int nXfers)
  1438. {
  1439.     return TWAIN_SetCapOneValue(CAP_XFERCOUNT, TWTY_INT16, nXfers);
  1440. } // TWAIN_NegotiateXferCount
  1441.  
  1442.  
  1443. int EZTAPI TWAIN_NegotiatePixelTypes(unsigned wPixTypes)
  1444. {
  1445.     TW_CAPABILITY         cap;
  1446.     void far *            pv;
  1447.     int                    fSuccess = FALSE;
  1448.  
  1449.     if (nState != TWAIN_SOURCE_OPEN) {
  1450.         return RecordError(ED_NOT_STATE_4);
  1451.     }
  1452.  
  1453.     if (TWAIN_ANYTYPE == wPixTypes) {
  1454.         return TRUE;            // that was easy!
  1455.     }
  1456.                                                                            
  1457.                                                                            
  1458.     // Fill in capability structure
  1459.     cap.Cap = ICAP_PIXELTYPE;            // capability id
  1460.     cap.ConType = TWON_ENUMERATION;        // favorite type of container (should be ignored...)
  1461.  
  1462.     if (!TWAIN_DS(DG_CONTROL, DAT_CAPABILITY, MSG_GET, (TW_MEMREF)&cap)) {
  1463.         return RecordError(ED_CAP_GET);
  1464.     }
  1465.     if (!cap.hContainer) {
  1466.         return RecordError(ED_NULL_HCON);
  1467.     }
  1468.     if (!(pv = GlobalLock(cap.hContainer))) {
  1469.         // this source is invalid, further negotiation is unlikely to succeed
  1470.         return RecordError(ED_BAD_HCON);
  1471.     }
  1472.  
  1473.     switch (cap.ConType) {
  1474.  
  1475.         case TWON_ENUMERATION: {
  1476.             TW_ENUMERATION far *pcon = (TW_ENUMERATION far *)pv;
  1477.             if (pcon->NumItems < 1) {
  1478.                 RecordError(ED_CAP_GET_EMPTY);
  1479.             } else if (pcon->ItemType != TWTY_UINT16 && pcon->ItemType != TWTY_INT16) {
  1480.                 RecordError(ED_BAD_ITEMTYPE);
  1481.             } else {
  1482.                 pcon->CurrentIndex = TWON_DONTCARE32;    // don't change current value
  1483.                 pcon->DefaultIndex = TWON_DONTCARE32;    // don't change default value
  1484.                 pcon->NumItems = Intersect16(wPixTypes, (unsigned)pcon->NumItems, (TW_UINT16 far *)pcon->ItemList);
  1485.                 fSuccess = (pcon->NumItems != 0);
  1486.                 if (!fSuccess) RecordError(ED_CAP_SET_EMPTY);
  1487.             }
  1488.             break;
  1489.         }
  1490.         
  1491.         case TWON_ARRAY: {
  1492.             // this is technically illegal - TWAIN 1.5, p9-30, Containers for MSG_GET: TW_ENUMERATION, TW_ONEVALUE
  1493.             TW_ARRAY far *pcon = (TW_ARRAY far *)pv;
  1494.             if (pcon->NumItems < 1) {
  1495.                 RecordError(ED_CAP_GET_EMPTY);
  1496.             } else if (pcon->ItemType != TWTY_UINT16 && pcon->ItemType != TWTY_INT16) {
  1497.                 RecordError(ED_BAD_ITEMTYPE);
  1498.             } else {
  1499.                 pcon->NumItems = Intersect16(wPixTypes, (unsigned)pcon->NumItems, (TW_UINT16 far *)pcon->ItemList);
  1500.                 fSuccess = (pcon->NumItems != 0);
  1501.                 if (!fSuccess) RecordError(ED_CAP_SET_EMPTY);
  1502.             }
  1503.             break;
  1504.         }
  1505.  
  1506.         case TWON_ONEVALUE: {
  1507.             TW_ONEVALUE far *pcon = (TW_ONEVALUE far *)pv;
  1508.             fSuccess = ((1 << pcon->Item) & wPixTypes);
  1509.             if (!fSuccess) RecordError(ED_CAP_SET_EMPTY);
  1510.             break;
  1511.         }
  1512.         
  1513.         default:
  1514.             // something we don't understand, abandon negotiations
  1515.             RecordError(ED_BAD_CONTYPE);
  1516.             break;
  1517.     } // switch
  1518.  
  1519.     GlobalUnlock(cap.hContainer);
  1520.  
  1521.     if (fSuccess) {
  1522.         // For enums (and arrays) send intersection back, to restrict it.
  1523.         // For one vals, don't bother - could only cause confusion.
  1524.         if (cap.ConType != TWON_ONEVALUE) {
  1525.             fSuccess = TWAIN_DS(DG_CONTROL, DAT_CAPABILITY, MSG_SET, (TW_MEMREF)&cap);
  1526.             if (!fSuccess) RecordError(ED_CAP_SET);
  1527.         }
  1528.     }
  1529.     GlobalFree(cap.hContainer);
  1530.     
  1531.     return fSuccess;
  1532. } // TWAIN_NegotiatePixelTypes
  1533.  
  1534.  
  1535. int EZTAPI TWAIN_GetCurrentUnits(void)
  1536. {
  1537.     int nUnits = TWUN_INCHES;
  1538.     TWAIN_GetCapCurrent(ICAP_UNITS, TWTY_UINT16, &nUnits);
  1539.     return nUnits;
  1540. } // TWAIN_GetCurrentUnits
  1541.  
  1542.  
  1543. int EZTAPI TWAIN_SetCurrentUnits(int nUnits)
  1544. // Negotiate the current pixel type for acquisition.
  1545. // Negotiation is only allowed in State 4 (TWAIN_SOURCE_OPEN)
  1546. // The source may select this pixel type, but don't assume it will.
  1547. {
  1548.     return TWAIN_SetCapOneValue(ICAP_UNITS, TWTY_UINT16, (TW_UINT16)nUnits);
  1549. } // TWAIN_SetCurrentUnits
  1550.  
  1551.  
  1552. int EZTAPI TWAIN_GetBitDepth(void)
  1553. // Ask the source for the current bitdepth.
  1554. // This value depends on the current PixelType.
  1555. // Bit depth is per color channel e.g. 24-bit RGB has bit depth 8.
  1556. // If anything goes wrong, this function returns 0.
  1557. {
  1558.     int nBits = 0;
  1559.     TWAIN_GetCapCurrent(ICAP_BITDEPTH, TWTY_UINT16, &nBits);
  1560.     return nBits;
  1561. } // TWAIN_GetBitDepth
  1562.  
  1563. int EZTAPI TWAIN_SetBitDepth(int nBits)
  1564. // (Try to) set the current bitdepth (for the current pixel type).
  1565. {
  1566.     return TWAIN_SetCapOneValue(ICAP_BITDEPTH, TWTY_UINT16, (TW_UINT16)nBits);
  1567. } // TWAIN_SetBitDepth
  1568.  
  1569.  
  1570. int EZTAPI TWAIN_GetPixelType(void)
  1571. // Ask the source for the current pixel type.
  1572. // If anything goes wrong (it shouldn't!), this function returns 0 (TWPT_BW).
  1573. {
  1574.     int nPixType = 0;
  1575.     TWAIN_GetCapCurrent(ICAP_PIXELTYPE, TWTY_UINT16, &nPixType);
  1576.     return nPixType;
  1577. } // TWAIN_GetPixelType
  1578.  
  1579. int EZTAPI TWAIN_SetCurrentPixelType(int nPixType)
  1580. // Negotiate the current pixel type for acquisition.
  1581. // Negotiation is only allowed in State 4 (TWAIN_SOURCE_OPEN)
  1582. // The source may select this pixel type, but don't assume it will.
  1583. {
  1584.     return TWAIN_SetCapOneValue(ICAP_PIXELTYPE, TWTY_UINT16, (TW_UINT16)nPixType);
  1585. } // TWAIN_SetCurrentPixelType
  1586.  
  1587.  
  1588. /*double EZTAPI TWAIN_GetCurrentResolution(void)
  1589. {
  1590.     TW_FIX32 res;
  1591.     TWAIN_GetCapCurrent(ICAP_XRESOLUTION, TWTY_FIX32, &res);
  1592.  
  1593.     return Fix32ToFloat(res);
  1594. } // TWAIN_GetCurrentResolution
  1595.  
  1596. int EZTAPI TWAIN_SetCurrentResolution(double dRes)
  1597. // Negotiate the current resolution for acquisition.
  1598. // Negotiation is only allowed in State 4 (TWAIN_SOURCE_OPEN)
  1599. // The source may select this resolution, but don't assume it will.
  1600. {
  1601.     return TWAIN_SetCapOneValue(ICAP_XRESOLUTION, TWTY_FIX32, ToFix32(dRes));
  1602. } // TWAIN_SetCurrentResolution
  1603.  
  1604. */
  1605.  
  1606. int EZTAPI TWAIN_SetCapOneValue(unsigned Cap, unsigned ItemType, long ItemVal)
  1607. {
  1608.     TW_CAPABILITY    cap;
  1609.     pTW_ONEVALUE    pv;
  1610.     BOOL            bSuccess;
  1611.  
  1612.     if (nState != TWAIN_SOURCE_OPEN) {
  1613.         TWAIN_ErrorBox("Attempt to set capability outside State 4.");
  1614.         return FALSE;
  1615.     }
  1616.  
  1617.     cap.Cap = Cap;            // capability id
  1618.     cap.ConType = TWON_ONEVALUE;        // container type
  1619.     cap.hContainer = GlobalAlloc(GHND, sizeof (TW_ONEVALUE));
  1620.     if (!cap.hContainer) {
  1621.         TWAIN_ErrorBox(szInsuffMem);
  1622.         return FALSE;
  1623.     }
  1624.     pv = (pTW_ONEVALUE)GlobalLock(cap.hContainer);
  1625.     pv->ItemType = ItemType;
  1626.     pv->Item = ItemVal;
  1627.     GlobalUnlock(cap.hContainer);
  1628.     bSuccess = TWAIN_DS(DG_CONTROL, DAT_CAPABILITY, MSG_SET, (TW_MEMREF)&cap);
  1629.     GlobalFree(cap.hContainer);
  1630.     return bSuccess;
  1631. } // TWAIN_SetCapOneValue
  1632.  
  1633.  
  1634. const size_t nTypeSize[13] =
  1635.     {    sizeof (TW_INT8),
  1636.         sizeof (TW_INT16),
  1637.         sizeof (TW_INT32),
  1638.         sizeof (TW_UINT8),
  1639.         sizeof (TW_UINT16),
  1640.         sizeof (TW_UINT32),
  1641.         sizeof (TW_BOOL),
  1642.         sizeof (TW_FIX32),
  1643.         sizeof (TW_FRAME),
  1644.         sizeof (TW_STR32),
  1645.         sizeof (TW_STR64),
  1646.         sizeof (TW_STR128),
  1647.         sizeof (TW_STR255),
  1648.     };
  1649.  
  1650. // helper function:
  1651. int TypeMatch(unsigned nTypeA, unsigned nTypeB)
  1652. {
  1653.     // Integral types match if they are the same size.
  1654.     // All other types match only if they are equal
  1655.     return nTypeA == nTypeB ||
  1656.            (nTypeA <= TWTY_UINT32 &&
  1657.             nTypeB <= TWTY_UINT32 &&
  1658.             nTypeSize[nTypeA] == nTypeSize[nTypeB]);
  1659. } // TypeMatch
  1660.  
  1661.  
  1662.  
  1663. int EZTAPI TWAIN_GetCapCurrent(unsigned Cap, unsigned ItemType, void FAR *pVal)
  1664. {
  1665.     TW_CAPABILITY     cap;
  1666.     void far *        pv = NULL;
  1667.     BOOL            bSuccess = FALSE;
  1668.  
  1669.     assert(pVal != NULL);
  1670.  
  1671.     if (nState < TWAIN_SOURCE_OPEN) {
  1672.         TWAIN_ErrorBox("Attempt to get capability value below State 4.");
  1673.         return FALSE;
  1674.     }
  1675.  
  1676.     // Fill in capability structure
  1677.     cap.Cap = Cap;                    // capability id
  1678.     cap.ConType = TWON_ONEVALUE;    // favorite type of container (should be ignored...)
  1679.     cap.hContainer = NULL;
  1680.  
  1681.     if (TWAIN_DS(DG_CONTROL, DAT_CAPABILITY, MSG_GETCURRENT, (TW_MEMREF)&cap) &&
  1682.         cap.hContainer &&
  1683.         (pv = GlobalLock(cap.hContainer))) {
  1684.  
  1685.         if (cap.ConType == TWON_ENUMERATION) {
  1686.             TW_ENUMERATION far *pcon = (TW_ENUMERATION far *)pv;
  1687.             TW_UINT32 index = pcon->CurrentIndex;
  1688.             if (index < pcon->NumItems && TypeMatch(pcon->ItemType, ItemType)) {
  1689.                 LPSTR pitem = (LPSTR)pcon->ItemList + index*nTypeSize[ItemType];
  1690.                 FMEMCPY(pVal, pitem, nTypeSize[ItemType]);
  1691.                 bSuccess = TRUE;
  1692.             }
  1693.         } else if (cap.ConType == TWON_ONEVALUE) {
  1694.             TW_ONEVALUE far *pcon = (TW_ONEVALUE far *)pv;
  1695.             if (TypeMatch(pcon->ItemType, ItemType)) {
  1696.                 FMEMCPY(pVal, &pcon->Item, nTypeSize[ItemType]);
  1697.                 bSuccess = TRUE;
  1698.             }
  1699.         }
  1700.     }
  1701.  
  1702.     if (pv) GlobalUnlock(cap.hContainer);
  1703.     if (cap.hContainer) GlobalFree(cap.hContainer);
  1704.  
  1705.     return bSuccess;
  1706. } 
  1707.  
  1708. //-------------------------- The primitive functions
  1709.  
  1710.  
  1711. int EZTAPI TWAIN_DS(unsigned long dg, unsigned dat, unsigned msg, void FAR *pd)
  1712. // Call the current source with a triplet
  1713. {
  1714.     assert(nState >= 4);
  1715.     rc = TWRC_FAILURE;
  1716.     if (pDSM_Entry) {
  1717.         rc = (*pDSM_Entry)(&AppId, &SourceId,
  1718.                            (TW_UINT32)dg,
  1719.                            (TW_UINT16)dat,
  1720.                            (TW_UINT16)msg,
  1721.                            (TW_MEMREF)pd);
  1722.     }
  1723.     return (rc == TWRC_SUCCESS);
  1724. } // TWAIN_DS
  1725.  
  1726.  
  1727.  
  1728. int EZTAPI TWAIN_Mgr(unsigned long dg, unsigned dat, unsigned msg, void FAR *pd)
  1729. // Call the Source Manager with a triplet
  1730. {
  1731.     rc = TWRC_FAILURE;
  1732.     if (pDSM_Entry) {
  1733.         rc = (*pDSM_Entry)(&AppId, NULL,
  1734.                            (TW_UINT32)dg,
  1735.                            (TW_UINT16)dat,
  1736.                            (TW_UINT16)msg,
  1737.                            (TW_MEMREF)pd);
  1738.     }
  1739.     return (rc == TWRC_SUCCESS);
  1740. } // TWAIN_Mgr
  1741.  
  1742.  
  1743.  
  1744. unsigned EZTAPI TWAIN_GetResultCode(void)
  1745. {
  1746.     return rc;
  1747. } // TWAIN_GetResultCode
  1748.  
  1749.  
  1750.  
  1751. unsigned EZTAPI TWAIN_GetConditionCode(void)
  1752. {
  1753.     TW_STATUS    twStatus;
  1754.  
  1755.     if (nState >= 4) {
  1756.         // get source status if open
  1757.         TWAIN_DS(DG_CONTROL, DAT_STATUS, MSG_GET, (TW_MEMREF)&twStatus);
  1758.     } else if (nState == 3) {
  1759.         // otherwise get source manager status
  1760.         TWAIN_Mgr(DG_CONTROL, DAT_STATUS, MSG_GET, (TW_MEMREF)&twStatus);
  1761.     } else {
  1762.         // nothing open, not a good time to get condition code!
  1763.         return TWCC_SEQERROR;
  1764.     }
  1765.     if (rc == TWRC_SUCCESS) {
  1766.         return twStatus.ConditionCode;
  1767.     } else {
  1768.         return TWCC_BUMMER;            // what can I say. 
  1769.     }
  1770. } // TWAIN_GetConditionCode
  1771.  
  1772.  
  1773. //------------ Private functions
  1774.  
  1775.  
  1776. HWND CreateProxyWindow(void)
  1777. {
  1778.     HWND hwnd;
  1779.     hwnd = CreateWindow("STATIC",                        // class
  1780.                         "Acquire Proxy",                // title
  1781.                         WS_POPUPWINDOW | WS_VISIBLE,    // style
  1782.                         CW_USEDEFAULT, CW_USEDEFAULT,    // x, y
  1783.                         CW_USEDEFAULT, CW_USEDEFAULT,    // width, height
  1784.                         HWND_DESKTOP,                    // parent window
  1785.                         NULL,                            // hmenu
  1786.                         hinstLib,                        // hinst
  1787.                         NULL);                            // lpvparam
  1788.     return hwnd;
  1789. } // CreateProxyWindow
  1790.  
  1791.  
  1792. int RecordError(ErrorDetail ed)
  1793. {
  1794.     if (nErrDetail == ED_NONE) {
  1795.         nErrDetail = ed;
  1796.         if (ed > ED_START_TRIPLET_ERRS && ed < ED_END_TRIPLET_ERRS) {
  1797.             nErrRC = TWAIN_GetResultCode();
  1798.             nErrCC = TWAIN_GetConditionCode();
  1799.         } else {
  1800.             nErrRC = 0;
  1801.             nErrCC = 0;
  1802.         }
  1803.     }
  1804.     return FALSE;
  1805. } // RecordError
  1806.  
  1807.  
  1808. void ClearError(void)
  1809. {
  1810.     nErrDetail = ED_NONE;
  1811. } // ClearError
  1812.  
  1813.  
  1814. void TWAIN_ReportLastError(LPSTR lpzGeneral)
  1815. {
  1816. /*    if (nErrDetail > ED_START_TRIPLET_ERRS && nErrDetail < ED_END_TRIPLET_ERRS) {
  1817.         wvsprintf(szMsg, "%s\n%s\nRC:   %s\nCC:   %s",
  1818.             lpzGeneral, (LPSTR)pszErrDescrip[nErrDetail],
  1819.             (LPSTR)pszRC[nErrRC], (LPSTR)pszCC[nErrCC]);
  1820.     } else {
  1821.         wvsprintf(szMsg, "%s\n%s", lpzGeneral, (LPSTR)pszErrDescrip[nErrDetail]);
  1822.     }*/
  1823.     TWAIN_ErrorBox("TWAIN_ReportLastError: an error occurred");
  1824. } // ReportLastError; stripped down by dsn to avoid using C RTL
  1825.  
  1826.  
  1827. void TWAIN_ErrorBox(const char *szMsg)
  1828. {
  1829.     MessageBox(NULL, (LPSTR)szMsg, "TWAIN Error", MB_ICONEXCLAMATION | MB_OK);
  1830. } // TWAIN_ErrorBox
  1831.  
  1832.  
  1833. unsigned BitCount(unsigned W)
  1834. {
  1835.     unsigned n = 0;
  1836.  
  1837.     while (W) {
  1838.         n += (W & 1);
  1839.         W >>= 1;
  1840.     } // while
  1841.     return n;
  1842. } // BitCount
  1843.  
  1844.  
  1845. unsigned Intersect16(unsigned wMask, unsigned nItems, TW_UINT16 far *pItem)
  1846. {
  1847.     unsigned    wSet;
  1848.     unsigned    i;
  1849.  
  1850.     // In wSet, construct set of available items.
  1851.     // Note that items that cannot be represented in wMask are also
  1852.     // unrepresentable in wSet so are implicitly discarded
  1853.     for (i = wSet = 0 ; i < nItems; i++) {
  1854.         wSet |= 1 << pItem[i];
  1855.     } // for
  1856.  
  1857.     // Discard anything in wMask that isn't in wSet
  1858.     wMask &= wSet;
  1859.  
  1860.     // Re-fill the item table with intersection set
  1861.     for (i = nItems = 0; wMask ; wMask>>=1,i++) {
  1862.         if (wMask & 1) {
  1863.             pItem[nItems++] = i;
  1864.         }
  1865.     } // for
  1866.  
  1867.     return nItems;
  1868. }
  1869.  
  1870. /*
  1871. TW_UINT32 ToFix32(double r)
  1872. {
  1873.     TW_FIX32 fix;
  1874.     TW_INT32 val = (TW_INT32)(r * 65536.0 + 0.5);
  1875.     fix.Whole = (TW_INT16)(val >> 16);            // most significant 16 bits
  1876.     fix.Frac = (TW_UINT16)(val & 0xffff);        // least
  1877.     assert(sizeof (TW_FIX32) == sizeof (TW_UINT32));
  1878.     return *(TW_UINT32*)&fix;
  1879. } // ToFix32
  1880.  
  1881. double Fix32ToFloat(TW_FIX32 fix)
  1882. {
  1883.     TW_INT32 val = ((TW_INT32)fix.Whole << 16) | ((TW_UINT32)fix.Frac & 0xffff);
  1884.     return val / 65536.0;
  1885. } // Fix32ToFloat
  1886. */
  1887.  
  1888. // The routine below is a modified version of code posted by Zafir Anjum
  1889. // on www.codeguru.com.  The original code was designed for MFC; below it
  1890. // has been translated into straight C.  Also, one other change is that rather
  1891. // than dynamically allocate only the memory needed for pLP, I fix the size of
  1892. // the array at the beginning so that it's sufficient for whatever might come
  1893. // along so as to eliminate any dependence on the C runtime library.
  1894.  
  1895. /*HBITMAP EZTAPI DIBToDDB( HANDLE hDIB )
  1896. {
  1897.       LPBITMAPINFOHEADER      lpbi;
  1898.       HBITMAP                 hbm;
  1899.       HPALETTE                pal;
  1900.       HPALETTE                pOldPal;
  1901.       HDC                     dc;
  1902.  
  1903.       UINT                          nSize;
  1904.       LOGPALETTE                  *pLP;
  1905.       BYTE                          logpalbuffer[5012];
  1906.               // max size = sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) *256 colors
  1907.               //          = 2 + 2 + 1024 = 1028; theoretically only need this much
  1908.               // overshoot just in case; above size ought to be PLENTY
  1909.       int                     nColors;
  1910.       int                     i;
  1911.       LPVOID                  lpDIBBits;
  1912.       BITMAPINFO              *bmInfo;
  1913.  
  1914.       bmInfo = (LPBITMAPINFO) (&hDIB);
  1915.  
  1916.       if (hDIB == NULL)
  1917.              return NULL;
  1918.  
  1919.       dc = GetDC(NULL);  // stuff normally taken care of when MFC is used
  1920.       pal = NULL;
  1921.  
  1922.       lpbi = (LPBITMAPINFOHEADER)hDIB;
  1923.  
  1924.       nColors = lpbi->biClrUsed ? lpbi->biClrUsed :
  1925.                                                                 1 << lpbi->biBitCount;
  1926.  
  1927.       if( bmInfo->bmiHeader.biBitCount > 8 )
  1928.               lpDIBBits = (LPVOID)((LPDWORD)(bmInfo->bmiColors +
  1929.                                 bmInfo->bmiHeader.biClrUsed) +
  1930.                                 ((bmInfo->bmiHeader.biCompression == BI_BITFIELDS) ? 3 : 0));
  1931.       else
  1932.              lpDIBBits = (LPVOID)(bmInfo->bmiColors + nColors);
  1933.  
  1934.           // Create and select a logical palette if needed
  1935.       if( nColors <= 256 && GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE)
  1936.       {
  1937.                     nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * nColors);
  1938.                     pLP = (LOGPALETTE *) logpalbuffer; //new BYTE[nSize];
  1939.  
  1940.                     pLP->palVersion = 0x300;
  1941.                     pLP->palNumEntries = nColors;
  1942.  
  1943.                     for(i=0; i < nColors; i++)
  1944.                     {
  1945.                           pLP->palPalEntry[i].peRed = bmInfo->bmiColors[i].rgbRed;
  1946.                           pLP->palPalEntry[i].peGreen = bmInfo->bmiColors[i].rgbGreen;
  1947.                           pLP->palPalEntry[i].peBlue = bmInfo->bmiColors[i].rgbBlue;
  1948.                           pLP->palPalEntry[i].peFlags = 0;
  1949.                     }
  1950.  
  1951.                     pal = CreatePalette( pLP );
  1952.  
  1953.                     // Select and realize the palette
  1954.                     pOldPal = SelectPalette( dc, &pal, FALSE );
  1955.                     RealizePalette(dc);
  1956.       }
  1957.  
  1958.  
  1959.       hbm = CreateDIBitmap(dc,           // handle to device context
  1960.                                 (LPBITMAPINFOHEADER)lpbi,       // pointer to bitmap info header
  1961.                                 (LONG)CBM_INIT,                 // initialization flag
  1962.                                 lpDIBBits,                      // pointer to initialization data
  1963.                                 (LPBITMAPINFO)lpbi,             // pointer to bitmap info
  1964.                                 DIB_RGB_COLORS );               // color-data usage
  1965.  
  1966.       if (pal)
  1967.              SelectPalette(dc, pOldPal,FALSE);
  1968.  
  1969.       ReleaseDC(NULL, dc);
  1970.       return hbm;
  1971. }*/
  1972.