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

Last change on this file since 51 was 51, checked in by sandervl, 26 years ago

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