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