2 * Implementation of some printer driver bits
4 * Copyright 1996 John Harvey
5 * Copyright 1998 Huw Davies
6 * Copyright 1998 Andreas Mohr
7 * Copyright 1999 Klaas van Gend
18 #include "wine/wingdi16.h"
22 #include "debugtools.h"
30 DEFAULT_DEBUG_CHANNEL(print)
32 static char PrinterModel[] = "Printer Model";
33 static char DefaultDevMode[] = "Default DevMode";
34 static char PrinterDriverData[] = "PrinterDriverData";
35 static char Printers[] = "System\\CurrentControlSet\\Control\\Print\\Printers\\";
37 /******************************************************************
38 * StartDoc16 [GDI.377]
41 INT16 WINAPI StartDoc16( HDC16 hdc, const DOCINFO16 *lpdoc )
45 docA.cbSize = lpdoc->cbSize;
46 docA.lpszDocName = PTR_SEG_TO_LIN(lpdoc->lpszDocName);
47 docA.lpszOutput = PTR_SEG_TO_LIN(lpdoc->lpszOutput);
49 if(lpdoc->cbSize >= 14)
50 docA.lpszDatatype = PTR_SEG_TO_LIN(lpdoc->lpszDatatype);
52 docA.lpszDatatype = NULL;
54 if(lpdoc->cbSize >= 18)
55 docA.fwType = lpdoc->fwType;
59 return StartDocA(hdc, &docA);
62 /******************************************************************
63 * StartDocA [GDI32.347]
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.
70 INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
72 DC *dc = DC_GetDCPtr( hdc );
74 TRACE("DocName = '%s' Output = '%s' Datatype = '%s'\n",
75 doc->lpszDocName, doc->lpszOutput, doc->lpszDatatype);
77 if(!dc) return SP_ERROR;
79 if(dc->funcs->pStartDoc)
80 return dc->funcs->pStartDoc( dc, doc );
82 return Escape(hdc, STARTDOC, strlen(doc->lpszDocName),
83 doc->lpszDocName, (LPVOID)doc);
86 /*************************************************************************
87 * StartDocW [GDI32.348]
90 INT WINAPI StartDocW(HDC hdc, const DOCINFOW* doc)
95 docA.cbSize = doc->cbSize;
96 docA.lpszDocName = doc->lpszDocName ?
97 HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDocName ) : NULL;
98 docA.lpszOutput = doc->lpszOutput ?
99 HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszOutput ) : NULL;
100 docA.lpszDatatype = doc->lpszDatatype ?
101 HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDatatype ) : NULL;
102 docA.fwType = doc->fwType;
104 ret = StartDocA(hdc, &docA);
107 HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDocName );
109 HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszOutput );
110 if(docA.lpszDatatype)
111 HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDatatype );
116 /******************************************************************
120 INT16 WINAPI EndDoc16(HDC16 hdc)
125 /******************************************************************
129 INT WINAPI EndDoc(HDC hdc)
131 DC *dc = DC_GetDCPtr( hdc );
132 if(!dc) return SP_ERROR;
134 if(dc->funcs->pEndDoc)
135 return dc->funcs->pEndDoc( dc );
137 return Escape(hdc, ENDDOC, 0, 0, 0);
140 /******************************************************************
141 * StartPage16 [GDI.379]
144 INT16 WINAPI StartPage16(HDC16 hdc)
146 return StartPage(hdc);
149 /******************************************************************
150 * StartPage [GDI32.349]
153 INT WINAPI StartPage(HDC hdc)
155 DC *dc = DC_GetDCPtr( hdc );
156 if(!dc) return SP_ERROR;
158 if(dc->funcs->pStartPage)
159 return dc->funcs->pStartPage( dc );
165 /******************************************************************
166 * EndPage16 [GDI.380]
169 INT16 WINAPI EndPage16( HDC16 hdc )
174 /******************************************************************
178 INT WINAPI EndPage(HDC hdc)
180 DC *dc = DC_GetDCPtr( hdc );
181 if(!dc) return SP_ERROR;
183 if(dc->funcs->pEndPage)
184 return dc->funcs->pEndPage( dc );
186 return Escape(hdc, NEWFRAME, 0, 0, 0);
189 /******************************************************************************
190 * AbortDoc16 [GDI.382]
192 INT16 WINAPI AbortDoc16(HDC16 hdc)
194 return AbortDoc(hdc);
197 /******************************************************************************
198 * AbortDoc [GDI32.105]
200 INT WINAPI AbortDoc(HDC hdc)
202 DC *dc = DC_GetDCPtr( hdc );
203 if(!dc) return SP_ERROR;
205 if(dc->funcs->pAbortDoc)
206 return dc->funcs->pAbortDoc( dc );
208 return Escape(hdc, ABORTDOC, 0, 0, 0);
211 /**********************************************************************
212 * QueryAbort16 (GDI.155)
214 * Calls the app's AbortProc function if avail.
217 * TRUE if no AbortProc avail or AbortProc wants to continue printing.
218 * FALSE if AbortProc wants to abort printing.
220 BOOL16 WINAPI QueryAbort16(HDC16 hdc, INT16 reserved)
222 DC *dc = DC_GetDCPtr( hdc );
225 ERR("Invalid hdc %04x\n", hdc);
229 if(!dc->w.pAbortProc)
231 return dc->w.pAbortProc(hdc, 0);
234 /* ### start build ### */
235 extern WORD CALLBACK PRTDRV_CallTo16_word_ww(FARPROC16,WORD,WORD);
236 /* ### stop build ### */
238 /**********************************************************************
239 * SetAbortProc16 (GDI.381)
242 INT16 WINAPI SetAbortProc16(HDC16 hdc, SEGPTR abrtprc)
244 ABORTPROC proc32 = (ABORTPROC)THUNK_Alloc((FARPROC16)abrtprc,
245 (RELAY)PRTDRV_CallTo16_word_ww);
246 return SetAbortProc(hdc, proc32);
249 /**********************************************************************
250 * SetAbortProc (GDI32.301)
253 INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
255 DC *dc = DC_GetDCPtr( hdc );
257 if(dc->w.pAbortProc) THUNK_Free((FARPROC)dc->w.pAbortProc);
258 dc->w.pAbortProc = abrtprc;
263 /****************** misc. printer related functions */
266 * The following function should implement a queing system
275 static struct hpq *hpqueue;
277 /**********************************************************************
281 HPQ16 WINAPI CreatePQ16(INT16 size)
288 tmp_size = size << 2;
289 if (!(hpq = GlobalAlloc16(GMEM_SHARE|GMEM_MOVEABLE, tmp_size + 8)))
291 pPQ = GlobalLock16(hpq);
300 FIXME("(%d): stub\n",size);
305 /**********************************************************************
309 INT16 WINAPI DeletePQ16(HPQ16 hPQ)
311 return GlobalFree16((HGLOBAL16)hPQ);
314 /**********************************************************************
315 * ExtractPQ (GDI.232)
318 INT16 WINAPI ExtractPQ16(HPQ16 hPQ)
320 struct hpq *queue, *prev, *current, *currentPrev;
321 int key = 0, tag = -1;
322 currentPrev = prev = NULL;
323 queue = current = hpqueue;
329 currentPrev = current;
330 current = current->next;
333 if (current->key < key)
345 prev->next = queue->next;
347 hpqueue = queue->next;
348 HeapFree(GetProcessHeap(), 0, queue);
351 TRACE("%x got tag %d key %d\n", hPQ, tag, key);
356 /**********************************************************************
360 INT16 WINAPI InsertPQ16(HPQ16 hPQ, INT16 tag, INT16 key)
362 struct hpq *queueItem = HeapAlloc(GetProcessHeap(), 0, sizeof(struct hpq));
363 if(queueItem == NULL) {
364 ERR("Memory exausted!");
367 queueItem->next = hpqueue;
369 queueItem->key = key;
370 queueItem->tag = tag;
372 FIXME("(%x %d %d): stub???\n", hPQ, tag, key);
376 /**********************************************************************
380 INT16 WINAPI MinPQ16(HPQ16 hPQ)
382 FIXME("(%x): stub\n", hPQ);
386 /**********************************************************************
390 INT16 WINAPI SizePQ16(HPQ16 hPQ, INT16 sizechange)
392 FIXME("(%x %d): stub\n", hPQ, sizechange);
399 * The following functions implement part of the spooling process to
400 * print manager. I would like to see wine have a version of print managers
401 * that used LPR/LPD. For simplicity print jobs will be sent to a file for
404 typedef struct PRINTJOB
412 } PRINTJOB, *PPRINTJOB;
414 #define MAX_PRINT_JOBS 1
417 PPRINTJOB gPrintJobsTable[MAX_PRINT_JOBS];
420 static PPRINTJOB FindPrintJobFromHandle(HANDLE16 hHandle)
422 return gPrintJobsTable[0];
425 static int CreateSpoolFile(LPCSTR pszOutput)
429 char *psCmdP = psCmd;
431 /* TTD convert the 'output device' into a spool file name */
433 if (pszOutput == NULL || *pszOutput == '\0')
436 PROFILE_GetWineIniString( "spooler", pszOutput, "", psCmd, sizeof(psCmd) );
437 TRACE("Got printerSpoolCommand '%s' for output device '%s'\n",
440 psCmdP = (char *)pszOutput;
443 while (*psCmdP && isspace(*psCmdP))
459 TRACE("In child need to exec %s\n",psCmdP);
469 TRACE("Need to execute a cmnd and pipe the output to it\n");
473 DOS_FULL_NAME fullName;
475 TRACE("Just assume its a file\n");
478 * The file name can be dos based, we have to find its
479 * Unix correspondant file name
481 DOSFS_GetFullName(psCmdP, FALSE, &fullName);
483 if ((fd = open(fullName.long_name, O_CREAT | O_TRUNC | O_WRONLY , 0600)) < 0)
485 ERR("Failed to create spool file %s, errno = %d\n",
486 fullName.long_name, errno);
492 static int FreePrintJob(HANDLE16 hJob)
497 pPrintJob = FindPrintJobFromHandle(hJob);
498 if (pPrintJob != NULL)
500 gPrintJobsTable[pPrintJob->nIndex] = NULL;
501 HeapFree(GetProcessHeap(), 0, pPrintJob->pszOutput);
502 HeapFree(GetProcessHeap(), 0, pPrintJob->pszTitle);
503 if (pPrintJob->fd >= 0) close(pPrintJob->fd);
504 HeapFree(GetProcessHeap(), 0, pPrintJob);
510 /**********************************************************************
514 HPJOB16 WINAPI OpenJob16(LPCSTR lpOutput, LPCSTR lpTitle, HDC16 hDC)
516 HPJOB16 hHandle = (HPJOB16)SP_ERROR;
519 TRACE("'%s' '%s' %04x\n", lpOutput, lpTitle, hDC);
521 pPrintJob = gPrintJobsTable[0];
522 if (pPrintJob == NULL)
526 /* Try an create a spool file */
527 fd = CreateSpoolFile(lpOutput);
530 pPrintJob = HeapAlloc(GetProcessHeap(), 0, sizeof(PRINTJOB));
531 if(pPrintJob == NULL) {
532 WARN("Memory exausted!");
538 pPrintJob->pszOutput = HEAP_strdupA(GetProcessHeap(), 0, lpOutput);
540 pPrintJob->pszTitle = HEAP_strdupA(GetProcessHeap(), 0, lpTitle);
541 pPrintJob->hDC = hDC;
543 pPrintJob->nIndex = 0;
544 pPrintJob->hHandle = hHandle;
545 gPrintJobsTable[pPrintJob->nIndex] = pPrintJob;
548 TRACE("return %04x\n", hHandle);
552 /**********************************************************************
556 INT16 WINAPI CloseJob16(HPJOB16 hJob)
559 PPRINTJOB pPrintJob = NULL;
561 TRACE("%04x\n", hJob);
563 pPrintJob = FindPrintJobFromHandle(hJob);
564 if (pPrintJob != NULL)
566 /* Close the spool file */
567 close(pPrintJob->fd);
574 /**********************************************************************
575 * WriteSpool (GDI.241)
578 INT16 WINAPI WriteSpool16(HPJOB16 hJob, LPSTR lpData, INT16 cch)
581 PPRINTJOB pPrintJob = NULL;
583 TRACE("%04x %08lx %04x\n", hJob, (DWORD)lpData, cch);
585 pPrintJob = FindPrintJobFromHandle(hJob);
586 if (pPrintJob != NULL && pPrintJob->fd >= 0 && cch)
588 if (write(pPrintJob->fd, lpData, cch) != cch)
592 if (pPrintJob->hDC == 0) {
593 TRACE("hDC == 0 so no QueryAbort\n");
595 else if (!(QueryAbort16(pPrintJob->hDC, (nRet == SP_OUTOFDISK) ? nRet : 0 )))
597 CloseJob16(hJob); /* printing aborted */
604 /**********************************************************************
605 * WriteDialog (GDI.242)
608 INT16 WINAPI WriteDialog16(HPJOB16 hJob, LPSTR lpMsg, INT16 cchMsg)
610 TRACE("%04x %04x '%s'\n", hJob, cchMsg, lpMsg);
612 return Callout.MessageBoxA(0, lpMsg, "Printing Error", MB_OKCANCEL);
616 /**********************************************************************
617 * DeleteJob (GDI.244)
620 INT16 WINAPI DeleteJob16(HPJOB16 hJob, INT16 nNotUsed)
624 TRACE("%04x\n", hJob);
626 nRet = FreePrintJob(hJob);
631 * The following two function would allow a page to be sent to the printer
632 * when it has been processed. For simplicity they havn't been implemented.
633 * This means a whole job has to be processed before it is sent to the printer.
636 /**********************************************************************
637 * StartSpoolPage (GDI.246)
640 INT16 WINAPI StartSpoolPage16(HPJOB16 hJob)
642 FIXME("StartSpoolPage GDI.246 unimplemented\n");
648 /**********************************************************************
649 * EndSpoolPage (GDI.247)
652 INT16 WINAPI EndSpoolPage16(HPJOB16 hJob)
654 FIXME("EndSpoolPage GDI.247 unimplemented\n");
659 /**********************************************************************
660 * GetSpoolJob (GDI.245)
663 DWORD WINAPI GetSpoolJob16(int nOption, LONG param)
666 TRACE("In GetSpoolJob param 0x%lx noption %d\n",param, nOption);
671 /******************************************************************
672 * DrvGetPrinterDataInternal
674 * Helper for DrvGetPrinterData
676 static DWORD DrvGetPrinterDataInternal(LPSTR RegStr_Printer,
677 LPBYTE lpPrinterData, int cbData, int what)
681 DWORD dwType, cbQueryData;
683 if (!(RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey))) {
684 if (what == INT_PD_DEFAULT_DEVMODE) { /* "Default DevMode" */
685 if (!(RegQueryValueExA(hkey, DefaultDevMode, 0, &dwType, 0, &cbQueryData))) {
688 else if ((cbQueryData) && (cbQueryData <= cbData)) {
689 cbQueryData = cbData;
690 if (RegQueryValueExA(hkey, DefaultDevMode, 0,
691 &dwType, lpPrinterData, &cbQueryData))
695 } else { /* "Printer Driver" */
697 RegQueryValueExA(hkey, "Printer Driver", 0,
698 &dwType, lpPrinterData, &cbQueryData);
702 if (hkey) RegCloseKey(hkey);
706 /******************************************************************
707 * DrvGetPrinterData [GDI.282]
710 DWORD WINAPI DrvGetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
711 LPDWORD lpType, LPBYTE lpPrinterData,
712 int cbData, LPDWORD lpNeeded)
714 LPSTR RegStr_Printer;
715 HKEY hkey = 0, hkey2 = 0;
717 DWORD dwType, PrinterAttr, cbPrinterAttr, SetData, size;
719 if (HIWORD(lpPrinter))
720 TRACE("printer %s\n",lpPrinter);
722 TRACE("printer %p\n",lpPrinter);
723 if (HIWORD(lpProfile))
724 TRACE("profile %s\n",lpProfile);
726 TRACE("profile %p\n",lpProfile);
727 TRACE("lpType %p\n",lpType);
729 if ((!lpPrinter) || (!lpProfile) || (!lpNeeded))
730 return ERROR_INVALID_PARAMETER;
732 RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
733 strlen(Printers) + strlen(lpPrinter) + 2);
734 strcpy(RegStr_Printer, Printers);
735 strcat(RegStr_Printer, lpPrinter);
737 if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
738 (!strcmp(lpProfile, DefaultDevMode)))) {
739 size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
740 INT_PD_DEFAULT_DEVMODE);
743 if ((lpPrinterData) && (*lpNeeded > cbData))
744 res = ERROR_MORE_DATA;
746 else res = ERROR_INVALID_PRINTER_NAME;
749 if (((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
750 (!strcmp(lpProfile, PrinterModel)))) {
752 if (!lpPrinterData) goto failed;
754 res = ERROR_MORE_DATA;
757 size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
758 INT_PD_DEFAULT_MODEL);
759 if ((size+1) && (lpType))
762 res = ERROR_INVALID_PRINTER_NAME;
766 if ((res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)))
769 if ((res = RegQueryValueExA(hkey, "Attributes", 0,
770 &dwType, (LPBYTE)&PrinterAttr, &cbPrinterAttr)))
772 if ((res = RegOpenKeyA(hkey, PrinterDriverData, &hkey2)))
775 res = RegQueryValueExA(hkey2, lpProfile, 0,
776 lpType, lpPrinterData, lpNeeded);
777 if ((res != ERROR_CANTREAD) &&
779 (PRINTER_ATTRIBUTE_ENABLE_BIDI|PRINTER_ATTRIBUTE_NETWORK))
780 == PRINTER_ATTRIBUTE_NETWORK))
782 if (!(res) && (*lpType == REG_DWORD) && (*(LPDWORD)lpPrinterData == -1))
783 res = ERROR_INVALID_DATA;
788 RegSetValueExA(hkey2, lpProfile, 0, REG_DWORD, (LPBYTE)&SetData, 4); /* no result returned */
793 if (hkey2) RegCloseKey(hkey2);
794 if (hkey) RegCloseKey(hkey);
795 HeapFree(GetProcessHeap(), 0, RegStr_Printer);
800 /******************************************************************
801 * DrvSetPrinterData [GDI.281]
804 DWORD WINAPI DrvSetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
805 DWORD lpType, LPBYTE lpPrinterData,
808 LPSTR RegStr_Printer;
812 if (HIWORD(lpPrinter))
813 TRACE("printer %s\n",lpPrinter);
815 TRACE("printer %p\n",lpPrinter);
816 if (HIWORD(lpProfile))
817 TRACE("profile %s\n",lpProfile);
819 TRACE("profile %p\n",lpProfile);
820 TRACE("lpType %08lx\n",lpType);
822 if ((!lpPrinter) || (!lpProfile) ||
823 ((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
824 (!strcmp(lpProfile, PrinterModel))))
825 return ERROR_INVALID_PARAMETER;
827 RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
828 strlen(Printers) + strlen(lpPrinter) + 2);
829 strcpy(RegStr_Printer, Printers);
830 strcat(RegStr_Printer, lpPrinter);
832 if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
833 (!strcmp(lpProfile, DefaultDevMode)))) {
834 if ( RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)
836 RegSetValueExA(hkey, DefaultDevMode, 0, REG_BINARY,
837 lpPrinterData, dwSize) != ERROR_SUCCESS )
838 res = ERROR_INVALID_PRINTER_NAME;
842 strcat(RegStr_Printer, "\\");
844 if( (res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)) ==
848 res = RegDeleteValueA(hkey, lpProfile);
850 res = RegSetValueExA(hkey, lpProfile, 0, lpType,
851 lpPrinterData, dwSize);
855 if (hkey) RegCloseKey(hkey);
856 HeapFree(GetProcessHeap(), 0, RegStr_Printer);