#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