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

Last change on this file since 5856 was 5472, checked in by sandervl, 25 years ago

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