1 /* 2 * TWAIN32 Source Manager 3 * 4 * Copyright 2000 Corel Corporation 5 * Copyright 2006 Marcus Meissner 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 20 */ 21 22 #include "twain_i.h" 23 24 #include <winuser.h> 25 26 #include "resource.h" 27 28 static TW_UINT16 DSM_initialized; /* whether Source Manager is initialized */ 29 static TW_UINT32 DSM_sourceId; /* source id generator */ 30 static TW_UINT16 DSM_currentDevice; /* keep track of device during enumeration */ 31 static HWND DSM_parent; 32 static UINT event_message; 33 34 struct all_devices { 35 char *modname; 36 TW_IDENTITY identity; 37 }; 38 39 static int nrdevices = 0; 40 static struct all_devices *devices = NULL; 41 42 static void 43 twain_add_onedriver(const char *dsname) { 44 HMODULE hmod; 45 DSENTRYPROC dsEntry; 46 TW_IDENTITY fakeOrigin; 47 TW_IDENTITY sourceId; 48 TW_UINT16 ret; 49 50 hmod = LoadLibraryA(dsname); 51 if (!hmod) { 52 ERR("Failed to load TWAIN Source %s\n", dsname); 53 return; 54 } 55 dsEntry = (DSENTRYPROC)GetProcAddress(hmod, "DS_Entry"); 56 if (!dsEntry) { 57 ERR("Failed to find DS_Entry() in TWAIN DS %s\n", dsname); 58 return; 59 } 60 /* Loop to do multiple detects, mostly for sane.ds and gphoto2.ds */ 61 do { 62 int i; 63 64 sourceId.Id = DSM_sourceId; 65 sourceId.ProtocolMajor = TWON_PROTOCOLMAJOR; 66 sourceId.ProtocolMinor = TWON_PROTOCOLMINOR; 67 ret = dsEntry (&fakeOrigin, DG_CONTROL, DAT_IDENTITY, MSG_GET, &sourceId); 68 if (ret != TWRC_SUCCESS) { 69 ERR("Source->(DG_CONTROL,DAT_IDENTITY,MSG_GET) failed!\n"); 70 break; 71 } 72 TRACE("Manufacturer: %s\n", debugstr_a(sourceId.Manufacturer)); 73 TRACE("ProductFamily: %s\n", debugstr_a(sourceId.ProductFamily)); 74 TRACE("ProductName: %s\n", debugstr_a(sourceId.ProductName)); 75 76 for (i=0;i<nrdevices;i++) { 77 if (!strcmp(sourceId.ProductName,devices[i].identity.ProductName)) 78 break; 79 } 80 if (i < nrdevices) 81 break; 82 if (nrdevices) 83 devices = HeapReAlloc(GetProcessHeap(), 0, devices, sizeof(devices[0])*(nrdevices+1)); 84 else 85 devices = HeapAlloc(GetProcessHeap(), 0, sizeof(devices[0])); 86 if ((devices[nrdevices].modname = HeapAlloc(GetProcessHeap(), 0, strlen(dsname) + 1))) 87 lstrcpyA(devices[nrdevices].modname, dsname); 88 devices[nrdevices].identity = sourceId; 89 nrdevices++; 90 DSM_sourceId++; 91 } while (1); 92 FreeLibrary (hmod); 93 } 94 95 static BOOL detectionrun = FALSE; 96 97 static void 98 twain_autodetect(void) { 99 if (detectionrun) return; 100 detectionrun = TRUE; 101 102 twain_add_onedriver("sane.ds"); 103 twain_add_onedriver("gphoto2.ds"); 104 #if 0 105 twain_add_onedriver("c:\\windows\\Twain_32\\Largan\\sp503a.ds"); 106 twain_add_onedriver("c:\\windows\\Twain_32\\vivicam10\\vivicam10.ds"); 107 twain_add_onedriver("c:\\windows\\Twain_32\\ws30slim\\sp500a.ds"); 108 #endif 109 } 110 111 /* DG_CONTROL/DAT_NULL/MSG_CLOSEDSREQ|MSG_DEVICEEVENT|MSG_XFERREADY */ 112 TW_UINT16 TWAIN_ControlNull (pTW_IDENTITY pOrigin, pTW_IDENTITY pDest, activeDS *pSource, TW_UINT16 MSG, TW_MEMREF pData) 113 { 114 struct pending_message *message; 115 116 TRACE ("DG_CONTROL/DAT_NULL MSG=%i\n", MSG); 117 118 if (MSG != MSG_CLOSEDSREQ && 119 MSG != MSG_DEVICEEVENT && 120 MSG != MSG_XFERREADY) 121 { 122 DSM_twCC = TWCC_BADPROTOCOL; 123 return TWRC_FAILURE; 124 } 125 126 message = HeapAlloc(GetProcessHeap(), 0, sizeof(*message)); 127 if (!message) 128 { 129 DSM_twCC = TWCC_LOWMEMORY; 130 return TWRC_FAILURE; 131 } 132 133 message->msg = MSG; 134 list_add_tail(&pSource->pending_messages, &message->entry); 135 136 /* Delphi twain only sends us messages from one window, and it 137 doesn't even give us the real handle to that window. Other 138 applications might decide to forward messages sent to DSM_parent 139 or to the one supplied to ENABLEDS. So let's try very hard to 140 find a window that will work. */ 141 if (DSM_parent) 142 PostMessageW(DSM_parent, event_message, 0, 0); 143 if (pSource->ui_window && pSource->ui_window != DSM_parent) 144 PostMessageW(pSource->ui_window, event_message, 0, 0); 145 if (pSource->event_window && pSource->event_window != pSource->ui_window && 146 pSource->event_window != DSM_parent) 147 PostMessageW(pSource->event_window, event_message, 0, 0); 148 PostMessageW(0, event_message, 0, 0); 149 150 return TWRC_SUCCESS; 151 } 152 153 /* Filters MSG_PROCESSEVENT messages before reaching the data source */ 154 TW_UINT16 TWAIN_ProcessEvent (pTW_IDENTITY pOrigin, activeDS *pSource, TW_MEMREF pData) 155 { 156 TW_EVENT *event = (TW_EVENT*)pData; 157 MSG *msg = (MSG*)event->pEvent; 158 TW_UINT16 result = TWRC_NOTDSEVENT; 159 160 TRACE("%x,%x\n", msg->message, event_message); 161 162 if (msg->message == event_message) 163 { 164 if (!list_empty (&pSource->pending_messages)) 165 { 166 struct list *entry = list_head (&pSource->pending_messages); 167 struct pending_message *message = LIST_ENTRY(entry, struct pending_message, entry); 168 event->TWMessage = message->msg; 169 list_remove (entry); 170 TRACE("<-- %x\n", event->TWMessage); 171 } 172 else 173 event->TWMessage = MSG_NULL; 174 result = TWRC_DSEVENT; 175 } 176 177 if (msg->hwnd) 178 { 179 MSG dummy; 180 pSource->event_window = msg->hwnd; 181 if (!list_empty (&pSource->pending_messages) && 182 !PeekMessageW(&dummy, msg->hwnd, event_message, event_message, PM_NOREMOVE)) 183 { 184 PostMessageW(msg->hwnd, event_message, 0, 0); 185 } 186 } 187 188 return result; 189 } 190 191 /* DG_CONTROL/DAT_IDENTITY/MSG_CLOSEDS */ 192 TW_UINT16 TWAIN_CloseDS (pTW_IDENTITY pOrigin, TW_MEMREF pData) 193 { 194 TW_UINT16 twRC = TWRC_SUCCESS; 195 pTW_IDENTITY pIdentity = (pTW_IDENTITY) pData; 196 activeDS *currentDS = NULL, *prevDS = NULL; 197 198 TRACE ("DG_CONTROL/DAT_IDENTITY/MSG_CLOSEDS\n"); 199 200 for (currentDS = activeSources; currentDS; currentDS = currentDS->next) { 201 if (currentDS->identity.Id == pIdentity->Id) 202 break; 203 prevDS = currentDS; 204 } 205 if (!currentDS) { 206 DSM_twCC = TWCC_NODS; 207 return TWRC_FAILURE; 208 } 209 twRC = currentDS->dsEntry (pOrigin, DG_CONTROL, DAT_IDENTITY, MSG_CLOSEDS, pData); 210 /* This causes crashes due to still open Windows, so leave out for now. 211 * FreeLibrary (currentDS->hmod); 212 */ 213 if (prevDS) 214 prevDS->next = currentDS->next; 215 else 216 activeSources = currentDS->next; 217 HeapFree (GetProcessHeap(), 0, currentDS); 218 if (twRC == TWRC_SUCCESS) 219 DSM_twCC = TWCC_SUCCESS; 220 else /* FIXME: unclear how to get TWCC */ 221 DSM_twCC = TWCC_SEQERROR; 222 return twRC; 223 } 224 225 /* DG_CONTROL/DAT_IDENTITY/MSG_GETDEFAULT */ 226 TW_UINT16 TWAIN_IdentityGetDefault (pTW_IDENTITY pOrigin, TW_MEMREF pData) 227 { 228 pTW_IDENTITY pSourceIdentity = (pTW_IDENTITY) pData; 229 230 TRACE("DG_CONTROL/DAT_IDENTITY/MSG_GETDEFAULT\n"); 231 DSM_twCC = TWCC_NODS; 232 twain_autodetect(); 233 if (!nrdevices) 234 return TWRC_FAILURE; 235 *pSourceIdentity = devices[0].identity; 236 DSM_twCC = TWCC_SUCCESS; 237 return TWRC_SUCCESS; 238 } 239 240 /* DG_CONTROL/DAT_IDENTITY/MSG_GETFIRST */ 241 TW_UINT16 TWAIN_IdentityGetFirst (pTW_IDENTITY pOrigin, TW_MEMREF pData) 242 { 243 pTW_IDENTITY pSourceIdentity = (pTW_IDENTITY) pData; 244 245 TRACE ("DG_CONTROL/DAT_IDENTITY/MSG_GETFIRST\n"); 246 twain_autodetect(); 247 if (!nrdevices) { 248 TRACE ("no entries found.\n"); 249 DSM_twCC = TWCC_NODS; 250 return TWRC_FAILURE; 251 } 252 DSM_currentDevice = 0; 253 *pSourceIdentity = devices[DSM_currentDevice++].identity; 254 return TWRC_SUCCESS; 255 } 256 257 /* DG_CONTROL/DAT_IDENTITY/MSG_GETNEXT */ 258 TW_UINT16 TWAIN_IdentityGetNext (pTW_IDENTITY pOrigin, TW_MEMREF pData) 259 { 260 pTW_IDENTITY pSourceIdentity = (pTW_IDENTITY) pData; 261 262 TRACE("DG_CONTROL/DAT_IDENTITY/MSG_GETNEXT\n"); 263 if (!nrdevices || (DSM_currentDevice == nrdevices)) { 264 DSM_twCC = TWCC_SUCCESS; 265 return TWRC_ENDOFLIST; 266 } 267 *pSourceIdentity = devices[DSM_currentDevice++].identity; 268 return TWRC_SUCCESS; 269 } 270 271 /* DG_CONTROL/DAT_IDENTITY/MSG_OPENDS */ 272 TW_UINT16 TWAIN_OpenDS (pTW_IDENTITY pOrigin, TW_MEMREF pData) 273 { 274 TW_UINT16 i = 0; 275 pTW_IDENTITY pIdentity = (pTW_IDENTITY) pData; 276 activeDS *newSource; 277 const char *modname = NULL; 278 HMODULE hmod; 279 280 TRACE("DG_CONTROL/DAT_IDENTITY/MSG_OPENDS\n"); 281 TRACE("pIdentity is %s\n", pIdentity->ProductName); 282 if (!DSM_initialized) { 283 FIXME("seq error\n"); 284 DSM_twCC = TWCC_SEQERROR; 285 return TWRC_FAILURE; 286 } 287 twain_autodetect(); 288 if (!nrdevices) { 289 FIXME("no devs.\n"); 290 DSM_twCC = TWCC_NODS; 291 return TWRC_FAILURE; 292 } 293 294 if (pIdentity->ProductName[0] != '\0') { 295 /* Make sure the source to be opened exists in the device list */ 296 for (i = 0; i<nrdevices; i++) 297 if (!strcmp (devices[i].identity.ProductName, pIdentity->ProductName)) 298 break; 299 if (i == nrdevices) 300 i = 0; 301 } /* else use the first device */ 302 303 /* the source is found in the device list */ 304 newSource = HeapAlloc (GetProcessHeap(), 0, sizeof (activeDS)); 305 if (!newSource) { 306 DSM_twCC = TWCC_LOWMEMORY; 307 FIXME("Out of memory.\n"); 308 return TWRC_FAILURE; 309 } 310 hmod = LoadLibraryA(devices[i].modname); 311 if (!hmod) { 312 ERR("Failed to load TWAIN Source %s\n", modname); 313 DSM_twCC = TWCC_OPERATIONERROR; 314 HeapFree(GetProcessHeap(), 0, newSource); 315 return TWRC_FAILURE; 316 } 317 newSource->hmod = hmod; 318 newSource->dsEntry = (DSENTRYPROC)GetProcAddress(hmod, "DS_Entry"); 319 /* Assign id for the opened data source */ 320 pIdentity->Id = DSM_sourceId ++; 321 if (TWRC_SUCCESS != newSource->dsEntry (pOrigin, DG_CONTROL, DAT_IDENTITY, MSG_OPENDS, pIdentity)) { 322 DSM_twCC = TWCC_OPERATIONERROR; 323 HeapFree(GetProcessHeap(), 0, newSource); 324 DSM_sourceId--; 325 return TWRC_FAILURE; 326 } 327 /* add the data source to an internal active source list */ 328 newSource->next = activeSources; 329 newSource->identity.Id = pIdentity->Id; 330 strcpy (newSource->identity.ProductName, pIdentity->ProductName); 331 list_init(&newSource->pending_messages); 332 newSource->ui_window = NULL; 333 newSource->event_window = NULL; 334 activeSources = newSource; 335 DSM_twCC = TWCC_SUCCESS; 336 return TWRC_SUCCESS; 337 } 338 339 typedef struct { 340 pTW_IDENTITY origin; 341 pTW_IDENTITY result; 342 } userselect_data; 343 344 static INT_PTR CALLBACK userselect_dlgproc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) 345 { 346 switch (msg) 347 { 348 case WM_INITDIALOG: 349 { 350 userselect_data *data = (userselect_data*)lparam; 351 int i; 352 HWND sourcelist; 353 BOOL any_devices = FALSE; 354 355 SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR)data); 356 357 sourcelist = GetDlgItem(hwnd, IDC_LISTSOURCE); 358 359 for (i=0; i<nrdevices; i++) 360 { 361 TW_IDENTITY *id = &devices[i].identity; 362 LRESULT index; 363 364 if ((id->SupportedGroups & data->origin->SupportedGroups) == 0) 365 continue; 366 367 index = SendMessageA(sourcelist, LB_ADDSTRING, 0, (LPARAM)id->ProductName); 368 SendMessageW(sourcelist, LB_SETITEMDATA, (WPARAM)index, (LPARAM)i); 369 any_devices = TRUE; 370 } 371 372 if (any_devices) 373 { 374 EnableWindow(GetDlgItem(hwnd, IDOK), TRUE); 375 376 /* FIXME: Select the supplied product name or default source. */ 377 SendMessageW(sourcelist, LB_SETCURSEL, 0, 0); 378 } 379 380 return TRUE; 381 } 382 case WM_CLOSE: 383 EndDialog(hwnd, 0); 384 return TRUE; 385 case WM_COMMAND: 386 if (wparam == MAKEWPARAM(IDCANCEL, BN_CLICKED)) 387 { 388 EndDialog(hwnd, 0); 389 return TRUE; 390 } 391 else if (wparam == MAKEWPARAM(IDOK, BN_CLICKED) || 392 wparam == MAKEWPARAM(IDC_LISTSOURCE, LBN_DBLCLK)) 393 { 394 userselect_data *data = (userselect_data*)GetWindowLongPtrW(hwnd, DWLP_USER); 395 HWND sourcelist; 396 LRESULT index; 397 398 sourcelist = GetDlgItem(hwnd, IDC_LISTSOURCE); 399 400 index = SendMessageW(sourcelist, LB_GETCURSEL, 0, 0); 401 402 if (index == LB_ERR) 403 return TRUE; 404 405 index = SendMessageW(sourcelist, LB_GETITEMDATA, (WPARAM)index, 0); 406 407 *data->result = devices[index].identity; 408 409 /* FIXME: Save this as the default source */ 410 411 EndDialog(hwnd, 1); 412 return TRUE; 413 } 414 break; 415 } 416 return FALSE; 417 } 418 419 /* DG_CONTROL/DAT_IDENTITY/MSG_USERSELECT */ 420 TW_UINT16 TWAIN_UserSelect (pTW_IDENTITY pOrigin, TW_MEMREF pData) 421 { 422 userselect_data param = {pOrigin, pData}; 423 HWND parent = DSM_parent; 424 425 TRACE("DG_CONTROL/DAT_IDENTITY/MSG_USERSELECT SupportedGroups=0x%x ProductName=%s\n", 426 pOrigin->SupportedGroups, wine_dbgstr_a(param.result->ProductName)); 427 428 twain_autodetect(); 429 430 if (!IsWindow(parent)) 431 parent = NULL; 432 433 if (DialogBoxParamW(DSM_hinstance, MAKEINTRESOURCEW(DLG_USERSELECT), 434 parent, userselect_dlgproc, (LPARAM)¶m) == 0) 435 { 436 TRACE("canceled\n"); 437 DSM_twCC = TWCC_SUCCESS; 438 return TWRC_CANCEL; 439 } 440 441 TRACE("<-- %s\n", wine_dbgstr_a(param.result->ProductName)); 442 DSM_twCC = TWCC_SUCCESS; 443 return TWRC_SUCCESS; 444 } 445 446 /* DG_CONTROL/DAT_PARENT/MSG_CLOSEDSM */ 447 TW_UINT16 TWAIN_CloseDSM (pTW_IDENTITY pOrigin, TW_MEMREF pData) 448 { 449 activeDS *currentDS = activeSources, *nextDS; 450 451 TRACE("DG_CONTROL/DAT_PARENT/MSG_CLOSEDSM\n"); 452 453 if (DSM_initialized) 454 { 455 DSM_initialized = FALSE; 456 457 /* If there are data sources still open, close them now. */ 458 while (currentDS != NULL) 459 { 460 nextDS = currentDS->next; 461 currentDS->dsEntry (pOrigin, DG_CONTROL, DAT_IDENTITY, MSG_CLOSEDS, pData); 462 HeapFree (GetProcessHeap(), 0, currentDS); 463 currentDS = nextDS; 464 } 465 activeSources = NULL; 466 DSM_parent = NULL; 467 DSM_twCC = TWCC_SUCCESS; 468 return TWRC_SUCCESS; 469 } else { 470 DSM_twCC = TWCC_SEQERROR; 471 return TWRC_FAILURE; 472 } 473 } 474 475 /* DG_CONTROL/DAT_PARENT/MSG_OPENDSM */ 476 TW_UINT16 TWAIN_OpenDSM (pTW_IDENTITY pOrigin, TW_MEMREF pData) 477 { 478 TW_UINT16 twRC = TWRC_SUCCESS; 479 480 TRACE("DG_CONTROL/DAT_PARENT/MSG_OPENDSM\n"); 481 if (!DSM_initialized) { 482 event_message = RegisterWindowMessageA("WINE TWAIN_32 EVENT"); 483 DSM_currentDevice = 0; 484 DSM_initialized = TRUE; 485 DSM_twCC = TWCC_SUCCESS; 486 twRC = TWRC_SUCCESS; 487 } else { 488 /* operation invoked in invalid state */ 489 DSM_twCC = TWCC_SEQERROR; 490 twRC = TWRC_FAILURE; 491 } 492 DSM_parent = (HWND)pData; 493 return twRC; 494 } 495 496 /* DG_CONTROL/DAT_STATUS/MSG_GET */ 497 TW_UINT16 TWAIN_GetDSMStatus (pTW_IDENTITY pOrigin, TW_MEMREF pData) 498 { 499 pTW_STATUS pSourceStatus = (pTW_STATUS) pData; 500 501 TRACE ("DG_CONTROL/DAT_STATUS/MSG_GET\n"); 502 503 pSourceStatus->ConditionCode = DSM_twCC; 504 DSM_twCC = TWCC_SUCCESS; /* clear the condition code */ 505 return TWRC_SUCCESS; 506 } 507