#ifdef _WIN32
#pragma warning(disable : 4996)
#endif
 
#define TTWAINLIB_MAIN
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdio.h>
#include "ttwain_state.h"
#include "ttwain_statePD.h"
#include "ttwain_error.h"
#include "ttwain_win.h"
#include "ttwain_winPD.h"
#include "ttwain_util.h"
#include "ttwain_utilP.h"
#include "ttwain_conversion.h"
#include "ttwainP.h"
 
#include "ttwain_global_def.h"
 
#ifdef __cplusplus
extern "C" {
#endif
#ifdef MACOSX
extern int exitTwainSession(void);
#endif
static void TTWAIN_FreeVar(void);
 
#define RELEASE_STR "5.1"
#define TITLEBAR_STR "Toonz5.1"
#define TwProgramName "Toonz5.1"
 
#define COMPANY "Digital Video"
#define PRODUCT "TOONZ"
 
#ifndef min
#define min(a, b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef max
#define max(a, b) (((a) > (b)) ? (a) : (b))
#endif
 
#define CEIL(x) ((int)(x) < (x) ? (int)(x) + 1 : (int)(x))
 
#define PRINTF
/*---------------------------------------------------------------------------*/
/* LOCAL PROTOTYPES
 */
/*---------------------------------------------------------------------------*/
static int TTWAIN_DoOneTransfer(void);
static int TTWAIN_WaitForXfer(void *hwnd);
static void *TTWAIN_WaitForNativeXfer(void *hwnd);
static int TTWAIN_WaitForMemoryXfer(void *hwnd);
static int TTWAIN_NativeXferHandler(void);
static int TTWAIN_MemoryXferHandler(void);
static int TTWAIN_AbortAllPendingXfers(void);
static void TTWAIN_ModalEventLoop(void);
static void TTWAIN_BreakModalLoop(void);
static void TTWAIN_EmptyMessageQueue(void);
/*---------------------------------------------------------------------------*/
void TTWAIN_SetState(TWAINSTATE status);
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* int TTWAIN_LoadSourceManager(void)      <- this is in ttwain_state.h */
 
/* int TTWAIN_SelectImageSource(void* hwnd) <-\
   int TTWAIN_SelectImageSource(void* hwnd) <-|--\
   int TTWAIN_OpenDefaultSource(void)       <-|-- these are in ttwain.h
   int TTWAIN_CloseAll        (void *hwnd)  <-/
*/
 
/* these are local */
static int TTWAIN_EnableSource(void *hwnd);
int TTWAIN_MessageHook(void *lpmsg);
static int TTWAIN_EndXfer(void);
static int TTWAIN_DisableSource(void);
static int TTWAIN_CloseSource(void);
static int TTWAIN_CloseSourceManager(void *hwnd);
 
/* int TTWAIN_UnloadSourceManager(void)       <- this is in ttwain_state.h */
 
static int TTWAIN_MGR(TUINT32 dg, TUINT32 dat, TUINT32 msg, void *pd);
 
#define INVERT_BYTE(START, HOWMANY)                                            \
  {                                                                            \
    UCHAR *p = (START);                                                        \
    unsigned int ijk;                                                          \
    for (ijk = 0; ijk < (HOWMANY); ijk++, p++) {                               \
      *p = ~*p;                                                                \
    }                                                                          \
  }
 
#define BB(H, L) (H << 8 | L)
/*---------------------------------------------------------------------------*/
/*	  TWAIN STATE		 					     */
/*---------------------------------------------------------------------------*/
/*STATE 1 TO 2*/
int TTWAIN_LoadSourceManager(void) {
  TTWAIN_InitVar();
  return TTWAIN_LoadSourceManagerPD();
}
/*---------------------------------------------------------------------------*/
/*STATE 2 TO 3*/
int TTWAIN_OpenSourceManager(void *hwnd) {
  TTwainData.hwnd32SM = (TW_INT32)TTWAIN_GetValidHwnd(hwnd);
 
  if (TTWAIN_GetState() < TWAIN_SM_OPEN) {
    if (TTWAIN_LoadSourceManager() &&
        TTWAIN_MGR(DG_CONTROL, DAT_PARENT, MSG_OPENDSM, &TTwainData.hwnd32SM)) {
      assert(TTWAIN_GetState() == TWAIN_SM_OPEN);
    }
  }
  return (TTWAIN_GetState() >= TWAIN_SM_OPEN);
}
/*---------------------------------------------------------------------------*/
/*STATE 3*/
static TW_IDENTITY newSourceId;
int TTWAIN_SelectImageSource(void *hwnd) {
  int success           = FALSE;
  TWAINSTATE entryState = TTWAIN_GetState();
 
  if (TTWAIN_GetState() >= TWAIN_SM_OPEN || TTWAIN_OpenSourceManager(hwnd)) {
    // TW_IDENTITY	newSourceId;
    memset(&newSourceId, 0, sizeof newSourceId);
 
    TTWAIN_MGR(DG_CONTROL, DAT_IDENTITY, MSG_GETDEFAULT, &newSourceId);
    /* Post the Select Source dialog */
    success =
        TTWAIN_MGR(DG_CONTROL, DAT_IDENTITY, MSG_USERSELECT, &newSourceId);
  } else {
    char msg[2048];
    sprintf(msg, "Unable to open Source Manager (%s)", DSM_FILENAME);
    TTWAIN_ErrorBox(msg);
    return FALSE;
  }
 
  if (entryState < TWAIN_SM_OPEN) {
    TTWAIN_CloseSourceManager(hwnd);
    if (entryState < TWAIN_SM_LOADED) {
      TTWAIN_UnloadSourceManager();
    }
  }
  return success;
}
/*---------------------------------------------------------------------------*/
/*STATE 3 TO 4*/
int TTWAIN_OpenDefaultSource(void) {
  TW_IDENTITY tempId;
  int rc;
  static int first_time = TRUE;
 
  if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN) {
    if (TTWAIN_GetState() < TWAIN_SM_OPEN && !TTWAIN_OpenSourceManager(NULL))
      return FALSE;
 
    rc = TTWAIN_MGR(DG_CONTROL, DAT_IDENTITY, MSG_GETFIRST, &tempId);
    while (rc && tempId.Id != 0) {
      if (strcmp((char *)newSourceId.ProductName, (char *)tempId.ProductName) ==
          0) {
        newSourceId = tempId;
        break;
      }
      rc = TTWAIN_MGR(DG_CONTROL, DAT_IDENTITY, MSG_GETNEXT, &tempId);
    }
 
    if (TTWAIN_MGR(DG_CONTROL, DAT_IDENTITY, MSG_OPENDS, &newSourceId)) {
      assert(TTWAIN_GetState() == TWAIN_SOURCE_OPEN);
    }
  }
 
  if (first_time && (TTWAIN_GetState() == TWAIN_SOURCE_OPEN)) {
    TTWAIN_GetSupportedCaps();
    /*first_time = FALSE;*/
  }
  return (TTWAIN_GetState() == TWAIN_SOURCE_OPEN);
}
/*---------------------------------------------------------------------------*/
/*STATE 4 TO 5*/
static int TTWAIN_EnableSource(void *hwnd) {
  if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN && !TTWAIN_OpenDefaultSource())
    return FALSE;
 
  TTwainData.twainUI.ShowUI  = TTWAIN_GetUIStatus();
  TTwainData.twainUI.ModalUI = TTWAIN_GetModalStatus();
  TTwainData.twainUI.hParent = (TW_HANDLE)TTWAIN_GetValidHwnd(hwnd);
  TTWAIN_DS(DG_CONTROL, DAT_USERINTERFACE, MSG_ENABLEDS, &TTwainData.twainUI);
  return (TTWAIN_GetState() == TWAIN_SOURCE_ENABLED);
}
/*---------------------------------------------------------------------------*/
/*STATE 5 TO 6 TO 7*/
int TTWAIN_MessageHook(void *lpmsg)
/* returns TRUE if msg processed by TWAIN (source) */
{
  int bProcessed = FALSE;
  // printf("%s\n", __PRETTY_FUNCTION__);
  if (TTWAIN_GetState() >= TWAIN_SOURCE_ENABLED) {
/* source enabled */
#ifdef _WIN32
    TW_EVENT twEvent;
    twEvent.pEvent    = (TW_MEMREF)lpmsg;
    twEvent.TWMessage = MSG_NULL;
    /* see if source wants to process (eat) the message */
    bProcessed = (TTWAIN_DS(DG_CONTROL, DAT_EVENT, MSG_PROCESSEVENT,
                            &twEvent) == TWRC_DSEVENT);
#else
    TW_EVENT twEvent;
    twEvent.pEvent    = (TW_MEMREF)0;
    twEvent.TWMessage = (TW_UINT32)lpmsg;
#endif
    switch (twEvent.TWMessage) {
    case MSG_XFERREADY:
#ifdef MACOSX
      TTWAIN_SetState(TWAIN_TRANSFER_READY);
#endif
      assert(TTWAIN_GetState() == TWAIN_TRANSFER_READY);
      TTWAIN_DoOneTransfer();
      break;
    case MSG_CLOSEDSREQ:
      TTWAIN_DisableSource();
      break;
    case MSG_NULL:
      /* no message returned from DS */
      break;
    } /* switch */
  }
  return bProcessed;
}
/*---------------------------------------------------------------------------*/
/*STATE 7 TO 6 TO 5*/
static int TTWAIN_EndXfer(void) {
  if (TTWAIN_GetState() == TWAIN_TRANSFERRING)
    TTWAIN_DS(DG_CONTROL, DAT_PENDINGXFERS, MSG_ENDXFER,
              &TTwainData.transferInfo.pendingXfers);
  return (TTWAIN_GetState() < TWAIN_TRANSFERRING);
}
/*---------------------------------------------------------------------------*/
/* STATE 5 TO 1 */
/* 3 OP + 1 PD OP*/
 
