ole32/tests: Some Windows versions need the class to be registered.
[wine] / dlls / gdi32 / printdrv16.c
CommitLineData
de75fe0a
RS
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
53WINE_DEFAULT_DEBUG_CHANNEL(print);
54
55static const char PrinterModel[] = "Printer Model";
56static const char DefaultDevMode[] = "Default DevMode";
57static const char PrinterDriverData[] = "PrinterDriverData";
58static 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 */
69BOOL16 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 */
88static 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 */
113INT16 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 */
129INT 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 */
145struct hpq
146{
147 struct hpq *next;
148 int tag;
149 int key;
150};
151
152static struct hpq *hpqueue;
153
154/**********************************************************************
155 * CreatePQ (GDI.230)
156 *
157 */
158HPQ16 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 */
186INT16 WINAPI DeletePQ16(HPQ16 hPQ)
187{
188 return GlobalFree16(hPQ);
189}
190
191/**********************************************************************
192 * ExtractPQ (GDI.232)
193 *
194 */
195INT16 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 */
237INT16 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 */
257INT16 WINAPI MinPQ16(HPQ16 hPQ)
258{
259 FIXME("(%x): stub\n", hPQ);
260 return 0;
261}
262
263/**********************************************************************
264 * SizePQ (GDI.234)
265 *
266 */
267INT16 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 */
281typedef 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
294static PPRINTJOB gPrintJobsTable[MAX_PRINT_JOBS];
295
296
297static PPRINTJOB FindPrintJobFromHandle(HANDLE16 hHandle)
298{
299 return gPrintJobsTable[0];
300}
301
302static 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
ec1c9492 360 execl("/bin/sh", "/bin/sh", "-c", psCmdP, NULL);
de75fe0a
RS
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
45b944ed 378 * corresponding Unix file name.
de75fe0a
RS
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
394static 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 */
416HPJOB16 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 */
462INT16 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 */
484INT16 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
515typedef INT (WINAPI *MSGBOX_PROC)( HWND, LPCSTR, LPCSTR, UINT );
516
517/**********************************************************************
518 * WriteDialog (GDI.242)
519 *
520 */
521INT16 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 */
542INT16 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 */
562INT16 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 */
574INT16 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 */
585DWORD 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 */
598static DWORD DrvGetPrinterDataInternal(LPSTR RegStr_Printer,
599LPBYTE 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 */
632DWORD 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
714failed:
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 */
726DWORD 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}