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
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.
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.
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
25 #include "wine/port.h"
41 #include "wine/winbase16.h"
42 #include "wine/wingdi16.h"
47 #include "wine/debug.h"
52 WINE_DEFAULT_DEBUG_CHANNEL(print);
54 static char PrinterModel[] = "Printer Model";
55 static char DefaultDevMode[] = "Default DevMode";
56 static char PrinterDriverData[] = "PrinterDriverData";
57 static char Printers[] = "System\\CurrentControlSet\\Control\\Print\\Printers\\";
60 /******************************************************************
63 * StartDoc calls the STARTDOC Escape with the input data pointing to DocName
64 * and the output data (which is used as a second input parameter).pointing at
65 * the whole docinfo structure. This seems to be an undocumented feature of
66 * the STARTDOC Escape.
68 * Note: we now do it the other way, with the STARTDOC Escape calling StartDoc.
70 INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
73 DC *dc = DC_GetDCPtr( hdc );
75 TRACE("DocName = '%s' Output = '%s' Datatype = '%s'\n",
76 doc->lpszDocName, doc->lpszOutput, doc->lpszDatatype);
78 if(!dc) return SP_ERROR;
80 if (dc->funcs->pStartDoc) ret = dc->funcs->pStartDoc( dc->physDev, doc );
81 GDI_ReleaseObj( hdc );
85 /*************************************************************************
89 INT WINAPI StartDocW(HDC hdc, const DOCINFOW* doc)
94 docA.cbSize = doc->cbSize;
95 docA.lpszDocName = doc->lpszDocName ?
96 HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDocName ) : NULL;
97 docA.lpszOutput = doc->lpszOutput ?
98 HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszOutput ) : NULL;
99 docA.lpszDatatype = doc->lpszDatatype ?
100 HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDatatype ) : NULL;
101 docA.fwType = doc->fwType;
103 ret = StartDocA(hdc, &docA);
106 HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDocName );
108 HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszOutput );
109 if(docA.lpszDatatype)
110 HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDatatype );
116 /******************************************************************
120 INT WINAPI EndDoc(HDC hdc)
123 DC *dc = DC_GetDCPtr( hdc );
124 if(!dc) return SP_ERROR;
126 if (dc->funcs->pEndDoc) ret = dc->funcs->pEndDoc( dc->physDev );
127 GDI_ReleaseObj( hdc );
132 /******************************************************************
133 * StartPage [GDI32.@]
136 INT WINAPI StartPage(HDC hdc)
139 DC *dc = DC_GetDCPtr( hdc );
140 if(!dc) return SP_ERROR;
142 if(dc->funcs->pStartPage)
143 ret = dc->funcs->pStartPage( dc->physDev );
146 GDI_ReleaseObj( hdc );
151 /******************************************************************
155 INT WINAPI EndPage(HDC hdc)
157 ABORTPROC abort_proc;
159 DC *dc = DC_GetDCPtr( hdc );
160 if(!dc) return SP_ERROR;
162 if (dc->funcs->pEndPage) ret = dc->funcs->pEndPage( dc->physDev );
163 abort_proc = dc->pAbortProc;
164 GDI_ReleaseObj( hdc );
165 if (abort_proc && !abort_proc( hdc, 0 ))
174 /******************************************************************************
177 INT WINAPI AbortDoc(HDC hdc)
180 DC *dc = DC_GetDCPtr( hdc );
181 if(!dc) return SP_ERROR;
183 if (dc->funcs->pAbortDoc) ret = dc->funcs->pAbortDoc( dc->physDev );
184 GDI_ReleaseObj( hdc );
188 /**********************************************************************
189 * QueryAbort (GDI.155)
191 * Calls the app's AbortProc function if avail.
194 * TRUE if no AbortProc avail or AbortProc wants to continue printing.
195 * FALSE if AbortProc wants to abort printing.
197 BOOL16 WINAPI QueryAbort16(HDC16 hdc16, INT16 reserved)
200 HDC hdc = HDC_32( hdc16 );
201 DC *dc = DC_GetDCPtr( hdc );
205 ERR("Invalid hdc %p\n", hdc);
209 abproc = dc->pAbortProc;
210 GDI_ReleaseObj( hdc );
213 ret = abproc(hdc, 0);
218 /**********************************************************************
221 static BOOL CALLBACK call_abort_proc16( HDC hdc, INT code )
224 DC *dc = DC_GetDCPtr( hdc );
226 if (!dc) return FALSE;
227 proc16 = dc->pAbortProc16;
228 GDI_ReleaseObj( hdc );
234 args[1] = HDC_16(hdc);
236 WOWCallback16Ex( (DWORD)proc16, WCB16_PASCAL, sizeof(args), args, &ret );
243 /**********************************************************************
244 * SetAbortProc (GDI.381)
246 INT16 WINAPI SetAbortProc16(HDC16 hdc16, ABORTPROC16 abrtprc)
248 HDC hdc = HDC_32( hdc16 );
249 DC *dc = DC_GetDCPtr( hdc );
251 if (!dc) return FALSE;
252 dc->pAbortProc16 = abrtprc;
253 GDI_ReleaseObj( hdc );
254 return SetAbortProc( hdc, call_abort_proc16 );
257 /**********************************************************************
258 * SetAbortProc (GDI32.@)
261 INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
263 DC *dc = DC_GetDCPtr( hdc );
265 if (!dc) return FALSE;
266 dc->pAbortProc = abrtprc;
267 GDI_ReleaseObj( hdc );
272 /****************** misc. printer related functions */
275 * The following function should implement a queing system
284 static struct hpq *hpqueue;
286 /**********************************************************************
290 HPQ16 WINAPI CreatePQ16(INT16 size)
297 tmp_size = size << 2;
298 if (!(hpq = GlobalAlloc16(GMEM_SHARE|GMEM_MOVEABLE, tmp_size + 8)))
300 pPQ = GlobalLock16(hpq);
309 FIXME("(%d): stub\n",size);
314 /**********************************************************************
318 INT16 WINAPI DeletePQ16(HPQ16 hPQ)
320 return GlobalFree16((HGLOBAL16)hPQ);
323 /**********************************************************************
324 * ExtractPQ (GDI.232)
327 INT16 WINAPI ExtractPQ16(HPQ16 hPQ)
329 struct hpq *queue, *prev, *current, *currentPrev;
330 int key = 0, tag = -1;
331 currentPrev = prev = NULL;
332 queue = current = hpqueue;
338 currentPrev = current;
339 current = current->next;
342 if (current->key < key)
354 prev->next = queue->next;
356 hpqueue = queue->next;
357 HeapFree(GetProcessHeap(), 0, queue);
360 TRACE("%x got tag %d key %d\n", hPQ, tag, key);
365 /**********************************************************************
369 INT16 WINAPI InsertPQ16(HPQ16 hPQ, INT16 tag, INT16 key)
371 struct hpq *queueItem = HeapAlloc(GetProcessHeap(), 0, sizeof(struct hpq));
372 if(queueItem == NULL) {
373 ERR("Memory exausted!\n");
376 queueItem->next = hpqueue;
378 queueItem->key = key;
379 queueItem->tag = tag;
381 FIXME("(%x %d %d): stub???\n", hPQ, tag, key);
385 /**********************************************************************
389 INT16 WINAPI MinPQ16(HPQ16 hPQ)
391 FIXME("(%x): stub\n", hPQ);
395 /**********************************************************************
399 INT16 WINAPI SizePQ16(HPQ16 hPQ, INT16 sizechange)
401 FIXME("(%x %d): stub\n", hPQ, sizechange);
408 * The following functions implement part of the spooling process to
409 * print manager. I would like to see wine have a version of print managers
410 * that used LPR/LPD. For simplicity print jobs will be sent to a file for
413 typedef struct PRINTJOB
421 } PRINTJOB, *PPRINTJOB;
423 #define MAX_PRINT_JOBS 1
426 PPRINTJOB gPrintJobsTable[MAX_PRINT_JOBS];
429 static PPRINTJOB FindPrintJobFromHandle(HANDLE16 hHandle)
431 return gPrintJobsTable[0];
434 static int CreateSpoolFile(LPCSTR pszOutput)
438 char *psCmdP = psCmd;
440 /* TTD convert the 'output device' into a spool file name */
442 if (pszOutput == NULL || *pszOutput == '\0')
445 if (!strncmp("LPR:",pszOutput,4))
446 sprintf(psCmd,"|lpr -P%s",pszOutput+4);
452 if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\spooler", &hkey))
454 DWORD type, count = sizeof(psCmd);
455 RegQueryValueExA(hkey, pszOutput, 0, &type, psCmd, &count);
459 TRACE("Got printerSpoolCommand '%s' for output device '%s'\n",
462 psCmdP = (char *)pszOutput;
465 while (*psCmdP && isspace(*psCmdP))
481 TRACE("In child need to exec %s\n",psCmdP);
491 TRACE("Need to execute a cmnd and pipe the output to it\n");
495 char buffer[MAX_PATH];
497 TRACE("Just assume it's a file\n");
500 * The file name can be dos based, we have to find its
501 * Unix correspondant file name
503 wine_get_unix_file_name(psCmdP, buffer, sizeof(buffer));
505 if ((fd = open(buffer, O_CREAT | O_TRUNC | O_WRONLY , 0600)) < 0)
507 ERR("Failed to create spool file '%s' ('%s'). (error %s)\n",
508 buffer, psCmdP, strerror(errno));
514 static int FreePrintJob(HANDLE16 hJob)
519 pPrintJob = FindPrintJobFromHandle(hJob);
520 if (pPrintJob != NULL)
522 gPrintJobsTable[pPrintJob->nIndex] = NULL;
523 HeapFree(GetProcessHeap(), 0, pPrintJob->pszOutput);
524 HeapFree(GetProcessHeap(), 0, pPrintJob->pszTitle);
525 if (pPrintJob->fd >= 0) close(pPrintJob->fd);
526 HeapFree(GetProcessHeap(), 0, pPrintJob);
532 /**********************************************************************
536 HPJOB16 WINAPI OpenJob16(LPCSTR lpOutput, LPCSTR lpTitle, HDC16 hDC)
538 HPJOB16 hHandle = (HPJOB16)SP_ERROR;
541 TRACE("'%s' '%s' %04x\n", lpOutput, lpTitle, hDC);
543 pPrintJob = gPrintJobsTable[0];
544 if (pPrintJob == NULL)
548 /* Try and create a spool file */
549 fd = CreateSpoolFile(lpOutput);
552 pPrintJob = HeapAlloc(GetProcessHeap(), 0, sizeof(PRINTJOB));
553 if(pPrintJob == NULL) {
554 WARN("Memory exausted!\n");
560 pPrintJob->pszOutput = HeapAlloc(GetProcessHeap(), 0, strlen(lpOutput)+1);
561 strcpy( pPrintJob->pszOutput, lpOutput );
564 pPrintJob->pszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(lpTitle)+1);
565 strcpy( pPrintJob->pszTitle, lpTitle );
567 pPrintJob->hDC = hDC;
569 pPrintJob->nIndex = 0;
570 pPrintJob->hHandle = hHandle;
571 gPrintJobsTable[pPrintJob->nIndex] = pPrintJob;
574 TRACE("return %04x\n", hHandle);
578 /**********************************************************************
582 INT16 WINAPI CloseJob16(HPJOB16 hJob)
585 PPRINTJOB pPrintJob = NULL;
587 TRACE("%04x\n", hJob);
589 pPrintJob = FindPrintJobFromHandle(hJob);
590 if (pPrintJob != NULL)
592 /* Close the spool file */
593 close(pPrintJob->fd);
600 /**********************************************************************
601 * WriteSpool (GDI.241)
604 INT16 WINAPI WriteSpool16(HPJOB16 hJob, LPSTR lpData, INT16 cch)
607 PPRINTJOB pPrintJob = NULL;
609 TRACE("%04x %08lx %04x\n", hJob, (DWORD)lpData, cch);
611 pPrintJob = FindPrintJobFromHandle(hJob);
612 if (pPrintJob != NULL && pPrintJob->fd >= 0 && cch)
614 if (write(pPrintJob->fd, lpData, cch) != cch)
619 /* FIXME: We just cannot call 16 bit functions from here, since we
620 * have acquired several locks (DC). And we do not really need to.
622 if (pPrintJob->hDC == 0) {
623 TRACE("hDC == 0 so no QueryAbort\n");
625 else if (!(QueryAbort16(pPrintJob->hDC, (nRet == SP_OUTOFDISK) ? nRet : 0 )))
627 CloseJob16(hJob); /* printing aborted */
635 typedef INT (WINAPI *MSGBOX_PROC)( HWND, LPCSTR, LPCSTR, UINT );
637 /**********************************************************************
638 * WriteDialog (GDI.242)
641 INT16 WINAPI WriteDialog16(HPJOB16 hJob, LPSTR lpMsg, INT16 cchMsg)
644 MSGBOX_PROC pMessageBoxA;
647 TRACE("%04x %04x '%s'\n", hJob, cchMsg, lpMsg);
649 if ((mod = GetModuleHandleA("user32.dll")))
651 if ((pMessageBoxA = (MSGBOX_PROC)GetProcAddress( mod, "MessageBoxA" )))
652 ret = pMessageBoxA(0, lpMsg, "Printing Error", MB_OKCANCEL);
658 /**********************************************************************
659 * DeleteJob (GDI.244)
662 INT16 WINAPI DeleteJob16(HPJOB16 hJob, INT16 nNotUsed)
666 TRACE("%04x\n", hJob);
668 nRet = FreePrintJob(hJob);
673 * The following two function would allow a page to be sent to the printer
674 * when it has been processed. For simplicity they havn't been implemented.
675 * This means a whole job has to be processed before it is sent to the printer.
678 /**********************************************************************
679 * StartSpoolPage (GDI.246)
682 INT16 WINAPI StartSpoolPage16(HPJOB16 hJob)
684 FIXME("StartSpoolPage GDI.246 unimplemented\n");
690 /**********************************************************************
691 * EndSpoolPage (GDI.247)
694 INT16 WINAPI EndSpoolPage16(HPJOB16 hJob)
696 FIXME("EndSpoolPage GDI.247 unimplemented\n");
701 /**********************************************************************
702 * GetSpoolJob (GDI.245)
705 DWORD WINAPI GetSpoolJob16(int nOption, LONG param)
708 TRACE("In GetSpoolJob param 0x%lx noption %d\n",param, nOption);
713 /******************************************************************
714 * DrvGetPrinterDataInternal
716 * Helper for DrvGetPrinterData
718 static DWORD DrvGetPrinterDataInternal(LPSTR RegStr_Printer,
719 LPBYTE lpPrinterData, int cbData, int what)
723 DWORD dwType, cbQueryData;
725 if (!(RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey))) {
726 if (what == INT_PD_DEFAULT_DEVMODE) { /* "Default DevMode" */
727 if (!(RegQueryValueExA(hkey, DefaultDevMode, 0, &dwType, 0, &cbQueryData))) {
730 else if ((cbQueryData) && (cbQueryData <= cbData)) {
731 cbQueryData = cbData;
732 if (RegQueryValueExA(hkey, DefaultDevMode, 0,
733 &dwType, lpPrinterData, &cbQueryData))
737 } else { /* "Printer Driver" */
739 RegQueryValueExA(hkey, "Printer Driver", 0,
740 &dwType, lpPrinterData, &cbQueryData);
744 if (hkey) RegCloseKey(hkey);
748 /******************************************************************
749 * DrvGetPrinterData (GDI.282)
752 DWORD WINAPI DrvGetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
753 LPDWORD lpType, LPBYTE lpPrinterData,
754 int cbData, LPDWORD lpNeeded)
756 LPSTR RegStr_Printer;
757 HKEY hkey = 0, hkey2 = 0;
759 DWORD dwType, PrinterAttr, cbPrinterAttr, SetData, size;
761 if (HIWORD(lpPrinter))
762 TRACE("printer %s\n",lpPrinter);
764 TRACE("printer %p\n",lpPrinter);
765 if (HIWORD(lpProfile))
766 TRACE("profile %s\n",lpProfile);
768 TRACE("profile %p\n",lpProfile);
769 TRACE("lpType %p\n",lpType);
771 if ((!lpPrinter) || (!lpProfile) || (!lpNeeded))
772 return ERROR_INVALID_PARAMETER;
774 RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
775 strlen(Printers) + strlen(lpPrinter) + 2);
776 strcpy(RegStr_Printer, Printers);
777 strcat(RegStr_Printer, lpPrinter);
779 if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
780 (!strcmp(lpProfile, DefaultDevMode)))) {
781 size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
782 INT_PD_DEFAULT_DEVMODE);
785 if ((lpPrinterData) && (*lpNeeded > cbData))
786 res = ERROR_MORE_DATA;
788 else res = ERROR_INVALID_PRINTER_NAME;
791 if (((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
792 (!strcmp(lpProfile, PrinterModel)))) {
794 if (!lpPrinterData) goto failed;
796 res = ERROR_MORE_DATA;
799 size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
800 INT_PD_DEFAULT_MODEL);
801 if ((size+1) && (lpType))
804 res = ERROR_INVALID_PRINTER_NAME;
808 if ((res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)))
811 if ((res = RegQueryValueExA(hkey, "Attributes", 0,
812 &dwType, (LPBYTE)&PrinterAttr, &cbPrinterAttr)))
814 if ((res = RegOpenKeyA(hkey, PrinterDriverData, &hkey2)))
817 res = RegQueryValueExA(hkey2, lpProfile, 0,
818 lpType, lpPrinterData, lpNeeded);
819 if ((res != ERROR_CANTREAD) &&
821 (PRINTER_ATTRIBUTE_ENABLE_BIDI|PRINTER_ATTRIBUTE_NETWORK))
822 == PRINTER_ATTRIBUTE_NETWORK))
824 if (!(res) && (*lpType == REG_DWORD) && (*(LPDWORD)lpPrinterData == -1))
825 res = ERROR_INVALID_DATA;
830 RegSetValueExA(hkey2, lpProfile, 0, REG_DWORD, (LPBYTE)&SetData, 4); /* no result returned */
835 if (hkey2) RegCloseKey(hkey2);
836 if (hkey) RegCloseKey(hkey);
837 HeapFree(GetProcessHeap(), 0, RegStr_Printer);
842 /******************************************************************
843 * DrvSetPrinterData (GDI.281)
846 DWORD WINAPI DrvSetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
847 DWORD lpType, LPBYTE lpPrinterData,
850 LPSTR RegStr_Printer;
854 if (HIWORD(lpPrinter))
855 TRACE("printer %s\n",lpPrinter);
857 TRACE("printer %p\n",lpPrinter);
858 if (HIWORD(lpProfile))
859 TRACE("profile %s\n",lpProfile);
861 TRACE("profile %p\n",lpProfile);
862 TRACE("lpType %08lx\n",lpType);
864 if ((!lpPrinter) || (!lpProfile) ||
865 ((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
866 (!strcmp(lpProfile, PrinterModel))))
867 return ERROR_INVALID_PARAMETER;
869 RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
870 strlen(Printers) + strlen(lpPrinter) + 2);
871 strcpy(RegStr_Printer, Printers);
872 strcat(RegStr_Printer, lpPrinter);
874 if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
875 (!strcmp(lpProfile, DefaultDevMode)))) {
876 if ( RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)
878 RegSetValueExA(hkey, DefaultDevMode, 0, REG_BINARY,
879 lpPrinterData, dwSize) != ERROR_SUCCESS )
880 res = ERROR_INVALID_PRINTER_NAME;
884 strcat(RegStr_Printer, "\\");
886 if( (res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)) ==
890 res = RegDeleteValueA(hkey, lpProfile);
892 res = RegSetValueExA(hkey, lpProfile, 0, lpType,
893 lpPrinterData, dwSize);
897 if (hkey) RegCloseKey(hkey);
898 HeapFree(GetProcessHeap(), 0, RegStr_Printer);