#ifdef _MSC_VER

#pragma warning(disable : 4996)

#endif

#define TTWAINLIB_MAIN

#include <assert.h></assert.h>

#include <string.h></string.h>

#include <stdlib.h></stdlib.h>

#include <ctype.h></ctype.h>

#include <stdio.h></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))

#ifndef _WIN32

#define PRINTF(args...)

#else

#define PRINTF

#endif

/*---------------------------------------------------------------------------*/

/* 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];

    snprintf(msg, sizeof(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];

      snprintf(msg, sizeof(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];

snprintf(dbg_str, sizeof(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...*/

}

/*---------------------------------------------------------------------------*/

static void bringToTop(HWND hwnd) { BringWindowToTop(hwnd); }

static 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);