source: trunk/src/winspool/winspool.cpp@ 4792

Last change on this file since 4792 was 4594, checked in by sandervl, 25 years ago

Partially implemented EnumPrintersA + call Open32 for DeviceCapabilitiesA/W
File size: 100.6 KB
Line 
1/* $Id: winspool.cpp,v 1.5 2000-11-15 10:54:24 sandervl Exp $ */
2
3/*
4 *
5 * Project Odin Software License can be found in LICENSE.TXT
6 *
7 * WINSPOOL stubs
8 *
9 * Copyright 1998 Patrick Haller
10 * Copyright 2000 Sander van Leeuwen (sandervl@xs4all.nl)
11 *
12 *
13 * Partially based on Wine code (dlls\winspool\info.c (EnumPrinters, DeviceCapabilitiesA/W)
14 *
15 * Copyright 1996 John Harvey
16 * Copyright 1998 Andreas Mohr
17 * Copyright 1999 Klaas van Gend
18 * Copyright 1999, 2000 Huw D M Davies
19 *
20 * TODO: far from complete (although the Spl API seems to provide everything we need!)
21 *
22 */
23
24/****************************************************************************
25 * Includes *
26 ****************************************************************************/
27
28#include <os2win.h>
29#include <winspool.h>
30#include <odinwrap.h>
31#include <heapstring.h>
32#include <win\winnls.h>
33
34#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
37#include <misc.h>
38#include "oslibspl.h"
39
40ODINDEBUGCHANNEL(WINSPOOL)
41
42
43/*****************************************************************************
44 * Name : BOOL EnumPrintersA
45 * Purpose :
46 * Parameters:
47 * Variables :
48 * Result :
49 * Remark :
50 * Status :
51 *
52 * Author : SvL
53 *****************************************************************************/
54
55ODINFUNCTION7(BOOL, EnumPrintersA,
56 DWORD, dwType,
57 LPTSTR, lpszName,
58 DWORD, dwLevel,
59 LPBYTE, lpbPrinters,
60 DWORD, cbBuf,
61 LPDWORD, lpdwNeeded,
62 LPDWORD, lpdwReturned)
63{
64 ULONG cReturned, cTotal, cbNeeded, flType;
65 int used, nameoff;
66 OSLIB_PRINTERINFO *printerInfo;
67 PRINTER_INFO_1A *pi1;
68 PRINTER_INFO_2A *pi2;
69 PRINTER_INFO_4A *pi4;
70 PRINTER_INFO_5A *pi5;
71 LPSTR lpszPrinterStrings;
72
73 if(lpbPrinters)
74 memset(lpbPrinters, 0, cbBuf);
75
76 if(lpdwReturned)
77 *lpdwReturned = 0;
78
79 if (!((dwType & PRINTER_ENUM_LOCAL) || (dwType & PRINTER_ENUM_NAME)))
80 {
81 dprintf(("Invalid parameters !(PRINTER_ENUM_LOCAL & PRINTER_ENUM_NAME)!!"));
82 SetLastError(ERROR_INVALID_FLAGS);
83 return FALSE;
84 }
85
86 if(lpszName) {//TODO:
87 dprintf(("remote printer enumeration not (yet) supported!!"));
88 flType = OSLIB_SPL_PR_ALL;
89 }
90 else flType = OSLIB_SPL_PR_LOCAL_ONLY | OSLIB_SPL_PR_ALL;
91
92 if(OSLibSplEnumPrinters(flType, NULL, 0, &cReturned, &cTotal, &cbNeeded) == FALSE) {
93 SetLastError(ERROR_FILE_NOT_FOUND); //todo wrong error
94 return FALSE;
95 }
96 if(cTotal == 0) {//no printers installed
97 SetLastError(ERROR_SUCCESS);
98 return TRUE;
99 }
100
101 switch(dwLevel) {
102 case 1:
103 used = cTotal * sizeof(PRINTER_INFO_1A);
104 break;
105
106 case 2:
107 used = cTotal * sizeof(PRINTER_INFO_2A);
108 break;
109
110 case 4:
111 used = cTotal * sizeof(PRINTER_INFO_4A);
112 break;
113
114 case 5:
115 used = cTotal * sizeof(PRINTER_INFO_5A);
116 break;
117
118 default:
119 dprintf(("ERROR: EnumPrintersA: Unknown level %d!", dwLevel));
120 SetLastError(ERROR_INVALID_LEVEL);
121 return FALSE;
122 }
123 nameoff = used;
124 used += cbNeeded; //add size of printer names
125
126 if(used > cbBuf) {
127 if(lpdwNeeded)
128 *lpdwNeeded = used;
129 SetLastError(ERROR_INSUFFICIENT_BUFFER);
130 return FALSE;
131 }
132
133 printerInfo = (OSLIB_PRINTERINFO *)malloc(cbNeeded);
134 if(OSLibSplEnumPrinters(flType, printerInfo, cbNeeded, &cReturned, &cTotal, &cbNeeded) == FALSE) {
135 free(printerInfo);
136 SetLastError(ERROR_FILE_NOT_FOUND);
137 return FALSE;
138 }
139 lpszPrinterStrings = (char *)lpbPrinters + nameoff;
140
141 for(int i=0;i<cReturned;i++) {
142 switch(dwLevel) {
143 case 1:
144 pi1 = (PRINTER_INFO_1A *)lpbPrinters;
145 lpbPrinters += sizeof(PRINTER_INFO_1A);
146
147 pi1->Flags = PRINTER_ENUM_ICON8;
148 pi1->pName = lpszPrinterStrings;
149 strcpy(lpszPrinterStrings, printerInfo[i].pszPrintDestinationName);
150 lpszPrinterStrings += strlen(printerInfo[i].pszPrintDestinationName)+1;
151
152 if(printerInfo[i].pszDescription) {
153 pi1->pDescription = lpszPrinterStrings;
154 strcpy(lpszPrinterStrings, printerInfo[i].pszDescription);
155 lpszPrinterStrings += strlen(printerInfo[i].pszDescription)+1;
156 }
157 //pComment empty
158 break;
159
160 case 2:
161 pi2 = (PRINTER_INFO_2A *)lpbPrinters;
162 lpbPrinters += sizeof(PRINTER_INFO_2A);
163
164 pi2->pPrinterName = lpszPrinterStrings;
165 strcpy(lpszPrinterStrings, printerInfo[i].pszPrintDestinationName);
166 lpszPrinterStrings += strlen(printerInfo[i].pszPrintDestinationName)+1;
167 pi2->pDriverName = pi2->pPrinterName; //TODO:might not be correct!
168
169 if(printerInfo[i].pszLocalName) {
170 pi2->pPortName = lpszPrinterStrings;
171 strcpy(lpszPrinterStrings, printerInfo[i].pszLocalName);
172 lpszPrinterStrings += strlen(printerInfo[i].pszLocalName)+1;
173 }
174
175 if(printerInfo[i].pszComputerName) {
176 pi2->pServerName = lpszPrinterStrings;
177 strcpy(lpszPrinterStrings, printerInfo[i].pszComputerName);
178 lpszPrinterStrings += strlen(printerInfo[i].pszComputerName)+1;
179 }
180
181 pi2->Attributes = PRINTER_ATTRIBUTE_QUEUED; //todo
182
183 dprintf(("EnumPrinters level 2 NOT COMPLETE!!"));
184 //todo not complete
185 break;
186
187 case 4:
188 pi4 = (PRINTER_INFO_4A *)lpbPrinters;
189 lpbPrinters += sizeof(PRINTER_INFO_4A);
190
191 pi4->Attributes = PRINTER_ATTRIBUTE_QUEUED; //todo
192 pi4->pPrinterName = lpszPrinterStrings;
193 strcpy(lpszPrinterStrings, printerInfo[i].pszPrintDestinationName);
194 lpszPrinterStrings += strlen(printerInfo[i].pszPrintDestinationName)+1;
195
196 if(printerInfo[i].pszComputerName) {
197 pi4->pServerName = lpszPrinterStrings;
198 strcpy(lpszPrinterStrings, printerInfo[i].pszComputerName);
199 lpszPrinterStrings += strlen(printerInfo[i].pszComputerName)+1;
200 }
201 dprintf(("EnumPrinters level 4 NOT COMPLETE!!"));
202 break;
203
204 case 5:
205 pi5 = (PRINTER_INFO_5A *)lpbPrinters;
206 lpbPrinters += sizeof(PRINTER_INFO_5A);
207
208 pi5->Attributes = PRINTER_ATTRIBUTE_QUEUED; //todo
209 pi5->pPrinterName = lpszPrinterStrings;
210 strcpy(lpszPrinterStrings, printerInfo[i].pszPrintDestinationName);
211 lpszPrinterStrings += strlen(printerInfo[i].pszPrintDestinationName)+1;
212
213 if(printerInfo[i].pszLocalName) {
214 pi5->pPortName = lpszPrinterStrings;
215 strcpy(lpszPrinterStrings, printerInfo[i].pszLocalName);
216 lpszPrinterStrings += strlen(printerInfo[i].pszLocalName)+1;
217 }
218 dprintf(("EnumPrinters level 5 NOT COMPLETE!!"));
219 break;
220 }
221 }
222 free(printerInfo);
223
224 if(lpdwNeeded)
225 *lpdwNeeded = used;
226
227 if(lpdwReturned)
228 *lpdwReturned = cReturned;
229 SetLastError(ERROR_SUCCESS);
230 return TRUE;
231}
232
233
234/*****************************************************************************
235 * Name : BOOL ClosePrinter
236 * Purpose :
237 * Parameters:
238 * Variables :
239 * Result :
240 * Remark :
241 * Status : UNTESTED STUB
242 *
243 * Author : Markus Montkowski [09.07.98 13:39:08]
244 *****************************************************************************/
245
246ODINFUNCTION1(BOOL, ClosePrinter,
247 HANDLE, hPrinter)
248{
249 dprintf(("ClosePrinter, not implemented\n"));
250 return(TRUE);
251}
252
253
254/*****************************************************************************
255 * Name : BOOL OpenPrinterA
256 * Purpose :
257 * Parameters:
258 * Variables :
259 * Result :
260 * Remark :
261 * Status : UNTESTED STUB
262 *
263 * Author : Markus Montkowski [09.07.98 13:39:08]
264 *****************************************************************************/
265
266ODINFUNCTION3(BOOL, OpenPrinterA,
267 LPSTR, pPrinterName,
268 HANDLE *, phPrinter,
269 PRINTER_DEFAULTSA *, pDefault)
270{
271 dprintf(("OpenPrinterA, not implemented\n"));
272 return(FALSE);
273}
274
275
276/*****************************************************************************
277 * Name : LONG DocumentPropertiesA
278 * Purpose :
279 * Parameters:
280 * Variables :
281 * Result :
282 * Remark :
283 * Status : UNTESTED STUB
284 *
285 * Author : Markus Montkowski [09.07.98 13:39:08]
286 *****************************************************************************/
287
288ODINFUNCTION6(LONG, DocumentPropertiesA,
289 HWND, hwnd,
290 HANDLE, hPrinter,
291 LPSTR, lpszDeviceName,
292 LPDEVMODEA, pdmOutput,
293 LPDEVMODEA, pdmInput,
294 DWORD, fMode)
295{
296 dprintf(("DocumentPropertiesA, not implemented\n"));
297 return(-1);
298}
299
300
301/*****************************************************************************
302 * Name : BOOL AbortPrinter
303 * Purpose :
304 * Parameters: HANDLE hPrinter handle to printer object
305 * Variables :
306 * Result :
307 * Remark :
308 * Status : UNTESTED STUB
309 *
310 * Stub Generated through PE2LX Stubwizard 0.01 from Markus Montkowski
311 *
312 * Author : Markus Montkowski [09.07.98 13:39:08]
313 *****************************************************************************/
314
315ODINFUNCTION1(BOOL, AbortPrinter,
316 HANDLE, hPrinter)
317
318{
319 dprintf(("WINSPOOL: AbortPrinter not implemented\n"));
320 return (FALSE);
321}
322
323
324
325/*****************************************************************************
326 * Name : BOOL AddFormA
327 * Purpose :
328 * Parameters: HANDLE hPrinter handle to printer object
329 * DWORD Level data-structure level
330 * LPBYTE pForm pointer to form info. data structure
331 * Variables :
332 * Result :
333 * Remark :
334 * Status : UNTESTED STUB
335 *
336 * Stub Generated through PE2LX Stubwizard 0.01 from Markus Montkowski
337 *
338 * Author : Markus Montkowski [09.07.98 13:47:45]
339 *****************************************************************************/
340
341ODINFUNCTION3(BOOL, AddFormA,
342 HANDLE, hPrinter,
343 DWORD, Level,
344 LPBYTE, pForm)
345{
346 dprintf(("WINSPOOL: AddFormA not implemented\n"));
347 return (FALSE);
348}
349
350/*****************************************************************************
351 * Name : BOOL AddFormW
352 * Purpose :
353 * Parameters: HANDLE hPrinter handle to printer object
354 * DWORD Level data-structure level
355 * LPBYTE pForm pointer to form info. data structure
356 * Variables :
357 * Result :
358 * Remark :
359 * Status : UNTESTED STUB
360 *
361 * Stub Generated through PE2LX Stubwizard 0.01 from Markus Montkowski
362 *
363 * Author : Markus Montkowski [09.07.98 13:47:45]
364 *****************************************************************************/
365
366ODINFUNCTION3(BOOL, AddFormW,
367 HANDLE, hPrinter,
368 DWORD, Level,
369 LPBYTE, pForm)
370{
371 dprintf(("WINSPOOL: AddFormW not implemented\n"));
372 return (FALSE);
373}
374
375
376/*****************************************************************************
377 * Name : BOOL AddJobA
378 * Purpose :
379 * Parameters: HANDLE hPrinter specifies printer for the print job
380 * DWORD Level specifies version of print job information data structure
381 * LPBYTE pData pointer to buffer to receive print job information data
382 * DWORD cbBuf specifies size of buffer pointed to by pData
383 * LPDWORD pcbNeeded pointer to variable to receive size of print job information data
384 * Variables :
385 * Result :
386 * Remark :
387 * Status : UNTESTED STUB
388 *
389 * Stub Generated through PE2LX Stubwizard 0.01 from Markus Montkowski
390 *
391 * Author : Markus Montkowski [09.07.98 13:50:28]
392 *****************************************************************************/
393
394ODINFUNCTION5(BOOL, AddJobA,
395 HANDLE, hPrinter,
396 DWORD, Level,
397 LPBYTE, pData,
398 DWORD, cbBuf,
399 LPDWORD, pcbNeeded)
400{
401 dprintf(("WINSPOOL: AddJobA not implemented\n"));
402 return (FALSE);
403}
404
405/*****************************************************************************
406 * Name : BOOL AddJobW
407 * Purpose :
408 * Parameters: HANDLE hPrinter specifies printer for the print job
409 * DWORD Level specifies version of print job information
410 * data structure
411 * LPBYTE pData pointer to buffer to receive print job
412 * information data
413 * DWORD cbBuf specifies size of buffer pointed to by pData
414 * LPDWORD pcbNeeded pointer to variable to receive size of print
415 * job information data
416 * Variables :
417 * Result :
418 * Remark :
419 * Status : UNTESTED STUB
420 *
421 * Stub Generated through PE2LX Stubwizard 0.01 from Markus Montkowski
422 *
423 * Author : Markus Montkowski [09.07.98 13:50:28]
424 *****************************************************************************/
425
426ODINFUNCTION5(BOOL, AddJobW,
427 HANDLE, hPrinter,
428 DWORD, Level,
429 LPBYTE, pData,
430 DWORD, cbBuf,
431 LPDWORD, pcbNeeded)
432{
433 dprintf(("WINSPOOL: AddJobW not implemented\n"));
434 return (FALSE);
435}
436
437
438/*****************************************************************************
439 * Name : BOOL AddMonitorA
440 * Purpose :
441 * Parameters: LPSTR pName pointer to server name
442 * DWORD Level monitor info. structure level
443 * LPBYTE pMonitors pointer to monitor info. structure
444 * Variables :
445 * Result :
446 * Remark :
447 * Status : UNTESTED STUB
448 *
449 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
450 *
451 * Author : Markus Montkowski [09.07.98 14:15:55]
452 *****************************************************************************/
453
454ODINFUNCTION3(BOOL, AddMonitorA,
455 LPSTR, pName,
456 DWORD, Level,
457 LPBYTE, pMonitors)
458{
459 dprintf(("WINSPOOL: AddMonitorA not implemented\n"));
460 return (FALSE);
461}
462
463
464/*****************************************************************************
465 * Name : BOOL AddMonitorW
466 * Purpose :
467 * Parameters: LPWSTR pName pointer to server name
468 * DWORD Level monitor info. structure level
469 * LPBYTE pMonitors pointer to monitor info. structure
470 * Variables :
471 * Result :
472 * Remark :
473 * Status : UNTESTED STUB
474 *
475 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
476 *
477 * Author : Markus Montkowski [09.07.98 14:15:55]
478 *****************************************************************************/
479
480ODINFUNCTION3(BOOL, AddMonitorW,
481 LPWSTR, pName,
482 DWORD, Level,
483 LPBYTE, pMonitors)
484{
485 dprintf(("WINSPOOL: AddMonitorW not implemented\n"));
486 return (FALSE);
487}
488
489
490/*****************************************************************************
491 * Name : BOOL AddPortA
492 * Purpose :
493 * Parameters: LPSTR pName pointer to a server name
494 * HWND hWnd handle to parent window
495 * LPSTR pMonitorName pointer to a monitor name
496 * Variables :
497 * Result :
498 * Remark :
499 * Status : UNTESTED STUB
500 *
501 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
502 *
503 * Author : Markus Montkowski [09.07.98 14:16:31]
504 *****************************************************************************/
505
506ODINFUNCTION3(BOOL, AddPortA,
507 LPSTR, pName,
508 HWND, hWnd,
509 LPSTR, pMonitorName)
510{
511 dprintf(("WINSPOOL: AddPortA not implemented\n"));
512 return (FALSE);
513}
514
515
516/*****************************************************************************
517 * Name : BOOL AddPortW
518 * Purpose :
519 * Parameters: LPWSTR pName pointer to a server name
520 * HWND hWnd handle to parent window
521 * LPWSTR pMonitorName pointer to a monitor name
522 * Variables :
523 * Result :
524 * Remark :
525 * Status : UNTESTED STUB
526 *
527 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
528 *
529 * Author : Markus Montkowski [09.07.98 14:16:31]
530 *****************************************************************************/
531
532ODINFUNCTION3(BOOL, AddPortW,
533 LPWSTR, pName,
534 HWND, hWnd,
535 LPWSTR, pMonitorName)
536{
537 dprintf(("WINSPOOL: AddPortW not implemented\n"));
538 return (FALSE);
539}
540
541
542/*****************************************************************************
543 * Name : BOOL AddPrintProcessorA
544 * Purpose :
545 * Parameters: LPSTR pName pointer to server name
546 * LPSTR pEnvironment pointer to environment name
547 * LPSTR pPathName pointer to path
548 * LPSTR pPrintProcessorName pointer to print-processor name
549 * Variables :
550 * Result :
551 * Remark :
552 * Status : UNTESTED STUB
553 *
554 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
555 *
556 * Author : Markus Montkowski [09.07.98 14:17:46]
557 *****************************************************************************/
558
559ODINFUNCTION4(BOOL, AddPrintProcessorA,
560 LPSTR, pName,
561 LPSTR, pEnvironment,
562 LPSTR, pPathName,
563 LPSTR, pPrintProcessorName)
564{
565 dprintf(("WINSPOOL: AddPrintProcessorA not implemented\n"));
566 return (FALSE);
567}
568
569
570/*****************************************************************************
571 * Name : BOOL AddPrintProcessorW
572 * Purpose :
573 * Parameters: LPWSTR pName pointer to server name
574 * LPWSTR pEnvironment pointer to environment name
575 * LPWSTR pPathName pointer to path
576 * LPWSTR pPrintProcessorName pointer to print-processor name
577 * Variables :
578 * Result :
579 * Remark :
580 * Status : UNTESTED STUB
581 *
582 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
583 *
584 * Author : Markus Montkowski [09.07.98 14:17:46]
585 *****************************************************************************/
586
587ODINFUNCTION4(BOOL, AddPrintProcessorW,
588 LPWSTR, pName,
589 LPWSTR, pEnvironment,
590 LPWSTR, pPathName,
591 LPWSTR, pPrintProcessorName)
592{
593 dprintf(("WINSPOOL: AddPrintProcessorW not implemented\n"));
594 return (FALSE);
595}
596
597
598/*****************************************************************************
599 * Name : BOOL AddPrintProvidorA
600 * Purpose :
601 * Parameters: LPSTR pName pointer to server name
602 * DWORD Level provider information structure level
603 * LPBYTE pProvidorInfo pointer to provider information structure
604 * Variables :
605 * Result :
606 * Remark :
607 * Status : UNTESTED STUB
608 *
609 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
610 *
611 * Author : Markus Montkowski [09.07.98 14:18:16]
612 *****************************************************************************/
613
614ODINFUNCTION3(BOOL, AddPrintProvidorA,
615 LPSTR, pName,
616 DWORD, Level,
617 LPBYTE, pProvidorInfo)
618{
619 dprintf(("WINSPOOL: AddPrintProvidorA not implemented\n"));
620 return (FALSE);
621}
622
623
624/*****************************************************************************
625 * Name : BOOL AddPrintProvidorW
626 * Purpose :
627 * Parameters: LPWSTR pName pointer to server name
628 * DWORD Level provider information structure level
629 * LPBYTE pProvidorInfo pointer to provider information structure
630 * Variables :
631 * Result :
632 * Remark :
633 * Status : UNTESTED STUB
634 *
635 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
636 *
637 * Author : Markus Montkowski [09.07.98 14:18:16]
638 *****************************************************************************/
639
640ODINFUNCTION3(BOOL, AddPrintProvidorW,
641 LPWSTR, pName,
642 DWORD, Level,
643 LPBYTE, pProvidorInfo)
644{
645 dprintf(("WINSPOOL: AddPrintProvidorW not implemented\n"));
646 return (FALSE);
647}
648
649
650/*****************************************************************************
651 * Name : HANDLE AddPrinterA
652 * Purpose :
653 * Parameters: LPSTR pName pointer to server name
654 * DWORD Level printer info. structure level
655 * LPBYTE pPrinter pointer to structure
656 * Variables :
657 * Result :
658 * Remark :
659 * Status : UNTESTED STUB
660 *
661 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
662 *
663 * Author : Markus Montkowski [09.07.98 14:18:56]
664 *****************************************************************************/
665
666ODINFUNCTION3(HANDLE, AddPrinterA,
667 LPSTR, pName,
668 DWORD, Level,
669 LPBYTE, pPrinter)
670{
671 dprintf(("WINSPOOL: AddPrinterA not implemented\n"));
672 return (NULL);
673}
674
675
676/*****************************************************************************
677 * Name : HANDLE AddPrinterW
678 * Purpose :
679 * Parameters: LPWSTR pName pointer to server name
680 * DWORD Level printer info. structure level
681 * LPBYTE pPrinter pointer to structure
682 * Variables :
683 * Result :
684 * Remark :
685 * Status : UNTESTED STUB
686 *
687 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
688 *
689 * Author : Markus Montkowski [09.07.98 14:18:56]
690 *****************************************************************************/
691
692ODINFUNCTION3(HANDLE, AddPrinterW,
693 LPWSTR, pName,
694 DWORD, Level,
695 LPBYTE, pPrinter)
696{
697 dprintf(("WINSPOOL: AddPrinterW not implemented\n"));
698 return (NULL);
699}
700
701
702/*****************************************************************************
703 * Name : BOOL AddPrinterConnectionA
704 * Purpose :
705 * Parameters: LPSTR pName pointer to printer name
706 * Variables :
707 * Result :
708 * Remark :
709 * Status : UNTESTED STUB
710 *
711 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
712 *
713 * Author : Markus Montkowski [09.07.98 14:19:22]
714 *****************************************************************************/
715
716ODINFUNCTION1(BOOL, AddPrinterConnectionA,
717 LPSTR, pName)
718{
719 dprintf(("WINSPOOL: AddPrinterConnectionA not implemented\n"));
720 return (FALSE);
721}
722
723
724/*****************************************************************************
725 * Name : BOOL AddPrinterConnectionW
726 * Purpose :
727 * Parameters: LPWSTR pName pointer to printer name
728 * Variables :
729 * Result :
730 * Remark :
731 * Status : UNTESTED STUB
732 *
733 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
734 *
735 * Author : Markus Montkowski [09.07.98 14:19:22]
736 *****************************************************************************/
737
738ODINFUNCTION1(BOOL, AddPrinterConnectionW,
739 LPWSTR, pName)
740{
741 dprintf(("WINSPOOL: AddPrinterConnectionW not implemented\n"));
742 return (FALSE);
743}
744
745
746/*****************************************************************************
747 * Name : BOOL AddPrinterDriverA
748 * Purpose :
749 * Parameters: LPSTR pName pointer to server name
750 * DWORD Level printer info. structure level
751 * LPBYTE pDriverInfo pointer to printer info. structure
752 * Variables :
753 * Result :
754 * Remark :
755 * Status : UNTESTED STUB
756 *
757 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
758 *
759 * Author : Markus Montkowski [09.07.98 14:20:04]
760 *****************************************************************************/
761
762ODINFUNCTION3(BOOL, AddPrinterDriverA,
763 LPSTR, pName,
764 DWORD, Level,
765 LPBYTE, pDriverInfo)
766{
767 dprintf(("WINSPOOL: AddPrinterDriverA not implemented\n"));
768 return (FALSE);
769}
770
771
772/*****************************************************************************
773 * Name : BOOL AddPrinterDriverW
774 * Purpose :
775 * Parameters: LPWSTR pName pointer to server name
776 * DWORD Level printer info. structure level
777 * LPBYTE pDriverInfo pointer to printer info. structure
778 * Variables :
779 * Result :
780 * Remark :
781 * Status : UNTESTED STUB
782 *
783 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
784 *
785 * Author : Markus Montkowski [09.07.98 14:20:04]
786 *****************************************************************************/
787
788ODINFUNCTION3(BOOL, AddPrinterDriverW,
789 LPWSTR, pName,
790 DWORD, Level,
791 LPBYTE, pDriverInfo)
792{
793 dprintf(("WINSPOOL: AddPrinterDriverW not implemented\n"));
794 return (FALSE);
795}
796
797
798/*****************************************************************************
799 * Name : LONG AdvancedDocumentPropertiesA
800 * Purpose :
801 * Parameters: HWND hWnd handle to dialog box's parent window
802 * HANDLE hPrinter handle to printer object
803 * LPSTR pDeviceName pointer to driver name
804 * LPDEVMODEA pDevModeInput pointer to modified device mode structure
805 * LPDEVMODEA pDevModeInput pointer to original device mode structure
806 * Variables :
807 * Result :
808 * Remark :
809 * Status : UNTESTED STUB
810 *
811 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
812 *
813 * Author : Markus Montkowski [09.07.98 14:21:59]
814 *****************************************************************************/
815
816ODINFUNCTION5(LONG, AdvancedDocumentPropertiesA,
817 HWND, hWnd,
818 HANDLE, hPrinter,
819 LPSTR, pDeviceName,
820 LPDEVMODEA, pDevModeOutput,
821 LPDEVMODEA, pDevModeInput)
822{
823 dprintf(("WINSPOOL: AdvancedDocumentPropertiesA not implemented\n"));
824 return (0);
825}
826
827
828/*****************************************************************************
829 * Name : LONG AdvancedDocumentPropertiesW
830 * Purpose :
831 * Parameters: HWND hWnd handle to dialog box's parent window
832 * HANDLE hPrinter handle to printer object
833 * LPWSTR pDeviceName pointer to driver name
834 * LPDEVMODEW pDevModeOutput pointer to modified device mode structure
835 * LPDEVMODEW pDevModeInput pointer to original device mode structure
836 * Variables :
837 * Result :
838 * Remark :
839 * Status : UNTESTED STUB
840 *
841 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
842 *
843 * Author : Markus Montkowski [09.07.98 14:21:59]
844 *****************************************************************************/
845
846ODINFUNCTION5(LONG, AdvancedDocumentPropertiesW,
847 HWND, hWnd,
848 HANDLE, hPrinter,
849 LPWSTR, pDeviceName,
850 LPDEVMODEW, pDevModeOutput,
851 LPDEVMODEW, pDevModeInput)
852{
853 dprintf(("WINSPOOL: AdvancedDocumentPropertiesW not implemented\n"));
854 return (0);
855}
856
857
858/*****************************************************************************
859 * Name : BOOL ConfigurePortA
860 * Purpose :
861 * Parameters: LPSTR pName pointer to server name
862 * HWND hWnd handle to parent window of the dialog box
863 * LPSTR pPortName pointer to port name
864 * Variables :
865 * Result :
866 * Remark :
867 * Status : UNTESTED STUB
868 *
869 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
870 *
871 * Author : Markus Montkowski [09.07.98 14:24:42]
872 *****************************************************************************/
873
874ODINFUNCTION3(BOOL, ConfigurePortA,
875 LPSTR, pName,
876 HWND, hWnd,
877 LPSTR, pPortName)
878{
879 dprintf(("WINSPOOL: ConfigurePortA not implemented\n"));
880 return (FALSE);
881}
882
883
884/*****************************************************************************
885 * Name : BOOL ConfigurePortW
886 * Purpose :
887 * Parameters: LPWSTR pName pointer to server name
888 * HWND hWnd handle to parent window of the dialog box
889 * LPWSTR pPortName pointer to port name
890 * Variables :
891 * Result :
892 * Remark :
893 * Status : UNTESTED STUB
894 *
895 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
896 *
897 * Author : Markus Montkowski [09.07.98 14:24:43]
898 *****************************************************************************/
899
900ODINFUNCTION3(BOOL, ConfigurePortW,
901 LPWSTR, pName,
902 HWND, hWnd,
903 LPWSTR, pPortName)
904{
905 dprintf(("WINSPOOL: ConfigurePortW not implemented\n"));
906 return (FALSE);
907}
908
909
910/*****************************************************************************
911 * Name : HANDLE ConnectToPrinterDlg
912 * Purpose :
913 * Parameters: HWND hwnd handle to parent window of dialog box
914 * DWORD Flags reserved for future use, must be zero
915 * Variables :
916 * Result :
917 * Remark :
918 * Status : UNTESTED STUB
919 *
920 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
921 *
922 * Author : Markus Montkowski [09.07.98 14:25:13]
923 *****************************************************************************/
924
925ODINFUNCTION2(HANDLE, ConnectToPrinterDlg,
926 HWND, hwnd,
927 DWORD, Flags)
928{
929 dprintf(("WINSPOOL: ConnectToPrinterDlg not implemented\n"));
930 return (NULL);
931}
932
933
934/***********************************************************
935 * DEVMODEdupWtoA
936 * Creates an ascii copy of supplied devmode on heap
937 */
938static LPDEVMODEA DEVMODEdupWtoA(HANDLE heap, const DEVMODEW *dmW)
939{
940 LPDEVMODEA dmA;
941 DWORD size;
942 BOOL Formname;
943 ptrdiff_t off_formname = (char *)dmW->dmFormName - (char *)dmW;
944
945 if(!dmW) return NULL;
946 Formname = (dmW->dmSize > off_formname);
947 size = dmW->dmSize - CCHDEVICENAME - (Formname ? CCHFORMNAME : 0);
948 dmA = (LPDEVMODEA)HeapAlloc(heap, HEAP_ZERO_MEMORY, size + dmW->dmDriverExtra);
949 WideCharToMultiByte(CP_ACP, 0, dmW->dmDeviceName, -1, (LPSTR)dmA->dmDeviceName,
950 CCHDEVICENAME, NULL, NULL);
951 if(!Formname) {
952 memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
953 dmW->dmSize - CCHDEVICENAME * sizeof(WCHAR));
954 } else {
955 memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
956 off_formname - CCHDEVICENAME * sizeof(WCHAR));
957 WideCharToMultiByte(CP_ACP, 0, dmW->dmFormName, -1, (LPSTR)dmA->dmFormName,
958 CCHFORMNAME, NULL, NULL);
959 memcpy(&dmA->dmLogPixels, &dmW->dmLogPixels, dmW->dmSize -
960 (off_formname + CCHFORMNAME * sizeof(WCHAR)));
961 }
962 dmA->dmSize = size;
963 memcpy((char *)dmA + dmA->dmSize, (char *)dmW + dmW->dmSize,
964 dmW->dmDriverExtra);
965 return dmA;
966}
967
968/*****************************************************************************
969 * Name : DWORD DeviceCapabilitiesA
970 * Purpose :
971 * Parameters: LPCSTR pDevice pointer to a printer-name string
972 * LPCSTR pPort pointer to a port-name string
973 * WORD fwCapability device capability to query
974 * LPSTR pOutput pointer to the output
975 * CONST DEVMODE *pDevMode pointer to structure with device data
976 * Variables :
977 * Result :
978 * Remark :
979 * Status : UNTESTED STUB
980 *
981 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
982 *
983 * Author : Markus Montkowski [09.07.98 14:27:08]
984 *****************************************************************************/
985
986ODINFUNCTION5(INT, DeviceCapabilitiesA,
987 LPCSTR, pDevice,
988 LPCSTR, pPort,
989 WORD, fwCapability,
990 LPSTR, pOutput,
991 DEVMODEA *, pDevMode)
992{
993 dprintf(("WINSPOOL: DeviceCapabilitiesA %s %s %x %x %x", pDevice, pPort, fwCapability, pOutput, pDevMode));
994 return O32_DeviceCapabilities(pDevice, pPort, fwCapability, pOutput, pDevMode);
995}
996
997
998/*****************************************************************************
999 * DeviceCapabilitiesW [WINSPOOL.152]
1000 *
1001 * Call DeviceCapabilitiesA since we later call 16bit stuff anyway
1002 *
1003 */
1004ODINFUNCTION5(INT, DeviceCapabilitiesW, LPCWSTR, pDevice, LPCWSTR, pPort,
1005 WORD, fwCapability, LPWSTR, pOutput,
1006 CONST DEVMODEW *, pDevMode)
1007{
1008 LPDEVMODEA dmA = DEVMODEdupWtoA(GetProcessHeap(), pDevMode);
1009 LPSTR pDeviceA = HEAP_strdupWtoA(GetProcessHeap(),0,pDevice);
1010 LPSTR pPortA = HEAP_strdupWtoA(GetProcessHeap(),0,pPort);
1011 INT ret;
1012
1013 if(pOutput && (fwCapability == DC_BINNAMES ||
1014 fwCapability == DC_FILEDEPENDENCIES ||
1015 fwCapability == DC_PAPERNAMES)) {
1016 /* These need A -> W translation */
1017 INT size = 0, i;
1018 LPSTR pOutputA;
1019 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability, NULL,
1020 dmA);
1021 if(ret == -1)
1022 return ret;
1023 switch(fwCapability) {
1024 case DC_BINNAMES:
1025 size = 24;
1026 break;
1027 case DC_PAPERNAMES:
1028 case DC_FILEDEPENDENCIES:
1029 size = 64;
1030 break;
1031 }
1032 pOutputA = (LPSTR)HeapAlloc(GetProcessHeap(), 0, size * ret);
1033 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability, pOutputA,
1034 dmA);
1035 for(i = 0; i < ret; i++)
1036 MultiByteToWideChar(CP_ACP, 0, pOutputA + (i * size), -1,
1037 pOutput + (i * size), size);
1038 HeapFree(GetProcessHeap(), 0, pOutputA);
1039 } else {
1040 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability,
1041 (LPSTR)pOutput, dmA);
1042 }
1043 HeapFree(GetProcessHeap(),0,pPortA);
1044 HeapFree(GetProcessHeap(),0,pDeviceA);
1045 HeapFree(GetProcessHeap(),0,dmA);
1046 return ret;
1047}
1048
1049
1050/*****************************************************************************
1051 * Name : BOOL DeleteFormA
1052 * Purpose :
1053 * Parameters: HANDLE hPrinter handle to printer object
1054 * LPSTR pFormName pointer to form name
1055 * Variables :
1056 * Result :
1057 * Remark :
1058 * Status : UNTESTED STUB
1059 *
1060 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1061 *
1062 * Author : Markus Montkowski [09.07.98 14:28:10]
1063 *****************************************************************************/
1064
1065ODINFUNCTION2(BOOL, DeleteFormA,
1066 HANDLE, hPrinter,
1067 LPSTR, pFormName)
1068{
1069 dprintf(("WINSPOOL: DeleteFormA not implemented\n"));
1070 return (FALSE);
1071}
1072
1073
1074/*****************************************************************************
1075 * Name : BOOL DeleteFormW
1076 * Purpose :
1077 * Parameters: HANDLE hPrinter handle to printer object
1078 * LPWSTR pFormName pointer to form name
1079 * Variables :
1080 * Result :
1081 * Remark :
1082 * Status : UNTESTED STUB
1083 *
1084 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1085 *
1086 * Author : Markus Montkowski [09.07.98 14:28:10]
1087 *****************************************************************************/
1088
1089ODINFUNCTION2(BOOL, DeleteFormW,
1090 HANDLE, hPrinter,
1091 LPWSTR, pFormName)
1092{
1093 dprintf(("WINSPOOL: DeleteFormW not implemented\n"));
1094 return (FALSE);
1095}
1096
1097
1098/*****************************************************************************
1099 * Name : BOOL DeleteMonitorA
1100 * Purpose :
1101 * Parameters: LPSTR pName pointer to server name
1102 * LPSTR pEnvironment pointer to environment string
1103 * LPSTR pMonitorName pointer to monitor name
1104 * Variables :
1105 * Result :
1106 * Remark :
1107 * Status : UNTESTED STUB
1108 *
1109 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1110 *
1111 * Author : Markus Montkowski [09.07.98 14:28:35]
1112 *****************************************************************************/
1113
1114ODINFUNCTION3(BOOL, DeleteMonitorA,
1115 LPSTR, pName,
1116 LPSTR, pEnvironment,
1117 LPSTR, pMonitorName)
1118{
1119 dprintf(("WINSPOOL: DeleteMonitorA not implemented\n"));
1120 return (FALSE);
1121}
1122
1123
1124/*****************************************************************************
1125 * Name : BOOL DeleteMonitorW
1126 * Purpose :
1127 * Parameters: LPWSTR pName pointer to server name
1128 * LPWSTR pEnvironment pointer to environment string
1129 * LPWSTR pMonitorName pointer to monitor name
1130 * Variables :
1131 * Result :
1132 * Remark :
1133 * Status : UNTESTED STUB
1134 *
1135 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1136 *
1137 * Author : Markus Montkowski [09.07.98 14:28:35]
1138 *****************************************************************************/
1139
1140ODINFUNCTION3(BOOL, DeleteMonitorW,
1141 LPWSTR, pName,
1142 LPWSTR, pEnvironment,
1143 LPWSTR, pMonitorName)
1144{
1145 dprintf(("WINSPOOL: DeleteMonitorW not implemented\n"));
1146 return (FALSE);
1147}
1148
1149
1150/*****************************************************************************
1151 * Name : BOOL DeletePortA
1152 * Purpose :
1153 * Parameters: LPSTR pName pointer to server name
1154 * HWND hWnd handle to window that displays dialog box
1155 * LPSTR pPortName pointer to port name
1156 * Variables :
1157 * Result :
1158 * Remark :
1159 * Status : UNTESTED STUB
1160 *
1161 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1162 *
1163 * Author : Markus Montkowski [09.07.98 14:28:58]
1164 *****************************************************************************/
1165
1166ODINFUNCTION3(BOOL, DeletePortA,
1167 LPSTR, pName,
1168 HWND, hWnd,
1169 LPSTR, pPortName)
1170{
1171 dprintf(("WINSPOOL: DeletePortA not implemented\n"));
1172 return (FALSE);
1173}
1174
1175
1176/*****************************************************************************
1177 * Name : BOOL DeletePortW
1178 * Purpose :
1179 * Parameters: LPWSTR pName pointer to server name
1180 * HWND hWnd handle to window that displays dialog box
1181 * LPWSTR pPortName pointer to port name
1182 * Variables :
1183 * Result :
1184 * Remark :
1185 * Status : UNTESTED STUB
1186 *
1187 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1188 *
1189 * Author : Markus Montkowski [09.07.98 14:28:58]
1190 *****************************************************************************/
1191
1192ODINFUNCTION3(BOOL, DeletePortW,
1193 LPWSTR, pName,
1194 HWND, hWnd,
1195 LPWSTR, pPortName)
1196{
1197 dprintf(("WINSPOOL: DeletePortW not implemented\n"));
1198 return (FALSE);
1199}
1200
1201
1202/*****************************************************************************
1203 * Name : BOOL DeletePrintProcessorA
1204 * Purpose :
1205 * Parameters: LPSTR pName pointer to server name
1206 * LPSTR pEnvironment pointer to environment string
1207 * LPSTR pPrintProcessorName pointer to processor name
1208 * Variables :
1209 * Result :
1210 * Remark :
1211 * Status : UNTESTED STUB
1212 *
1213 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1214 *
1215 * Author : Markus Montkowski [09.07.98 14:30:08]
1216 *****************************************************************************/
1217
1218ODINFUNCTION3(BOOL, DeletePrintProcessorA,
1219 LPSTR, pName,
1220 LPSTR, pEnvironment,
1221 LPSTR, pPrintProcessorName)
1222{
1223 dprintf(("WINSPOOL: DeletePrintProcessorA not implemented\n"));
1224 return (FALSE);
1225}
1226
1227
1228/*****************************************************************************
1229 * Name : BOOL DeletePrintProcessorW
1230 * Purpose :
1231 * Parameters: LPWSTR pName pointer to server name
1232 * LPWSTR pEnvironment pointer to environment string
1233 * LPWSTR pPrintProcessorName pointer to processor name
1234 * Variables :
1235 * Result :
1236 * Remark :
1237 * Status : UNTESTED STUB
1238 *
1239 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1240 *
1241 * Author : Markus Montkowski [09.07.98 14:30:08]
1242 *****************************************************************************/
1243
1244ODINFUNCTION3(BOOL, DeletePrintProcessorW,
1245 LPWSTR, pName,
1246 LPWSTR, pEnvironment,
1247 LPWSTR, pPrintProcessorName)
1248{
1249 dprintf(("WINSPOOL: DeletePrintProcessorW not implemented\n"));
1250 return (FALSE);
1251}
1252
1253
1254/*****************************************************************************
1255 * Name : BOOL DeletePrintProvidorA
1256 * Purpose :
1257 * Parameters: LPSTR pName pointer to server name
1258 * LPSTR pEnvironment pointer to environment string
1259 * LPSTR pPrintProvidorName pointer to provider name
1260 * Variables :
1261 * Result :
1262 * Remark :
1263 * Status : UNTESTED STUB
1264 *
1265 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1266 *
1267 * Author : Markus Montkowski [09.07.98 14:30:29]
1268 *****************************************************************************/
1269
1270ODINFUNCTION3(BOOL, DeletePrintProvidorA,
1271 LPSTR, pName,
1272 LPSTR, pEnvironment,
1273 LPSTR, pPrintProvidorName)
1274{
1275 dprintf(("WINSPOOL: DeletePrintProvidorA not implemented\n"));
1276 return (FALSE);
1277}
1278
1279
1280/*****************************************************************************
1281 * Name : BOOL DeletePrintProvidorW
1282 * Purpose :
1283 * Parameters: LPWSTR pName pointer to server name
1284 * LPWSTR pEnvironment pointer to environment string
1285 * LPWSTR pPrintProvidorName pointer to provider name
1286 * Variables :
1287 * Result :
1288 * Remark :
1289 * Status : UNTESTED STUB
1290 *
1291 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1292 *
1293 * Author : Markus Montkowski [09.07.98 14:30:29]
1294 *****************************************************************************/
1295
1296ODINFUNCTION3(BOOL, DeletePrintProvidorW,
1297 LPWSTR, pName,
1298 LPWSTR, pEnvironment,
1299 LPWSTR, pPrintProvidorName)
1300{
1301 dprintf(("WINSPOOL: DeletePrintProvidorW not implemented\n"));
1302 return (FALSE);
1303}
1304
1305
1306/*****************************************************************************
1307 * Name : BOOL DeletePrinter
1308 * Purpose :
1309 * Parameters: HANDLE hPrinter handle to printer object
1310 * Variables :
1311 * Result :
1312 * Remark :
1313 * Status : UNTESTED STUB
1314 *
1315 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1316 *
1317 * Author : Markus Montkowski [09.07.98 14:30:50]
1318 *****************************************************************************/
1319
1320ODINFUNCTION1(BOOL, DeletePrinter,
1321 HANDLE, hPrinter)
1322{
1323 dprintf(("WINSPOOL: DeletePrinter not implemented\n"));
1324 return (FALSE);
1325}
1326
1327
1328/*****************************************************************************
1329 * Name : BOOL DeletePrinterConnectionA
1330 * Purpose :
1331 * Parameters: LPSTR pName pointer to printer name
1332 * Variables :
1333 * Result :
1334 * Remark :
1335 * Status : UNTESTED STUB
1336 *
1337 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1338 *
1339 * Author : Markus Montkowski [09.07.98 14:31:48]
1340 *****************************************************************************/
1341
1342ODINFUNCTION1(BOOL, DeletePrinterConnectionA,
1343 LPSTR, pName)
1344{
1345 dprintf(("WINSPOOL: DeletePrinterConnectionA not implemented\n"));
1346 return (FALSE);
1347}
1348
1349
1350/*****************************************************************************
1351 * Name : BOOL DeletePrinterConnectionW
1352 * Purpose :
1353 * Parameters: LPWSTR pName pointer to printer name
1354 * Variables :
1355 * Result :
1356 * Remark :
1357 * Status : UNTESTED STUB
1358 *
1359 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1360 *
1361 * Author : Markus Montkowski [09.07.98 14:31:48]
1362 *****************************************************************************/
1363
1364ODINFUNCTION1(BOOL, DeletePrinterConnectionW,
1365 LPWSTR, pName)
1366{
1367 dprintf(("WINSPOOL: DeletePrinterConnectionW not implemented\n"));
1368 return (FALSE);
1369}
1370
1371
1372/*****************************************************************************
1373 * Name : BOOL DeletePrinterDriverA
1374 * Purpose :
1375 * Parameters: LPSTR pName pointer to server name
1376 * LPSTR pEnvironment pointer to environment
1377 * LPSTR pDriverName pointer to driver name
1378 * Variables :
1379 * Result :
1380 * Remark :
1381 * Status : UNTESTED STUB
1382 *
1383 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1384 *
1385 * Author : Markus Montkowski [09.07.98 14:32:38]
1386 *****************************************************************************/
1387
1388ODINFUNCTION3(BOOL, DeletePrinterDriverA,
1389 LPSTR, pName,
1390 LPSTR, pEnvironment,
1391 LPSTR, pDriverName)
1392{
1393 dprintf(("WINSPOOL: DeletePrinterDriverA not implemented\n"));
1394 return (FALSE);
1395}
1396
1397
1398/*****************************************************************************
1399 * Name : BOOL DeletePrinterDriverW
1400 * Purpose :
1401 * Parameters: LPWSTR pName pointer to server name
1402 * LPWSTR pEnvironment pointer to environment
1403 * LPWSTR pDriverName pointer to driver name
1404 * Variables :
1405 * Result :
1406 * Remark :
1407 * Status : UNTESTED STUB
1408 *
1409 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1410 *
1411 * Author : Markus Montkowski [09.07.98 14:32:38]
1412 *****************************************************************************/
1413
1414ODINFUNCTION3(BOOL, DeletePrinterDriverW,
1415 LPWSTR, pName,
1416 LPWSTR, pEnvironment,
1417 LPWSTR, pDriverName)
1418{
1419 dprintf(("WINSPOOL: DeletePrinterDriverW not implemented\n"));
1420 return (FALSE);
1421}
1422
1423
1424/*****************************************************************************
1425 * Name : BOOL EndDocPrinter
1426 * Purpose :
1427 * Parameters: HANDLE hPrinter handle to printer object
1428 * Variables :
1429 * Result :
1430 * Remark :
1431 * Status : UNTESTED STUB
1432 *
1433 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1434 *
1435 * Author : Markus Montkowski [09.07.98 14:34:09]
1436 *****************************************************************************/
1437
1438ODINFUNCTION1(BOOL, EndDocPrinter,
1439 HANDLE, hPrinter)
1440{
1441 dprintf(("WINSPOOL: EndDocPrinter not implemented\n"));
1442 return (FALSE);
1443}
1444
1445
1446/*****************************************************************************
1447 * Name : BOOL EndPagePrinter
1448 * Purpose :
1449 * Parameters: HANDLE hPrinter handle to printer object
1450 * Variables :
1451 * Result :
1452 * Remark :
1453 * Status : UNTESTED STUB
1454 *
1455 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1456 *
1457 * Author : Markus Montkowski [09.07.98 14:34:27]
1458 *****************************************************************************/
1459
1460ODINFUNCTION1(BOOL, EndPagePrinter,
1461 HANDLE, hPrinter)
1462{
1463 dprintf(("WINSPOOL: EndPagePrinter not implemented\n"));
1464 return (FALSE);
1465}
1466
1467
1468/*****************************************************************************
1469 * Name : BOOL EnumFormsA
1470 * Purpose :
1471 * Parameters: HANDLE hPrinter handle to printer object
1472 * DWORD Level data-structure level
1473 * LPBYTE pForm points to buffer that receives form info. structure array
1474 * DWORD cbBuf count of bytes in buffer
1475 * LPDWORD pcbNeeded points to variable to receive count of bytes copied or required
1476 * LPDWORD pcReturned points to variable to receive count of structures copied
1477 * Variables :
1478 * Result :
1479 * Remark :
1480 * Status : UNTESTED STUB
1481 *
1482 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1483 *
1484 * Author : Markus Montkowski [09.07.98 14:35:07]
1485 *****************************************************************************/
1486
1487ODINFUNCTION6(BOOL, EnumFormsA,
1488 HANDLE, hPrinter,
1489 DWORD, Level,
1490 LPBYTE, pForm,
1491 DWORD, cbBuf,
1492 LPDWORD, pcbNeeded,
1493 LPDWORD, pcReturned)
1494{
1495 dprintf(("WINSPOOL: EnumFormsA not implemented\n"));
1496 return (FALSE);
1497}
1498
1499
1500/*****************************************************************************
1501 * Name : BOOL EnumFormsW
1502 * Purpose :
1503 * Parameters: HANDLE hPrinter handle to printer object
1504 * DWORD Level data-structure level
1505 * LPBYTE pForm points to buffer that receives form info. structure array
1506 * DWORD cbBuf count of bytes in buffer
1507 * LPDWORD pcbNeeded points to variable to receive count of bytes copied or required
1508 * LPDWORD pcReturned points to variable to receive count of structures copied
1509 * Variables :
1510 * Result :
1511 * Remark :
1512 * Status : UNTESTED STUB
1513 *
1514 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1515 *
1516 * Author : Markus Montkowski [09.07.98 14:35:07]
1517 *****************************************************************************/
1518
1519ODINFUNCTION6(BOOL, EnumFormsW,
1520 HANDLE, hPrinter,
1521 DWORD, Level,
1522 LPBYTE, pForm,
1523 DWORD, cbBuf,
1524 LPDWORD, pcbNeeded,
1525 LPDWORD, pcReturned)
1526{
1527 dprintf(("WINSPOOL: EnumFormsW not implemented\n"));
1528
1529 return (FALSE);
1530}
1531
1532
1533/*****************************************************************************
1534 * Name : BOOL EnumJobsA
1535 * Purpose :
1536 * Parameters: HANDLE hPrinter handle to printer object
1537 * DWORD FirstJob location of first job in print queue to enumerate
1538 * DWORD NoJobs number of jobs to enumerate
1539 * DWORD Level structure level
1540 * LPBYTE pJob pointer to structure array
1541 * DWORD cbBuf size of array, in bytes
1542 * LPDWORD pcbNeeded addr. of variable with no. of bytes copied (or required)
1543 * LPDWORD pcReturned addr. of variable with no. of job info. structures copied
1544 * Variables :
1545 * Result :
1546 * Remark :
1547 * Status : UNTESTED STUB
1548 *
1549 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1550 *
1551 * Author : Markus Montkowski [09.07.98 14:36:24]
1552 *****************************************************************************/
1553
1554ODINFUNCTION8(BOOL, EnumJobsA,
1555 HANDLE, hPrinter,
1556 DWORD, FirstJob,
1557 DWORD, NoJobs,
1558 DWORD, Level,
1559 LPBYTE, pJob,
1560 DWORD, cbBuf,
1561 LPDWORD, pcbNeeded,
1562 LPDWORD, pcReturned)
1563{
1564 dprintf(("WINSPOOL: EnumJobsA not implemented\n"));
1565 return (FALSE);
1566}
1567
1568
1569/*****************************************************************************
1570 * Name : BOOL EnumJobsW
1571 * Purpose :
1572 * Parameters: HANDLE hPrinter handle to printer object
1573 * DWORD FirstJob location of first job in print queue to enumerate
1574 * DWORD NoJobs number of jobs to enumerate
1575 * DWORD Level structure level
1576 * LPBYTE pJob pointer to structure array
1577 * DWORD cbBuf size of array, in bytes
1578 * LPDWORD pcbNeeded addr. of variable with no. of bytes copied (or required)
1579 * LPDWORD pcReturned addr. of variable with no. of job info. structures copied
1580 * Variables :
1581 * Result :
1582 * Remark :
1583 * Status : UNTESTED STUB
1584 *
1585 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1586 *
1587 * Author : Markus Montkowski [09.07.98 14:36:24]
1588 *****************************************************************************/
1589
1590ODINFUNCTION8(BOOL, EnumJobsW,
1591 HANDLE, hPrinter,
1592 DWORD, FirstJob,
1593 DWORD, NoJobs,
1594 DWORD, Level,
1595 LPBYTE, pJob,
1596 DWORD, cbBuf,
1597 LPDWORD, pcbNeeded,
1598 LPDWORD, pcReturned)
1599{
1600 dprintf(("WINSPOOL: EnumJobsW not implemented\n"));
1601 return (FALSE);
1602}
1603
1604
1605/*****************************************************************************
1606 * Name : BOOL EnumMonitorsA
1607 * Purpose :
1608 * Parameters: LPSTR pName pointer to server name
1609 * DWORD Level structure level
1610 * LPBYTE pMonitors pointer to structure array
1611 * DWORD cbBuf size, in bytes, of buffer
1612 * LPDWORD pcbNeeded addr. of variable with no. of bytes copied (or required)
1613 * LPDWORD pcReturned addr. of variable with no. of job info. structures copied
1614 * Variables :
1615 * Result :
1616 * Remark :
1617 * Status : UNTESTED STUB
1618 *
1619 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1620 *
1621 * Author : Markus Montkowski [09.07.98 14:38:50]
1622 *****************************************************************************/
1623
1624ODINFUNCTION6(BOOL, EnumMonitorsA,
1625 LPSTR, pName,
1626 DWORD, Level,
1627 LPBYTE, pMonitors,
1628 DWORD, cbBuf,
1629 LPDWORD, pcbNeeded,
1630 LPDWORD, pcReturned)
1631{
1632 dprintf(("WINSPOOL: EnumMonitorsA not implemented\n"));
1633 return (FALSE);
1634}
1635
1636
1637/*****************************************************************************
1638 * Name : BOOL EnumMonitorsW
1639 * Purpose :
1640 * Parameters: LPWSTR pName pointer to server name
1641 * DWORD Level structure level
1642 * LPBYTE pMonitors pointer to structure array
1643 * DWORD cbBuf size, in bytes, of buffer
1644 * LPDWORD pcbNeeded addr. of variable with no. of bytes copied (or required)
1645 * LPDWORD pcReturned addr. of variable with no. of job info. structures copied
1646 * Variables :
1647 * Result :
1648 * Remark :
1649 * Status : UNTESTED STUB
1650 *
1651 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1652 *
1653 * Author : Markus Montkowski [09.07.98 14:38:50]
1654 *****************************************************************************/
1655
1656ODINFUNCTION6(BOOL, EnumMonitorsW,
1657 LPWSTR, pName,
1658 DWORD, Level,
1659 LPBYTE, pMonitors,
1660 DWORD, cbBuf,
1661 LPDWORD, pcbNeeded,
1662 LPDWORD, pcReturned)
1663{
1664 dprintf(("WINSPOOL: EnumMonitorsW not implemented\n"));
1665 return (FALSE);
1666}
1667
1668
1669/*****************************************************************************
1670 * Name : BOOL EnumPortsA
1671 * Purpose :
1672 * Parameters: LPSTR pName pointer to server name
1673 * DWORD Level specifies type of port info structure
1674 * LPBYTE pPorts pointer to buffer to receive array of port info. structures
1675 * DWORD cbBuf specifies size, in bytes, of buffer
1676 * LPDWORD pcbNeeded buffer size)
1677 * LPDWORD pcReturned pointer to number of PORT_INFO_*. structures stored into buffer
1678 * Variables :
1679 * Result :
1680 * Remark :
1681 * Status : UNTESTED STUB
1682 *
1683 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1684 *
1685 * Author : Markus Montkowski [09.07.98 14:39:09]
1686 *****************************************************************************/
1687
1688ODINFUNCTION6(BOOL, EnumPortsA,
1689 LPSTR, pName,
1690 DWORD, Level,
1691 LPBYTE, pPorts,
1692 DWORD, cbBuf,
1693 LPDWORD, pcbNeeded,
1694 LPDWORD, pcReturned)
1695{
1696 dprintf(("WINSPOOL: EnumPortsA not implemented\n"));
1697 return (FALSE);
1698}
1699
1700
1701/*****************************************************************************
1702 * Name : BOOL EnumPortsW
1703 * Purpose :
1704 * Parameters: LPWSTR pName pointer to server name
1705 * DWORD Level specifies type of port info structure
1706 * LPBYTE pPorts pointer to buffer to receive array of port info. structures
1707 * DWORD cbBuf specifies size, in bytes, of buffer
1708 * LPDWORD pcbNeeded buffer size)
1709 * LPDWORD pcReturned pointer to number of PORT_INFO_*. structures stored into buffer
1710 * Variables :
1711 * Result :
1712 * Remark :
1713 * Status : UNTESTED STUB
1714 *
1715 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1716 *
1717 * Author : Markus Montkowski [09.07.98 14:39:09]
1718 *****************************************************************************/
1719
1720ODINFUNCTION6(BOOL, EnumPortsW,
1721 LPWSTR, pName,
1722 DWORD, Level,
1723 LPBYTE, pPorts,
1724 DWORD, cbBuf,
1725 LPDWORD, pcbNeeded,
1726 LPDWORD, pcReturned)
1727{
1728 dprintf(("WINSPOOL: EnumPortsW not implemented\n"));
1729 return (FALSE);
1730}
1731
1732
1733/*****************************************************************************
1734 * Name : BOOL EnumPrintProcessorDatatypesA
1735 * Purpose :
1736 * Parameters: LPSTR pName points to server name string
1737 * LPSTR pPrintProcessorName points to print processor name string
1738 * DWORD Level specifies version of print processor data type structures
1739 * LPBYTE pDatatypes points to buffer to receive print processor data type structures
1740 * DWORD cbBuf specifies size, in bytes, of buffer
1741 * LPDWORD pcbNeeded points to number of bytes copied (or required)
1742 * LPDWORD pcReturned points to number of data structures obtained
1743 * Variables :
1744 * Result :
1745 * Remark :
1746 * Status : UNTESTED STUB
1747 *
1748 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1749 *
1750 * Author : Markus Montkowski [09.07.98 14:39:29]
1751 *****************************************************************************/
1752
1753ODINFUNCTION7(BOOL, EnumPrintProcessorDatatypesA,
1754 LPSTR, pName,
1755 LPSTR, pPrintProcessorName,
1756 DWORD, Level,
1757 LPBYTE, pDatatypes,
1758 DWORD, cbBuf,
1759 LPDWORD, pcbNeeded,
1760 LPDWORD, pcReturned)
1761{
1762 dprintf(("WINSPOOL: EnumPrintProcessorDatatypesA not implemented\n"));
1763 return (FALSE);
1764}
1765
1766
1767/*****************************************************************************
1768 * Name : BOOL EnumPrintProcessorDatatypesW
1769 * Purpose :
1770 * Parameters: LPWSTR pName points to server name string
1771 * LPWSTR pPrintProcessorName points to print processor name string
1772 * DWORD Level specifies version of print processor data type structures
1773 * LPBYTE pDatatypes points to buffer to receive print processor data type structures
1774 * DWORD cbBuf specifies size, in bytes, of buffer
1775 * LPDWORD pcbNeeded points to number of bytes copied (or required)
1776 * LPDWORD pcReturned points to number of data structures obtained
1777 * Variables :
1778 * Result :
1779 * Remark :
1780 * Status : UNTESTED STUB
1781 *
1782 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1783 *
1784 * Author : Markus Montkowski [09.07.98 14:39:30]
1785 *****************************************************************************/
1786
1787ODINFUNCTION7(BOOL, EnumPrintProcessorDatatypesW,
1788 LPWSTR, pName,
1789 LPWSTR, pPrintProcessorName,
1790 DWORD, Level,
1791 LPBYTE, pDatatypes,
1792 DWORD, cbBuf,
1793 LPDWORD, pcbNeeded,
1794 LPDWORD, pcReturned)
1795{
1796 dprintf(("WINSPOOL: EnumPrintProcessorDatatypesW not implemented\n"));
1797 return (FALSE);
1798}
1799
1800
1801/*****************************************************************************
1802 * Name : BOOL EnumPrintProcessorsA
1803 * Purpose :
1804 * Parameters: LPSTR pName points to server name
1805 * LPSTR pEnvironment points to environment name
1806 * DWORD Level structure level
1807 * LPBYTE pPrintProcessorInfo points to structure array
1808 * DWORD cbBuf array length in bytes
1809 * LPDWORD pcbNeeded points to number of bytes copied (or required)
1810 * LPDWORD pcReturned points to number of job info. structures copied
1811 * Variables :
1812 * Result :
1813 * Remark :
1814 * Status : UNTESTED STUB
1815 *
1816 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1817 *
1818 * Author : Markus Montkowski [09.07.98 14:39:52]
1819 *****************************************************************************/
1820
1821ODINFUNCTION7(BOOL, EnumPrintProcessorsA,
1822 LPSTR, pName,
1823 LPSTR, pEnvironment,
1824 DWORD, Level,
1825 LPBYTE, pPrintProcessorInfo,
1826 DWORD, cbBuf,
1827 LPDWORD, pcbNeeded,
1828 LPDWORD, pcReturned)
1829{
1830 dprintf(("WINSPOOL: EnumPrintProcessorsA not implemented\n"));
1831 return (FALSE);
1832}
1833
1834
1835/*****************************************************************************
1836 * Name : BOOL EnumPrintProcessorsW
1837 * Purpose :
1838 * Parameters: LPWSTR pName points to server name
1839 * LPWSTR pEnvironment points to environment name
1840 * DWORD Level structure level
1841 * LPBYTE pPrintProcessorInfo points to structure array
1842 * DWORD cbBuf array length in bytes
1843 * LPDWORD pcbNeeded points to number of bytes copied (or required)
1844 * LPDWORD pcReturned points to number of job info. structures copied
1845 * Variables :
1846 * Result :
1847 * Remark :
1848 * Status : UNTESTED STUB
1849 *
1850 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1851 *
1852 * Author : Markus Montkowski [09.07.98 14:39:52]
1853 *****************************************************************************/
1854
1855ODINFUNCTION7(BOOL, EnumPrintProcessorsW,
1856 LPWSTR, pName,
1857 LPWSTR, pEnvironment,
1858 DWORD, Level,
1859 LPBYTE, pPrintProcessorInfo,
1860 DWORD, cbBuf,
1861 LPDWORD, pcbNeeded,
1862 LPDWORD, pcReturned)
1863{
1864 dprintf(("WINSPOOL: EnumPrintProcessorsW not implemented\n"));
1865 return (FALSE);
1866}
1867
1868
1869/*****************************************************************************
1870 * Name : BOOL EnumPrinterDriversA
1871 * Purpose :
1872 * Parameters: LPSTR pName pointer to server name
1873 * LPSTR pEnvironment pointer to environment name
1874 * DWORD Level structure level
1875 * LPBYTE pDriverInfo pointer to an array of structures
1876 * DWORD cbBuf size, in bytes, of array
1877 * LPDWORD pcbNeeded pointer to number of bytes copied (or required)
1878 * LPDWORD pcReturned pointer to number of DRIVER_INFO. structures
1879 * Variables :
1880 * Result :
1881 * Remark :
1882 * Status : UNTESTED STUB
1883 *
1884 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1885 *
1886 * Author : Markus Montkowski [09.07.98 14:40:23]
1887 *****************************************************************************/
1888
1889ODINFUNCTION7(BOOL, EnumPrinterDriversA,
1890 LPSTR, pName,
1891 LPSTR, pEnvironment,
1892 DWORD, Level,
1893 LPBYTE, pDriverInfo,
1894 DWORD, cbBuf,
1895 LPDWORD, pcbNeeded,
1896 LPDWORD, pcReturned)
1897{
1898 dprintf(("WINSPOOL: EnumPrinterDriversA not implemented\n"));
1899 return (FALSE);
1900}
1901
1902
1903/*****************************************************************************
1904 * Name : BOOL EnumPrinterDriversW
1905 * Purpose :
1906 * Parameters: LPWSTR pName pointer to server name
1907 * LPWSTR pEnvironment pointer to environment name
1908 * DWORD Level structure level
1909 * LPBYTE pDriverInfo pointer to an array of structures
1910 * DWORD cbBuf size, in bytes, of array
1911 * LPDWORD pcbNeeded pointer to number of bytes copied (or required)
1912 * LPDWORD pcReturned pointer to number of DRIVER_INFO. structures
1913 * Variables :
1914 * Result :
1915 * Remark :
1916 * Status : UNTESTED STUB
1917 *
1918 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1919 *
1920 * Author : Markus Montkowski [09.07.98 14:40:24]
1921 *****************************************************************************/
1922
1923ODINFUNCTION7(BOOL, EnumPrinterDriversW,
1924 LPWSTR, pName,
1925 LPWSTR, pEnvironment,
1926 DWORD, Level,
1927 LPBYTE, pDriverInfo,
1928 DWORD, cbBuf,
1929 LPDWORD, pcbNeeded,
1930 LPDWORD, pcReturned)
1931{
1932 dprintf(("WINSPOOL: EnumPrinterDriversW not implemented\n"));
1933 return (FALSE);
1934}
1935
1936
1937/*****************************************************************************
1938 * Name : BOOL EnumPrintersW
1939 * Purpose :
1940 * Parameters: DWORD Flags types of printer objects to enumerate
1941 * LPWSTR Name name of printer object
1942 * DWORD Level specifies type of printer info structure
1943 * LPBYTE pPrinterEnum pointer to buffer to receive printer info structures
1944 * DWORD cbBuf size, in bytes, of array
1945 * LPDWORD pcbNeeded pointer to variable with no. of bytes copied (or required)
1946 * LPDWORD pcReturned pointer to variable with no. of printer info. structures copied
1947 * Variables :
1948 * Result :
1949 * Remark :
1950 * Status : UNTESTED STUB
1951 *
1952 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1953 *
1954 * Author : Markus Montkowski [09.07.98 14:40:55]
1955 *****************************************************************************/
1956
1957ODINFUNCTION7(BOOL, EnumPrintersW,
1958 DWORD, Flags,
1959 LPWSTR, Name,
1960 DWORD, Level,
1961 LPBYTE, pPrinterEnum,
1962 DWORD, cbBuf,
1963 LPDWORD, pcbNeeded,
1964 LPDWORD, pcReturned)
1965{
1966 dprintf(("WINSPOOL: EnumPrintersW not implemented\n"));
1967 return (FALSE);
1968}
1969
1970
1971/*****************************************************************************
1972 * Name : BOOL FindClosePrinterChangeNotification
1973 * Purpose :
1974 * Parameters: HANDLE hChange handle to change notification object to close
1975 * Variables :
1976 * Result :
1977 * Remark :
1978 * Status : UNTESTED STUB
1979 *
1980 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1981 *
1982 * Author : Markus Montkowski [09.07.98 14:41:51]
1983 *****************************************************************************/
1984
1985ODINFUNCTION1(BOOL, FindClosePrinterChangeNotification,
1986 HANDLE, hChange)
1987{
1988 dprintf(("WINSPOOL: FindClosePrinterChangeNotification not implemented\n"));
1989 return (FALSE);
1990}
1991
1992
1993/*****************************************************************************
1994 * Name : HANDLE FindFirstPrinterChangeNotification
1995 * Purpose :
1996 * Parameters: HANDLE hPrinter handle to printer or print server to monitor for changes
1997 * DWORD fdwFlags flags that specify the conditions to monitor
1998 * DWORD fdwOptions reserved, must be zero
1999 * LPVOID pPrinterNotifyOptions pointer to structure specifying printer information to monitor
2000 * Variables :
2001 * Result :
2002 * Remark :
2003 * Status : UNTESTED STUB
2004 *
2005 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2006 *
2007 * Author : Markus Montkowski [09.07.98 14:42:05]
2008 *****************************************************************************/
2009
2010ODINFUNCTION4(HANDLE, FindFirstPrinterChangeNotification,
2011 HANDLE, hPrinter,
2012 DWORD, fdwFlags,
2013 DWORD, fdwOptions,
2014 LPVOID, pPrinterNotifyOptions)
2015{
2016 dprintf(("WINSPOOL: FindFirstPrinterChangeNotification not implemented\n"));
2017 return (NULL);
2018}
2019
2020
2021/*****************************************************************************
2022 * Name : BOOL FindNextPrinterChangeNotification
2023 * Purpose :
2024 * Parameters: HANDLE hChange handle to change notification object of interest
2025 * PDWORD pdwChange pointer to a value that indicates the condition that changed
2026 * LPVOID pPrinterNotifyOptions pointer to a structure that specifies a refresh flag
2027 * LPVOID *ppPrinterNotifyInfo pointer to a pointer that receives printer information buffer
2028 * Variables :
2029 * Result :
2030 * Remark :
2031 * Status : UNTESTED STUB
2032 *
2033 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2034 *
2035 * Author : Markus Montkowski [09.07.98 14:42:20]
2036 *****************************************************************************/
2037
2038ODINFUNCTION4(BOOL, FindNextPrinterChangeNotification,
2039 HANDLE, hChange,
2040 PDWORD, pdwChange,
2041 LPVOID, pPrinterNotifyOptions,
2042 LPPRINTER_NOTIFY_INFO, ppPrinterNotifyInfo)
2043{
2044 dprintf(("WINSPOOL: FindNextPrinterChangeNotification not implemented\n"));
2045 return (FALSE);
2046}
2047
2048
2049/*****************************************************************************
2050 * Name : BOOL FreePrinterNotifyInfo
2051 * Purpose :
2052 * Parameters: PPRINTER_NOTIFY_INFO pPrinterNotifyInfo pointer to a PRINTER_NOTIFY_INFO buffer
2053 * Variables :
2054 * Result :
2055 * Remark :
2056 * Status : UNTESTED STUB
2057 *
2058 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2059 *
2060 * Author : Markus Montkowski [09.07.98 14:43:02]
2061 *****************************************************************************/
2062
2063ODINFUNCTION1(BOOL, FreePrinterNotifyInfo,
2064 LPPRINTER_NOTIFY_INFO, pPrinterNotifyInfo)
2065{
2066 dprintf(("WINSPOOL: FreePrinterNotifyInfo not implemented\n"));
2067 return (FALSE);
2068}
2069
2070
2071/*****************************************************************************
2072 * Name : BOOL GetFormA
2073 * Purpose :
2074 * Parameters: HANDLE hPrinter handle of printer
2075 * LPSTR pFormName address of form name
2076 * DWORD Level structure level
2077 * LPBYTE pForm address of structure array
2078 * DWORD cbBuf count of bytes in array
2079 * LPDWORD pcbNeeded addr. of variable with count of bytes retrieved (or required)
2080 * Variables :
2081 * Result :
2082 * Remark :
2083 * Status : UNTESTED STUB
2084 *
2085 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2086 *
2087 * Author : Markus Montkowski [09.07.98 14:43:32]
2088 *****************************************************************************/
2089
2090ODINFUNCTION6(BOOL, GetFormA,
2091 HANDLE, hPrinter,
2092 LPSTR, pFormName,
2093 DWORD, Level,
2094 LPBYTE, pForm,
2095 DWORD, cbBuf,
2096 LPDWORD, pcbNeeded)
2097{
2098 dprintf(("WINSPOOL: GetFormA not implemented\n"));
2099 return (FALSE);
2100}
2101
2102
2103/*****************************************************************************
2104 * Name : BOOL GetFormW
2105 * Purpose :
2106 * Parameters: HANDLE hPrinter handle of printer
2107 * LPWSTR pFormName address of form name
2108 * DWORD Level structure level
2109 * LPBYTE pForm address of structure array
2110 * DWORD cbBuf count of bytes in array
2111 * LPDWORD pcbNeeded addr. of variable with count of bytes retrieved (or required)
2112 * Variables :
2113 * Result :
2114 * Remark :
2115 * Status : UNTESTED STUB
2116 *
2117 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2118 *
2119 * Author : Markus Montkowski [09.07.98 14:43:32]
2120 *****************************************************************************/
2121
2122ODINFUNCTION6(BOOL, GetFormW,
2123 HANDLE, hPrinter,
2124 LPWSTR, pFormName,
2125 DWORD, Level,
2126 LPBYTE, pForm,
2127 DWORD, cbBuf,
2128 LPDWORD, pcbNeeded)
2129{
2130 dprintf(("WINSPOOL: GetFormW not implemented\n"));
2131 return (FALSE);
2132}
2133
2134
2135/*****************************************************************************
2136 * Name : BOOL GetJobA
2137 * Purpose :
2138 * Parameters: HANDLE hPrinter handle of printer
2139 * DWORD JobId job identifier value
2140 * DWORD Level data-structure level
2141 * LPBYTE pJob address of data-structure array
2142 * DWORD cbBuf count of bytes in array
2143 * LPDWORD pcbNeeded address of value that contains count of bytes retrieved (or required)
2144 * Variables :
2145 * Result :
2146 * Remark :
2147 * Status : UNTESTED STUB
2148 *
2149 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2150 *
2151 * Author : Markus Montkowski [09.07.98 14:43:50]
2152 *****************************************************************************/
2153
2154ODINFUNCTION6(BOOL, GetJobA,
2155 HANDLE, hPrinter,
2156 DWORD, JobId,
2157 DWORD, Level,
2158 LPBYTE, pJob,
2159 DWORD, cbBuf,
2160 LPDWORD, pcbNeeded)
2161{
2162 dprintf(("WINSPOOL: GetJobA not implemented\n"));
2163 return (FALSE);
2164}
2165
2166
2167/*****************************************************************************
2168 * Name : BOOL GetJobW
2169 * Purpose :
2170 * Parameters: HANDLE hPrinter handle of printer
2171 * DWORD JobId job identifier value
2172 * DWORD Level data-structure level
2173 * LPBYTE pJob address of data-structure array
2174 * DWORD cbBuf count of bytes in array
2175 * LPDWORD pcbNeeded address of value that contains count of bytes retrieved (or required)
2176 * Variables :
2177 * Result :
2178 * Remark :
2179 * Status : UNTESTED STUB
2180 *
2181 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2182 *
2183 * Author : Markus Montkowski [09.07.98 14:43:50]
2184 *****************************************************************************/
2185
2186ODINFUNCTION6(BOOL, GetJobW,
2187 HANDLE, hPrinter,
2188 DWORD, JobId,
2189 DWORD, Level,
2190 LPBYTE, pJob,
2191 DWORD, cbBuf,
2192 LPDWORD, pcbNeeded)
2193{
2194 dprintf(("WINSPOOL: GetJobW not implemented\n"));
2195 return (FALSE);
2196}
2197
2198
2199/*****************************************************************************
2200 * Name : BOOL GetPrintProcessorDirectoryA
2201 * Purpose :
2202 * Parameters: LPSTR pName address of server name
2203 * LPSTR pEnvironment address of environment
2204 * DWORD Level structure level
2205 * LPBYTE pPrintProcessorInfo address of structure array
2206 * DWORD cbBuf size, in bytes, of array
2207 * LPDWORD pcbNeeded address of variable with number of bytes retrieved (or required)
2208 * Variables :
2209 * Result :
2210 * Remark :
2211 * Status : UNTESTED STUB
2212 *
2213 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2214 *
2215 * Author : Markus Montkowski [09.07.98 14:45:14]
2216 *****************************************************************************/
2217
2218ODINFUNCTION6(BOOL, GetPrintProcessorDirectoryA,
2219 LPSTR, pName,
2220 LPSTR, pEnvironment,
2221 DWORD, Level,
2222 LPBYTE, pPrintProcessorInfo,
2223 DWORD, cbBuf,
2224 LPDWORD, pcbNeeded)
2225{
2226 dprintf(("WINSPOOL: GetPrintProcessorDirectoryA not implemented\n"));
2227 return (FALSE);
2228}
2229
2230
2231/*****************************************************************************
2232 * Name : BOOL GetPrintProcessorDirectoryW
2233 * Purpose :
2234 * Parameters: LPWSTR pName address of server name
2235 * LPWSTR pEnvironment address of environment
2236 * DWORD Level structure level
2237 * LPBYTE pPrintProcessorInfo address of structure array
2238 * DWORD cbBuf size, in bytes, of array
2239 * LPDWORD pcbNeeded address of variable with number of bytes retrieved (or required)
2240 * Variables :
2241 * Result :
2242 * Remark :
2243 * Status : UNTESTED STUB
2244 *
2245 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2246 *
2247 * Author : Markus Montkowski [09.07.98 14:45:14]
2248 *****************************************************************************/
2249
2250ODINFUNCTION6(BOOL, GetPrintProcessorDirectoryW,
2251 LPWSTR, pName,
2252 LPWSTR, pEnvironment,
2253 DWORD, Level,
2254 LPBYTE, pPrintProcessorInfo,
2255 DWORD, cbBuf,
2256 LPDWORD, pcbNeeded)
2257{
2258 dprintf(("WINSPOOL: GetPrintProcessorDirectoryW not implemented\n"));
2259 return (FALSE);
2260}
2261
2262
2263/*****************************************************************************
2264 * Name : BOOL GetPrinterA
2265 * Purpose :
2266 * Parameters: HANDLE hPrinter handle to printer of interest
2267 * DWORD Level version of printer info data structure
2268 * LPBYTE pPrinter pointer to array of bytes that receives printer info. structure
2269 * DWORD cbBuf size, in bytes, of array of bytes
2270 * LPDWORD pcbNeeded pointer to variable with count of bytes retrieved (or required)
2271 * Variables :
2272 * Result :
2273 * Remark :
2274 * Status : UNTESTED STUB
2275 *
2276 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2277 *
2278 * Author : Markus Montkowski [09.07.98 14:45:36]
2279 *****************************************************************************/
2280
2281ODINFUNCTION5(BOOL, GetPrinterA,
2282 HANDLE, hPrinter,
2283 DWORD, Level,
2284 LPBYTE, pPrinter,
2285 DWORD, cbBuf,
2286 LPDWORD, pcbNeeded)
2287{
2288 dprintf(("WINSPOOL: GetPrinterA not implemented\n"));
2289 return (FALSE);
2290}
2291
2292
2293/*****************************************************************************
2294 * Name : BOOL GetPrinterW
2295 * Purpose :
2296 * Parameters: HANDLE hPrinter handle to printer of interest
2297 * DWORD Level version of printer info data structure
2298 * LPBYTE pPrinter pointer to array of bytes that receives printer info. structure
2299 * DWORD cbBuf size, in bytes, of array of bytes
2300 * LPDWORD pcbNeeded pointer to variable with count of bytes retrieved (or required)
2301 * Variables :
2302 * Result :
2303 * Remark :
2304 * Status : UNTESTED STUB
2305 *
2306 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2307 *
2308 * Author : Markus Montkowski [09.07.98 14:45:36]
2309 *****************************************************************************/
2310
2311ODINFUNCTION5(BOOL, GetPrinterW,
2312 HANDLE, hPrinter,
2313 DWORD, Level,
2314 LPBYTE, pPrinter,
2315 DWORD, cbBuf,
2316 LPDWORD, pcbNeeded)
2317{
2318 dprintf(("WINSPOOL: GetPrinterW not implemented\n"));
2319 return (FALSE);
2320}
2321
2322
2323/*****************************************************************************
2324 * Name : DWORD GetPrinterDataA
2325 * Purpose :
2326 * Parameters: HANDLE hPrinter handle of printer object
2327 * LPSTR pValueName address of data type
2328 * LPDWORD pType reserved
2329 * LPBYTE pData address of array of bytes that receives data
2330 * DWORD nSize size, in bytes, of array
2331 * LPDWORD pcbNeeded address of variable with number of bytes retrieved (or required)
2332 * Variables :
2333 * Result :
2334 * Remark :
2335 * Status : UNTESTED STUB
2336 *
2337 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2338 *
2339 * Author : Markus Montkowski [09.07.98 14:46:35]
2340 *****************************************************************************/
2341
2342ODINFUNCTION6(DWORD, GetPrinterDataA,
2343 HANDLE, hPrinter,
2344 LPSTR, pValueName,
2345 LPDWORD, pType,
2346 LPBYTE, pData,
2347 DWORD, nSize,
2348 LPDWORD, pcbNeeded)
2349{
2350 dprintf(("WINSPOOL: GetPrinterDataA not implemented\n"));
2351 return (0);
2352}
2353
2354
2355/*****************************************************************************
2356 * Name : DWORD GetPrinterDataW
2357 * Purpose :
2358 * Parameters: HANDLE hPrinter handle of printer object
2359 * LPWSTR pValueName address of data type
2360 * LPDWORD pType reserved
2361 * LPBYTE pData address of array of bytes that receives data
2362 * DWORD nSize size, in bytes, of array
2363 * LPDWORD pcbNeeded address of variable with number of bytes retrieved (or required)
2364 * Variables :
2365 * Result :
2366 * Remark :
2367 * Status : UNTESTED STUB
2368 *
2369 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2370 *
2371 * Author : Markus Montkowski [09.07.98 14:46:35]
2372 *****************************************************************************/
2373
2374ODINFUNCTION6(DWORD, GetPrinterDataW,
2375 HANDLE, hPrinter,
2376 LPWSTR, pValueName,
2377 LPDWORD, pType,
2378 LPBYTE, pData,
2379 DWORD, nSize,
2380 LPDWORD, pcbNeeded)
2381{
2382 dprintf(("WINSPOOL: GetPrinterDataW not implemented\n"));
2383 return (0);
2384}
2385
2386
2387/*****************************************************************************
2388 * Name : BOOL GetPrinterDriverA
2389 * Purpose :
2390 * Parameters: HANDLE hPrinter printer object
2391 * LPSTR pEnvironment address of environment
2392 * DWORD Level structure level
2393 * LPBYTE pDriverInfo address of structure array
2394 * DWORD cbBuf size, in bytes, of array
2395 * LPDWORD pcbNeeded address of variable with number of bytes retrieved (or required)
2396 * Variables :
2397 * Result :
2398 * Remark :
2399 * Status : UNTESTED STUB
2400 *
2401 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2402 *
2403 * Author : Markus Montkowski [09.07.98 14:47:01]
2404 *****************************************************************************/
2405
2406ODINFUNCTION6(BOOL, GetPrinterDriverA,
2407 HANDLE, hPrinter,
2408 LPSTR, pEnvironment,
2409 DWORD, Level,
2410 LPBYTE, pDriverInfo,
2411 DWORD, cbBuf,
2412 LPDWORD, pcbNeeded)
2413{
2414 dprintf(("WINSPOOL: GetPrinterDriverA not implemented\n"));
2415 return (FALSE);
2416}
2417
2418
2419/*****************************************************************************
2420 * Name : BOOL GetPrinterDriverW
2421 * Purpose :
2422 * Parameters: HANDLE hPrinter printer object
2423 * LPWSTR pEnvironment address of environment
2424 * DWORD Level structure level
2425 * LPBYTE pDriverInfo address of structure array
2426 * DWORD cbBuf size, in bytes, of array
2427 * LPDWORD pcbNeeded address of variable with number of bytes retrieved (or required)
2428 * Variables :
2429 * Result :
2430 * Remark :
2431 * Status : UNTESTED STUB
2432 *
2433 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2434 *
2435 * Author : Markus Montkowski [09.07.98 14:47:01]
2436 *****************************************************************************/
2437
2438ODINFUNCTION6(BOOL, GetPrinterDriverW,
2439 HANDLE, hPrinter,
2440 LPWSTR, pEnvironment,
2441 DWORD, Level,
2442 LPBYTE, pDriverInfo,
2443 DWORD, cbBuf,
2444 LPDWORD, pcbNeeded)
2445{
2446 dprintf(("WINSPOOL: GetPrinterDriverW not implemented\n"));
2447 return (FALSE);
2448}
2449
2450
2451/*****************************************************************************
2452 * Name : BOOL GetPrinterDriverDirectoryA
2453 * Purpose :
2454 * Parameters: LPSTR pName address of server name
2455 * LPSTR pEnvironment address of environment
2456 * DWORD Level address of structure
2457 * LPBYTE pDriverDirectory address of structure array that receives path
2458 * DWORD cbBuf size, in bytes, of array
2459 * LPDWORD pcbNeeded address of variable with number of bytes retrieved (or required)
2460 * Variables :
2461 * Result :
2462 * Remark :
2463 * Status : UNTESTED STUB
2464 *
2465 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2466 *
2467 * Author : Markus Montkowski [09.07.98 14:47:16]
2468 *****************************************************************************/
2469
2470ODINFUNCTION6(BOOL, GetPrinterDriverDirectoryA,
2471 LPSTR, pName,
2472 LPSTR, pEnvironment,
2473 DWORD, Level,
2474 LPBYTE, pDriverDirectory,
2475 DWORD, cbBuf,
2476 LPDWORD, pcbNeeded)
2477{
2478 dprintf(("WINSPOOL: GetPrinterDriverDirectoryA not implemented\n"));
2479 return (FALSE);
2480}
2481
2482
2483/*****************************************************************************
2484 * Name : BOOL GetPrinterDriverDirectoryW
2485 * Purpose :
2486 * Parameters: LPWSTR pName address of server name
2487 * LPWSTR pEnvironment address of environment
2488 * DWORD Level address of structure
2489 * LPBYTE pDriverDirectory address of structure array that receives path
2490 * DWORD cbBuf size, in bytes, of array
2491 * LPDWORD pcbNeeded address of variable with number of bytes retrieved (or required)
2492 * Variables :
2493 * Result :
2494 * Remark :
2495 * Status : UNTESTED STUB
2496 *
2497 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2498 *
2499 * Author : Markus Montkowski [09.07.98 14:47:16]
2500 *****************************************************************************/
2501
2502ODINFUNCTION6(BOOL, GetPrinterDriverDirectoryW,
2503 LPWSTR, pName,
2504 LPWSTR, pEnvironment,
2505 DWORD, Level,
2506 LPBYTE, pDriverDirectory,
2507 DWORD, cbBuf,
2508 LPDWORD, pcbNeeded)
2509{
2510 dprintf(("WINSPOOL: GetPrinterDriverDirectoryW not implemented\n"));
2511 return (FALSE);
2512}
2513
2514
2515
2516/*****************************************************************************
2517 * Name : BOOL OpenPrinterW
2518 * Purpose :
2519 * Parameters: LPWSTR pPrinterName pointer to printer or server name
2520 * HANDLE * phPrinter pointer to printer or server handle
2521 * PRINTER_DEFAULTSW * pDefault pointer to printer defaults structure
2522 * Variables :
2523 * Result :
2524 * Remark :
2525 * Status : UNTESTED STUB
2526 *
2527 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2528 *
2529 * Author : Markus Montkowski [09.07.98 14:48:19]
2530 *****************************************************************************/
2531
2532ODINFUNCTION3(BOOL, OpenPrinterW,
2533 LPWSTR, pPrinterName,
2534 HANDLE *, phPrinter,
2535 PRINTER_DEFAULTSW *, pDefault)
2536{
2537 dprintf(("WINSPOOL: OpenPrinterW not implemented\n"));
2538 return (FALSE);
2539}
2540
2541
2542/*****************************************************************************
2543 * Name : HPRINTER PrinterMessageBoxA
2544 * Purpose :
2545 * Parameters: HANDLE hPrinter handle of printer
2546 * DWORD Error error identifier
2547 * HWND hWnd handle of owner window
2548 * LPSTR pText pointer to message box text
2549 * LPSTR pCaption pointer to message box title
2550 * DWORD dwType style of message box
2551 * Variables :
2552 * Result :
2553 * Remark :
2554 * Status : UNTESTED STUB
2555 *
2556 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2557 *
2558 * Author : Markus Montkowski [09.07.98 14:50:13]
2559 *****************************************************************************/
2560
2561ODINFUNCTION6(HPRINTER, PrinterMessageBoxA,
2562 HANDLE, hPrinter,
2563 DWORD, Error,
2564 HWND, hWnd,
2565 LPSTR, pText,
2566 LPSTR, pCaption,
2567 DWORD, dwType)
2568{
2569 dprintf(("WINSPOOL: PrinterMessageBoxA not implemented\n"));
2570 return (0);
2571}
2572
2573
2574/*****************************************************************************
2575 * Name : HPRINTER PrinterMessageBoxW
2576 * Purpose :
2577 * Parameters: HANDLE hPrinter handle of printer
2578 * DWORD Error error identifier
2579 * HWND hWnd handle of owner window
2580 * LPWSTR pText pointer to message box text
2581 * LPWSTR pCaption pointer to message box title
2582 * DWORD dwType style of message box
2583 * Variables :
2584 * Result :
2585 * Remark :
2586 * Status : UNTESTED STUB
2587 *
2588 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2589 *
2590 * Author : Markus Montkowski [09.07.98 14:50:13]
2591 *****************************************************************************/
2592
2593ODINFUNCTION6(HPRINTER, PrinterMessageBoxW,
2594 HANDLE, hPrinter,
2595 DWORD, Error,
2596 HWND, hWnd,
2597 LPWSTR, pText,
2598 LPWSTR, pCaption,
2599 DWORD, dwType)
2600{
2601 dprintf(("WINSPOOL: PrinterMessageBoxW not implemented\n"));
2602 return (0);
2603}
2604
2605
2606/*****************************************************************************
2607 * Name : BOOL PrinterProperties
2608 * Purpose :
2609 * Parameters: HWND hWnd handle of parent window
2610 * HANDLE hPrinter handle of printer object
2611 * Variables :
2612 * Result :
2613 * Remark :
2614 * Status : UNTESTED STUB
2615 *
2616 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2617 *
2618 * Author : Markus Montkowski [09.07.98 14:50:49]
2619 *****************************************************************************/
2620
2621ODINFUNCTION2(BOOL, PrinterProperties,
2622 HWND, hWnd,
2623 HANDLE, hPrinter)
2624{
2625 dprintf(("WINSPOOL: PrinterProperties not implemented\n"));
2626 return (FALSE);
2627}
2628
2629
2630/*****************************************************************************
2631 * Name : BOOL ReadPrinter
2632 * Purpose :
2633 * Parameters: HANDLE hPrinter handle of printer object
2634 * LPVOID pBuf address of array of bytes that receives data
2635 * DWORD cbBuf size, in bytes, of array
2636 * LPDWORD pNoBytesRead address of variable with number of bytes retrieved
2637 * Variables :
2638 * Result :
2639 * Remark :
2640 * Status : UNTESTED STUB
2641 *
2642 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2643 *
2644 * Author : Markus Montkowski [09.07.98 14:51:17]
2645 *****************************************************************************/
2646ODINFUNCTION4(BOOL, ReadPrinter,
2647 HANDLE, hPrinter,
2648 LPVOID, pBuf,
2649 DWORD, cbBuf,
2650 LPDWORD, pNoBytesRead)
2651{
2652 dprintf(("WINSPOOL: ReadPrinter not implemented\n"));
2653 return (FALSE);
2654}
2655
2656
2657/*****************************************************************************
2658 * Name : BOOL ResetPrinterA
2659 * Purpose :
2660 * Parameters: HANDLE hPrinter printer handle
2661 * PRINTER_DEFAULTSA * pDefault address of printer defaults structure
2662 * Variables :
2663 * Result :
2664 * Remark :
2665 * Status : UNTESTED STUB
2666 *
2667 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2668 *
2669 * Author : Markus Montkowski [09.07.98 14:51:52]
2670 *****************************************************************************/
2671
2672ODINFUNCTION2(BOOL, ResetPrinterA,
2673 HANDLE, hPrinter,
2674 PRINTER_DEFAULTSA *, pDefault)
2675{
2676 dprintf(("WINSPOOL: ResetPrinterA not implemented\n"));
2677 return (FALSE);
2678}
2679
2680
2681/*****************************************************************************
2682 * Name : BOOL ResetPrinterW
2683 * Purpose :
2684 * Parameters: HANDLE hPrinter printer handle
2685 * PRINTER_DEFAULTSW * pDefault address of printer defaults structure
2686 * Variables :
2687 * Result :
2688 * Remark :
2689 * Status : UNTESTED STUB
2690 *
2691 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2692 *
2693 * Author : Markus Montkowski [09.07.98 14:51:52]
2694 *****************************************************************************/
2695
2696ODINFUNCTION2(BOOL, ResetPrinterW,
2697 HANDLE, hPrinter,
2698 PRINTER_DEFAULTSW *, pDefault)
2699{
2700 dprintf(("WINSPOOL: ResetPrinterW not implemented\n"));
2701 return (FALSE);
2702}
2703
2704/*****************************************************************************
2705 * Name : BOOL ScheduleJob
2706 * Purpose :
2707 * Parameters: HANDLE hPrinter specifies printer for the print job
2708 * DWORD dwJobID print job identifier
2709 * Variables :
2710 * Result :
2711 * Remark :
2712 * Status : UNTESTED STUB
2713 *
2714 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2715 *
2716 * Author : Markus Montkowski [09.07.98 14:52:39]
2717 *****************************************************************************/
2718
2719ODINFUNCTION2(BOOL, ScheduleJob,
2720 HANDLE, hPrinter,
2721 DWORD, dwJobID)
2722{
2723 dprintf(("WINSPOOL: ScheduleJob not implemented\n"));
2724 return (FALSE);
2725}
2726
2727
2728/*****************************************************************************
2729 * Name : BOOL SetFormA
2730 * Purpose :
2731 * Parameters: HANDLE hPrinter handle of printer object
2732 * LPSTR pFormName address of form name
2733 * DWORD Level structure level
2734 * LPBYTE pForm address of structure array
2735 * Variables :
2736 * Result :
2737 * Remark :
2738 * Status : UNTESTED STUB
2739 *
2740 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2741 *
2742 * Author : Markus Montkowski [09.07.98 14:53:20]
2743 *****************************************************************************/
2744
2745ODINFUNCTION4(BOOL, SetFormA,
2746 HANDLE, hPrinter,
2747 LPSTR, pFormName,
2748 DWORD, Level,
2749 LPBYTE, pForm)
2750{
2751 dprintf(("WINSPOOL: SetFormA not implemented\n"));
2752 return (FALSE);
2753}
2754
2755
2756/*****************************************************************************
2757 * Name : BOOL SetFormW
2758 * Purpose :
2759 * Parameters: HANDLE hPrinter handle of printer object
2760 * LPWSTR pFormName address of form name
2761 * DWORD Level structure level
2762 * LPBYTE pForm address of structure array
2763 * Variables :
2764 * Result :
2765 * Remark :
2766 * Status : UNTESTED STUB
2767 *
2768 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2769 *
2770 * Author : Markus Montkowski [09.07.98 14:53:20]
2771 *****************************************************************************/
2772
2773ODINFUNCTION4(BOOL, SetFormW,
2774 HANDLE, hPrinter,
2775 LPWSTR, pFormName,
2776 DWORD, Level,
2777 LPBYTE, pForm)
2778{
2779 dprintf(("WINSPOOL: SetFormW not implemented\n"));
2780 return (FALSE);
2781}
2782
2783
2784/*****************************************************************************
2785 * Name : BOOL SetJobA
2786 * Purpose :
2787 * Parameters: HANDLE hPrinter handle to printer object
2788 * DWORD JobId print job identifier
2789 * DWORD Level specifies type of job information structure
2790 * LPBYTE pJob pointer to job information structure
2791 * DWORD Command job command value
2792 * Variables :
2793 * Result :
2794 * Remark :
2795 * Status : UNTESTED STUB
2796 *
2797 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2798 *
2799 * Author : Markus Montkowski [09.07.98 14:53:47]
2800 *****************************************************************************/
2801
2802ODINFUNCTION5(BOOL, SetJobA,
2803 HANDLE, hPrinter,
2804 DWORD, JobId,
2805 DWORD, Level,
2806 LPBYTE, pJob,
2807 DWORD, Command)
2808{
2809 dprintf(("WINSPOOL: SetJobA not implemented\n"));
2810 return (FALSE);
2811}
2812
2813
2814/*****************************************************************************
2815 * Name : BOOL SetJobW
2816 * Purpose :
2817 * Parameters: HANDLE hPrinter handle to printer object
2818 * DWORD JobId print job identifier
2819 * DWORD Level specifies type of job information structure
2820 * LPBYTE pJob pointer to job information structure
2821 * DWORD Command job command value
2822 * Variables :
2823 * Result :
2824 * Remark :
2825 * Status : UNTESTED STUB
2826 *
2827 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2828 *
2829 * Author : Markus Montkowski [09.07.98 14:53:47]
2830 *****************************************************************************/
2831
2832ODINFUNCTION5(BOOL, SetJobW,
2833 HANDLE, hPrinter,
2834 DWORD, JobId,
2835 DWORD, Level,
2836 LPBYTE, pJob,
2837 DWORD, Command)
2838{
2839 dprintf(("WINSPOOL: SetJobW not implemented\n"));
2840 return (FALSE);
2841}
2842
2843/*****************************************************************************
2844 * Name : BOOL SetPrinterA
2845 * Purpose :
2846 * Parameters: HANDLE hPrinter handle of printer object
2847 * DWORD Level structure level
2848 * LPBYTE pPrinter address of array containing printer data
2849 * DWORD Command printer-state command
2850 * Variables :
2851 * Result :
2852 * Remark :
2853 * Status : UNTESTED STUB
2854 *
2855 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2856 *
2857 * Author : Markus Montkowski [09.07.98 14:55:03]
2858 *****************************************************************************/
2859
2860ODINFUNCTION4(BOOL, SetPrinterA,
2861 HANDLE, hPrinter,
2862 DWORD, Level,
2863 LPBYTE, pPrinter,
2864 DWORD, Command)
2865{
2866 dprintf(("WINSPOOL: SetPrinterA not implemented\n"));
2867 return (FALSE);
2868}
2869
2870
2871/*****************************************************************************
2872 * Name : BOOL SetPrinterW
2873 * Purpose :
2874 * Parameters: HANDLE hPrinter handle of printer object
2875 * DWORD Level structure level
2876 * LPBYTE pPrinter address of array containing printer data
2877 * DWORD Command printer-state command
2878 * Variables :
2879 * Result :
2880 * Remark :
2881 * Status : UNTESTED STUB
2882 *
2883 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2884 *
2885 * Author : Markus Montkowski [09.07.98 14:55:03]
2886 *****************************************************************************/
2887
2888ODINFUNCTION4(BOOL, SetPrinterW,
2889 HANDLE, hPrinter,
2890 DWORD, Level,
2891 LPBYTE, pPrinter,
2892 DWORD, Command)
2893{
2894 dprintf(("WINSPOOL: SetPrinterW not implemented\n"));
2895 return (FALSE);
2896}
2897
2898
2899/*****************************************************************************
2900 * Name : DWORD SetPrinterDataA
2901 * Purpose :
2902 * Parameters: HANDLE hPrinter handle of printer object
2903 * LPSTR pValueName address of data type
2904 * DWORD Type flag for value type
2905 * LPBYTE pData address of array that specifies printer data
2906 * DWORD cbData size, in bytes, of array
2907 * Variables :
2908 * Result :
2909 * Remark :
2910 * Status : UNTESTED STUB
2911 *
2912 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2913 *
2914 * Author : Markus Montkowski [09.07.98 14:55:52]
2915 *****************************************************************************/
2916
2917ODINFUNCTION5(DWORD, SetPrinterDataA,
2918 HANDLE, hPrinter,
2919 LPSTR, pValueName,
2920 DWORD, Type,
2921 LPBYTE, pData,
2922 DWORD, cbData)
2923{
2924 dprintf(("WINSPOOL: SetPrinterDataA not implemented\n"));
2925 return (0);
2926}
2927
2928
2929/*****************************************************************************
2930 * Name : DWORD SetPrinterDataW
2931 * Purpose :
2932 * Parameters: HANDLE hPrinter handle of printer object
2933 * LPWSTR pValueName address of data type
2934 * DWORD Type flag for value type
2935 * LPBYTE pData address of array that specifies printer data
2936 * DWORD cbData size, in bytes, of array
2937 * Variables :
2938 * Result :
2939 * Remark :
2940 * Status : UNTESTED STUB
2941 *
2942 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2943 *
2944 * Author : Markus Montkowski [09.07.98 14:55:52]
2945 *****************************************************************************/
2946
2947ODINFUNCTION5(DWORD, SetPrinterDataW,
2948 HANDLE, hPrinter,
2949 LPWSTR, pValueName,
2950 DWORD, Type,
2951 LPBYTE, pData,
2952 DWORD, cbData)
2953{
2954 dprintf(("WINSPOOL: SetPrinterDataW not implemented\n"));
2955 return (0);
2956}
2957
2958
2959/*****************************************************************************
2960 * Name : DWORD StartDocPrinterA
2961 * Purpose :
2962 * Parameters: HANDLE hPrinter handle of printer object
2963 * DWORD Level structure level
2964 * LPBYTE pDocInfo address of structure
2965 * Variables :
2966 * Result :
2967 * Remark :
2968 * Status : UNTESTED STUB
2969 *
2970 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2971 *
2972 * Author : Markus Montkowski [09.07.98 14:56:45]
2973 *****************************************************************************/
2974
2975ODINFUNCTION3(DWORD, StartDocPrinterA,
2976 HANDLE, hPrinter,
2977 DWORD, Level,
2978 LPBYTE, pDocInfo)
2979{
2980 dprintf(("WINSPOOL: StartDocPrinterA not implemented\n"));
2981 return (0);
2982}
2983
2984
2985/*****************************************************************************
2986 * Name : DWORD StartDocPrinterW
2987 * Purpose :
2988 * Parameters: HANDLE hPrinter handle of printer object
2989 * DWORD Level structure level
2990 * LPBYTE pDocInfo address of structure
2991 * Variables :
2992 * Result :
2993 * Remark :
2994 * Status : UNTESTED STUB
2995 *
2996 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2997 *
2998 * Author : Markus Montkowski [09.07.98 14:56:45]
2999 *****************************************************************************/
3000
3001ODINFUNCTION3(DWORD, StartDocPrinterW,
3002 HANDLE, hPrinter,
3003 DWORD, Level,
3004 LPBYTE, pDocInfo)
3005{
3006 dprintf(("WINSPOOL: StartDocPrinterW not implemented\n"));
3007 return (0);
3008}
3009
3010/*****************************************************************************
3011 * Name : BOOL StartPagePrinter
3012 * Purpose :
3013 * Parameters: HANDLE hPrinter handle of printer object
3014 * Variables :
3015 * Result :
3016 * Remark :
3017 * Status : UNTESTED STUB
3018 *
3019 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
3020 *
3021 * Author : Markus Montkowski [09.07.98 14:57:38]
3022 *****************************************************************************/
3023
3024ODINFUNCTION1(BOOL, StartPagePrinter,
3025 HANDLE, hPrinter)
3026{
3027 dprintf(("WINSPOOL: StartPagePrinter not implemented\n"));
3028 return (FALSE);
3029}
3030
3031
3032/*****************************************************************************
3033 * Name : BOOL WritePrinter
3034 * Purpose :
3035 * Parameters: HANDLE hPrinter handle to printer object
3036 * LPVOID pBuf pointer to array that contains printer data
3037 * DWORD cbBuf size, in bytes, of array
3038 * LPDWORD pcWritten addr. of variable with count of bytes written
3039 * Variables :
3040 * Result :
3041 * Remark :
3042 * Status : UNTESTED STUB
3043 *
3044 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
3045 *
3046 * Author : Markus Montkowski [09.07.98 14:58:49]
3047 *****************************************************************************/
3048
3049ODINFUNCTION4(BOOL, WritePrinter,
3050 HANDLE, hPrinter,
3051 LPVOID, pBuf,
3052 DWORD, cbBuf,
3053 LPDWORD, pcWritten)
3054{
3055 dprintf(("WINSPOOL: WritePrinter not implemented\n"));
3056 return (FALSE);
3057}
3058
3059
3060/*********************************************************************
3061 * DeletePrinterDataA (WINSPOOL.152)
3062 */
3063ODINFUNCTION2(DWORD, DeletePrinterDataA,
3064 HANDLE, hPrinter,
3065 LPSTR, pValueName)
3066{
3067 dprintf(("WINSPOOL: DeletePrinterDataA not implemented\n"));
3068 return (FALSE);
3069}
3070
3071
3072/*********************************************************************
3073 * DeletePrinterDataW (WINSPOOL.153)
3074 */
3075ODINFUNCTION2(DWORD, DeletePrinterDataW,
3076 HANDLE, hPrinter,
3077 LPWSTR, pValueName)
3078{
3079 dprintf(("WINSPOOL: DeletePrinterDataW not implemented\n"));
3080 return (FALSE);
3081}
3082
3083
3084/*********************************************************************
3085 * DocumentPropertiesW (WINSPOOL.166)
3086 */
3087ODINFUNCTION6(LONG, DocumentPropertiesW,
3088 HWND, hWnd,
3089 HANDLE, hPrinter,
3090 LPWSTR, pDeviceName,
3091 PDEVMODEW, pDevModeOutput,
3092 PDEVMODEW, pDevModeInput,
3093 DWORD, fMode)
3094{
3095 dprintf(("WINSPOOL: DocumentPropertiesW not implemented\n"));
3096 return (FALSE);
3097}
3098
3099
3100/*********************************************************************
3101 * EnumPrinterDataA (WINSPOOL.183)
3102 */
3103ODINFUNCTION9(DWORD, EnumPrinterDataA,
3104 HANDLE, hPrinter,
3105 DWORD, dwIndex,
3106 LPSTR, pValueName,
3107 DWORD, cbValueName,
3108 LPDWORD, pcbValueName,
3109 LPDWORD, pType,
3110 LPBYTE, pData,
3111 DWORD, cbData,
3112 LPDWORD, pcbData)
3113{
3114 dprintf(("WINSPOOL: EnumPrinterDataA not implemented\n"));
3115 return (FALSE);
3116}
3117
3118
3119/*********************************************************************
3120 * EnumPrinterDataW (WINSPOOL.184)
3121 */
3122ODINFUNCTION9(DWORD, EnumPrinterDataW,
3123 HANDLE, hPrinter,
3124 DWORD, dwIndex,
3125 LPWSTR, pValueName,
3126 DWORD, cbValueName,
3127 LPDWORD, pcbValueName,
3128 LPDWORD, pType,
3129 LPBYTE, pData,
3130 DWORD, cbData,
3131 LPDWORD, pcbData)
3132{
3133 dprintf(("WINSPOOL: EnumPrinterDataW not implemented\n"));
3134 return (FALSE);
3135}
3136
3137
3138/*********************************************************************
3139 * SetPortA (WINSPOOL.226)
3140 */
3141ODINFUNCTION4(BOOL, SetPortA,
3142 LPSTR, pName,
3143 LPSTR, pPortName,
3144 DWORD, dwLevel,
3145 LPBYTE, pPortInfo)
3146{
3147 dprintf(("WINSPOOL: SetPortA not implemented\n"));
3148 return (FALSE);
3149}
3150
3151
3152/*********************************************************************
3153 * SetPortW (WINSPOOL.227)
3154 */
3155ODINFUNCTION4(BOOL, SetPortW,
3156 LPWSTR, pName,
3157 LPWSTR, pPortName,
3158 DWORD, dwLevel,
3159 LPBYTE, pPortInfo)
3160{
3161 dprintf(("WINSPOOL: SetPortW not implemented\n"));
3162 return (FALSE);
3163}
Note: See TracBrowser for help on using the repository browser.