#ifdef WIN32

#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 CASE \

	break;   \

	case

#define DEFAULT \

	break;      \

	default

#define RELEASE_STR "5.1"

#define TITLEBAR_STR "Toonz5.1"

#define TwProgramName "Toonz5.1"

#define COMPANY "Digital Video"

#define PRODUCT "TOONZ"

#define MIN(A, B) (((A) < (B)) ? (A) : (B))

#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)

{