/*STATE 5 TO 4*/
static int TTWAIN_DisableSource(void) {
  TTWAIN_AbortAllPendingXfers();
 
  if ((TTWAIN_GetState() >= TWAIN_SOURCE_ENABLED) &&
      (TTWAIN_DS(DG_CONTROL, DAT_USERINTERFACE, MSG_DISABLEDS,
                 &TTwainData.twainUI) == TWRC_SUCCESS)) {
    assert(TTWAIN_GetState() == TWAIN_SOURCE_OPEN);
    return FALSE;
  }
  TTWAIN_EmptyMessageQueue();
  return (TTWAIN_GetState() < TWAIN_SOURCE_ENABLED);
}
/*---------------------------------------------------------------------------*/
/*STATE 4 TO 3*/
static int TTWAIN_CloseSource(void) {
  TTwainData.resultCode = TWRC_SUCCESS;
 
  TTWAIN_DisableSource();
  if (TTWAIN_GetState() == TWAIN_SOURCE_OPEN &&
      TTWAIN_MGR(DG_CONTROL, DAT_IDENTITY, MSG_CLOSEDS, &TTwainData.sourceId)) {
    assert(TTWAIN_GetState() == TWAIN_SM_OPEN);
  }
  return (TTWAIN_GetState() <= TWAIN_SM_OPEN);
}
/*---------------------------------------------------------------------------*/
/*STATE 3 TO 2*/
static int TTWAIN_CloseSourceManager(void *hwnd) {
  TTWAIN_EmptyMessageQueue();
  TTwainData.hwnd32SM = (TW_INT32)TTWAIN_GetValidHwnd(hwnd);
 
  TTwainData.resultCode = TWRC_SUCCESS;
 
  if (TTWAIN_CloseSource() &&
      TTWAIN_MGR(DG_CONTROL, DAT_PARENT, MSG_CLOSEDSM, &TTwainData.hwnd32SM)) {
    assert(TTWAIN_GetState() == TWAIN_SM_LOADED);
  }
  return (TTWAIN_GetState() <= TWAIN_SM_LOADED);
}
/*---------------------------------------------------------------------------*/
/*STATE 2 TO 1*/
int TTWAIN_UnloadSourceManager(void) {
  TTWAIN_CloseSourceManager(NULL);
  return TTWAIN_UnloadSourceManagerPD();
}
/*---------------------------------------------------------------------------*/
int TTWAIN_CloseAll(void *hwnd) {
  TTWAIN_EndXfer();
  TTWAIN_DisableSource();
  TTWAIN_CloseSource();
  TTWAIN_CloseSourceManager(hwnd);
  TTWAIN_UnloadSourceManager();
  TTWAIN_FreeVar();
  return 1;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*    MISC. AUX FUNCTIONS						     */
/*---------------------------------------------------------------------------*/
TWAINSTATE TTWAIN_GetState(void) { return TTwainData.twainState; }
/*---------------------------------------------------------------------------*/
void TTWAIN_SetState(TWAINSTATE status) { TTwainData.twainState = status; }
/*---------------------------------------------------------------------------*/
static int TTWAIN_AbortAllPendingXfers(void) {
  TTWAIN_EndXfer();
  if (TTWAIN_GetState() == TWAIN_TRANSFER_READY) {
    TTWAIN_DS(DG_CONTROL, DAT_PENDINGXFERS, MSG_RESET,
              &TTwainData.transferInfo.pendingXfers);
  }
  TTWAIN_EmptyMessageQueue();
  return (TTWAIN_GetState() < TWAIN_TRANSFER_READY);
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*		DATA SOURCE						     */
/*---------------------------------------------------------------------------*/
TW_INT16 TTWAIN_DS(TUINT32 dg, TUINT32 dat, TUINT32 msg,
                   void *pd) { /* Call the current source with a triplet */
  int bOk                   = FALSE;
  static TUINT32 nMemBuffer = 0;
 
  PRINTF("%s dg=0x%x dat=0x%x msg=0x%x pd=0x%x\n", __FUNCTION__, dg, dat, msg,
         pd);
 
  assert(TTWAIN_GetState() >= TWAIN_SOURCE_OPEN);
  TTwainData.resultCode = TWRC_FAILURE;
  if (dg == DG_IMAGE) {
    if (dat == DAT_IMAGEMEMXFER) {
      if (msg == MSG_GET && pd != NULL) {
        pTW_IMAGEMEMXFER pmxb = (pTW_IMAGEMEMXFER)pd;
        pmxb->Compression     = TWON_DONTCARE16;
        pmxb->BytesPerRow     = TWON_DONTCARE32;
        pmxb->Columns         = TWON_DONTCARE32;
        pmxb->Rows            = TWON_DONTCARE32;
        pmxb->XOffset         = TWON_DONTCARE32;
        pmxb->YOffset         = TWON_DONTCARE32;
        pmxb->BytesWritten    = TWON_DONTCARE32;
      }
    }
  }
  if (TTwainData.DSM_Entry) {
    TTwainData.resultCode = (*TTwainData.DSM_Entry)(
        &TTwainData.appId, &TTwainData.sourceId, (TW_UINT32)dg, (TW_UINT16)dat,
        (TW_UINT16)msg, (TW_MEMREF)pd);
    bOk = (TTwainData.resultCode == TWRC_SUCCESS);
 
    if (dg == DG_CONTROL) {
      switch (dat) {
      case DAT_EVENT:
        if (msg == MSG_PROCESSEVENT) {
          if (((pTW_EVENT)pd)->TWMessage == MSG_XFERREADY) {
            TTWAIN_SetState(TWAIN_TRANSFER_READY);
          }
          bOk = (TTwainData.resultCode == TWRC_DSEVENT);
        }
        break;
 
      case DAT_CAPABILITY:
        break;
 
      case DAT_PENDINGXFERS:
        if (msg == MSG_ENDXFER && bOk) {
          TTWAIN_SetState(((pTW_PENDINGXFERS)pd)->Count ? TWAIN_TRANSFER_READY
                                                        : TWAIN_SOURCE_ENABLED);
        }
        if (msg == MSG_RESET && bOk) {
          TTWAIN_SetState(TWAIN_SOURCE_ENABLED);
        }
        break;
 
      case DAT_USERINTERFACE:
        if (msg == MSG_ENABLEDS) {
          if (TTwainData.resultCode == TWRC_FAILURE ||
              TTwainData.resultCode == TWRC_CANCEL) {
            TTWAIN_RecordError();
          } else {
            /* TTwainData.resultCode could be either SUCCESS or CHECKSTATUS */
            TTWAIN_SetState(TWAIN_SOURCE_ENABLED);
            bOk = TRUE;
          }
        }
        if (msg == MSG_DISABLEDS && bOk) {
          TTWAIN_SetState(TWAIN_SOURCE_OPEN);
#ifdef MACOSX
          exitTwainSession();  // exited from TwainUI using close button
#endif
        }
        break;
 
      case DAT_SETUPMEMXFER:
        if (msg == MSG_GET && bOk) {
          nMemBuffer = 0;
        }
        break;
      } /* switch */
    } else if (dg == DG_IMAGE) {
      if (dat == DAT_IMAGENATIVEXFER || dat == DAT_IMAGEFILEXFER) {
        /* Native and File transfers work much the same way. */
        if (msg == MSG_GET) {
          bOk = (TTwainData.resultCode == TWRC_XFERDONE);
          switch (TTwainData.resultCode) {
          case TWRC_XFERDONE:
          case TWRC_CANCEL:
            TTWAIN_SetState(TWAIN_TRANSFERRING);
            /* Need to acknowledge end of transfer with */
            /* DG_CONTROL / DAT_PENDINGXFERS / MSG_ENDXFER */
            break;
 
          case TWRC_FAILURE:
          default:
            /* Transfer failed (e.g. insufficient memory, write-locked file) */
            /* check condition code for more info */
            TTWAIN_SetState(TWAIN_TRANSFER_READY);
            /* The image is still pending */
            break;
          } /* switch */
        }
      } else if (dat == DAT_IMAGEMEMXFER) {
        if (msg == MSG_GET) {
          bOk = FALSE;
          switch (TTwainData.resultCode) {
          case TWRC_SUCCESS:
          case TWRC_XFERDONE:
            bOk = TRUE;
            nMemBuffer++;
            TTWAIN_SetState(TWAIN_TRANSFERRING);
            break;
 
          case TWRC_FAILURE:
            /* "If the failure occurred during the transfer of the first
buffer, the session is in State 6. If the failure occurred
on a subsequent buffer, the session is in State 7."
*/
            TTWAIN_SetState(nMemBuffer == 0 ? TWAIN_TRANSFER_READY
                                            : TWAIN_TRANSFERRING);
            break;
 
          case TWRC_CANCEL:
            /* Transfer cancelled, no state change. */
            TTWAIN_BreakModalLoop();
            break;
          } /* switch */
        }
      }
    }
  }
 
  /*
if (!bOk)
TTWAIN_RecordError();
*/
  return TTwainData.resultCode;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*	    DATA SOURCE MANAGER						     */
/*---------------------------------------------------------------------------*/
static int TTWAIN_MGR(TUINT32 dg, TUINT32 dat, TUINT32 msg, void *pd)
/* Call the Source Manager with a triplet */
{
  int bOk               = FALSE;
  TTwainData.resultCode = TWRC_FAILURE;
 
  if (TTwainData.DSM_Entry) {
    TTwainData.resultCode =
        (*TTwainData.DSM_Entry)(&TTwainData.appId, NULL, (TW_UINT32)dg,
                                (TW_UINT16)dat, (TW_UINT16)msg, (TW_MEMREF)pd);
    bOk = (TTwainData.resultCode == TWRC_SUCCESS);
    if (dg == DG_CONTROL) {
      if (dat == DAT_IDENTITY) {
        if (msg == MSG_OPENDS) {
          if (bOk) {
            /* Source opened - record identity for future triplets */
            memcpy(&TTwainData.sourceId, pd, sizeof(TW_IDENTITY));
            TTWAIN_SetState(TWAIN_SOURCE_OPEN);
          } else { /*RecordError(ED_DSM_FAILURE);*/
            TTWAIN_RecordError();
          }
        }
        if (msg == MSG_CLOSEDS && bOk) {
          TTWAIN_SetState(TWAIN_SM_OPEN);
        }
      }
      if (dat == DAT_PARENT) {
        if (msg == MSG_OPENDSM && bOk) {
          TTWAIN_SetState(TWAIN_SM_OPEN);
        }
        if (msg == MSG_CLOSEDSM && bOk) {
          TTWAIN_SetState(TWAIN_SM_LOADED);
        }
      }
    }
  }
  return bOk;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*			ERRORS						     */
/*---------------------------------------------------------------------------*/
TUINT32 TTWAIN_GetConditionCode(void) {
  TW_STATUS twStatus;
  TW_INT16 rcLast        = TTwainData.resultCode;
  TW_INT16 rc            = TWRC_FAILURE;
  twStatus.ConditionCode = TWCC_BUMMER;
 
  if (TTWAIN_GetState() >= 4) {
    /* get source status if open */
    rc = TTWAIN_DS(DG_CONTROL, DAT_STATUS, MSG_GET, (TW_MEMREF)&twStatus);
  } else if (TTWAIN_GetState() == 3) {
    /* otherwise get source manager status */
    rc = TTWAIN_MGR(DG_CONTROL, DAT_STATUS, MSG_GET, (TW_MEMREF)&twStatus);
  }
  TTwainData.resultCode = rcLast;
 
  if (rc != TWRC_SUCCESS) return -1;
  return twStatus.ConditionCode;
}
/*---------------------------------------------------------------------------*/
TUINT32 TTWAIN_GetResultCode(void) { return TTwainData.resultCode; }
/*---------------------------------------------------------------------------*/
int TTWAIN_DSM_HasEntryPoint(void) { return !!(TTwainData.DSM_Entry); }
/*---------------------------------------------------------------------------*/
static int TTWAIN_DoOneTransfer(void) {
  int rc = FALSE;
  switch (TTwainData.transferInfo.transferMech) {
  case TTWAIN_TRANSFERMODE_NATIVE:
    rc = TTWAIN_NativeXferHandler();
    break;
  case TTWAIN_TRANSFERMODE_FILE:
    assert(!"NOT IMPL!");
    /*TTWAIN_FileXferHandler(); */
    break;
  case TTWAIN_TRANSFERMODE_MEMORY:
    rc = TTWAIN_MemoryXferHandler();
    break;
  } /* switch */
 
  TTwainData.transferInfo.lastTransferWasOk = rc;
  /* If inside ModalEventLoop, break out */
  TTWAIN_BreakModalLoop();
 
  /* Acknowledge transfer */
  TTWAIN_EndXfer();
  assert(TTWAIN_GetState() == TWAIN_TRANSFER_READY ||
         TTWAIN_GetState() == TWAIN_SOURCE_ENABLED);
  return rc;
}
/*---------------------------------------------------------------------------*/
void TTWAIN_RegisterApp(
    int majorNum, int minorNum, /* app. revision*/
    int nLanguage,    /* (human) language (use TWLG_xxx from TWAIN.H) */
    int nCountry,     /* country (use TWCY_xxx from TWAIN.H)	     */
    char *version,    /* version info string                          */
    char *manufacter, /* name of manufacter			     */
    char *family,     /* product family				     */
    char *product)    /* specific product			     */
{
  memset(&TTwainData.appId, 0, sizeof(TTwainData.appId));
  TTwainData.appId.Id =
      0; /* init to 0, but Source Manager will assign THE real value*/
  TTwainData.appId.Version.MajorNum = majorNum;
  TTwainData.appId.Version.MinorNum = minorNum;
  TTwainData.appId.Version.Language = nLanguage;
  TTwainData.appId.Version.Country  = nCountry;
  TTwainData.appId.ProtocolMajor    = TWON_PROTOCOLMAJOR;
  TTwainData.appId.ProtocolMinor    = TWON_PROTOCOLMINOR;
  TTwainData.appId.SupportedGroups  = DG_IMAGE | DG_CONTROL;
  strcpy((char *)TTwainData.appId.Version.Info, version);
  strcpy((char *)TTwainData.appId.Manufacturer, manufacter);
  strcpy((char *)TTwainData.appId.ProductFamily, family);
  strcpy((char *)TTwainData.appId.ProductName, product);
}
/*---------------------------------------------------------------------------*/
void *TTWAIN_AcquireNative(void *hwnd) {
  void *hnative = NULL;
 
  TTwainData.transferInfo.lastTransferWasOk = FALSE;
 
  if (TTwainData.transferInfo.transferMech != TTWAIN_TRANSFERMODE_NATIVE)
    return 0;
 
  hwnd = TTWAIN_GetValidHwnd(hwnd);
  if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN) {
    if (!TTWAIN_OpenSourceManager(hwnd)) /* Bring up to state 4 */
    {
      char msg[2048];
      sprintf(msg, "Unable to open Source Manager (%s)", DSM_FILENAME);
      TTWAIN_ErrorBox(msg);
      return 0;
    }
    if (!TTWAIN_OpenDefaultSource())
      /*TTWAIN_ReportLastError("Unable to open default Data Source.");*/
      TTWAIN_RecordError();
    else
      assert(TTWAIN_GetState() == TWAIN_SOURCE_OPEN);
  }
 
  if (TTWAIN_GetState() >= TWAIN_SOURCE_OPEN)
    hnative = TTWAIN_WaitForNativeXfer(hwnd);
 
  if (!TTwainData.transferInfo.multiTransfer) {
    /* shut everything down in the right sequence */
    TTWAIN_AbortAllPendingXfers(); /* TRANSFER_READY or TRANSFERRING ->
                                      SOURCE_ENABLED */
    TTWAIN_UnloadSourceManager();
  }
 
  TTwainData.transferInfo.lastTransferWasOk = !!(hnative);
  return hnative;
}
/*---------------------------------------------------------------------------*/
#ifdef _WIN32
 
typedef void(MyFun)(HWND);
 
/*it's an hack function to force bring to top the twain UI module window     */
static BOOL CALLBACK myHackEnumFunction(HWND hwnd, LPARAM lParam) {
  MyFun *f = 0;
 
#define TITLESIZE (1024)
  char title[TITLESIZE + 1];
  int len;
 
  GetWindowText(hwnd, (char *)&title, TITLESIZE);
  if (title[0] == 0x00) return 1; /*continue the search....*/
 
  len = strlen(TTwainData.sourceId.ProductName);
  if (!len) return 0;
 
  len--;
 
  while (
      len &&
      (isdigit(TTwainData.sourceId.ProductName[len]) /*skip digit at the end*/
       || TTwainData.sourceId.ProductName[len] == '.')) /*skip . */
    len--;
 
  if (len && !strncmp(title, TTwainData.sourceId.ProductName, len)) {
    /*
char dbg_str[1024];
sprintf(dbg_str,"set focus on 0x%8x %s\n",hwnd, title);
OutputDebugString(dbg_str);
*/
    f = (MyFun *)lParam;
    f(hwnd);
 
    return FALSE; /*it means stop the search...*/
  }
  return 1; /*continue the search....*/
}
 
/*---------------------------------------------------------------------------*/
 
static BOOL CALLBACK myHackEnumFunction2(HWND hwnd, LPARAM lParam) {
  MyFun *f = 0;
  char *ptr;
 
#define TITLESIZE (1024)
  char title[TITLESIZE + 1];
 
  GetWindowText(hwnd, (char *)&title, TITLESIZE);
  if (title[0] == 0x00) return 1; /*continue the search....*/
 
  ptr = strstr(title, TTwainData.sourceId.Manufacturer);
  if (!ptr) return 1; /*continue the search....*/
 
  f = (MyFun *)lParam;
  f(hwnd);
 
  return FALSE; /*it means stop the search...*/
}
 
/*---------------------------------------------------------------------------*/
 
void bringToTop(HWND hwnd) { BringWindowToTop(hwnd); }
 
void putToBottom(HWND hwnd) {
  const int unused = 0;
 
  BOOL rc = SetWindowPos(hwnd,         // handle to window
                         HWND_BOTTOM,  // placement-order handle
                         unused,       // horizontal position
                         unused,       // vertical position
                         unused,       // width
                         unused,       // height
                         SWP_ASYNCWINDOWPOS | SWP_NOMOVE |
                             SWP_NOSIZE  // window-positioning options
                         );
}
 
static void myHackFunction(int v) {
  BOOL rc;
  if (v == 1)
    rc = EnumWindows((WNDENUMPROC)myHackEnumFunction, (LPARAM)&bringToTop);
  else
    rc = EnumWindows((WNDENUMPROC)myHackEnumFunction, (LPARAM)&putToBottom);
 
  if (rc) /* it means that myHackEnumFunction fails to find the proper window to
             bring up or put down*/
  {
    if (v == 1)
      rc = EnumWindows((WNDENUMPROC)myHackEnumFunction2, (LPARAM)&bringToTop);
    else
      rc = EnumWindows((WNDENUMPROC)myHackEnumFunction2, (LPARAM)&putToBottom);
  }
}
#else
static void myHackFunction(int v) { /*it's empty...*/
}
#endif
/*---------------------------------------------------------------------------*/
int TTWAIN_AcquireMemory(void *hwnd) {
  int rc                                    = FALSE;
  TTwainData.transferInfo.lastTransferWasOk = FALSE;
 
  if (TTwainData.transferInfo.transferMech != TTWAIN_TRANSFERMODE_MEMORY)
    return FALSE;
 
  myHackFunction(1);
 
  hwnd = TTWAIN_GetValidHwnd(hwnd);
  if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN) {
    if (!TTWAIN_OpenSourceManager(hwnd)) /* Bring up to state 4 */
    {
      TTWAIN_ErrorBox("Unable to open Source Manager (" DSM_FILENAME ")");
      return FALSE;
    }
    if (!TTWAIN_OpenDefaultSource())
      /*TTWAIN_ReportLastError("Unable to open default Data Source.");*/
      TTWAIN_RecordError();
    else
      assert(TTWAIN_GetState() == TWAIN_SOURCE_OPEN);
  }
 
  if (TTWAIN_GetState() >= TWAIN_SOURCE_OPEN)
    rc = TTWAIN_WaitForMemoryXfer(hwnd);
 
  if (!TTwainData.transferInfo.multiTransfer) {
    /* shut everything down in the right sequence */
    TTWAIN_AbortAllPendingXfers(); /* TRANSFER_READY or TRANSFERRING ->
                                      SOURCE_ENABLED */
    TTWAIN_UnloadSourceManager();
  }
 
  myHackFunction(0);
 
  return TTwainData.transferInfo.lastTransferWasOk;
}
/*---------------------------------------------------------------------------*/
void TTWAIN_StopAcquire(void) { TTwainData.transferInfo.oneAtLeast = FALSE; }
/*---------------------------------------------------------------------------*/
static void *TTWAIN_WaitForNativeXfer(void *hwnd) {
  TTwainData.transferInfo.hDib = NULL;
  if (TTWAIN_GetState() >= TWAIN_SOURCE_OPEN)
    TTWAIN_WaitForXfer(hwnd);
  else
    TTWAIN_ErrorBox("TWAIN_WaitForNativeXfer called in state < 4.");
  return TTwainData.transferInfo.hDib;
}
/*---------------------------------------------------------------------------*/
static int TTWAIN_WaitForMemoryXfer(void *hwnd) {
  int rc = FALSE;
  if (TTWAIN_GetState() >= TWAIN_SOURCE_OPEN)
    rc = TTWAIN_WaitForXfer(hwnd);
  else
    TTWAIN_ErrorBox("TWAIN_WaitForNativeXfer called in state < 4.");
  return rc;
}
/*---------------------------------------------------------------------------*/
static int TTWAIN_WaitForXfer(void *hwnd) {
  int bWasEnabled;
  int rc = FALSE;
  /* Make up a valid window if we weren't given one */
  hwnd = TTWAIN_GetValidHwnd(hwnd);
  /* Disable the parent window during the modal acquire */
  bWasEnabled = (TTWAIN_EnableWindow(hwnd, FALSE) == 0);
 
  TTwainData.transferInfo.oneAtLeast = TRUE;
  /*
TTWAIN_DS( DG_CONTROL,DAT_PENDINGXFERS, MSG_ENDXFER,
       (TW_MEMREF)&TTwainData.transferInfo.pendingXfers);
*/
  do {
    if (TTWAIN_GetState() == TWAIN_TRANSFER_READY)
      rc = TTWAIN_DoOneTransfer();
    else if (TTWAIN_GetState() >= TWAIN_SOURCE_ENABLED ||
             TTWAIN_EnableSource(hwnd)) {
      /* source is enabled, wait for transfer or source closed */
      if (TTwainData.resultCode != TWRC_CANCEL)
        TTWAIN_ModalEventLoop();
      else {
        TTWAIN_BreakModalLoop();
        break;
      }
    } else
      /*TTWAIN_ReportLastError("Failed to enable Data Source.");*/
      TTWAIN_RecordError();
  } while (TTwainData.transferInfo.pendingXfers.Count &&
           TTwainData.transferInfo.oneAtLeast /*&& rc*/);
 
  /* Re-enable the parent window if it was enabled */
  TTWAIN_EnableWindow(hwnd, bWasEnabled);
  return rc;
}
/*---------------------------------------------------------------------------*/
void TTWAIN_FreeMemory(void *hMem) {
  free(hMem);
  /*
if (hMem)
GLOBAL_FREE(hMem);
*/
}
/*---------------------------------------------------------------------------*/
static void TTWAIN_ModalEventLoop(void) { TTWAIN_ModalEventLoopPD(); }
/*---------------------------------------------------------------------------*/
static void TTWAIN_BreakModalLoop(void) { TTwainData.breakModalLoop = TRUE; }
/*---------------------------------------------------------------------------*/
static void TTWAIN_EmptyMessageQueue(void) { TTWAIN_EmptyMessageQueuePD(); }
/*---------------------------------------------------------------------------*/
static int TTWAIN_NativeXferHandler(void) {
  TW_UINT32 hNative;
 
  assert(TTWAIN_GetState() == TWAIN_TRANSFER_READY);
  if (TTWAIN_DS(DG_IMAGE, DAT_IMAGENATIVEXFER, MSG_GET, &hNative) ==
      TWRC_XFERDONE)
    TTwainData.transferInfo.hDib = (void *)hNative;
  else
    TTwainData.transferInfo.hDib = NULL;
  return (!!TTwainData.transferInfo.hDib);
}
/*---------------------------------------------------------------------------*/
static int TTWAIN_MemoryXferHandler(void) {
  TW_IMAGEMEMXFER *imageMemXfer = 0;
  TW_HANDLE imageMemXferH       = 0;
  TW_HANDLE transferBufferH     = 0;
  TW_SETUPMEMXFER setup;
  TW_IMAGEINFO info;
  TW_IMAGELAYOUT imageLayout;
  TUINT32 nTransferDone;
  TW_INT16 rc1, rc2, rc3, rc4, twRC2;
  int ret               = FALSE;
  int stopScanning      = 0;
  UCHAR *transferBuffer = 0;
  UCHAR *sourceBuffer   = 0;
  UCHAR *targetBuffer   = 0;
  unsigned int rows;
  double pixSize;
  int extraX              = 0;
  int extraY              = 0;
  TW_UINT32 rowsToCopy    = 0;
  TW_UINT32 rowsRemaining = 0;
  TW_UINT32 bytesToCopy   = 0;
  TW_UINT32 bytesToWrap   = 0;
  TW_UINT32 memorySize    = 0;
  int imgInfoOk; /* on Mac often (always) is impossible to get the imageinfo
                                                                           about
                    the transfer... so no I can't prealloc memory
                                                                           and
                    do other checks about size etc...
                                                                  */
 
  /*printf("%s\n", __PRETTY_FUNCTION__);*/
 
  memset(&info, 0, sizeof(TW_IMAGEINFO));
  rc1       = TTWAIN_DS(DG_IMAGE, DAT_IMAGEINFO, MSG_GET, (TW_MEMREF)&info);
  imgInfoOk = (rc1 == TWRC_SUCCESS);
 
  /*printf("get image info returns %d\n", imgInfoOk);*/
 
  rc4 = TTWAIN_DS(DG_IMAGE, DAT_IMAGELAYOUT, MSG_GET, &imageLayout);
 
  /* determine the transfer buffer size */
  rc2 = TTWAIN_DS(DG_CONTROL, DAT_SETUPMEMXFER, MSG_GET, (TW_MEMREF)&setup);
  transferBufferH = GLOBAL_ALLOC(GMEM_FIXED, setup.Preferred);
  if (!transferBufferH) return FALSE;
  transferBuffer = (UCHAR *)GLOBAL_LOCK(transferBufferH);
 
  if (imgInfoOk) {
    pixSize    = info.BitsPerPixel / 8.0;
    memorySize = info.ImageLength * CEIL(info.ImageWidth * pixSize);
  } else {
    /* we need to allocate incrementally the memory needs to store the image*/
    memorySize =
        setup.Preferred; /* start using the setupmemxfer.preferred size*/
    pixSize = 3;
  }
 
  if (TTwainData.transferInfo.usageMode == TTWAIN_MODE_UNLEASHED) {
    /*
TTwainData.transferInfo = GLOBAL_ALLOC(GMEM_FIXED, memorySize);
*/
    TTwainData.transferInfo.memoryBuffer = (UCHAR *)malloc(memorySize);
 
    if (!TTwainData.transferInfo.memoryBuffer) {
      /*tmsg_error("unable to allocate memory!");*/
      return FALSE;
    }
    if (imgInfoOk) {
      TTwainData.transferInfo.memorySize  = memorySize;
      TTwainData.transferInfo.preferredLx = info.ImageWidth;
      TTwainData.transferInfo.preferredLy = info.ImageLength;
    } else {
      TTwainData.transferInfo.memorySize  = setup.Preferred;
      TTwainData.transferInfo.preferredLx = 0;
      TTwainData.transferInfo.preferredLy = 0;
    }
  }
 
  extraX = info.ImageWidth - TTwainData.transferInfo.preferredLx;
  extraY = info.ImageLength - TTwainData.transferInfo.preferredLy;
 
  rowsRemaining = min(TTwainData.transferInfo.preferredLy, info.ImageLength);
 
  targetBuffer = TTwainData.transferInfo.memoryBuffer;
 
  /*clean-up the buffer
memset(targetBuffer, 0xff, TTwainData.transferInfo.memorySize);
*/
 
  imageMemXferH = GLOBAL_ALLOC(GMEM_FIXED, sizeof(TW_IMAGEMEMXFER));
  if (!imageMemXferH) return FALSE;
 
  imageMemXfer = (TW_IMAGEMEMXFER *)GLOBAL_LOCK(imageMemXferH);
 
  imageMemXfer->Memory.TheMem                = (char *)transferBuffer;
  imageMemXfer->Memory.Length                = setup.Preferred;
  imageMemXfer->Memory.Flags                 = TWMF_APPOWNS | TWMF_POINTER;
  TTwainData.transferInfo.pendingXfers.Count = 0;
  /* transfer the data -- loop until done or canceled */
  nTransferDone = 0;
  do {
    rc3 =
        TTWAIN_DS(DG_IMAGE, DAT_IMAGEMEMXFER, MSG_GET, (TW_MEMREF)imageMemXfer);
    nTransferDone++;
    switch (rc3) {
    case TWRC_SUCCESS:
      PRINTF("IMAGEMEMXFER, GET, returns SUCCESS\n");
      if (imgInfoOk) {
        TW_UINT32 colsToCopy;
        rowsToCopy = min(imageMemXfer->Rows, rowsRemaining);
        colsToCopy = min(imageMemXfer->Columns,
                         (unsigned long)TTwainData.transferInfo.preferredLx);
        bytesToCopy = CEIL(colsToCopy * pixSize);
        bytesToWrap = CEIL(TTwainData.transferInfo.preferredLx * pixSize);
      } else {
        TW_UINT32 newMemorySize;
        rowsToCopy  = imageMemXfer->Rows;
        bytesToCopy = imageMemXfer->BytesPerRow;
        bytesToWrap = bytesToCopy;
        newMemorySize =
            (TTwainData.transferInfo.preferredLy + imageMemXfer->Rows) *
            imageMemXfer->BytesPerRow;
        if (TTwainData.transferInfo.memorySize < newMemorySize) {
          TTwainData.transferInfo.memoryBuffer = (UCHAR *)realloc(
              TTwainData.transferInfo.memoryBuffer, newMemorySize);
          TTwainData.transferInfo.memorySize = newMemorySize;
          targetBuffer =
              TTwainData.transferInfo.memoryBuffer +
              (TTwainData.transferInfo.preferredLy * imageMemXfer->BytesPerRow);
        }
        TTwainData.transferInfo.preferredLy += rowsToCopy;
        if ((int)imageMemXfer->Columns > TTwainData.transferInfo.preferredLx)
          TTwainData.transferInfo.preferredLx = imageMemXfer->Columns;
      }
 
      sourceBuffer = (UCHAR *)imageMemXfer->Memory.TheMem;
      if (TTwainData.transferInfo.nextImageNeedsToBeInverted)
        INVERT_BYTE(sourceBuffer, bytesToCopy)
 
      for (rows = 0; rows < rowsToCopy; rows++) {
        memcpy(targetBuffer, sourceBuffer, bytesToCopy);
        targetBuffer += bytesToWrap;
        sourceBuffer += imageMemXfer->BytesPerRow;
      }
      rowsRemaining -= rowsToCopy;
      break;
 
    case TWRC_XFERDONE:
      PRINTF("IMAGEMEMXFER, GET, returns XFERDONE\n");
      /*copy the last transfer data*/
      if (imgInfoOk) {
        TW_UINT32 colsToCopy;
        rowsToCopy = min(imageMemXfer->Rows, rowsRemaining);
        colsToCopy = min(imageMemXfer->Columns,
                         (unsigned long)TTwainData.transferInfo.preferredLx);
        bytesToCopy = CEIL(colsToCopy * pixSize);
        bytesToWrap = CEIL(TTwainData.transferInfo.preferredLx * pixSize);
      } else {
        TW_UINT32 newMemorySize;
        rowsToCopy  = imageMemXfer->Rows;
        bytesToCopy = imageMemXfer->BytesPerRow;
        bytesToWrap = bytesToCopy;
        newMemorySize =
            (TTwainData.transferInfo.preferredLy + imageMemXfer->Rows) *
            imageMemXfer->BytesPerRow;
        if (TTwainData.transferInfo.memorySize < newMemorySize) {
          TTwainData.transferInfo.memoryBuffer = (UCHAR *)realloc(
              TTwainData.transferInfo.memoryBuffer, newMemorySize);
          TTwainData.transferInfo.memorySize = newMemorySize;
          targetBuffer =
              TTwainData.transferInfo.memoryBuffer +
              (TTwainData.transferInfo.preferredLy * imageMemXfer->BytesPerRow);
        }
        TTwainData.transferInfo.preferredLy += rowsToCopy;
        if ((int)imageMemXfer->Columns > TTwainData.transferInfo.preferredLx)
          TTwainData.transferInfo.preferredLx = imageMemXfer->Columns;
      }
      sourceBuffer = (UCHAR *)imageMemXfer->Memory.TheMem;
      if (TTwainData.transferInfo.nextImageNeedsToBeInverted)
        INVERT_BYTE(sourceBuffer, bytesToCopy)
 
      for (rows = 0; rows < rowsToCopy; rows++) {
        memcpy(targetBuffer, sourceBuffer, bytesToCopy);
        targetBuffer += bytesToWrap;
        sourceBuffer += imageMemXfer->BytesPerRow;
      }
      rowsRemaining -= rowsToCopy;
      PRINTF("get pending xfers\n");
      twRC2 = TTWAIN_DS(DG_CONTROL, DAT_PENDINGXFERS, MSG_ENDXFER,
                        (TW_MEMREF)&TTwainData.transferInfo.pendingXfers);
      if (twRC2 != TWRC_SUCCESS) {
        printf("pending xfers != success");
        ret = FALSE;
        goto done;
      }
      PRINTF(" pending count = %d\n",
             TTwainData.transferInfo.pendingXfers.Count);
      if (TTwainData.transferInfo.pendingXfers.Count == 0) {
        ret = TRUE;
        goto done;
      }
      if (TTwainData.transferInfo.pendingXfers.Count == 0xffff) {
        ret = TRUE;
        goto done;
      }
      if (TTwainData.transferInfo.pendingXfers.Count == 0xfffe) {
        ret = TRUE;
        goto done;
      }
      ret = TRUE;
      goto done;
 
    case TWRC_CANCEL:
      TTWAIN_RecordError();
      twRC2 = TTWAIN_DS(DG_CONTROL, DAT_PENDINGXFERS, MSG_ENDXFER,
                        (TW_MEMREF)&TTwainData.transferInfo.pendingXfers);
      if (twRC2 != TWRC_SUCCESS) {
        ret = FALSE;
        goto done;
      }
      if (TTwainData.transferInfo.pendingXfers.Count == 0) {
        ret = FALSE;
        goto done;
      }
      break;
 
    case TWRC_FAILURE:
      PRINTF("IMAGEMEMXFER, GET, returns FAILURE\n");
      TTWAIN_RecordError();
      twRC2 = TTWAIN_DS(DG_CONTROL, DAT_PENDINGXFERS, MSG_ENDXFER,
                        (TW_MEMREF)&TTwainData.transferInfo.pendingXfers);
      if (twRC2 != TWRC_SUCCESS) {
        ret = FALSE;
        goto done;
      }
      if (TTwainData.transferInfo.pendingXfers.Count == 0) {
        ret = FALSE;
        goto done;
      }
      break;
 
    default:
      PRINTF("IMAGEMEMXFER, GET, returns ?!? Default handler called\n");
      /* Abort the image */
      TTWAIN_RecordError();
      twRC2 = TTWAIN_DS(DG_CONTROL, DAT_PENDINGXFERS, MSG_ENDXFER,
                        (TW_MEMREF)&TTwainData.transferInfo.pendingXfers);
      if (twRC2 != TWRC_SUCCESS) {
        ret = FALSE;
        goto done;
      }
      if (TTwainData.transferInfo.pendingXfers.Count == 0) {
        ret = FALSE;
        goto done;
      }
    }
  } while (rc3 == TWRC_SUCCESS);
 
done:
  if (ret == TRUE) {
    if (TTwainData.callback.onDoneCb) {
      float xdpi, ydpi;
      TTWAIN_PIXTYPE pixType;
      xdpi = TTWAIN_Fix32ToFloat(info.XResolution);
      ydpi = TTWAIN_Fix32ToFloat(info.YResolution);
 
      if (imgInfoOk) {
        xdpi = TTWAIN_Fix32ToFloat(info.XResolution);
        ydpi = TTWAIN_Fix32ToFloat(info.YResolution);
        switch (BB(info.PixelType, info.BitsPerPixel)) {
        case BB(TWPT_BW, 1):
          pixType = TTWAIN_BW;
          break;
        case BB(TWPT_GRAY, 8):
          pixType = TTWAIN_GRAY8;
          break;
        case BB(TWPT_RGB, 24):
          pixType = TTWAIN_RGB24;
          break;
        default:
          pixType = TTWAIN_RGB24;
          break;
        }
      } else {
        float lx = TTWAIN_Fix32ToFloat(imageLayout.Frame.Right) -
                   TTWAIN_Fix32ToFloat(imageLayout.Frame.Left);
        float ly = TTWAIN_Fix32ToFloat(imageLayout.Frame.Bottom) -
                   TTWAIN_Fix32ToFloat(imageLayout.Frame.Top);
 
        xdpi = (float)TTwainData.transferInfo.preferredLx / lx;
        ydpi = (float)TTwainData.transferInfo.preferredLy / ly;
 
        switch (imageMemXfer->BytesPerRow /
                TTwainData.transferInfo.preferredLx) {
        case 1:
          pixType = TTWAIN_GRAY8;
          break;
        case 3:
          pixType = TTWAIN_RGB24;
          break;
        default: {
          double b = (imageMemXfer->BytesPerRow /
                      (double)TTwainData.transferInfo.preferredLx);
          if ((b >= 0.125) && (b < 8))
            pixType = TTWAIN_BW;
          else {
            printf("unable to det pix type assume RGB24\n");
            pixType = TTWAIN_RGB24;
          }
          break;
        }
        }
      }
      stopScanning = !TTwainData.callback.onDoneCb(
          TTwainData.transferInfo.memoryBuffer, pixType,
          TTwainData.transferInfo.preferredLx,
          TTwainData.transferInfo.preferredLy,
          TTwainData.transferInfo.preferredLx, xdpi, ydpi,
          TTwainData.callback.onDoneArg);
#ifdef MACOSX
      PRINTF("stopScanning = %d\n", stopScanning);
      exitTwainSession();
#endif
    }
  } else /*ret == FALSE*/
  {
    if (TTwainData.callback.onErrorCb) {
      TTwainData.callback.onErrorCb(TTwainData.callback.onErrorArg, 0);
    }
  }
 
  if (imageMemXferH) {
    GLOBAL_UNLOCK(imageMemXferH);
    GLOBAL_FREE(imageMemXferH);
  }
 
  if (transferBufferH) {
    GLOBAL_UNLOCK(transferBuffer);
    GLOBAL_FREE(transferBufferH);
  }
  return ret && !stopScanning;
}
/*---------------------------------------------------------------------------*/
int TTWAIN_InitVar(void) {
  char *c;
  if (TTwainData.initDone) return TRUE;
 
  TTwainData.DSM_Entry                  = 0;
  TTwainData.hwnd32SM                   = 0;
  TTwainData.twainAvailable             = AVAIABLE_DONTKNOW;
  TTwainData.breakModalLoop             = FALSE;
  TTwainData.UIStatus                   = FALSE;
  TTwainData.twainState                 = TWAIN_PRESESSION;
  TTwainData.transferInfo.hDib          = 0;
  TTwainData.transferInfo.multiTransfer = TRUE;
  TTwainData.supportedCaps              = 0;
  TTwainData.resultCode                 = 0;
  TTwainData.ErrRC                      = 0;
  TTwainData.ErrCC                      = 0;
  TTwainData.modalStatus                = FALSE;
  TTwainData.appId.Id                   = 0;
  TTWAIN_ConvertRevStrToRevNum(RELEASE_STR, &TTwainData.appId.Version.MajorNum,
                               &TTwainData.appId.Version.MinorNum);
  TTwainData.appId.Version.Language = TWLG_USA;
  TTwainData.appId.Version.Country  = TWCY_USA;
  strcpy((char *)TTwainData.appId.Version.Info, TITLEBAR_STR);
 
  TTwainData.appId.ProtocolMajor   = TWON_PROTOCOLMAJOR;
  TTwainData.appId.ProtocolMinor   = TWON_PROTOCOLMINOR;
  TTwainData.appId.SupportedGroups = DG_IMAGE | DG_CONTROL;
 
  c = (char *)TTwainData.appId.Manufacturer;
#ifdef MACOSX
  *c = strlen(COMPANY);
  c++;
#endif
  strcpy(c, COMPANY);
 
  c = (char *)TTwainData.appId.ProductFamily;
#ifdef MACOSX
  *c = strlen(PRODUCT);
  c++;
#endif
  strcpy(c, PRODUCT);
 
  c = (char *)TTwainData.appId.ProductName;
#ifdef MACOSX
  *c = strlen(TwProgramName);
  c++;
#endif
  strcpy(c, TwProgramName);
 
  TTwainData.initDone = TRUE;
  return TRUE;
}
/*---------------------------------------------------------------------------*/
static void TTWAIN_FreeVar(void) {
  if (TTwainData.supportedCaps) {
    /* MEMORY LEAK !
GLOBAL_FREE(TTwainData.supportedCaps);
*/
    TTwainData.supportedCaps = 0;
  }
}
/*---------------------------------------------------------------------------*/
 
#ifdef __cplusplus
}
#endif