home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / twain / twain.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-24  |  31.1 KB  |  1,136 lines
  1. /*  
  2.  * TWAIN Plug-in
  3.  * Copyright (C) 1999 Craig Setera
  4.  * Craig Setera <setera@home.com>
  5.  * 03/31/1999
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License as published by
  9.  * the Free Software Foundation; either version 2 of the License, or
  10.  * (at your option) any later version.
  11.  *
  12.  * This program is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with this program; if not, write to the Free Software
  19.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20.  *
  21.  *
  22.  * Based on (at least) the following plug-ins:
  23.  * Screenshot
  24.  * GIF
  25.  * Randomize
  26.  *
  27.  * Any suggestions, bug-reports or patches are welcome.
  28.  * 
  29.  * This plug-in interfaces to the TWAIN support library in order
  30.  * to capture images from TWAIN devices directly into GIMP images.
  31.  * The plug-in is capable of acquiring the following type of
  32.  * images:
  33.  * - B/W (1 bit images translated to grayscale B/W)
  34.  * - Grayscale up to 16 bits per pixel
  35.  * - RGB up to 16 bits per sample (24, 30, 36, etc.)
  36.  * - Paletted images (both Gray and RGB)
  37.  *
  38.  * Prerequisites:
  39.  *  This plug-in will not compile on anything other than a Win32
  40.  *  platform.  Although the TWAIN documentation implies that there
  41.  *  is TWAIN support available on Macintosh, I neither have a 
  42.  *  Macintosh nor the interest in porting this.  If anyone else
  43.  *  has an interest, consult www.twain.org for more information on
  44.  *  interfacing to TWAIN.
  45.  *
  46.  * Known problems:
  47.  * - Multiple image transfers will hang the plug-in.  The current
  48.  *   configuration compiles with a maximum of single image transfers.
  49.  */
  50.  
  51. /* 
  52.  * Revision history
  53.  *  (02/07/99)  v0.1   First working version (internal)
  54.  *  (02/09/99)  v0.2   First release to anyone other than myself
  55.  *  (02/15/99)  v0.3   Added image dump and read support for debugging
  56.  *  (03/31/99)  v0.5   Added support for multi-byte samples and paletted 
  57.  *                     images.
  58.  */
  59. #include "config.h"
  60.  
  61. #include <glib.h>        /* Needed when compiling with gcc */
  62.  
  63. #include <stdio.h>
  64. #include <stdlib.h>
  65. #include <string.h>
  66. #include <ctype.h>
  67. #include <windows.h>
  68.  
  69. #include <gtk/gtk.h>
  70.  
  71. #include "libgimp/gimp.h"
  72. #include "libgimp/stdplugins-intl.h"
  73.  
  74. #include "tw_func.h"
  75. #include "tw_util.h"
  76.  
  77. #ifdef _DEBUG
  78. #include "tw_dump.h"
  79. #endif /* _DEBUG */
  80.  
  81. /*
  82.  * Plug-in Definitions
  83.  */
  84. #define PLUG_IN_NAME        "twain-acquire"
  85. #define PLUG_IN_DESCRIPTION "Capture an image from a TWAIN datasource"
  86. #define PLUG_IN_HELP        "This plug-in will capture an image from a TWAIN datasource"
  87. #define PLUG_IN_AUTHOR      "Craig Setera (setera@home.com)"
  88. #define PLUG_IN_COPYRIGHT   "Craig Setera"
  89. #define PLUG_IN_VERSION     "v0.5 (03/31/1999)"
  90.  
  91. #ifdef _DEBUG
  92. #define PLUG_IN_D_NAME        "twain-acquire-dump"
  93. #define PLUG_IN_D_MENU_PATH   "<Toolbox>/File/Acquire/TWAIN (Dump)..."
  94.  
  95. #define PLUG_IN_R_NAME        "twain-acquire-read"
  96. #define PLUG_IN_R_MENU_PATH   "<Toolbox>/File/Acquire/TWAIN (Read)..."
  97. #endif /* _DEBUG */
  98.  
  99. /*
  100.  * Application definitions
  101.  */
  102. #define APP_NAME "TWAIN"
  103. #define MAX_IMAGES 1
  104. #define SHOW_WINDOW 0
  105. #define WM_TRANSFER_IMAGE (WM_USER + 100)
  106.  
  107. /*
  108.  * Definition of the run states 
  109.  */
  110. #define RUN_STANDARD 0
  111. #define RUN_DUMP 1
  112. #define RUN_READDUMP 2
  113.  
  114. /* Global variables */
  115. pTW_SESSION twSession = NULL;
  116.  
  117. static HWND        hwnd = NULL;
  118. static HINSTANCE   hInst = NULL;
  119. static char        *destBuf = NULL;
  120. static int         twain_run_mode = RUN_STANDARD;
  121.  
  122. /* Forward declarations */
  123. void preTransferCallback(void *);
  124. int  beginTransferCallback(pTW_IMAGEINFO, void *);
  125. int  dataTransferCallback(pTW_IMAGEINFO, pTW_IMAGEMEMXFER, void *);
  126. int  endTransferCallback(int, int, void *);
  127. void postTransferCallback(int, void *);
  128.  
  129. static void init(void);
  130. static void quit(void);
  131. static void query(void);
  132. static void run(char *, int, GimpParam *, int *, GimpParam **);
  133.  
  134. /* This plug-in's functions */
  135. GimpPlugInInfo PLUG_IN_INFO =
  136. {
  137.   NULL,    /* init_proc */
  138.   NULL,    /* quit_proc */
  139.   query,   /* query_proc */
  140.   run,     /* run_proc */
  141. };
  142.     
  143. extern void set_gimp_PLUG_IN_INFO_PTR(GimpPlugInInfo *);
  144.  
  145. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  146.  
  147. /* Data structure holding data between runs */
  148. /* Currently unused... Eventually may be used
  149.  * to track dialog data.
  150.  */
  151. typedef struct {
  152.   gchar  sourceName[34];
  153.   gfloat xResolution;
  154.   gfloat yResolution;
  155.   gint   xOffset;
  156.   gint   yOffset;
  157.   gint   width;
  158.   gint   height;
  159.   gint   imageType;
  160. } TwainValues;
  161.  
  162. /* Default Twain values */
  163. static TwainValues twainvals = 
  164. { 
  165.   "",
  166.   100.0, 100.0,
  167.   0, 0,
  168.   0, 0,
  169.   TWPT_RGB
  170. };
  171.  
  172. /* The standard callback functions */
  173. TXFR_CB_FUNCS standardCbFuncs = {
  174.   preTransferCallback,
  175.   beginTransferCallback,
  176.   dataTransferCallback,
  177.   endTransferCallback,
  178.   postTransferCallback };
  179.  
  180. /******************************************************************
  181.  * Dump handling
  182.  ******************************************************************/
  183.  
  184. #ifdef _DEBUG
  185. /* The dumper callback functions */
  186. TXFR_CB_FUNCS dumperCbFuncs = {
  187.   dumpPreTransferCallback,
  188.   dumpBeginTransferCallback,
  189.   dumpDataTransferCallback,
  190.   dumpEndTransferCallback,
  191.   dumpPostTransferCallback };
  192.  
  193. static void
  194. setRunMode(char *argv[])
  195. {
  196.   char *exeName = strrchr(argv[0], '\\') + 1;
  197.  
  198.   LogMessage("Executable name: %s\n", exeName);
  199.  
  200.   if (!_stricmp(exeName, "DTWAIN.EXE"))
  201.     twain_run_mode = RUN_DUMP;
  202.  
  203.   if (!_stricmp(exeName, "RTWAIN.EXE"))
  204.     twain_run_mode = RUN_READDUMP;
  205. }
  206. #endif /* _DEBUG */
  207.     
  208. /******************************************************************
  209.  * Win32 entry point and setup...
  210.  ******************************************************************/
  211.     
  212. /*
  213.  * WinMain
  214.  *
  215.  * The standard gimp entry point won't quite cut it for
  216.  * this plug-in.  This plug-in requires creation of a
  217.  * standard Win32 window (hidden) in order to receive
  218.  * and process window messages on behalf of the TWAIN
  219.  * datasource.
  220.  */
  221. int APIENTRY 
  222. WinMain(HINSTANCE hInstance,
  223.     HINSTANCE hPrevInstance,
  224.     LPSTR     lpCmdLine,
  225.     int       nCmdShow)
  226. {
  227.         
  228.   /* 
  229.    * Normally, we would do all of the Windows-ish set up of
  230.    * the window classes and stuff here in WinMain.  But,
  231.    * the only time we really need the window and message
  232.    * queues is during the plug-in run.  So, all of that will
  233.    * be done during run().  This avoids all of the Windows
  234.    * setup stuff for the query().  Stash the instance handle now
  235.    * so it is available from the run() procedure.
  236.    */
  237.   hInst = hInstance;
  238.  
  239. #ifdef _DEBUG
  240.   /* When in debug version, we allow different run modes...
  241.    * make sure that it is correctly set.
  242.    */
  243.   setRunMode(__argv);
  244. #endif /* _DEBUG */
  245.  
  246.   /*
  247.    * Now, call gimp_main... This is what the MAIN() macro
  248.    * would usually do.
  249.    */
  250.   set_gimp_PLUG_IN_INFO_PTR(&PLUG_IN_INFO);
  251.   return gimp_main(__argc, __argv);
  252. }
  253.     
  254. /*
  255.  * initTwainAppIdentity
  256.  *
  257.  * Initialize and return our application's identity for
  258.  * the TWAIN runtime.
  259.  */
  260. static pTW_IDENTITY
  261. getAppIdentity(void)
  262. {
  263.   pTW_IDENTITY appIdentity = g_new (TW_IDENTITY, 1);
  264.         
  265.   /* Set up the application identity */
  266.   appIdentity->Id = 0;
  267.   appIdentity->Version.MajorNum = 0;
  268.   appIdentity->Version.MinorNum = 1;
  269.   appIdentity->Version.Language = TWLG_USA;
  270.   appIdentity->Version.Country = TWCY_USA;
  271.   strcpy(appIdentity->Version.Info, "GIMP TWAIN 0.5");
  272.   appIdentity->ProtocolMajor = TWON_PROTOCOLMAJOR;
  273.   appIdentity->ProtocolMinor = TWON_PROTOCOLMINOR;
  274.   appIdentity->SupportedGroups = DG_IMAGE;
  275.   strcpy(appIdentity->Manufacturer, "Craig Setera");
  276.   strcpy(appIdentity->ProductFamily, "GIMP");
  277.   strcpy(appIdentity->ProductName, "GIMP for Win32");
  278.         
  279.   return appIdentity;
  280. }
  281.     
  282. /*
  283.  * initializeTwain
  284.  *
  285.  * Do the necessary TWAIN initialization.  This sets up
  286.  * our TWAIN session information.  The session stuff is
  287.  * something built by me on top of the standard TWAIN
  288.  * datasource manager calls.
  289.  */
  290. void
  291. initializeTwain(void)
  292. {
  293.   pTW_IDENTITY appIdentity;
  294.         
  295.   /* Get our application's identity */
  296.   appIdentity = getAppIdentity();
  297.         
  298.   /* Create a new session object */
  299.   twSession = newSession(appIdentity);
  300.         
  301.   /* Register our image transfer callback functions */
  302. #ifdef _DEBUG
  303.   if (twain_run_mode == RUN_DUMP)
  304.     registerTransferCallbacks(twSession, &dumperCbFuncs, NULL);
  305.   else
  306. #endif /* _DEBUG */
  307.     registerTransferCallbacks(twSession, &standardCbFuncs, NULL);
  308. }
  309.     
  310. /*
  311.  * InitApplication
  312.  *
  313.  * Initialize window data and register the window class
  314.  */
  315. BOOL 
  316. InitApplication(HINSTANCE hInstance)
  317. {
  318.   WNDCLASS wc;
  319.   BOOL retValue;
  320.         
  321.   /*
  322.    * Fill in window class structure with parameters to describe
  323.    * the main window.
  324.    */
  325.   wc.style = CS_HREDRAW | CS_VREDRAW;
  326.   wc.lpfnWndProc = (WNDPROC) WndProc;
  327.   wc.cbClsExtra = 0;
  328.   wc.cbWndExtra = 0;
  329.   wc.hInstance = hInstance;
  330.   wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  331.   wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  332.   wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
  333.   wc.lpszClassName = APP_NAME;
  334.   wc.lpszMenuName = NULL;
  335.         
  336.   /* Register the window class and stash success/failure code. */
  337.   retValue = RegisterClass(&wc);
  338.         
  339.   /* Log error */
  340.   if (!retValue)
  341.     LogLastWinError();
  342.         
  343.   return retValue;
  344. }
  345.     
  346. /*
  347.  * InitInstance
  348.  * 
  349.  * Create the main window for the application.  Used to
  350.  * interface with the TWAIN datasource.
  351.  */
  352. BOOL 
  353. InitInstance(HINSTANCE hInstance, int nCmdShow)
  354. {
  355.   /* Create our window */
  356.   hwnd = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPEDWINDOW,
  357.               CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
  358.               NULL, NULL, hInstance, NULL);
  359.         
  360.   if (!hwnd) {
  361.     return (FALSE);
  362.   }
  363.         
  364.   ShowWindow(hwnd, nCmdShow);
  365.   UpdateWindow(hwnd);
  366.         
  367.   return TRUE;
  368. }
  369.     
  370. /*
  371.  * twainWinMain
  372.  *
  373.  * This is the function that represents the code that
  374.  * would normally reside in WinMain (see above).  This
  375.  * function will get called during run() in order to set
  376.  * up the windowing environment necessary for TWAIN to
  377.  * operate.
  378.  */
  379. int
  380. twainWinMain(void) 
  381. {
  382.         
  383.   /* Initialize the twain information */
  384.   initializeTwain();
  385.         
  386.   /* Perform instance initialization */
  387.   if (!InitApplication(hInst))
  388.     return (FALSE);
  389.         
  390.   /* Perform application initialization */
  391.   if (!InitInstance(hInst, SHOW_WINDOW))
  392.     return (FALSE);
  393.         
  394.   /* 
  395.    * Call the main message processing loop...
  396.    * This call will not return until the application
  397.    * exits.
  398.    */
  399.   return twainMessageLoop(twSession);
  400. }
  401.     
  402. /*
  403.  * WndProc
  404.  *
  405.  * Process window message for the main window.
  406.  */
  407. LRESULT CALLBACK 
  408. WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  409. {
  410.   switch (message) {
  411.             
  412.   case WM_CREATE:
  413.     /* Register our window handle with the TWAIN
  414.      * support.
  415.      */
  416.     registerWindowHandle(twSession, hWnd);
  417.             
  418.     /* Schedule the image transfer by posting a message */
  419.     PostMessage(hWnd, WM_TRANSFER_IMAGE, 0, 0);
  420.     break;
  421.             
  422.   case WM_TRANSFER_IMAGE:
  423.     /* Get an image */
  424. #ifdef _DEBUG
  425.     if (twain_run_mode == RUN_READDUMP)
  426.       readDumpedImage(twSession);
  427.     else
  428. #endif /* _DEBUG */
  429.       getImage(twSession);
  430.     break;
  431.             
  432.   case WM_DESTROY:
  433.     LogMessage("Exiting application\n");
  434.     PostQuitMessage(0);
  435.     break;
  436.             
  437.   default:
  438.     return (DefWindowProc(hWnd, message, wParam, lParam));
  439.   }
  440.   return 0;
  441. }
  442.     
  443. /******************************************************************
  444.  * GIMP Plug-in entry points
  445.  ******************************************************************/
  446.     
  447. /*
  448.  * Plug-in Parameter definitions
  449.  */
  450. #define NUMBER_IN_ARGS 1
  451. #define IN_ARGS { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" }
  452. #define NUMBER_OUT_ARGS 2
  453. #define OUT_ARGS \
  454.     { GIMP_PDB_INT32, "image_count", "Number of acquired images" }, \
  455.     { GIMP_PDB_INT32ARRAY, "image_ids", "Array of acquired image identifiers" }
  456.  
  457.     
  458. /*
  459.  * query
  460.  *
  461.  * The plug-in is being queried.  Install our procedure for
  462.  * acquiring.
  463.  */
  464. static void 
  465. query(void)
  466. {
  467.   static GimpParamDef args[] = { IN_ARGS };
  468.   static GimpParamDef return_vals[] = { OUT_ARGS };
  469.  
  470.   INIT_I18N ();
  471.  
  472. #ifdef _DEBUG
  473.   if (twain_run_mode == RUN_DUMP)
  474.     /* the installation of the plugin */
  475.     gimp_install_procedure(PLUG_IN_D_NAME,
  476.                PLUG_IN_DESCRIPTION,
  477.                PLUG_IN_HELP,
  478.                PLUG_IN_AUTHOR,
  479.                PLUG_IN_COPYRIGHT,
  480.                PLUG_IN_VERSION,
  481.                PLUG_IN_D_MENU_PATH,
  482.                NULL,
  483.                GIMP_EXTENSION,        
  484.                NUMBER_IN_ARGS,
  485.                NUMBER_OUT_ARGS,
  486.                args,
  487.                return_vals);
  488.  
  489.   else if (twain_run_mode == RUN_READDUMP)
  490.     /* the installation of the plugin */
  491.     gimp_install_procedure(PLUG_IN_R_NAME,
  492.                PLUG_IN_DESCRIPTION,
  493.                PLUG_IN_HELP,
  494.                PLUG_IN_AUTHOR,
  495.                PLUG_IN_COPYRIGHT,
  496.                PLUG_IN_VERSION,
  497.                PLUG_IN_R_MENU_PATH,
  498.                NULL,
  499.                GIMP_EXTENSION,        
  500.                NUMBER_IN_ARGS,
  501.                NUMBER_OUT_ARGS,
  502.                args,
  503.                return_vals);
  504.   else
  505. #endif /* _DEBUG */
  506.     /* the installation of the plugin */
  507.     gimp_install_procedure(PLUG_IN_NAME,
  508.                PLUG_IN_DESCRIPTION,
  509.                PLUG_IN_HELP,
  510.                PLUG_IN_AUTHOR,
  511.                PLUG_IN_COPYRIGHT,
  512.                PLUG_IN_VERSION,
  513.                N_("<Toolbox>/File/Acquire/TWAIN..."),
  514.                NULL,
  515.                GIMP_EXTENSION,        
  516.                NUMBER_IN_ARGS,
  517.                NUMBER_OUT_ARGS,
  518.                args,
  519.                return_vals);
  520. }
  521.     
  522.     
  523. /* Return values storage */
  524. static GimpParam values[3];
  525.  
  526. /*
  527.  * run
  528.  *
  529.  * The plug-in is being requested to run.
  530.  * Capture an image from a TWAIN datasource
  531.  */
  532. static void 
  533. run(gchar *name,        /* name of plugin */
  534.     gint nparams,        /* number of in-paramters */
  535.     GimpParam *param,        /* in-parameters */
  536.     gint *nreturn_vals,            /* number of out-parameters */
  537.     GimpParam **return_vals)    /* out-parameters */
  538. {
  539.   GimpRunModeType run_mode;
  540.  
  541.   /* Initialize the return values
  542.    * Always return at least the status to the caller. 
  543.    */
  544.   values[0].type = GIMP_PDB_STATUS;
  545.   values[0].data.d_status = GIMP_PDB_SUCCESS;
  546.   *nreturn_vals = 1;
  547.   *return_vals = values;
  548.  
  549.   /* Before we get any further, verify that we have
  550.    * TWAIN and that there is actually a datasource
  551.    * to be used in doing the acquire.
  552.    */
  553.   if (!twainIsAvailable()) {
  554.     values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
  555.     return;
  556.   }
  557.  
  558.   /* Get the runmode from the in-parameters */
  559.   run_mode = param[0].data.d_int32;
  560.         
  561.   /* Set up the rest of the return parameters */
  562.   values[1].type = GIMP_PDB_INT32;
  563.   values[1].data.d_int32 = 0;
  564.   values[2].type = GIMP_PDB_INT32ARRAY;
  565.   values[2].data.d_int32array = g_new (gint32, MAX_IMAGES);
  566.         
  567.   /* How are we running today? */
  568.   switch (run_mode) {
  569.   case GIMP_RUN_INTERACTIVE:
  570.     /* Retrieve values from the last run...
  571.      * Currently ignored
  572.      */
  573.     gimp_get_data(PLUG_IN_NAME, &twainvals);
  574.     break;
  575.             
  576.   case GIMP_RUN_NONINTERACTIVE:
  577.     /* Currently, we don't do non-interactive calls.
  578.      * Bail if someone tries to call us non-interactively
  579.      */
  580.     values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
  581.     return;
  582.             
  583.   case GIMP_RUN_WITH_LAST_VALS:
  584.     /* Retrieve values from the last run...
  585.      * Currently ignored
  586.      */
  587.     gimp_get_data(PLUG_IN_NAME, &twainvals);
  588.     break;
  589.             
  590.   default:
  591.     break;
  592.   } /* switch */
  593.         
  594.   /* Have we succeeded so far? */
  595.   if (values[0].data.d_status == GIMP_PDB_SUCCESS)
  596.     twainWinMain();
  597.         
  598.   /* Check to make sure we got at least one valid
  599.    * image.
  600.    */
  601.   if (values[1].data.d_int32 > 0) {
  602.     /* An image was captured from the TWAIN
  603.      * datasource.  Do final Interactive
  604.      * steps.
  605.      */
  606.     if (run_mode == GIMP_RUN_INTERACTIVE) {
  607.       /* Store variable states for next run */
  608.       gimp_set_data(PLUG_IN_NAME, &twainvals, sizeof (TwainValues));
  609.     }
  610.             
  611.     /* Set return values */
  612.     *nreturn_vals = 3;
  613.   } else {
  614.     values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
  615.   }
  616. }
  617.     
  618. /***********************************************************************
  619.  * Image transfer callback functions
  620.  ***********************************************************************/
  621.     
  622. /* Data used to carry data between each of
  623.  * the callback function calls.
  624.  */
  625. typedef struct {
  626.   gint32 image_id;
  627.   gint32 layer_id;
  628.   GimpPixelRgn pixel_rgn;
  629.   GimpDrawable *drawable;
  630.   pTW_PALETTE8 paletteData;
  631.   int totalPixels;
  632.   int completedPixels;
  633. } ClientDataStruct, *pClientDataStruct;
  634.  
  635. /*
  636.  * preTransferCallback
  637.  *
  638.  * This callback function is called before any images
  639.  * are transferred.  Set up the one time only stuff.
  640.  */
  641. void
  642. preTransferCallback(void *clientData)
  643. {
  644.   /* Initialize our progress dialog */
  645.   gimp_progress_init(_("Transferring TWAIN data"));
  646. }
  647.  
  648. /*
  649.  * beginTransferCallback
  650.  *
  651.  * The following function is called at the beginning
  652.  * of each image transfer.
  653.  */
  654. int
  655. beginTransferCallback(pTW_IMAGEINFO imageInfo, void *clientData)
  656. {
  657.   int done = 0;
  658.   int imageType, layerType;
  659.  
  660.   pClientDataStruct theClientData = g_new (ClientDataStruct, 1);
  661.  
  662. #ifdef _DEBUG        
  663.   logBegin(imageInfo, clientData);
  664. #endif
  665.         
  666.   /* Decide on the image type */
  667.   switch (imageInfo->PixelType) {
  668.   case TWPT_BW:
  669.   case TWPT_GRAY:
  670.     /* Set up the image and layer types */
  671.     imageType = GIMP_GRAY;
  672.     layerType = GIMP_GRAY_IMAGE;
  673.     break;
  674.             
  675.   case TWPT_RGB:
  676.     /* Set up the image and layer types */
  677.     imageType = GIMP_RGB;
  678.     layerType = GIMP_RGB_IMAGE;
  679.     break;
  680.  
  681.   case TWPT_PALETTE:
  682.     /* Get the palette data */
  683.     theClientData->paletteData = g_new (TW_PALETTE8, 1);
  684.     twSession->twRC = callDSM(APP_IDENTITY(twSession), DS_IDENTITY(twSession),
  685.                   DG_IMAGE, DAT_PALETTE8, MSG_GET,
  686.                   (TW_MEMREF) theClientData->paletteData);
  687.     if (twSession->twRC != TWRC_SUCCESS)
  688.       return FALSE;
  689.  
  690.     switch (theClientData->paletteData->PaletteType) {
  691.     case TWPA_RGB:
  692.       /* Set up the image and layer types */
  693.       imageType = GIMP_RGB;
  694.       layerType = GIMP_RGB_IMAGE;
  695.       break;
  696.  
  697.     case TWPA_GRAY:
  698.       /* Set up the image and layer types */
  699.       imageType = GIMP_GRAY;
  700.       layerType = GIMP_GRAY_IMAGE;
  701.       break;
  702.  
  703.     default:
  704.       return FALSE;
  705.     }
  706.     break;
  707.  
  708.   default:
  709.     /* We don't know how to deal with anything other than
  710.      * the types listed above.  Bail for any other image
  711.      * type.
  712.      */
  713.     return FALSE;
  714.   }
  715.         
  716.   /* Create the GIMP image */
  717.   theClientData->image_id = gimp_image_new(imageInfo->ImageWidth, 
  718.                        imageInfo->ImageLength, imageType);
  719.             
  720.   /* Create a layer */
  721.   theClientData->layer_id = gimp_layer_new(theClientData->image_id,
  722.                        _("Background"),
  723.                        imageInfo->ImageWidth, 
  724.                        imageInfo->ImageLength,
  725.                        layerType, 100, GIMP_NORMAL_MODE);
  726.         
  727.   /* Add the layer to the image */
  728.   gimp_image_add_layer(theClientData->image_id, 
  729.                theClientData->layer_id, 0);
  730.         
  731.   /* Update the progress dialog */
  732.   theClientData->totalPixels = imageInfo->ImageWidth * imageInfo->ImageLength;
  733.   theClientData->completedPixels = 0;
  734.   gimp_progress_update((double) 0);
  735.         
  736.   /* Get our drawable */
  737.   theClientData->drawable = gimp_drawable_get(theClientData->layer_id);
  738.         
  739.   /* Initialize a pixel region for writing to the image */
  740.   gimp_pixel_rgn_init(&(theClientData->pixel_rgn), theClientData->drawable, 
  741.               0, 0, imageInfo->ImageWidth, imageInfo->ImageLength,
  742.               TRUE, FALSE);
  743.         
  744.   /* Store our client data for the data transfer callbacks */
  745.   if (clientData)
  746.     g_free (clientData);
  747.   setClientData(twSession, (void *) theClientData);
  748.         
  749.   /* Make sure to return TRUE to continue the image
  750.    * transfer
  751.    */
  752.   return TRUE;
  753. }
  754.     
  755. /*
  756.  * bitTransferCallback
  757.  *
  758.  * The following function is called for each memory
  759.  * block that is transferred from the data source if
  760.  * the image type is Black/White.
  761.  *
  762.  * Black and white data is unpacked from bit data
  763.  * into byte data and written into a gray scale GIMP
  764.  * image.
  765.  */
  766. static char bitMasks[] = { 128, 64, 32, 16, 8, 4, 2, 1 };
  767. static int 
  768. bitTransferCallback(pTW_IMAGEINFO imageInfo,
  769.             pTW_IMAGEMEMXFER imageMemXfer,
  770.             void *clientData)
  771. {
  772.   int row, col, offset;
  773.   char *srcBuf;
  774.   int rows = imageMemXfer->Rows;
  775.   int cols = imageMemXfer->Columns;
  776.   pClientDataStruct theClientData = (pClientDataStruct) clientData;
  777.         
  778.   /* Allocate a buffer as necessary */
  779.   if (!destBuf)
  780.     destBuf = g_new (char, rows * cols);
  781.         
  782.   /* Unpack the image data from bits into bytes */
  783.   srcBuf = (char *) imageMemXfer->Memory.TheMem;
  784.   offset = 0;
  785.   for (row = 0; row < rows; row++) {
  786.     for (col = 0; col < cols; col++) {
  787.       char byte = srcBuf[(row * imageMemXfer->BytesPerRow) + (col / 8)];
  788.       destBuf[offset++] = ((byte & bitMasks[col % 8]) != 0) ? 255 : 0;
  789.     }
  790.   }
  791.         
  792.   /* Update the complete chunk */
  793.   gimp_pixel_rgn_set_rect(&(theClientData->pixel_rgn), 
  794.               (guchar *) destBuf,
  795.               imageMemXfer->XOffset, imageMemXfer->YOffset,
  796.               cols, rows);
  797.         
  798.   /* Update the user on our progress */
  799.   theClientData->completedPixels += (cols * rows);
  800.   gimp_progress_update((double) theClientData->completedPixels / 
  801.                (double) theClientData->totalPixels);
  802.         
  803.   return TRUE;
  804. }
  805.     
  806. /*
  807.  * oneBytePerSampleTransferCallback
  808.  *
  809.  * The following function is called for each memory
  810.  * block that is transferred from the data source if
  811.  * the image type is Grayscale or RGB.  This transfer
  812.  * mode is quicker than the modes that require translation
  813.  * from a greater number of bits per sample down to the
  814.  * 8 bits per sample understood by The GIMP.
  815.  */
  816. static int 
  817. oneBytePerSampleTransferCallback(pTW_IMAGEINFO imageInfo,
  818.              pTW_IMAGEMEMXFER imageMemXfer,
  819.              void *clientData)
  820. {
  821.   int row;
  822.   char *srcBuf;
  823.   int bytesPerPixel = imageInfo->BitsPerPixel / 8;
  824.   int rows = imageMemXfer->Rows;
  825.   int cols = imageMemXfer->Columns;
  826.   pClientDataStruct theClientData = (pClientDataStruct) clientData;
  827.         
  828.   /* Allocate a buffer as necessary */
  829.   if (!destBuf)
  830.     destBuf = g_new (char, rows * cols * bytesPerPixel);
  831.         
  832.   /* The bytes coming from the source may not be padded in
  833.    * a way that The GIMP is terribly happy with.  It is
  834.    * possible to transfer row by row, but that is particularly
  835.    * expensive in terms of performance.  It is much cheaper
  836.    * to rearrange the data and transfer it in one large chunk.
  837.    * The next chunk of code rearranges the incoming data into
  838.    * a non-padded chunk for The GIMP.
  839.    */
  840.   srcBuf = (char *) imageMemXfer->Memory.TheMem;
  841.   for (row = 0; row < rows; row++) {
  842.     /* Copy the current row */
  843.     memcpy((destBuf + (row * bytesPerPixel * cols)),
  844.        (srcBuf + (row * imageMemXfer->BytesPerRow)),
  845.        (bytesPerPixel * cols));
  846.   }
  847.         
  848.   /* Update the complete chunk */
  849.   gimp_pixel_rgn_set_rect(&(theClientData->pixel_rgn), 
  850.               (guchar *) destBuf,
  851.               imageMemXfer->XOffset, imageMemXfer->YOffset,
  852.               cols, rows);
  853.         
  854.   /* Update the user on our progress */
  855.   theClientData->completedPixels += (cols * rows);
  856.   gimp_progress_update((double) theClientData->completedPixels / 
  857.                (double) theClientData->totalPixels);
  858.         
  859.   return TRUE;
  860. }
  861.     
  862. /*
  863.  * twoBytesPerSampleTransferCallback
  864.  *
  865.  * The following function is called for each memory
  866.  * block that is transferred from the data source if
  867.  * the image type is Grayscale or RGB.
  868.  */ 
  869. static int 
  870. twoBytesPerSampleTransferCallback(pTW_IMAGEINFO imageInfo,
  871.              pTW_IMAGEMEMXFER imageMemXfer,
  872.              void *clientData)
  873. {
  874.   static float ratio = 0.00390625;
  875.   int row, col, sample;
  876.   char *srcBuf, *destByte;
  877.   int rows = imageMemXfer->Rows;
  878.   int cols = imageMemXfer->Columns;
  879.   int bitsPerSample = imageInfo->BitsPerPixel / imageInfo->SamplesPerPixel;
  880.   int bytesPerSample = bitsPerSample / 8;
  881.  
  882.   TW_UINT16 *samplePtr;
  883.  
  884.   pClientDataStruct theClientData = (pClientDataStruct) clientData;
  885.         
  886.   /* Allocate a buffer as necessary */
  887.   if (!destBuf)
  888.     destBuf = g_new (char, rows * cols * imageInfo->SamplesPerPixel);
  889.         
  890.   /* The bytes coming from the source may not be padded in
  891.    * a way that The GIMP is terribly happy with.  It is
  892.    * possible to transfer row by row, but that is particularly
  893.    * expensive in terms of performance.  It is much cheaper
  894.    * to rearrange the data and transfer it in one large chunk.
  895.    * The next chunk of code rearranges the incoming data into
  896.    * a non-padded chunk for The GIMP.  This function must also
  897.    * reduce from multiple bytes per sample down to single byte
  898.    * per sample.
  899.    */
  900.   /* Work through the rows */
  901.   for (row = 0; row < rows; row++) {
  902.     /* The start of this source row */
  903.     samplePtr = (TW_UINT16 *) 
  904.       ((char *) imageMemXfer->Memory.TheMem + (row * imageMemXfer->BytesPerRow));
  905.  
  906.     /* The start of this dest row */
  907.     destByte = destBuf + (row * imageInfo->SamplesPerPixel * cols);
  908.  
  909.     /* Work through the columns */
  910.     for (col = 0; col < cols; col++) {
  911.       /* Finally, work through each of the samples */
  912.       for (sample = 0; sample < imageInfo->SamplesPerPixel; sample++) {
  913.                 /* Get the value */
  914.     TW_UINT16 value = *samplePtr;
  915.  
  916.                 /* Move the sample pointer */
  917.     samplePtr++;
  918.  
  919.                 /* Place in the destination */
  920.     *destByte = (char) ((float) value * (float) ratio);
  921.     destByte++;
  922.       }
  923.     }
  924.   }
  925.         
  926.   /* Send the complete chunk */
  927.   gimp_pixel_rgn_set_rect(&(theClientData->pixel_rgn), 
  928.               (guchar *) destBuf,
  929.               imageMemXfer->XOffset, imageMemXfer->YOffset,
  930.               cols, rows);
  931.         
  932.   /* Update the user on our progress */
  933.   theClientData->completedPixels += (cols * rows);
  934.   gimp_progress_update((double) theClientData->completedPixels / 
  935.                (double) theClientData->totalPixels);
  936.         
  937.   return TRUE;
  938. }
  939.     
  940. /*
  941.  * palettedTransferCallback
  942.  *
  943.  * The following function is called for each memory
  944.  * block that is transferred from the data source if
  945.  * the image type is paletted.  This does not create
  946.  * an indexed image type in The GIMP because for some
  947.  * reason it does not allow creation of a specific
  948.  * palette.  This function will create an RGB or Gray
  949.  * image and use the palette to set the details of
  950.  * the pixels.
  951.  */ 
  952. static int 
  953. palettedTransferCallback(pTW_IMAGEINFO imageInfo,
  954.              pTW_IMAGEMEMXFER imageMemXfer,
  955.              void *clientData)
  956. {
  957.   int channelsPerEntry;
  958.   int row, col;
  959.   int rows = imageMemXfer->Rows;
  960.   int cols = imageMemXfer->Columns;
  961.   char *destPtr = NULL, *srcPtr = NULL;
  962.  
  963.   /* Get the client data */
  964.   pClientDataStruct theClientData = (pClientDataStruct) clientData;
  965.         
  966.   /* Look up the palette entry size */
  967.   channelsPerEntry = 
  968.     (theClientData->paletteData->PaletteType == TWPA_RGB) ? 3 : 1;
  969.  
  970.   /* Allocate a buffer as necessary */
  971.   if (!destBuf)
  972.     destBuf = g_new (char, rows * cols * channelsPerEntry);
  973.  
  974.   /* Work through the rows */
  975.   destPtr = destBuf;
  976.   for (row = 0; row < rows; row++) {
  977.     srcPtr = (char *) ((char *) imageMemXfer->Memory.TheMem + 
  978.                (row * imageMemXfer->BytesPerRow));
  979.  
  980.     /* Work through the columns */
  981.     for (col = 0; col < cols; col++) {
  982.       /* Get the palette index */
  983.       int index = (unsigned char) *srcPtr;
  984.       srcPtr++;
  985.  
  986.       switch (theClientData->paletteData->PaletteType) {
  987.       case TWPA_GRAY:
  988.     *destPtr = theClientData->paletteData->Colors[index].Channel1;
  989.     destPtr++;
  990.     break;
  991.  
  992.       case TWPA_RGB:
  993.     *destPtr = theClientData->paletteData->Colors[index].Channel1;
  994.     destPtr++;
  995.     *destPtr = theClientData->paletteData->Colors[index].Channel2;
  996.     destPtr++;
  997.     *destPtr = theClientData->paletteData->Colors[index].Channel3;
  998.     destPtr++;
  999.       }
  1000.     }
  1001.   }
  1002.         
  1003.   /* Send the complete chunk */
  1004.   gimp_pixel_rgn_set_rect(&(theClientData->pixel_rgn), 
  1005.               (guchar *) destBuf,
  1006.               imageMemXfer->XOffset, imageMemXfer->YOffset,
  1007.               cols, rows);
  1008.         
  1009.   /* Update the user on our progress */
  1010.   theClientData->completedPixels += (cols * rows);
  1011.   gimp_progress_update((double) theClientData->completedPixels / 
  1012.                (double) theClientData->totalPixels);
  1013.         
  1014.   return TRUE;
  1015. }
  1016.     
  1017. /*
  1018.  * dataTransferCallback
  1019.  *
  1020.  * The following function is called for each memory
  1021.  * block that is transferred from the data source.
  1022.  */
  1023. int 
  1024. dataTransferCallback(pTW_IMAGEINFO imageInfo,
  1025.              pTW_IMAGEMEMXFER imageMemXfer,
  1026.              void *clientData)
  1027. {
  1028. #ifdef _DEBUG
  1029.   logData(imageInfo, imageMemXfer, clientData);
  1030. #endif
  1031.         
  1032.   /* Choose the appropriate transfer handler */
  1033.   switch (imageInfo->PixelType) {
  1034.   case TWPT_PALETTE:
  1035.     return palettedTransferCallback(imageInfo, imageMemXfer, clientData);
  1036.  
  1037.   case TWPT_BW:
  1038.     return bitTransferCallback(imageInfo, imageMemXfer, clientData);
  1039.             
  1040.   case TWPT_GRAY:
  1041.   case TWPT_RGB:
  1042.     switch (imageInfo->BitsPerPixel / imageInfo->SamplesPerPixel) {
  1043.     case 8:
  1044.       return oneBytePerSampleTransferCallback(imageInfo, imageMemXfer, clientData);
  1045.                 
  1046.     case 16:
  1047.       return twoBytesPerSampleTransferCallback(imageInfo, imageMemXfer, clientData);
  1048.  
  1049.     default:
  1050.       return FALSE;
  1051.     }
  1052.             
  1053.   default:
  1054.     return FALSE;
  1055.   }
  1056. }
  1057.     
  1058. /*
  1059.  * endTransferCallback
  1060.  *
  1061.  * The following function is called at the end of the
  1062.  * image transfer.  The caller will be handed
  1063.  * the image transfer completion state.  The
  1064.  * following values (defined in twain.h) are
  1065.  * possible:
  1066.  *
  1067.  * TWRC_XFERDONE
  1068.  *  The transfer completed successfully
  1069.  * TWRC_CANCEL
  1070.  *  The transfer was completed by the user
  1071.  * TWRC_FAILURE
  1072.  *  The transfer failed.
  1073.  */
  1074. int
  1075. endTransferCallback(int completionState, int pendingCount, void *clientData)
  1076. {
  1077.   pClientDataStruct theClientData = (pClientDataStruct) clientData;
  1078.         
  1079.   LogMessage("endTransferCallback: CompState = %d, pending = %d\n",
  1080.          completionState, pendingCount);
  1081.  
  1082.   /* Clean up and detach from the drawable */
  1083.   if (destBuf) {
  1084.     g_free (destBuf);
  1085.     destBuf = NULL;
  1086.   }
  1087.   gimp_drawable_flush(theClientData->drawable);
  1088.   gimp_drawable_detach(theClientData->drawable);
  1089.  
  1090.   /* Make sure to check our return code */
  1091.   if (completionState == TWRC_XFERDONE) {
  1092.     /* We have a completed image transfer */
  1093.     values[2].type = GIMP_PDB_INT32ARRAY;    
  1094.     values[2].data.d_int32array[values[1].data.d_int32++] =
  1095.       theClientData->image_id;
  1096.                 
  1097.     /* Display the image */
  1098.     LogMessage("Displaying image %d\n", theClientData->image_id);
  1099.     gimp_display_new (theClientData->image_id);
  1100.   } else {
  1101.     /* The transfer did not complete successfully */
  1102.     LogMessage("Deleting image\n");
  1103.     gimp_image_delete(theClientData->image_id);
  1104.   }
  1105.         
  1106.   /* Shut down if we have received all of the possible images */
  1107.   return (values[1].data.d_int32 < MAX_IMAGES);
  1108. }
  1109.  
  1110. /*
  1111.  * postTransferCallback
  1112.  *
  1113.  * This callback function will be called
  1114.  * after all possible images have been
  1115.  * transferred.
  1116.  */
  1117. void
  1118. postTransferCallback(int pendingCount, void *clientData)
  1119. {
  1120.   /* Shut things down. */
  1121.   if (pendingCount != 0)
  1122.     cancelPendingTransfers(twSession);
  1123.  
  1124.   /* This will close the datasource and datasource
  1125.    * manager.  Then the message queue will be shut
  1126.    * down and the run() procedure will finally be
  1127.    * able to finish.
  1128.    */
  1129.   disableDS(twSession);
  1130.   closeDS(twSession);
  1131.   closeDSM(twSession);
  1132.         
  1133.   /* Post a message to close up the application */
  1134.   PostQuitMessage(0);
  1135. }
  1136.