gdi: Use correct include file for FT_Get_Module.
[wine] / dlls / gdi / printdrv.c
1 /*
2  * Implementation of some printer driver bits
3  *
4  * Copyright 1996 John Harvey
5  * Copyright 1998 Huw Davies
6  * Copyright 1998 Andreas Mohr
7  * Copyright 1999 Klaas van Gend
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <signal.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <ctype.h>
33 #include <errno.h>
34 #ifdef HAVE_IO_H
35 # include <io.h>
36 #endif
37 #ifdef HAVE_UNISTD_H
38 # include <unistd.h>
39 #endif
40 #include <fcntl.h>
41 #include "windef.h"
42 #include "winbase.h"
43 #include "winuser.h"
44 #include "wine/winbase16.h"
45 #include "wine/wingdi16.h"
46 #include "winspool.h"
47 #include "winerror.h"
48 #include "winreg.h"
49 #include "wownt32.h"
50 #include "wine/debug.h"
51 #include "gdi.h"
52 #include "gdi_private.h"
53
54 WINE_DEFAULT_DEBUG_CHANNEL(print);
55
56 static const char PrinterModel[]      = "Printer Model";
57 static const char DefaultDevMode[]    = "Default DevMode";
58 static const char PrinterDriverData[] = "PrinterDriverData";
59 static const char Printers[]          = "System\\CurrentControlSet\\Control\\Print\\Printers\\";
60
61
62 /******************************************************************
63  *                  StartDocA  [GDI32.@]
64  *
65  * StartDoc calls the STARTDOC Escape with the input data pointing to DocName
66  * and the output data (which is used as a second input parameter).pointing at
67  * the whole docinfo structure.  This seems to be an undocumented feature of
68  * the STARTDOC Escape.
69  *
70  * Note: we now do it the other way, with the STARTDOC Escape calling StartDoc.
71  */
72 INT WINAPI StartDocW(HDC hdc, const DOCINFOW* doc)
73 {
74     INT ret = 0;
75     DC *dc = DC_GetDCPtr( hdc );
76
77     TRACE("DocName = %s Output = %s Datatype = %s\n",
78           debugstr_w(doc->lpszDocName), debugstr_w(doc->lpszOutput),
79           debugstr_w(doc->lpszDatatype));
80
81     if(!dc) return SP_ERROR;
82
83     if (dc->funcs->pStartDoc) ret = dc->funcs->pStartDoc( dc->physDev, doc );
84     GDI_ReleaseObj( hdc );
85     return ret;
86 }
87
88 /*************************************************************************
89  *                  StartDocA [GDI32.@]
90  *
91  */
92 INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
93 {
94     LPWSTR szDocName = NULL, szOutput = NULL, szDatatype = NULL;
95     DOCINFOW docW;
96     INT ret, len;
97
98     docW.cbSize = doc->cbSize;
99     if (doc->lpszDocName)
100     {
101         len = MultiByteToWideChar(CP_ACP,0,doc->lpszDocName,-1,NULL,0);
102         szDocName = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
103         MultiByteToWideChar(CP_ACP,0,doc->lpszDocName,-1,szDocName,len);
104     }
105     if (doc->lpszOutput)
106     {
107         len = MultiByteToWideChar(CP_ACP,0,doc->lpszOutput,-1,NULL,0);
108         szOutput = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
109         MultiByteToWideChar(CP_ACP,0,doc->lpszOutput,-1,szOutput,len);
110     }
111     if (doc->lpszDatatype)
112     {
113         len = MultiByteToWideChar(CP_ACP,0,doc->lpszDatatype,-1,NULL,0);
114         szDatatype = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
115         MultiByteToWideChar(CP_ACP,0,doc->lpszDatatype,-1,szDatatype,len);
116     }
117
118     docW.lpszDocName = szDocName;
119     docW.lpszOutput = szOutput;
120     docW.lpszDatatype = szDatatype;
121     docW.fwType = doc->fwType;
122
123     ret = StartDocW(hdc, &docW);
124
125     HeapFree( GetProcessHeap(), 0, szDocName );
126     HeapFree( GetProcessHeap(), 0, szOutput );
127     HeapFree( GetProcessHeap(), 0, szDatatype );
128
129     return ret;
130 }
131
132
133 /******************************************************************
134  *                  EndDoc  [GDI32.@]
135  *
136  */
137 INT WINAPI EndDoc(HDC hdc)
138 {
139     INT ret = 0;
140     DC *dc = DC_GetDCPtr( hdc );
141     if(!dc) return SP_ERROR;
142
143     if (dc->funcs->pEndDoc) ret = dc->funcs->pEndDoc( dc->physDev );
144     GDI_ReleaseObj( hdc );
145     return ret;
146 }
147
148
149 /******************************************************************
150  *                  StartPage  [GDI32.@]
151  *
152  */
153 INT WINAPI StartPage(HDC hdc)
154 {
155     INT ret = 1;
156     DC *dc = DC_GetDCPtr( hdc );
157     if(!dc) return SP_ERROR;
158
159     if(dc->funcs->pStartPage)
160         ret = dc->funcs->pStartPage( dc->physDev );
161     else
162         FIXME("stub\n");
163     GDI_ReleaseObj( hdc );
164     return ret;
165 }
166
167
168 /******************************************************************
169  *                  EndPage  [GDI32.@]
170  *
171  */
172 INT WINAPI EndPage(HDC hdc)
173 {
174     ABORTPROC abort_proc;
175     INT ret = 0;
176     DC *dc = DC_GetDCPtr( hdc );
177     if(!dc) return SP_ERROR;
178
179     if (dc->funcs->pEndPage) ret = dc->funcs->pEndPage( dc->physDev );
180     abort_proc = dc->pAbortProc;
181     GDI_ReleaseObj( hdc );
182     if (abort_proc && !abort_proc( hdc, 0 ))
183     {
184         EndDoc( hdc );
185         ret = 0;
186     }
187     return ret;
188 }
189
190
191 /******************************************************************************
192  *                 AbortDoc  [GDI32.@]
193  */
194 INT WINAPI AbortDoc(HDC hdc)
195 {
196     INT ret = 0;
197     DC *dc = DC_GetDCPtr( hdc );
198     if(!dc) return SP_ERROR;
199
200     if (dc->funcs->pAbortDoc) ret = dc->funcs->pAbortDoc( dc->physDev );
201     GDI_ReleaseObj( hdc );
202     return ret;
203 }
204
205 /**********************************************************************
206  *           QueryAbort   (GDI.155)
207  *
208  *  Calls the app's AbortProc function if avail.
209  *
210  * RETURNS
211  * TRUE if no AbortProc avail or AbortProc wants to continue printing.
212  * FALSE if AbortProc wants to abort printing.
213  */
214 BOOL16 WINAPI QueryAbort16(HDC16 hdc16, INT16 reserved)
215 {
216     BOOL ret = TRUE;
217     HDC hdc = HDC_32( hdc16 );
218     DC *dc = DC_GetDCPtr( hdc );
219     ABORTPROC abproc;
220
221     if(!dc) {
222         ERR("Invalid hdc %p\n", hdc);
223         return FALSE;
224     }
225
226     abproc = dc->pAbortProc;
227     GDI_ReleaseObj( hdc );
228
229     if (abproc)
230         ret = abproc(hdc, 0);
231     return ret;
232 }
233
234
235 /**********************************************************************
236  *           call_abort_proc16
237  */
238 static BOOL CALLBACK call_abort_proc16( HDC hdc, INT code )
239 {
240     ABORTPROC16 proc16;
241     DC *dc = DC_GetDCPtr( hdc );
242
243     if (!dc) return FALSE;
244     proc16 = dc->pAbortProc16;
245     GDI_ReleaseObj( hdc );
246     if (proc16)
247     {
248         WORD args[2];
249         DWORD ret;
250
251         args[1] = HDC_16(hdc);
252         args[0] = code;
253         WOWCallback16Ex( (DWORD)proc16, WCB16_PASCAL, sizeof(args), args, &ret );
254         return LOWORD(ret);
255     }
256     return TRUE;
257 }
258
259
260 /**********************************************************************
261  *           SetAbortProc   (GDI.381)
262  */
263 INT16 WINAPI SetAbortProc16(HDC16 hdc16, ABORTPROC16 abrtprc)
264 {
265     HDC hdc = HDC_32( hdc16 );
266     DC *dc = DC_GetDCPtr( hdc );
267
268     if (!dc) return FALSE;
269     dc->pAbortProc16 = abrtprc;
270     GDI_ReleaseObj( hdc );
271     return SetAbortProc( hdc, call_abort_proc16 );
272 }
273
274 /**********************************************************************
275  *           SetAbortProc   (GDI32.@)
276  *
277  */
278 INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
279 {
280     DC *dc = DC_GetDCPtr( hdc );
281
282     if (!dc) return FALSE;
283     dc->pAbortProc = abrtprc;
284     GDI_ReleaseObj( hdc );
285     return TRUE;
286 }
287
288
289 /****************** misc. printer related functions */
290
291 /*
292  * The following function should implement a queing system
293  */
294 struct hpq
295 {
296     struct hpq  *next;
297     int          tag;
298     int          key;
299 };
300
301 static struct hpq *hpqueue;
302
303 /**********************************************************************
304  *           CreatePQ   (GDI.230)
305  *
306  */
307 HPQ16 WINAPI CreatePQ16(INT16 size)
308 {
309 #if 0
310     HGLOBAL16 hpq = 0;
311     WORD tmp_size;
312     LPWORD pPQ;
313
314     tmp_size = size << 2;
315     if (!(hpq = GlobalAlloc16(GMEM_SHARE|GMEM_MOVEABLE, tmp_size + 8)))
316        return 0xffff;
317     pPQ = GlobalLock16(hpq);
318     *pPQ++ = 0;
319     *pPQ++ = tmp_size;
320     *pPQ++ = 0;
321     *pPQ++ = 0;
322     GlobalUnlock16(hpq);
323
324     return (HPQ16)hpq;
325 #else
326     FIXME("(%d): stub\n",size);
327     return 1;
328 #endif
329 }
330
331 /**********************************************************************
332  *           DeletePQ   (GDI.235)
333  *
334  */
335 INT16 WINAPI DeletePQ16(HPQ16 hPQ)
336 {
337     return GlobalFree16((HGLOBAL16)hPQ);
338 }
339
340 /**********************************************************************
341  *           ExtractPQ   (GDI.232)
342  *
343  */
344 INT16 WINAPI ExtractPQ16(HPQ16 hPQ)
345 {
346     struct hpq *queue, *prev, *current, *currentPrev;
347     int key = 0, tag = -1;
348     currentPrev = prev = NULL;
349     queue = current = hpqueue;
350     if (current)
351         key = current->key;
352
353     while (current)
354     {
355         currentPrev = current;
356         current = current->next;
357         if (current)
358         {
359             if (current->key < key)
360             {
361                 queue = current;
362                 prev = currentPrev;
363             }
364         }
365     }
366     if (queue)
367     {
368         tag = queue->tag;
369
370         if (prev)
371             prev->next = queue->next;
372         else
373             hpqueue = queue->next;
374         HeapFree(GetProcessHeap(), 0, queue);
375     }
376
377     TRACE("%x got tag %d key %d\n", hPQ, tag, key);
378
379     return tag;
380 }
381
382 /**********************************************************************
383  *           InsertPQ   (GDI.233)
384  *
385  */
386 INT16 WINAPI InsertPQ16(HPQ16 hPQ, INT16 tag, INT16 key)
387 {
388     struct hpq *queueItem = HeapAlloc(GetProcessHeap(), 0, sizeof(struct hpq));
389     if(queueItem == NULL) {
390         ERR("Memory exausted!\n");
391         return FALSE;
392     }
393     queueItem->next = hpqueue;
394     hpqueue = queueItem;
395     queueItem->key = key;
396     queueItem->tag = tag;
397
398     FIXME("(%x %d %d): stub???\n", hPQ, tag, key);
399     return TRUE;
400 }
401
402 /**********************************************************************
403  *           MinPQ   (GDI.231)
404  *
405  */
406 INT16 WINAPI MinPQ16(HPQ16 hPQ)
407 {
408     FIXME("(%x): stub\n", hPQ);
409     return 0;
410 }
411
412 /**********************************************************************
413  *           SizePQ   (GDI.234)
414  *
415  */
416 INT16 WINAPI SizePQ16(HPQ16 hPQ, INT16 sizechange)
417 {
418     FIXME("(%x %d): stub\n", hPQ, sizechange);
419     return -1;
420 }
421
422
423
424 /*
425  * The following functions implement part of the spooling process to
426  * print manager.  I would like to see wine have a version of print managers
427  * that used LPR/LPD.  For simplicity print jobs will be sent to a file for
428  * now.
429  */
430 typedef struct PRINTJOB
431 {
432     char        *pszOutput;
433     char        *pszTitle;
434     HDC16       hDC;
435     HANDLE16    hHandle;
436     int         nIndex;
437     int         fd;
438 } PRINTJOB, *PPRINTJOB;
439
440 #define MAX_PRINT_JOBS 1
441 #define SP_OK 1
442
443 PPRINTJOB gPrintJobsTable[MAX_PRINT_JOBS];
444
445
446 static PPRINTJOB FindPrintJobFromHandle(HANDLE16 hHandle)
447 {
448     return gPrintJobsTable[0];
449 }
450
451 static int CreateSpoolFile(LPCSTR pszOutput)
452 {
453     int fd=-1;
454     char psCmd[1024];
455     char *psCmdP = psCmd;
456     HKEY hkey;
457
458     /* TTD convert the 'output device' into a spool file name */
459
460     if (pszOutput == NULL || *pszOutput == '\0')
461       return -1;
462
463     psCmd[0] = 0;
464     /* @@ Wine registry key: HKCU\Software\Wine\Printing\Spooler */
465     if(!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Printing\\Spooler", &hkey))
466     {
467         DWORD type, count = sizeof(psCmd);
468         RegQueryValueExA(hkey, pszOutput, 0, &type, (LPBYTE)psCmd, &count);
469         RegCloseKey(hkey);
470     }
471     if (!psCmd[0] && !strncmp("LPR:",pszOutput,4))
472         sprintf(psCmd,"|lpr -P%s",pszOutput+4);
473
474     TRACE("Got printerSpoolCommand '%s' for output device '%s'\n",
475           psCmd, pszOutput);
476     if (!*psCmd)
477         psCmdP = (char *)pszOutput;
478     else
479     {
480         while (*psCmdP && isspace(*psCmdP))
481         {
482             psCmdP++;
483         }
484         if (!*psCmdP)
485             return -1;
486     }
487     TRACE("command: '%s'\n", psCmdP);
488 #ifdef HAVE_FORK
489     if (*psCmdP == '|')
490     {
491         int fds[2];
492         if (pipe(fds)) {
493             ERR("pipe() failed!\n"); 
494             return -1;
495         }
496         if (fork() == 0)
497         {
498             psCmdP++;
499
500             TRACE("In child need to exec %s\n",psCmdP);
501             close(0);
502             dup2(fds[0],0);
503             close (fds[1]);
504
505             /* reset signals that we previously set to SIG_IGN */
506             signal( SIGPIPE, SIG_DFL );
507             signal( SIGCHLD, SIG_DFL );
508
509             system(psCmdP);
510             exit(0);
511
512         }
513         close (fds[0]);
514         fd = fds[1];
515         TRACE("Need to execute a cmnd and pipe the output to it\n");
516     }
517     else
518 #endif
519     {
520         char *buffer;
521         WCHAR psCmdPW[MAX_PATH];
522
523         TRACE("Just assume it's a file\n");
524
525         /**
526          * The file name can be dos based, we have to find its
527          * Unix correspondant file name
528          */
529         MultiByteToWideChar(CP_ACP, 0, psCmdP, -1, psCmdPW, MAX_PATH);
530         if ((buffer = wine_get_unix_file_name(psCmdPW)))
531         {
532             if ((fd = open(buffer, O_CREAT | O_TRUNC | O_WRONLY , 0600)) < 0)
533             {
534                 ERR("Failed to create spool file '%s' ('%s'). (error %s)\n",
535                     buffer, psCmdP, strerror(errno));
536             }
537             HeapFree(GetProcessHeap(), 0, buffer);
538         }
539     }
540     return fd;
541 }
542
543 static int FreePrintJob(HANDLE16 hJob)
544 {
545     int nRet = SP_ERROR;
546     PPRINTJOB pPrintJob;
547
548     pPrintJob = FindPrintJobFromHandle(hJob);
549     if (pPrintJob != NULL)
550     {
551         gPrintJobsTable[pPrintJob->nIndex] = NULL;
552         HeapFree(GetProcessHeap(), 0, pPrintJob->pszOutput);
553         HeapFree(GetProcessHeap(), 0, pPrintJob->pszTitle);
554         if (pPrintJob->fd >= 0) close(pPrintJob->fd);
555         HeapFree(GetProcessHeap(), 0, pPrintJob);
556         nRet = SP_OK;
557     }
558     return nRet;
559 }
560
561 /**********************************************************************
562  *           OpenJob   (GDI.240)
563  *
564  */
565 HPJOB16 WINAPI OpenJob16(LPCSTR lpOutput, LPCSTR lpTitle, HDC16 hDC)
566 {
567     HPJOB16 hHandle = (HPJOB16)SP_ERROR;
568     PPRINTJOB pPrintJob;
569
570     TRACE("'%s' '%s' %04x\n", lpOutput, lpTitle, hDC);
571
572     pPrintJob = gPrintJobsTable[0];
573     if (pPrintJob == NULL)
574     {
575         int fd;
576
577         /* Try and create a spool file */
578         fd = CreateSpoolFile(lpOutput);
579         if (fd >= 0)
580         {
581             pPrintJob = HeapAlloc(GetProcessHeap(), 0, sizeof(PRINTJOB));
582             if(pPrintJob == NULL) {
583                 WARN("Memory exausted!\n");
584                 return hHandle;
585             }
586
587             hHandle = 1;
588
589             pPrintJob->pszOutput = HeapAlloc(GetProcessHeap(), 0, strlen(lpOutput)+1);
590             strcpy( pPrintJob->pszOutput, lpOutput );
591             if(lpTitle)
592             {
593                 pPrintJob->pszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(lpTitle)+1);
594                 strcpy( pPrintJob->pszTitle, lpTitle );
595             }
596             pPrintJob->hDC = hDC;
597             pPrintJob->fd = fd;
598             pPrintJob->nIndex = 0;
599             pPrintJob->hHandle = hHandle;
600             gPrintJobsTable[pPrintJob->nIndex] = pPrintJob;
601         }
602     }
603     TRACE("return %04x\n", hHandle);
604     return hHandle;
605 }
606
607 /**********************************************************************
608  *           CloseJob   (GDI.243)
609  *
610  */
611 INT16 WINAPI CloseJob16(HPJOB16 hJob)
612 {
613     int nRet = SP_ERROR;
614     PPRINTJOB pPrintJob = NULL;
615
616     TRACE("%04x\n", hJob);
617
618     pPrintJob = FindPrintJobFromHandle(hJob);
619     if (pPrintJob != NULL)
620     {
621         /* Close the spool file */
622         close(pPrintJob->fd);
623         FreePrintJob(hJob);
624         nRet  = 1;
625     }
626     return nRet;
627 }
628
629 /**********************************************************************
630  *           WriteSpool   (GDI.241)
631  *
632  */
633 INT16 WINAPI WriteSpool16(HPJOB16 hJob, LPSTR lpData, INT16 cch)
634 {
635     int nRet = SP_ERROR;
636     PPRINTJOB pPrintJob = NULL;
637
638     TRACE("%04x %p %04x\n", hJob, lpData, cch);
639
640     pPrintJob = FindPrintJobFromHandle(hJob);
641     if (pPrintJob != NULL && pPrintJob->fd >= 0 && cch)
642     {
643         if (write(pPrintJob->fd, lpData, cch) != cch)
644           nRet = SP_OUTOFDISK;
645         else
646           nRet = cch;
647 #if 0
648         /* FIXME: We just cannot call 16 bit functions from here, since we
649          * have acquired several locks (DC). And we do not really need to.
650          */
651         if (pPrintJob->hDC == 0) {
652             TRACE("hDC == 0 so no QueryAbort\n");
653         }
654         else if (!(QueryAbort16(pPrintJob->hDC, (nRet == SP_OUTOFDISK) ? nRet : 0 )))
655         {
656             CloseJob16(hJob); /* printing aborted */
657             nRet = SP_APPABORT;
658         }
659 #endif
660     }
661     return nRet;
662 }
663
664 typedef INT (WINAPI *MSGBOX_PROC)( HWND, LPCSTR, LPCSTR, UINT );
665
666 /**********************************************************************
667  *           WriteDialog   (GDI.242)
668  *
669  */
670 INT16 WINAPI WriteDialog16(HPJOB16 hJob, LPSTR lpMsg, INT16 cchMsg)
671 {
672     HMODULE mod;
673     MSGBOX_PROC pMessageBoxA;
674     INT16 ret = 0;
675
676     TRACE("%04x %04x '%s'\n", hJob,  cchMsg, lpMsg);
677
678     if ((mod = GetModuleHandleA("user32.dll")))
679     {
680         if ((pMessageBoxA = (MSGBOX_PROC)GetProcAddress( mod, "MessageBoxA" )))
681             ret = pMessageBoxA(0, lpMsg, "Printing Error", MB_OKCANCEL);
682     }
683     return ret;
684 }
685
686
687 /**********************************************************************
688  *           DeleteJob  (GDI.244)
689  *
690  */
691 INT16 WINAPI DeleteJob16(HPJOB16 hJob, INT16 nNotUsed)
692 {
693     int nRet;
694
695     TRACE("%04x\n", hJob);
696
697     nRet = FreePrintJob(hJob);
698     return nRet;
699 }
700
701 /*
702  * The following two function would allow a page to be sent to the printer
703  * when it has been processed.  For simplicity they havn't been implemented.
704  * This means a whole job has to be processed before it is sent to the printer.
705  */
706
707 /**********************************************************************
708  *           StartSpoolPage   (GDI.246)
709  *
710  */
711 INT16 WINAPI StartSpoolPage16(HPJOB16 hJob)
712 {
713     FIXME("StartSpoolPage GDI.246 unimplemented\n");
714     return 1;
715
716 }
717
718
719 /**********************************************************************
720  *           EndSpoolPage   (GDI.247)
721  *
722  */
723 INT16 WINAPI EndSpoolPage16(HPJOB16 hJob)
724 {
725     FIXME("EndSpoolPage GDI.247 unimplemented\n");
726     return 1;
727 }
728
729
730 /**********************************************************************
731  *           GetSpoolJob   (GDI.245)
732  *
733  */
734 DWORD WINAPI GetSpoolJob16(int nOption, LONG param)
735 {
736     DWORD retval = 0;
737     TRACE("In GetSpoolJob param 0x%lx noption %d\n",param, nOption);
738     return retval;
739 }
740
741
742 /******************************************************************
743  *                  DrvGetPrinterDataInternal
744  *
745  * Helper for DrvGetPrinterData
746  */
747 static DWORD DrvGetPrinterDataInternal(LPSTR RegStr_Printer,
748 LPBYTE lpPrinterData, int cbData, int what)
749 {
750     DWORD res = -1;
751     HKEY hkey;
752     DWORD dwType, cbQueryData;
753
754     if (!(RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey))) {
755         if (what == INT_PD_DEFAULT_DEVMODE) { /* "Default DevMode" */
756             if (!(RegQueryValueExA(hkey, DefaultDevMode, 0, &dwType, 0, &cbQueryData))) {
757                 if (!lpPrinterData)
758                     res = cbQueryData;
759                 else if ((cbQueryData) && (cbQueryData <= cbData)) {
760                     cbQueryData = cbData;
761                     if (RegQueryValueExA(hkey, DefaultDevMode, 0,
762                                 &dwType, lpPrinterData, &cbQueryData))
763                         res = cbQueryData;
764                 }
765             }
766         } else { /* "Printer Driver" */
767             cbQueryData = 32;
768             RegQueryValueExA(hkey, "Printer Driver", 0,
769                         &dwType, lpPrinterData, &cbQueryData);
770             res = cbQueryData;
771         }
772     }
773     if (hkey) RegCloseKey(hkey);
774     return res;
775 }
776
777 /******************************************************************
778  *                DrvGetPrinterData     (GDI.282)
779  *
780  */
781 DWORD WINAPI DrvGetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
782                                LPDWORD lpType, LPBYTE lpPrinterData,
783                                int cbData, LPDWORD lpNeeded)
784 {
785     LPSTR RegStr_Printer;
786     HKEY hkey = 0, hkey2 = 0;
787     DWORD res = 0;
788     DWORD dwType, PrinterAttr, cbPrinterAttr, SetData, size;
789
790     if (HIWORD(lpPrinter))
791             TRACE("printer %s\n",lpPrinter);
792     else
793             TRACE("printer %p\n",lpPrinter);
794     if (HIWORD(lpProfile))
795             TRACE("profile %s\n",lpProfile);
796     else
797             TRACE("profile %p\n",lpProfile);
798     TRACE("lpType %p\n",lpType);
799
800     if ((!lpPrinter) || (!lpProfile) || (!lpNeeded))
801         return ERROR_INVALID_PARAMETER;
802
803     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
804                                strlen(Printers) + strlen(lpPrinter) + 2);
805     strcpy(RegStr_Printer, Printers);
806     strcat(RegStr_Printer, lpPrinter);
807
808     if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
809     (!strcmp(lpProfile, DefaultDevMode)))) {
810         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
811                                          INT_PD_DEFAULT_DEVMODE);
812         if (size+1) {
813             *lpNeeded = size;
814             if ((lpPrinterData) && (*lpNeeded > cbData))
815                 res = ERROR_MORE_DATA;
816         }
817         else res = ERROR_INVALID_PRINTER_NAME;
818     }
819     else
820     if (((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
821     (!strcmp(lpProfile, PrinterModel)))) {
822         *lpNeeded = 32;
823         if (!lpPrinterData) goto failed;
824         if (cbData < 32) {
825             res = ERROR_MORE_DATA;
826             goto failed;
827         }
828         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
829                                          INT_PD_DEFAULT_MODEL);
830         if ((size+1) && (lpType))
831             *lpType = REG_SZ;
832         else
833             res = ERROR_INVALID_PRINTER_NAME;
834     }
835     else
836     {
837         if ((res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)))
838             goto failed;
839         cbPrinterAttr = 4;
840         if ((res = RegQueryValueExA(hkey, "Attributes", 0,
841                         &dwType, (LPBYTE)&PrinterAttr, &cbPrinterAttr)))
842             goto failed;
843         if ((res = RegOpenKeyA(hkey, PrinterDriverData, &hkey2)))
844             goto failed;
845         *lpNeeded = cbData;
846         res = RegQueryValueExA(hkey2, lpProfile, 0,
847                 lpType, lpPrinterData, lpNeeded);
848         if ((res != ERROR_CANTREAD) &&
849          ((PrinterAttr &
850         (PRINTER_ATTRIBUTE_ENABLE_BIDI|PRINTER_ATTRIBUTE_NETWORK))
851         == PRINTER_ATTRIBUTE_NETWORK))
852         {
853             if (!(res) && (*lpType == REG_DWORD) && (*(LPDWORD)lpPrinterData == -1))
854                 res = ERROR_INVALID_DATA;
855         }
856         else
857         {
858             SetData = -1;
859             RegSetValueExA(hkey2, lpProfile, 0, REG_DWORD, (LPBYTE)&SetData, 4); /* no result returned */
860         }
861     }
862
863 failed:
864     if (hkey2) RegCloseKey(hkey2);
865     if (hkey) RegCloseKey(hkey);
866     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
867     return res;
868 }
869
870
871 /******************************************************************
872  *                 DrvSetPrinterData     (GDI.281)
873  *
874  */
875 DWORD WINAPI DrvSetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
876                                DWORD lpType, LPBYTE lpPrinterData,
877                                DWORD dwSize)
878 {
879     LPSTR RegStr_Printer;
880     HKEY hkey = 0;
881     DWORD res = 0;
882
883     if (HIWORD(lpPrinter))
884             TRACE("printer %s\n",lpPrinter);
885     else
886             TRACE("printer %p\n",lpPrinter);
887     if (HIWORD(lpProfile))
888             TRACE("profile %s\n",lpProfile);
889     else
890             TRACE("profile %p\n",lpProfile);
891     TRACE("lpType %08lx\n",lpType);
892
893     if ((!lpPrinter) || (!lpProfile) ||
894     ((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
895     (!strcmp(lpProfile, PrinterModel))))
896         return ERROR_INVALID_PARAMETER;
897
898     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
899                         strlen(Printers) + strlen(lpPrinter) + 2);
900     strcpy(RegStr_Printer, Printers);
901     strcat(RegStr_Printer, lpPrinter);
902
903     if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
904     (!strcmp(lpProfile, DefaultDevMode)))) {
905         if ( RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)
906              != ERROR_SUCCESS ||
907              RegSetValueExA(hkey, DefaultDevMode, 0, REG_BINARY,
908                               lpPrinterData, dwSize) != ERROR_SUCCESS )
909                 res = ERROR_INVALID_PRINTER_NAME;
910     }
911     else
912     {
913         strcat(RegStr_Printer, "\\");
914
915         if( (res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)) ==
916             ERROR_SUCCESS ) {
917
918             if (!lpPrinterData)
919                 res = RegDeleteValueA(hkey, lpProfile);
920             else
921                 res = RegSetValueExA(hkey, lpProfile, 0, lpType,
922                                        lpPrinterData, dwSize);
923         }
924     }
925
926     if (hkey) RegCloseKey(hkey);
927     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
928     return res;
929 }