mshtml: Use stored nsdoc in IHTMLDocument2::write.
[wine] / dlls / gdi32 / printdrv16.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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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_private.h"
52
53 WINE_DEFAULT_DEBUG_CHANNEL(print);
54
55 static const char PrinterModel[]      = "Printer Model";
56 static const char DefaultDevMode[]    = "Default DevMode";
57 static const char PrinterDriverData[] = "PrinterDriverData";
58 static const char Printers[]          = "System\\CurrentControlSet\\Control\\Print\\Printers\\";
59
60 /**********************************************************************
61  *           QueryAbort   (GDI.155)
62  *
63  *  Calls the app's AbortProc function if avail.
64  *
65  * RETURNS
66  * TRUE if no AbortProc avail or AbortProc wants to continue printing.
67  * FALSE if AbortProc wants to abort printing.
68  */
69 BOOL16 WINAPI QueryAbort16(HDC16 hdc16, INT16 reserved)
70 {
71     BOOL ret = TRUE;
72     HDC hdc = HDC_32( hdc16 );
73     DC *dc = get_dc_ptr( hdc );
74
75     if(!dc) {
76         ERR("Invalid hdc %p\n", hdc);
77         return FALSE;
78     }
79     if (dc->pAbortProc) ret = dc->pAbortProc(hdc, 0);
80     release_dc_ptr( dc );
81     return ret;
82 }
83
84
85 /**********************************************************************
86  *           call_abort_proc16
87  */
88 static BOOL CALLBACK call_abort_proc16( HDC hdc, INT code )
89 {
90     ABORTPROC16 proc16;
91     DC *dc = get_dc_ptr( hdc );
92
93     if (!dc) return FALSE;
94     proc16 = dc->pAbortProc16;
95     release_dc_ptr( dc );
96     if (proc16)
97     {
98         WORD args[2];
99         DWORD ret;
100
101         args[1] = HDC_16(hdc);
102         args[0] = code;
103         WOWCallback16Ex( (DWORD)proc16, WCB16_PASCAL, sizeof(args), args, &ret );
104         return LOWORD(ret);
105     }
106     return TRUE;
107 }
108
109
110 /**********************************************************************
111  *           SetAbortProc   (GDI.381)
112  */
113 INT16 WINAPI SetAbortProc16(HDC16 hdc16, ABORTPROC16 abrtprc)
114 {
115     HDC hdc = HDC_32( hdc16 );
116     DC *dc = get_dc_ptr( hdc );
117
118     if (!dc) return FALSE;
119     dc->pAbortProc16 = abrtprc;
120     dc->pAbortProc   = call_abort_proc16;
121     release_dc_ptr( dc );
122     return TRUE;
123 }
124
125 /**********************************************************************
126  *           SetAbortProc   (GDI32.@)
127  *
128  */
129 INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
130 {
131     DC *dc = get_dc_ptr( hdc );
132
133     if (!dc) return FALSE;
134     dc->pAbortProc = abrtprc;
135     release_dc_ptr( dc );
136     return TRUE;
137 }
138
139
140 /****************** misc. printer related functions */
141
142 /*
143  * The following function should implement a queing system
144  */
145 struct hpq
146 {
147     struct hpq  *next;
148     int          tag;
149     int          key;
150 };
151
152 static struct hpq *hpqueue;
153
154 /**********************************************************************
155  *           CreatePQ   (GDI.230)
156  *
157  */
158 HPQ16 WINAPI CreatePQ16(INT16 size)
159 {
160 #if 0
161     HGLOBAL16 hpq = 0;
162     WORD tmp_size;
163     LPWORD pPQ;
164
165     tmp_size = size << 2;
166     if (!(hpq = GlobalAlloc16(GMEM_SHARE|GMEM_MOVEABLE, tmp_size + 8)))
167        return 0xffff;
168     pPQ = GlobalLock16(hpq);
169     *pPQ++ = 0;
170     *pPQ++ = tmp_size;
171     *pPQ++ = 0;
172     *pPQ++ = 0;
173     GlobalUnlock16(hpq);
174
175     return (HPQ16)hpq;
176 #else
177     FIXME("(%d): stub\n",size);
178     return 1;
179 #endif
180 }
181
182 /**********************************************************************
183  *           DeletePQ   (GDI.235)
184  *
185  */
186 INT16 WINAPI DeletePQ16(HPQ16 hPQ)
187 {
188     return GlobalFree16(hPQ);
189 }
190
191 /**********************************************************************
192  *           ExtractPQ   (GDI.232)
193  *
194  */
195 INT16 WINAPI ExtractPQ16(HPQ16 hPQ)
196 {
197     struct hpq *queue, *prev, *current, *currentPrev;
198     int key = 0, tag = -1;
199     currentPrev = prev = NULL;
200     queue = current = hpqueue;
201     if (current)
202         key = current->key;
203
204     while (current)
205     {
206         currentPrev = current;
207         current = current->next;
208         if (current)
209         {
210             if (current->key < key)
211             {
212                 queue = current;
213                 prev = currentPrev;
214             }
215         }
216     }
217     if (queue)
218     {
219         tag = queue->tag;
220
221         if (prev)
222             prev->next = queue->next;
223         else
224             hpqueue = queue->next;
225         HeapFree(GetProcessHeap(), 0, queue);
226     }
227
228     TRACE("%x got tag %d key %d\n", hPQ, tag, key);
229
230     return tag;
231 }
232
233 /**********************************************************************
234  *           InsertPQ   (GDI.233)
235  *
236  */
237 INT16 WINAPI InsertPQ16(HPQ16 hPQ, INT16 tag, INT16 key)
238 {
239     struct hpq *queueItem = HeapAlloc(GetProcessHeap(), 0, sizeof(struct hpq));
240     if(queueItem == NULL) {
241         ERR("Memory exausted!\n");
242         return FALSE;
243     }
244     queueItem->next = hpqueue;
245     hpqueue = queueItem;
246     queueItem->key = key;
247     queueItem->tag = tag;
248
249     FIXME("(%x %d %d): stub???\n", hPQ, tag, key);
250     return TRUE;
251 }
252
253 /**********************************************************************
254  *           MinPQ   (GDI.231)
255  *
256  */
257 INT16 WINAPI MinPQ16(HPQ16 hPQ)
258 {
259     FIXME("(%x): stub\n", hPQ);
260     return 0;
261 }
262
263 /**********************************************************************
264  *           SizePQ   (GDI.234)
265  *
266  */
267 INT16 WINAPI SizePQ16(HPQ16 hPQ, INT16 sizechange)
268 {
269     FIXME("(%x %d): stub\n", hPQ, sizechange);
270     return -1;
271 }
272
273
274
275 /*
276  * The following functions implement part of the spooling process to
277  * print manager.  I would like to see wine have a version of print managers
278  * that used LPR/LPD.  For simplicity print jobs will be sent to a file for
279  * now.
280  */
281 typedef struct PRINTJOB
282 {
283     char        *pszOutput;
284     char        *pszTitle;
285     HDC16       hDC;
286     HANDLE16    hHandle;
287     int         nIndex;
288     int         fd;
289 } PRINTJOB, *PPRINTJOB;
290
291 #define MAX_PRINT_JOBS 1
292 #define SP_OK 1
293
294 static PPRINTJOB gPrintJobsTable[MAX_PRINT_JOBS];
295
296
297 static PPRINTJOB FindPrintJobFromHandle(HANDLE16 hHandle)
298 {
299     return gPrintJobsTable[0];
300 }
301
302 static int CreateSpoolFile(LPCSTR pszOutput)
303 {
304     int fd=-1;
305     char psCmd[1024];
306     const char *psCmdP = psCmd;
307     HKEY hkey;
308
309     /* TTD convert the 'output device' into a spool file name */
310
311     if (pszOutput == NULL || *pszOutput == '\0')
312       return -1;
313
314     psCmd[0] = 0;
315     /* @@ Wine registry key: HKCU\Software\Wine\Printing\Spooler */
316     if(!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Printing\\Spooler", &hkey))
317     {
318         DWORD type, count = sizeof(psCmd);
319         RegQueryValueExA(hkey, pszOutput, 0, &type, (LPBYTE)psCmd, &count);
320         RegCloseKey(hkey);
321     }
322     if (!psCmd[0] && !strncmp("LPR:",pszOutput,4))
323         sprintf(psCmd,"|lpr -P'%s'",pszOutput+4);
324
325     TRACE("Got printerSpoolCommand '%s' for output device '%s'\n",
326           psCmd, pszOutput);
327     if (!*psCmd)
328         psCmdP = pszOutput;
329     else
330     {
331         while (*psCmdP && isspace(*psCmdP))
332         {
333             psCmdP++;
334         }
335         if (!*psCmdP)
336             return -1;
337     }
338     TRACE("command: '%s'\n", psCmdP);
339 #ifdef HAVE_FORK
340     if (*psCmdP == '|')
341     {
342         int fds[2];
343         if (pipe(fds)) {
344             ERR("pipe() failed!\n");
345             return -1;
346         }
347         if (fork() == 0)
348         {
349             psCmdP++;
350
351             TRACE("In child need to exec %s\n",psCmdP);
352             close(0);
353             dup2(fds[0],0);
354             close (fds[1]);
355
356             /* reset signals that we previously set to SIG_IGN */
357             signal( SIGPIPE, SIG_DFL );
358             signal( SIGCHLD, SIG_DFL );
359
360             execl("/bin/sh", "/bin/sh", "-c", psCmdP, (char*)0);
361             _exit(1);
362
363         }
364         close (fds[0]);
365         fd = fds[1];
366         TRACE("Need to execute a cmnd and pipe the output to it\n");
367     }
368     else
369 #endif
370     {
371         char *buffer;
372         WCHAR psCmdPW[MAX_PATH];
373
374         TRACE("Just assume it's a file\n");
375
376         /**
377          * The file name can be dos based, we have to find its
378          * corresponding Unix file name.
379          */
380         MultiByteToWideChar(CP_ACP, 0, psCmdP, -1, psCmdPW, MAX_PATH);
381         if ((buffer = wine_get_unix_file_name(psCmdPW)))
382         {
383             if ((fd = open(buffer, O_CREAT | O_TRUNC | O_WRONLY, 0666)) < 0)
384             {
385                 ERR("Failed to create spool file '%s' ('%s'). (error %s)\n",
386                     buffer, psCmdP, strerror(errno));
387             }
388             HeapFree(GetProcessHeap(), 0, buffer);
389         }
390     }
391     return fd;
392 }
393
394 static int FreePrintJob(HANDLE16 hJob)
395 {
396     int nRet = SP_ERROR;
397     PPRINTJOB pPrintJob;
398
399     pPrintJob = FindPrintJobFromHandle(hJob);
400     if (pPrintJob != NULL)
401     {
402         gPrintJobsTable[pPrintJob->nIndex] = NULL;
403         HeapFree(GetProcessHeap(), 0, pPrintJob->pszOutput);
404         HeapFree(GetProcessHeap(), 0, pPrintJob->pszTitle);
405         if (pPrintJob->fd >= 0) close(pPrintJob->fd);
406         HeapFree(GetProcessHeap(), 0, pPrintJob);
407         nRet = SP_OK;
408     }
409     return nRet;
410 }
411
412 /**********************************************************************
413  *           OpenJob   (GDI.240)
414  *
415  */
416 HPJOB16 WINAPI OpenJob16(LPCSTR lpOutput, LPCSTR lpTitle, HDC16 hDC)
417 {
418     HPJOB16 hHandle = (HPJOB16)SP_ERROR;
419     PPRINTJOB pPrintJob;
420
421     TRACE("'%s' '%s' %04x\n", lpOutput, lpTitle, hDC);
422
423     pPrintJob = gPrintJobsTable[0];
424     if (pPrintJob == NULL)
425     {
426         int fd;
427
428         /* Try and create a spool file */
429         fd = CreateSpoolFile(lpOutput);
430         if (fd >= 0)
431         {
432             pPrintJob = HeapAlloc(GetProcessHeap(), 0, sizeof(PRINTJOB));
433             if(pPrintJob == NULL) {
434                 WARN("Memory exausted!\n");
435                 return hHandle;
436             }
437
438             hHandle = 1;
439
440             pPrintJob->pszOutput = HeapAlloc(GetProcessHeap(), 0, strlen(lpOutput)+1);
441             strcpy( pPrintJob->pszOutput, lpOutput );
442             if(lpTitle)
443             {
444                 pPrintJob->pszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(lpTitle)+1);
445                 strcpy( pPrintJob->pszTitle, lpTitle );
446             }
447             pPrintJob->hDC = hDC;
448             pPrintJob->fd = fd;
449             pPrintJob->nIndex = 0;
450             pPrintJob->hHandle = hHandle;
451             gPrintJobsTable[pPrintJob->nIndex] = pPrintJob;
452         }
453     }
454     TRACE("return %04x\n", hHandle);
455     return hHandle;
456 }
457
458 /**********************************************************************
459  *           CloseJob   (GDI.243)
460  *
461  */
462 INT16 WINAPI CloseJob16(HPJOB16 hJob)
463 {
464     int nRet = SP_ERROR;
465     PPRINTJOB pPrintJob = NULL;
466
467     TRACE("%04x\n", hJob);
468
469     pPrintJob = FindPrintJobFromHandle(hJob);
470     if (pPrintJob != NULL)
471     {
472         /* Close the spool file */
473         close(pPrintJob->fd);
474         FreePrintJob(hJob);
475         nRet  = 1;
476     }
477     return nRet;
478 }
479
480 /**********************************************************************
481  *           WriteSpool   (GDI.241)
482  *
483  */
484 INT16 WINAPI WriteSpool16(HPJOB16 hJob, LPSTR lpData, INT16 cch)
485 {
486     int nRet = SP_ERROR;
487     PPRINTJOB pPrintJob = NULL;
488
489     TRACE("%04x %p %04x\n", hJob, lpData, cch);
490
491     pPrintJob = FindPrintJobFromHandle(hJob);
492     if (pPrintJob != NULL && pPrintJob->fd >= 0 && cch)
493     {
494         if (write(pPrintJob->fd, lpData, cch) != cch)
495           nRet = SP_OUTOFDISK;
496         else
497           nRet = cch;
498 #if 0
499         /* FIXME: We just cannot call 16 bit functions from here, since we
500          * have acquired several locks (DC). And we do not really need to.
501          */
502         if (pPrintJob->hDC == 0) {
503             TRACE("hDC == 0 so no QueryAbort\n");
504         }
505         else if (!(QueryAbort16(pPrintJob->hDC, (nRet == SP_OUTOFDISK) ? nRet : 0 )))
506         {
507             CloseJob16(hJob); /* printing aborted */
508             nRet = SP_APPABORT;
509         }
510 #endif
511     }
512     return nRet;
513 }
514
515 typedef INT (WINAPI *MSGBOX_PROC)( HWND, LPCSTR, LPCSTR, UINT );
516
517 /**********************************************************************
518  *           WriteDialog   (GDI.242)
519  *
520  */
521 INT16 WINAPI WriteDialog16(HPJOB16 hJob, LPSTR lpMsg, INT16 cchMsg)
522 {
523     HMODULE mod;
524     MSGBOX_PROC pMessageBoxA;
525     INT16 ret = 0;
526
527     TRACE("%04x %04x '%s'\n", hJob,  cchMsg, lpMsg);
528
529     if ((mod = GetModuleHandleA("user32.dll")))
530     {
531         if ((pMessageBoxA = (MSGBOX_PROC)GetProcAddress( mod, "MessageBoxA" )))
532             ret = pMessageBoxA(0, lpMsg, "Printing Error", MB_OKCANCEL);
533     }
534     return ret;
535 }
536
537
538 /**********************************************************************
539  *           DeleteJob  (GDI.244)
540  *
541  */
542 INT16 WINAPI DeleteJob16(HPJOB16 hJob, INT16 nNotUsed)
543 {
544     int nRet;
545
546     TRACE("%04x\n", hJob);
547
548     nRet = FreePrintJob(hJob);
549     return nRet;
550 }
551
552 /*
553  * The following two function would allow a page to be sent to the printer
554  * when it has been processed.  For simplicity they haven't been implemented.
555  * This means a whole job has to be processed before it is sent to the printer.
556  */
557
558 /**********************************************************************
559  *           StartSpoolPage   (GDI.246)
560  *
561  */
562 INT16 WINAPI StartSpoolPage16(HPJOB16 hJob)
563 {
564     FIXME("StartSpoolPage GDI.246 unimplemented\n");
565     return 1;
566
567 }
568
569
570 /**********************************************************************
571  *           EndSpoolPage   (GDI.247)
572  *
573  */
574 INT16 WINAPI EndSpoolPage16(HPJOB16 hJob)
575 {
576     FIXME("EndSpoolPage GDI.247 unimplemented\n");
577     return 1;
578 }
579
580
581 /**********************************************************************
582  *           GetSpoolJob   (GDI.245)
583  *
584  */
585 DWORD WINAPI GetSpoolJob16(int nOption, LONG param)
586 {
587     DWORD retval = 0;
588     TRACE("In GetSpoolJob param 0x%x noption %d\n",param, nOption);
589     return retval;
590 }
591
592
593 /******************************************************************
594  *                  DrvGetPrinterDataInternal
595  *
596  * Helper for DrvGetPrinterData
597  */
598 static DWORD DrvGetPrinterDataInternal(LPSTR RegStr_Printer,
599 LPBYTE lpPrinterData, int cbData, int what)
600 {
601     DWORD res = -1;
602     HKEY hkey;
603     DWORD dwType, cbQueryData;
604
605     if (!(RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey))) {
606         if (what == INT_PD_DEFAULT_DEVMODE) { /* "Default DevMode" */
607             if (!(RegQueryValueExA(hkey, DefaultDevMode, 0, &dwType, 0, &cbQueryData))) {
608                 if (!lpPrinterData)
609                     res = cbQueryData;
610                 else if ((cbQueryData) && (cbQueryData <= cbData)) {
611                     cbQueryData = cbData;
612                     if (RegQueryValueExA(hkey, DefaultDevMode, 0,
613                                 &dwType, lpPrinterData, &cbQueryData))
614                         res = cbQueryData;
615                 }
616             }
617         } else { /* "Printer Driver" */
618             cbQueryData = 32;
619             RegQueryValueExA(hkey, "Printer Driver", 0,
620                         &dwType, lpPrinterData, &cbQueryData);
621             res = cbQueryData;
622         }
623     }
624     if (hkey) RegCloseKey(hkey);
625     return res;
626 }
627
628 /******************************************************************
629  *                DrvGetPrinterData     (GDI.282)
630  *
631  */
632 DWORD WINAPI DrvGetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
633                                LPDWORD lpType, LPBYTE lpPrinterData,
634                                int cbData, LPDWORD lpNeeded)
635 {
636     LPSTR RegStr_Printer;
637     HKEY hkey = 0, hkey2 = 0;
638     DWORD res = 0;
639     DWORD dwType, PrinterAttr, cbPrinterAttr, SetData, size;
640
641     if (HIWORD(lpPrinter))
642             TRACE("printer %s\n",lpPrinter);
643     else
644             TRACE("printer %p\n",lpPrinter);
645     if (HIWORD(lpProfile))
646             TRACE("profile %s\n",lpProfile);
647     else
648             TRACE("profile %p\n",lpProfile);
649     TRACE("lpType %p\n",lpType);
650
651     if ((!lpPrinter) || (!lpProfile) || (!lpNeeded))
652         return ERROR_INVALID_PARAMETER;
653
654     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
655                                strlen(Printers) + strlen(lpPrinter) + 2);
656     strcpy(RegStr_Printer, Printers);
657     strcat(RegStr_Printer, lpPrinter);
658
659     if ((PtrToUlong(lpProfile) == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
660     (!strcmp(lpProfile, DefaultDevMode)))) {
661         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
662                                          INT_PD_DEFAULT_DEVMODE);
663         if (size+1) {
664             *lpNeeded = size;
665             if ((lpPrinterData) && (*lpNeeded > cbData))
666                 res = ERROR_MORE_DATA;
667         }
668         else res = ERROR_INVALID_PRINTER_NAME;
669     }
670     else
671     if ((PtrToUlong(lpProfile) == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
672     (!strcmp(lpProfile, PrinterModel)))) {
673         *lpNeeded = 32;
674         if (!lpPrinterData) goto failed;
675         if (cbData < 32) {
676             res = ERROR_MORE_DATA;
677             goto failed;
678         }
679         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
680                                          INT_PD_DEFAULT_MODEL);
681         if ((size+1) && (lpType))
682             *lpType = REG_SZ;
683         else
684             res = ERROR_INVALID_PRINTER_NAME;
685     }
686     else
687     {
688         if ((res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)))
689             goto failed;
690         cbPrinterAttr = 4;
691         if ((res = RegQueryValueExA(hkey, "Attributes", 0,
692                         &dwType, (LPBYTE)&PrinterAttr, &cbPrinterAttr)))
693             goto failed;
694         if ((res = RegOpenKeyA(hkey, PrinterDriverData, &hkey2)))
695             goto failed;
696         *lpNeeded = cbData;
697         res = RegQueryValueExA(hkey2, lpProfile, 0,
698                 lpType, lpPrinterData, lpNeeded);
699         if ((res != ERROR_CANTREAD) &&
700          ((PrinterAttr &
701         (PRINTER_ATTRIBUTE_ENABLE_BIDI|PRINTER_ATTRIBUTE_NETWORK))
702         == PRINTER_ATTRIBUTE_NETWORK))
703         {
704             if (!(res) && (*lpType == REG_DWORD) && (*(LPDWORD)lpPrinterData == -1))
705                 res = ERROR_INVALID_DATA;
706         }
707         else
708         {
709             SetData = -1;
710             RegSetValueExA(hkey2, lpProfile, 0, REG_DWORD, (LPBYTE)&SetData, 4); /* no result returned */
711         }
712     }
713
714 failed:
715     if (hkey2) RegCloseKey(hkey2);
716     if (hkey) RegCloseKey(hkey);
717     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
718     return res;
719 }
720
721
722 /******************************************************************
723  *                 DrvSetPrinterData     (GDI.281)
724  *
725  */
726 DWORD WINAPI DrvSetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
727                                DWORD lpType, LPBYTE lpPrinterData,
728                                DWORD dwSize)
729 {
730     LPSTR RegStr_Printer;
731     HKEY hkey = 0;
732     DWORD res = 0;
733
734     if (HIWORD(lpPrinter))
735             TRACE("printer %s\n",lpPrinter);
736     else
737             TRACE("printer %p\n",lpPrinter);
738     if (HIWORD(lpProfile))
739             TRACE("profile %s\n",lpProfile);
740     else
741             TRACE("profile %p\n",lpProfile);
742     TRACE("lpType %08x\n",lpType);
743
744     if ((!lpPrinter) || (!lpProfile) ||
745     (PtrToUlong(lpProfile) == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
746     (!strcmp(lpProfile, PrinterModel))))
747         return ERROR_INVALID_PARAMETER;
748
749     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
750                         strlen(Printers) + strlen(lpPrinter) + 2);
751     strcpy(RegStr_Printer, Printers);
752     strcat(RegStr_Printer, lpPrinter);
753
754     if ((PtrToUlong(lpProfile) == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
755     (!strcmp(lpProfile, DefaultDevMode)))) {
756         if ( RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)
757              != ERROR_SUCCESS ||
758              RegSetValueExA(hkey, DefaultDevMode, 0, REG_BINARY,
759                               lpPrinterData, dwSize) != ERROR_SUCCESS )
760                 res = ERROR_INVALID_PRINTER_NAME;
761     }
762     else
763     {
764         strcat(RegStr_Printer, "\\");
765
766         if( (res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)) ==
767             ERROR_SUCCESS ) {
768
769             if (!lpPrinterData)
770                 res = RegDeleteValueA(hkey, lpProfile);
771             else
772                 res = RegSetValueExA(hkey, lpProfile, 0, lpType,
773                                        lpPrinterData, dwSize);
774         }
775     }
776
777     if (hkey) RegCloseKey(hkey);
778     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
779     return res;
780 }