![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to winprint.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / print / winprint|
Return to winprint.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / winprint |
1.1 root 1: #include <windows.h>
2: #include <winspool.h>
3: #include <winsplp.h>
4:
5: #include "winprint.h"
6:
7: #include <excpt.h>
8: #include <string.h>
9:
10: #define PRINTPROCESSOR_TYPE_RAW 0
11: #define PRINTPROCESSOR_TYPE_JOURNAL 1
12: #define PRINTPROCESSOR_TYPE_TEXT 2
13: #define PRINTPROCESSOR_TYPE_NUM 3
14:
15: LPWSTR Datatypes[]={L"RAW", L"NT JNL 1.000", L"TEXT", 0};
16:
17: LPWSTR
18: AllocStr(
19: LPWSTR pString
20: )
21: {
22: LPWSTR pNewString;
23:
24: if (pString) {
25: pNewString = LocalAlloc(LMEM_FIXED, (wcslen(pString)+1)*sizeof(WCHAR));
26: wcscpy(pNewString, pString);
27: return pNewString;
28: }
29:
30: return NULL;
31: }
32:
33: BOOL
34: EnumPrintProcessorDatatypes(
35: LPWSTR pName,
36: LPWSTR pPrintProcessorName,
37: DWORD Level,
38: LPBYTE pDatatypes,
39: DWORD cbBuf,
40: LPDWORD pcbNeeded,
41: LPDWORD pcReturned
42: )
43: {
44: DATATYPES_INFO_1 *pInfo1 = (DATATYPES_INFO_1 *)pDatatypes;
45: LPWSTR *pMyDatatypes = Datatypes;
46: DWORD cbTotal=0;
47: LPBYTE pEnd;
48:
49: *pcReturned = 0;
50:
51: pEnd = (LPBYTE)pInfo1 + cbBuf;
52:
53: while (*pMyDatatypes) {
54:
55: cbTotal += wcslen(*pMyDatatypes)*sizeof(WCHAR) + sizeof(WCHAR) +
56: sizeof(DATATYPES_INFO_1);
57:
58: pMyDatatypes++;
59: }
60:
61: *pcbNeeded = cbTotal;
62:
63: if (cbTotal <= cbBuf) {
64:
65: pMyDatatypes = Datatypes;
66:
67: while (*pMyDatatypes) {
68:
69: pEnd -= wcslen(*pMyDatatypes)*sizeof(WCHAR) + sizeof(WCHAR);
70: wcscpy((LPWSTR)pEnd, *pMyDatatypes);
71: pInfo1->pName = (LPWSTR)pEnd;
72: pInfo1++;
73: (*pcReturned)++;
74:
75: pMyDatatypes++;
76: }
77:
78: } else {
79:
80: SetLastError(ERROR_INSUFFICIENT_BUFFER);
81: return FALSE;
82: }
83:
84: return TRUE;
85: }
86:
87: HANDLE
88: OpenPrintProcessor(
89: LPWSTR pPrinterName,
90: PPRINTPROCESSOROPENDATA pPrintProcessorOpenData
91: )
92: {
93: PPRINTPROCESSORDATA pData;
94: LPWSTR *pMyDatatypes=Datatypes;
95: DWORD uDatatype=0;
96: HANDLE hPrinter=0;
97: HDC hDC;
98:
99: while (*pMyDatatypes && wcscmp(*pMyDatatypes,
100: pPrintProcessorOpenData->pDatatype)) {
101: pMyDatatypes++;
102: uDatatype++;
103: }
104:
105: switch (uDatatype) {
106:
107: case 0:
108: if (!OpenPrinter(pPrinterName, &hPrinter, NULL))
109: return FALSE;
110: break;
111:
112: case 1:
113: if (!(hDC = CreateDC(L"", pPrinterName, L"",
114: pPrintProcessorOpenData->pDevMode)))
115: return FALSE;
116: break;
117:
118: default:
119: SetLastError(ERROR_INVALID_DATATYPE);
120: return FALSE;
121: }
122:
123: pData = (PPRINTPROCESSORDATA)LocalAlloc(LPTR, sizeof(PRINTPROCESSORDATA));
124:
125: pData->cb = sizeof(PRINTPROCESSORDATA);
126: pData->signature = PRINTPROCESSORDATA_SIGNATURE;
127: pData->JobId = pPrintProcessorOpenData->JobId;
128: pData->hPrinter = hPrinter;
129: pData->semPaused = CreateEvent(NULL, FALSE, TRUE,NULL);
130: pData->uDatatype = uDatatype;
131: pData->hDC = hDC;
132:
133: pData->pPrinterName = AllocStr(pPrinterName);
134: pData->pDatatype = AllocStr(pPrintProcessorOpenData->pDatatype);
135: pData->pDocument = AllocStr(pPrintProcessorOpenData->pDocumentName);
136: pData->pParameters = AllocStr(pPrintProcessorOpenData->pParameters);
137:
138: return (HANDLE)pData;
139: }
140:
141: BOOL
142: PrintDocumentOnPrintProcessor(
143: HANDLE hPrintProcessor,
144: LPWSTR pDocumentName
145: )
146: {
147: PPRINTPROCESSORDATA pData;
148: DOC_INFO_1 DocInfo;
149: DWORD rc;
150: DWORD NoRead, NoWritten;
151: HANDLE hPrinter;
152: BYTE Buffer[4096];
153:
154: if (!(pData = ValidateHandle(hPrintProcessor))) {
155:
156: SetLastError(ERROR_INVALID_HANDLE);
157: return FALSE;
158: }
159:
160: if (pData->uDatatype == 1) {
161:
162: try {
163: //!!! BUG BUG BUG - LPCWSTR
164: return GdiPlayJournal(pData->hDC, (LPCSTR)pDocumentName, 0, -1);
165:
166: } except (TRUE) {
167:
168: OutputDebugString(L"GdiPlayJournal gave an exception\n");
169:
170: return FALSE;
171: }
172: }
173:
174: if (!OpenPrinter(pDocumentName, &hPrinter, NULL)) {
175: return FALSE;
176: }
177:
178: DocInfo.pDocName = pData->pDocument;
179: DocInfo.pOutputFile = 0;
180: DocInfo.pDatatype = pData->pDatatype;
181:
182: if (!StartDocPrinter(pData->hPrinter, 1, (LPBYTE)&DocInfo)) {
183: ClosePrinter(hPrinter);
184: return FALSE;
185: }
186:
187: while ((rc = ReadPrinter(hPrinter, Buffer, sizeof(Buffer), &NoRead)) &&
188: NoRead) {
189:
190: if (pData->fsStatus & PRINTPROCESSOR_PAUSED)
191: WaitForSingleObject(pData->semPaused, INFINITE);
192:
193: if (pData->fsStatus & PRINTPROCESSOR_ABORTED) {
194: break;
195: }
196:
197: WritePrinter(pData->hPrinter, Buffer, NoRead, &NoWritten);
198: }
199:
200: EndDocPrinter(pData->hPrinter);
201:
202: ClosePrinter(hPrinter);
203:
204: return TRUE;
205: }
206:
207: BOOL
208: ClosePrintProcessor(
209: HANDLE hPrintProcessor
210: )
211: {
212: PPRINTPROCESSORDATA pData;
213:
214: pData = ValidateHandle(hPrintProcessor);
215:
216: if (!pData) {
217: SetLastError(ERROR_INVALID_HANDLE);
218: return FALSE;
219: }
220:
221: pData->signature = 0;
222:
223: /* Release any allocated resources */
224:
225: if (pData->hPrinter)
226: ClosePrinter(pData->hPrinter);
227:
228: if (pData->hDC)
229: DeleteDC(pData->hDC);
230:
231: CloseHandle(pData->semPaused);
232:
233: if (pData->pPrinterName)
234: LocalFree(pData->pPrinterName);
235:
236: if (pData->pDatatype)
237: LocalFree(pData->pDatatype);
238:
239: if (pData->pDocument)
240: LocalFree(pData->pDocument);
241:
242: if (pData->pParameters)
243: LocalFree(pData->pParameters);
244:
245: LocalFree(pData);
246:
247: return TRUE;
248: }
249:
250: BOOL
251: ControlPrintProcessor(
252: HANDLE hPrintProcessor,
253: DWORD Command
254: )
255: {
256: PPRINTPROCESSORDATA pData;
257:
258: if (pData = ValidateHandle(hPrintProcessor)) {
259:
260: switch (Command) {
261:
262: case JOB_CONTROL_PAUSE:
263:
264: ResetEvent(pData->semPaused);
265: pData->fsStatus |= PRINTPROCESSOR_PAUSED;
266: return TRUE;
267: break;
268:
269: case JOB_CONTROL_CANCEL:
270:
271: pData->fsStatus |= PRINTPROCESSOR_ABORTED;
272:
273: if (pData->uDatatype == PRINTPROCESSOR_TYPE_JOURNAL)
274: CancelDC(pData->hDC);
275:
276: /* fall through to release job if paused */
277:
278: case JOB_CONTROL_RESUME:
279:
280: if (pData->fsStatus & PRINTPROCESSOR_PAUSED) {
281:
282: SetEvent(pData->semPaused);
283: pData->fsStatus &= ~PRINTPROCESSOR_PAUSED;
284: }
285:
286: return TRUE;
287: break;
288:
289: default:
290:
291: return FALSE;
292: break;
293: }
294:
295: }
296:
297: return FALSE;
298: }
299:
300: BOOL
301: InstallPrintProcessor(
302: HWND hWnd
303: )
304: {
305: MessageBox(hWnd, L"WinPrint", L"Print Processor Setup", MB_OK);
306:
307: return TRUE;
308: }
309:
310: PPRINTPROCESSORDATA
311: ValidateHandle(
312: HANDLE hQProc
313: )
314: {
315: PPRINTPROCESSORDATA pData = (PPRINTPROCESSORDATA)hQProc;
316:
317: if (pData && pData->signature == PRINTPROCESSORDATA_SIGNATURE)
318: return( pData );
319:
320: return( NULL );
321: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.