?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "winex11: Refuse to set the pixel format for HWND_MESSAGE windows."
[wine.git] / dlls / wineps.drv / ppd.c
blob1cba1b85ef6fc01ae3ed838bd4a41151d559321e
1 /* PostScript Printer Description (PPD) file parser
2 *
3 * See http://www.adobe.com/supportservice/devrelations/PDFS/TN/5003.PPD_Spec_v4.3.pdf
4 *
5 * Copyright 1998 Huw D M Davies
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <string.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <ctype.h>
29 #include <locale.h>
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wine/debug.h"
33 #include "psdrv.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
36
37 typedef struct {
38 char *key;
39 char *option;
40 char *opttrans;
41 char *value;
42 char *valtrans;
43 } PPDTuple;
44
45
46 /* map of page names in ppd file to Windows paper constants */
47
48 static const struct {
49 const char *PSName;
50 WORD WinPage;
51 } PageTrans[] = {
52 {"10x11", DMPAPER_10X11},
53 {"10x14", DMPAPER_10X14},
54 {"11x17", DMPAPER_11X17}, /* not in Adobe PPD file spec */
55 {"12x11", DMPAPER_12X11},
56 {"15x11", DMPAPER_15X11},
57 {"9x11", DMPAPER_9X11},
58 {"A2", DMPAPER_A2},
59 {"A3", DMPAPER_A3},
60 {"A3.Transverse", DMPAPER_A3_TRANSVERSE},
61 {"A3Extra", DMPAPER_A3_EXTRA},
62 {"A3Extra.Transverse", DMPAPER_A3_EXTRA_TRANSVERSE},
63 {"A3Rotated", DMPAPER_A3_ROTATED},
64 {"A4", DMPAPER_A4},
65 {"A4.Transverse", DMPAPER_A4_TRANSVERSE},
66 {"A4Extra", DMPAPER_A4_EXTRA},
67 {"A4Plus", DMPAPER_A4_PLUS},
68 {"A4Rotated", DMPAPER_A4_ROTATED},
69 {"A4Small", DMPAPER_A4SMALL},
70 {"A5", DMPAPER_A5},
71 {"A5.Transverse", DMPAPER_A5_TRANSVERSE},
72 {"A5Extra", DMPAPER_A5_EXTRA},
73 {"A5Rotated", DMPAPER_A5_ROTATED},
74 {"A6", DMPAPER_A6},
75 {"A6Rotated", DMPAPER_A6_ROTATED},
76 {"ARCHC", DMPAPER_CSHEET},
77 {"ARCHD", DMPAPER_DSHEET},
78 {"ARCHE", DMPAPER_ESHEET},
79 {"B4", DMPAPER_B4},
80 {"B4Rotated", DMPAPER_B4_JIS_ROTATED},
81 {"B5", DMPAPER_B5},
82 {"B5.Transverse", DMPAPER_B5_TRANSVERSE},
83 {"B5Rotated", DMPAPER_B5_JIS_ROTATED},
84 {"B6", DMPAPER_B6_JIS},
85 {"B6Rotated", DMPAPER_B6_JIS_ROTATED},
86 {"C4", DMPAPER_ENV_C4}, /* use EnvC4 */
87 {"C5", DMPAPER_ENV_C5}, /* use EnvC5 */
88 {"C6", DMPAPER_ENV_C6}, /* use EnvC6 */
89 {"Comm10", DMPAPER_ENV_10}, /* use Env10 */
90 {"DL", DMPAPER_ENV_DL}, /* use EnvDL */
91 {"DoublePostcard", DMPAPER_DBL_JAPANESE_POSTCARD},
92 {"DoublePostcardRotated", DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED},
93 {"Env10", DMPAPER_ENV_10},
94 {"Env11", DMPAPER_ENV_11},
95 {"Env12", DMPAPER_ENV_12},
96 {"Env14", DMPAPER_ENV_14},
97 {"Env9", DMPAPER_ENV_9},
98 {"EnvC3", DMPAPER_ENV_C3},
99 {"EnvC4", DMPAPER_ENV_C4},
100 {"EnvC5", DMPAPER_ENV_C5},
101 {"EnvC6", DMPAPER_ENV_C6},
102 {"EnvC65", DMPAPER_ENV_C65},
103 {"EnvChou3", DMPAPER_JENV_CHOU3},
104 {"EnvChou3Rotated", DMPAPER_JENV_CHOU3_ROTATED},
105 {"EnvChou4", DMPAPER_JENV_CHOU4},
106 {"EnvChou4Rotated", DMPAPER_JENV_CHOU4_ROTATED},
107 {"EnvDL", DMPAPER_ENV_DL},
108 {"EnvISOB4", DMPAPER_ENV_B4},
109 {"EnvISOB5", DMPAPER_ENV_B5},
110 {"EnvISOB6", DMPAPER_ENV_B6},
111 {"EnvInvite", DMPAPER_ENV_INVITE},
112 {"EnvItalian", DMPAPER_ENV_ITALY},
113 {"EnvKaku2", DMPAPER_JENV_KAKU2},
114 {"EnvKaku2Rotated", DMPAPER_JENV_KAKU2_ROTATED},
115 {"EnvKaku3", DMPAPER_JENV_KAKU3},
116 {"EnvKaku3Rotated", DMPAPER_JENV_KAKU3_ROTATED},
117 {"EnvMonarch", DMPAPER_ENV_MONARCH},
118 {"EnvPRC1", DMPAPER_PENV_1},
119 {"EnvPRC10", DMPAPER_PENV_10},
120 {"EnvPRC10Rotated", DMPAPER_PENV_10_ROTATED},
121 {"EnvPRC1Rotated", DMPAPER_PENV_1_ROTATED},
122 {"EnvPRC2", DMPAPER_PENV_2},
123 {"EnvPRC2Rotated", DMPAPER_PENV_2_ROTATED},
124 {"EnvPRC3", DMPAPER_PENV_3},
125 {"EnvPRC3Rotated", DMPAPER_PENV_3_ROTATED},
126 {"EnvPRC4", DMPAPER_PENV_4},
127 {"EnvPRC4Rotated", DMPAPER_PENV_4_ROTATED},
128 {"EnvPRC5", DMPAPER_PENV_5},
129 {"EnvPRC5Rotated", DMPAPER_PENV_5_ROTATED},
130 {"EnvPRC6", DMPAPER_PENV_6},
131 {"EnvPRC6Rotated", DMPAPER_PENV_6_ROTATED},
132 {"EnvPRC7", DMPAPER_PENV_7},
133 {"EnvPRC7Rotated", DMPAPER_PENV_7_ROTATED},
134 {"EnvPRC8", DMPAPER_PENV_8},
135 {"EnvPRC8Rotated", DMPAPER_PENV_8_ROTATED},
136 {"EnvPRC9", DMPAPER_PENV_9},
137 {"EnvPRC9Rotated", DMPAPER_PENV_9_ROTATED},
138 {"EnvPersonal", DMPAPER_ENV_PERSONAL},
139 {"EnvYou4", DMPAPER_JENV_YOU4},
140 {"EnvYou4Rotated", DMPAPER_JENV_YOU4_ROTATED},
141 {"Executive", DMPAPER_EXECUTIVE},
142 {"FanFoldGerman", DMPAPER_FANFOLD_STD_GERMAN},
143 {"FanFoldGermanLegal", DMPAPER_FANFOLD_LGL_GERMAN},
144 {"FanFoldUS", DMPAPER_FANFOLD_US},
145 {"Folio", DMPAPER_FOLIO},
146 {"ISOB4", DMPAPER_ISO_B4},
147 {"ISOB5Extra", DMPAPER_B5_EXTRA},
148 {"Ledger", DMPAPER_LEDGER},
149 {"Legal", DMPAPER_LEGAL},
150 {"LegalExtra", DMPAPER_LEGAL_EXTRA},
151 {"Letter", DMPAPER_LETTER},
152 {"Letter.Transverse", DMPAPER_LETTER_TRANSVERSE},
153 {"LetterExtra", DMPAPER_LETTER_EXTRA},
154 {"LetterExtra.Transverse", DMPAPER_LETTER_EXTRA_TRANSVERSE},
155 {"LetterPlus", DMPAPER_LETTER_PLUS},
156 {"LetterRotated", DMPAPER_LETTER_ROTATED},
157 {"LetterSmall", DMPAPER_LETTERSMALL},
158 {"Monarch", DMPAPER_ENV_MONARCH}, /* use EnvMonarch */
159 {"Note", DMPAPER_NOTE},
160 {"PRC16K", DMPAPER_P16K},
161 {"PRC16KRotated", DMPAPER_P16K_ROTATED},
162 {"PRC32K", DMPAPER_P32K},
163 {"PRC32KBig", DMPAPER_P32KBIG},
164 {"PRC32KBigRotated", DMPAPER_P32KBIG_ROTATED},
165 {"PRC32KRotated", DMPAPER_P32K_ROTATED},
166 {"Postcard", DMPAPER_JAPANESE_POSTCARD},
167 {"PostcardRotated", DMPAPER_JAPANESE_POSTCARD_ROTATED},
168 {"Quarto", DMPAPER_QUARTO},
169 {"Statement", DMPAPER_STATEMENT},
170 {"SuperA", DMPAPER_A_PLUS},
171 {"SuperB", DMPAPER_B_PLUS},
172 {"Tabloid", DMPAPER_TABLOID},
173 {"TabloidExtra", DMPAPER_TABLOID_EXTRA},
174 {NULL, 0}
175 };
176
177 static WORD UserPageType = DMPAPER_USER;
178 static WORD UserBinType = DMBIN_USER;
179
180 /***********************************************************************
181 *
182 * PSDRV_PPDDecodeHex
183 *
184 * Copies str into a newly allocated string from the process heap substituting
185 * hex strings enclosed in '<' and '>' for their byte codes.
186 *
187 */
188 static char *PSDRV_PPDDecodeHex(char *str)
189 {
190 char *buf, *in, *out;
191 BOOL inhex = FALSE;
192
193 buf = HeapAlloc(PSDRV_Heap, 0, strlen(str) + 1);
194 if(!buf)
195 return NULL;
196
197 for(in = str, out = buf; *in; in++) {
198 if(!inhex) {
199 if(*in != '<')
200 *out++ = *in;
201 else
202 inhex = TRUE;
203 } else {
204 if(*in == '>') {
205 inhex = FALSE;
206 continue;
207 }
208 else if(isspace(*in))
209 continue;
210 else {
211 int i;
212 if(!isxdigit(*in) || !isxdigit(*(in + 1))) {
213 ERR("Invalid hex char in hex string\n");
214 HeapFree(PSDRV_Heap, 0, buf);
215 return NULL;
216 }
217 *out = 0;
218 for(i = 0; i < 2; i++) {
219 if(isdigit(*(in + i)))
220 *out |= (*(in + i) - '0') << ((1-i) * 4);
221 else
222 *out |= (toupper(*(in + i)) - 'A' + 10) << ((1-i) * 4);
223 }
224 out++;
225 in++;
226 }
227 }
228 }
229 *out = '\0';
230 return buf;
231 }
232
233
234 /***********************************************************************
235 *
236 * PSDRV_PPDGetTransValue
237 *
238 */
239 static BOOL PSDRV_PPDGetTransValue(char *start, PPDTuple *tuple)
240 {
241 char *buf, *end;
242
243 end = strpbrk(start, "\r\n");
244 if(end == start) return FALSE;
245 if(!end) end = start + strlen(start);
246 buf = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
247 memcpy(buf, start, end - start);
248 *(buf + (end - start)) = '\0';
249 tuple->valtrans = PSDRV_PPDDecodeHex(buf);
250 HeapFree( PSDRV_Heap, 0, buf );
251 return TRUE;
252 }
253
254
255 /***********************************************************************
256 *
257 * PSDRV_PPDGetInvocationValue
258 *
259 * Passed string that should be surrounded by `"'s, return string alloced
260 * from process heap.
261 */
262 static BOOL PSDRV_PPDGetInvocationValue(FILE *fp, char *pos, PPDTuple *tuple)
263 {
264 char *start, *end, *buf;
265 char line[257];
266 int len;
267
268 start = pos + 1;
269 buf = HeapAlloc( PSDRV_Heap, 0, strlen(start) + 1 );
270 len = 0;
271 do {
272 end = strchr(start, '"');
273 if(end) {
274 buf = HeapReAlloc( PSDRV_Heap, 0, buf,
275 len + (end - start) + 1 );
276 memcpy(buf + len, start, end - start);
277 *(buf + len + (end - start)) = '\0';
278 tuple->value = buf;
279 start = strchr(end, '/');
280 if(start)
281 return PSDRV_PPDGetTransValue(start + 1, tuple);
282 return TRUE;
283 } else {
284 int sl = strlen(start);
285 buf = HeapReAlloc( PSDRV_Heap, 0, buf, len + sl + 1 );
286 strcpy(buf + len, start);
287 len += sl;
288 }
289 } while( fgets((start = line), sizeof(line), fp) );
290
291 tuple->value = NULL;
292 HeapFree( PSDRV_Heap, 0, buf );
293 return FALSE;
294 }
295
296
297 /***********************************************************************
298 *
299 * PSDRV_PPDGetQuotedValue
300 *
301 * Passed string that should be surrounded by `"'s. Expand <xx> as hex
302 * return string alloced from process heap.
303 */
304 static BOOL PSDRV_PPDGetQuotedValue(FILE *fp, char *pos, PPDTuple *tuple)
305 {
306 char *buf;
307
308 if(!PSDRV_PPDGetInvocationValue(fp, pos, tuple))
309 return FALSE;
310 buf = PSDRV_PPDDecodeHex(tuple->value);
311 HeapFree(PSDRV_Heap, 0, tuple->value);
312 tuple->value = buf;
313 return TRUE;
314 }
315
316
317 /***********************************************************************
318 *
319 * PSDRV_PPDGetStringValue
320 *
321 * Just strip leading white space.
322 */
323 static BOOL PSDRV_PPDGetStringValue(char *str, PPDTuple *tuple)
324 {
325 char *start = str, *end;
326
327 while(*start != '\0' && isspace(*start))
328 start++;
329
330 end = strpbrk(start, "/\r\n");
331 if(!end) end = start + strlen(start);
332 tuple->value = HeapAlloc( PSDRV_Heap, 0, (end - start) + 1 );
333 memcpy(tuple->value, start, end - start);
334 *(tuple->value + (end - start)) = '\0';
335 if(*end == '/')
336 PSDRV_PPDGetTransValue(end + 1, tuple);
337 return TRUE;
338 }
339
340
341 /***********************************************************************
342 *
343 * PSDRV_PPDSymbolValue
344 *
345 * Not implemented yet.
346 */
347 static BOOL PSDRV_PPDGetSymbolValue(char *pos, PPDTuple *tuple)
348 {
349 FIXME("Stub\n");
350 return FALSE;
351 }
352
353
354 /*********************************************************************
355 *
356 * PSDRV_PPDGetNextTuple
357 *
358 * Gets the next Keyword Option Value tuple from the file. Allocs space off
359 * the process heap which should be free()ed by the caller if not needed.
360 */
361 static BOOL PSDRV_PPDGetNextTuple(FILE *fp, PPDTuple *tuple)
362 {
363 char line[257], *opt, *cp, *trans, *endkey;
364 BOOL gotoption;
365
366 start:
367
368 gotoption = TRUE;
369 opt = NULL;
370 memset(tuple, 0, sizeof(*tuple));
371
372 do {
373 if(!fgets(line, sizeof(line), fp))
374 return FALSE;
375 if(line[0] == '*' && line[1] != '%' && strncmp(line, "*End", 4))
376 break;
377 } while(1);
378
379 if(line[strlen(line)-1] != '\n') {
380 ERR("Line too long.\n");
381 goto start;
382 }
383
384 for(cp = line; !isspace(*cp) && *cp != ':'; cp++)
385 ;
386
387 endkey = cp;
388 if(*cp == ':') { /* <key>: */
389 gotoption = FALSE;
390 } else {
391 while(isspace(*cp))
392 cp++;
393 if(*cp == ':') { /* <key> : */
394 gotoption = FALSE;
395 } else { /* <key> <option> */
396 opt = cp;
397 }
398 }
399
400 tuple->key = HeapAlloc( PSDRV_Heap, 0, endkey - line + 1 );
401 if(!tuple->key) return FALSE;
402
403 memcpy(tuple->key, line, endkey - line);
404 tuple->key[endkey - line] = '\0';
405
406 if(gotoption) { /* opt points to 1st non-space character of the option */
407 cp = strpbrk(opt, ":/");
408 if(!cp) {
409 ERR("Error in line '%s'?\n", line);
410 HeapFree(GetProcessHeap(), 0, tuple->key);
411 goto start;
412 }
413 tuple->option = HeapAlloc( PSDRV_Heap, 0, cp - opt + 1 );
414 if(!tuple->option) return FALSE;
415 memcpy(tuple->option, opt, cp - opt);
416 tuple->option[cp - opt] = '\0';
417 if(*cp == '/') {
418 char *buf;
419 trans = cp + 1;
420 cp = strchr(trans, ':');
421 if(!cp) {
422 ERR("Error in line '%s'?\n", line);
423 HeapFree(GetProcessHeap(), 0, tuple->option);
424 HeapFree(GetProcessHeap(), 0, tuple->key);
425 goto start;
426 }
427 buf = HeapAlloc( PSDRV_Heap, 0, cp - trans + 1 );
428 if(!buf) return FALSE;
429 memcpy(buf, trans, cp - trans);
430 buf[cp - trans] = '\0';
431 tuple->opttrans = PSDRV_PPDDecodeHex(buf);
432 HeapFree( PSDRV_Heap, 0, buf );
433 }
434 }
435
436 /* cp should point to a ':', so we increment past it */
437 cp++;
438
439 while(isspace(*cp))
440 cp++;
441
442 switch(*cp) {
443 case '"':
444 if( (!gotoption && strncmp(tuple->key, "*?", 2) ) ||
445 !strncmp(tuple->key, "*JCL", 4))
446 PSDRV_PPDGetQuotedValue(fp, cp, tuple);
447 else
448 PSDRV_PPDGetInvocationValue(fp, cp, tuple);
449 break;
450
451 case '^':
452 PSDRV_PPDGetSymbolValue(cp, tuple);
453 break;
454
455 default:
456 PSDRV_PPDGetStringValue(cp, tuple);
457 }
458 return TRUE;
459 }
460
461 /*********************************************************************
462 * get_pagesize
463 *
464 * Searches ppd PageSize list to return entry matching name or optionally creates new
465 * entry which is appended to the list if name is not found.
466 */
467 static PAGESIZE *get_pagesize( PPD *ppd, char *name, BOOL create )
468 {
469 PAGESIZE *page;
470
471 LIST_FOR_EACH_ENTRY(page, &ppd->PageSizes, PAGESIZE, entry)
472 {
473 if(!strcmp(page->Name, name))
474 return page;
475 }
476
477 if (!create) return NULL;
478
479 page = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(*page) );
480 list_add_tail(&ppd->PageSizes, &page->entry);
481 return page;
482 }
483
484 static DUPLEX *get_duplex( PPD *ppd, const char *name )
485 {
486 DUPLEX *duplex;
487
488 LIST_FOR_EACH_ENTRY( duplex, &ppd->Duplexes, DUPLEX, entry )
489 {
490 if (!strcmp( duplex->Name, name ))
491 return duplex;
492 }
493
494 return NULL;
495 }
496
497 /**********************************************************************
498 *
499 * PSDRV_PPDGetWord
500 *
501 * Returns ptr alloced from heap to first word in str. Strips leading spaces.
502 * Puts ptr to next word in next
503 */
504 static char *PSDRV_PPDGetWord(char *str, char **next)
505 {
506 char *start, *end, *ret;
507
508 start = str;
509 while(start && *start && isspace(*start))
510 start++;
511 if(!start || !*start) return FALSE;
512
513 end = start;
514 while(*end && !isspace(*end))
515 end++;
516
517 ret = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
518 memcpy(ret, start, end - start );
519 *(ret + (end - start)) = '\0';
520
521 while(*end && isspace(*end))
522 end++;
523 if(*end)
524 *next = end;
525 else
526 *next = NULL;
527
528 return ret;
529 }
530
531 /************************************************************
532 * parse_resolution
533 *
534 * Helper to extract x and y resolutions from a resolution entry.
535 * Returns TRUE on successful parsing, otherwise FALSE.
536 *
537 * The ppd spec says that entries can either be:
538 * "nnndpi"
539 * or
540 * "nnnxmmmdpi"
541 * in the former case return sz.cx == cx.cy == nnn.
542 *
543 * There are broken ppd files out there (notably from Samsung) that
544 * use the form "nnnmmmdpi", so we have to work harder to spot these.
545 * We use a transition from a zero to a non-zero digit as separator
546 * (and fail if we find more than one of these). We also don't bother
547 * trying to parse "dpi" in case that's missing.
548 */
549 static BOOL parse_resolution(const char *str, SIZE *sz)
550 {
551 int tmp[2];
552 int *cur;
553 BOOL had_zero;
554 const char *c;
555
556 if(sscanf(str, "%dx%d", tmp, tmp + 1) == 2)
557 {
558 sz->cx = tmp[0];
559 sz->cy = tmp[1];
560 return TRUE;
561 }
562
563 tmp[0] = 0;
564 tmp[1] = -1;
565 cur = tmp;
566 had_zero = FALSE;
567 for(c = str; isdigit(*c); c++)
568 {
569 if(!had_zero || *c == '0')
570 {
571 *cur *= 10;
572 *cur += *c - '0';
573 if(*c == '0')
574 had_zero = TRUE;
575 }
576 else if(cur != tmp)
577 return FALSE;
578 else
579 {
580 cur++;
581 *cur = *c - '0';
582 had_zero = FALSE;
583 }
584 }
585 if(tmp[0] == 0) return FALSE;
586
587 sz->cx = tmp[0];
588 if(tmp[1] != -1)
589 sz->cy = tmp[1];
590 else
591 sz->cy = sz->cx;
592 return TRUE;
593 }
594
595 /*******************************************************************************
596 * PSDRV_AddSlot
597 *
598 */
599 static BOOL PSDRV_AddSlot(PPD *ppd, LPCSTR szName, LPCSTR szFullName,
600 LPSTR szInvocationString, WORD wWinBin)
601 {
602 INPUTSLOT *slot = HeapAlloc( PSDRV_Heap, 0, sizeof(INPUTSLOT) );
603 if (!slot) return FALSE;
604
605 slot->Name = szName;
606 slot->FullName = szFullName;
607 slot->InvocationString = szInvocationString;
608 slot->WinBin = wWinBin;
609
610 list_add_tail( &ppd->InputSlots, &slot->entry );
611 return TRUE;
612 }
613
614 static char *get_ppd_override( HANDLE printer, const char *value )
615 {
616 DWORD err, type, needed;
617 char *data;
618
619 err = GetPrinterDataExA( printer, "PPD Overrides", value, &type, NULL, 0, &needed );
620 if (err != ERROR_MORE_DATA || type != REG_SZ || needed == 0) return NULL;
621
622 data = HeapAlloc( PSDRV_Heap, 0, needed );
623 if (data)
624 {
625 GetPrinterDataExA( printer, "PPD Overrides", value, &type, (BYTE*)data, needed, &needed );
626 TRACE( "got override %s: %s\n", value, data );
627 }
628 return data;
629 }
630
631 /***********************************************************************
632 *
633 * PSDRV_ParsePPD
634 *
635 *
636 */
637 PPD *PSDRV_ParsePPD( char *fname, HANDLE printer )
638 {
639 FILE *fp;
640 PPD *ppd;
641 PPDTuple tuple;
642 char *default_pagesize = NULL, *default_duplex = NULL;
643 char *def_pagesize_override = NULL, *def_duplex_override = NULL;
644 PAGESIZE *page, *page_cursor2;
645
646 TRACE("file '%s'\n", fname);
647
648 if((fp = fopen(fname, "r")) == NULL) {
649 WARN("Couldn't open ppd file '%s'\n", fname);
650 return NULL;
651 }
652
653 ppd = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(*ppd));
654 if(!ppd) {
655 ERR("Unable to allocate memory for ppd\n");
656 fclose(fp);
657 return NULL;
658 }
659
660 ppd->ColorDevice = CD_NotSpecified;
661
662 list_init( &ppd->InstalledFonts );
663 list_init( &ppd->PageSizes );
664 list_init( &ppd->Constraints );
665 list_init( &ppd->InputSlots );
666 list_init( &ppd->Duplexes );
667
668 /* Some gimp-print ppd files don't contain a DefaultResolution line
669 so default to 300 */
670 ppd->DefaultResolution = 300;
671
672 /*
673 * The Windows PostScript drivers create the following "virtual bin" for
674 * every PostScript printer
675 */
676 if (!PSDRV_AddSlot( ppd, NULL, "Automatically Select", NULL, DMBIN_FORMSOURCE ))
677 {
678 HeapFree (PSDRV_Heap, 0, ppd);
679 fclose(fp);
680 return NULL;
681 }
682
683 while( PSDRV_PPDGetNextTuple(fp, &tuple)) {
684
685 if(!strcmp("*NickName", tuple.key)) {
686 ppd->NickName = tuple.value;
687 tuple.value = NULL;
688 TRACE("NickName = '%s'\n", ppd->NickName);
689 }
690
691 else if(!strcmp("*LanguageLevel", tuple.key)) {
692 sscanf(tuple.value, "%d", &(ppd->LanguageLevel));
693 TRACE("LanguageLevel = %d\n", ppd->LanguageLevel);
694 }
695
696 else if(!strcmp("*ColorDevice", tuple.key)) {
697 if(!strcasecmp(tuple.value, "true"))
698 ppd->ColorDevice = CD_True;
699 else
700 ppd->ColorDevice = CD_False;
701 TRACE("ColorDevice = %s\n", ppd->ColorDevice == CD_True ? "True" : "False");
702 }
703
704 else if((!strcmp("*DefaultResolution", tuple.key)) ||
705 (!strcmp("*DefaultJCLResolution", tuple.key))) {
706 SIZE sz;
707 if(parse_resolution(tuple.value, &sz))
708 {
709 TRACE("DefaultResolution %dx%d\n", sz.cx, sz.cy);
710 ppd->DefaultResolution = sz.cx;
711 }
712 else
713 WARN("failed to parse DefaultResolution %s\n", debugstr_a(tuple.value));
714 }
715
716 else if(!strcmp("*Font", tuple.key))
717 {
718 FONTNAME *fn = HeapAlloc( PSDRV_Heap, 0, sizeof(*fn) );
719 fn->Name = tuple.option;
720 tuple.option = NULL;
721 list_add_tail( &ppd->InstalledFonts, &fn->entry );
722 }
723
724 else if(!strcmp("*DefaultFont", tuple.key)) {
725 ppd->DefaultFont = tuple.value;
726 tuple.value = NULL;
727 }
728
729 else if(!strcmp("*JCLBegin", tuple.key)) {
730 ppd->JCLBegin = tuple.value;
731 tuple.value = NULL;
732 }
733
734 else if(!strcmp("*JCLToPSInterpreter", tuple.key)) {
735 ppd->JCLToPSInterpreter = tuple.value;
736 tuple.value = NULL;
737 }
738
739 else if(!strcmp("*JCLEnd", tuple.key)) {
740 ppd->JCLEnd = tuple.value;
741 tuple.value = NULL;
742 }
743
744 else if(!strcmp("*PageSize", tuple.key)) {
745 page = get_pagesize( ppd, tuple.option, TRUE );
746
747 if(!page->Name) {
748 int i;
749
750 page->Name = tuple.option;
751 tuple.option = NULL;
752
753 for(i = 0; PageTrans[i].PSName; i++) {
754 if(!strcmp(PageTrans[i].PSName, page->Name)) { /* case ? */
755 page->WinPage = PageTrans[i].WinPage;
756 break;
757 }
758 }
759 if(!page->WinPage) {
760 TRACE("Can't find Windows page type for '%s' - using %u\n",
761 page->Name, UserPageType);
762 page->WinPage = UserPageType++;
763 }
764 }
765 if(!page->FullName) {
766 if(tuple.opttrans) {
767 page->FullName = tuple.opttrans;
768 tuple.opttrans = NULL;
769 } else
770 {
771 page->FullName = HeapAlloc( PSDRV_Heap, 0, strlen(page->Name)+1 );
772 strcpy( page->FullName, page->Name );
773 }
774 }
775 if(!page->InvocationString) {
776 page->InvocationString = tuple.value;
777 tuple.value = NULL;
778 }
779 }
780
781 else if(!strcmp("*DefaultPageSize", tuple.key))
782 {
783 if (!default_pagesize)
784 {
785 default_pagesize = tuple.value;
786 tuple.value = NULL;
787 }
788 }
789
790 else if(!strcmp("*ImageableArea", tuple.key)) {
791 page = get_pagesize( ppd, tuple.option, TRUE );
792
793 if(!page->Name) {
794 page->Name = tuple.option;
795 tuple.option = NULL;
796 }
797 if(!page->FullName) {
798 page->FullName = tuple.opttrans;
799 tuple.opttrans = NULL;
800 }
801
802 #define PIA page->ImageableArea
803 if(!PIA) {
804 PIA = HeapAlloc( PSDRV_Heap, 0, sizeof(*PIA) );
805 push_lc_numeric("C");
806 sscanf(tuple.value, "%f%f%f%f", &PIA->llx, &PIA->lly,
807 &PIA->urx, &PIA->ury);
808 pop_lc_numeric();
809 }
810 #undef PIA
811 }
812
813 else if(!strcmp("*PaperDimension", tuple.key)) {
814 page = get_pagesize( ppd, tuple.option, TRUE );
815
816 if(!page->Name) {
817 page->Name = tuple.option;
818 tuple.option = NULL;
819 }
820 if(!page->FullName) {
821 page->FullName = tuple.opttrans;
822 tuple.opttrans = NULL;
823 }
824
825 #define PD page->PaperDimension
826 if(!PD) {
827 PD = HeapAlloc( PSDRV_Heap, 0, sizeof(*PD) );
828 push_lc_numeric("C");
829 sscanf(tuple.value, "%f%f", &PD->x, &PD->y);
830 pop_lc_numeric();
831 }
832 #undef PD
833 }
834
835 else if(!strcmp("*LandscapeOrientation", tuple.key)) {
836 if(!strcmp(tuple.value, "Plus90"))
837 ppd->LandscapeOrientation = 90;
838 else if(!strcmp(tuple.value, "Minus90"))
839 ppd->LandscapeOrientation = -90;
840
841 /* anything else, namely 'any', leaves value at 0 */
842
843 TRACE("LandscapeOrientation = %d\n",
844 ppd->LandscapeOrientation);
845 }
846
847 else if(!strcmp("*UIConstraints", tuple.key))
848 {
849 char *start;
850 CONSTRAINT *con = HeapAlloc( PSDRV_Heap, 0, sizeof(*con) );
851
852 start = tuple.value;
853 con->Feature1 = PSDRV_PPDGetWord(start, &start);
854 con->Value1 = PSDRV_PPDGetWord(start, &start);
855 con->Feature2 = PSDRV_PPDGetWord(start, &start);
856 con->Value2 = PSDRV_PPDGetWord(start, &start);
857
858 list_add_tail( &ppd->Constraints, &con->entry );
859 }
860
861 else if (!strcmp("*InputSlot", tuple.key))
862 {
863
864 if (!tuple.opttrans)
865 tuple.opttrans = tuple.option;
866
867 TRACE("Using Windows bin type %u for '%s'\n", UserBinType,
868 tuple.option);
869
870 /* FIXME - should check for failure */
871 PSDRV_AddSlot(ppd, tuple.option, tuple.opttrans, tuple.value,
872 UserBinType++);
873
874 tuple.option = tuple.opttrans = tuple.value = NULL;
875 }
876
877 /*
878 * Windows treats "manual feed" as another paper source. Most PPD
879 * files, however, treat it as a separate option which is either on or
880 * off.
881 */
882 else if (!strcmp("*ManualFeed", tuple.key) && tuple.option &&
883 !strcmp ("True", tuple.option))
884 {
885 /* FIXME - should check for failure */
886 PSDRV_AddSlot(ppd, "Manual Feed", "Manual Feed", tuple.value, DMBIN_MANUAL);
887 tuple.value = NULL;
888 }
889
890 else if(!strcmp("*TTRasterizer", tuple.key)) {
891 if(!strcasecmp("None", tuple.value))
892 ppd->TTRasterizer = RO_None;
893 else if(!strcasecmp("Accept68K", tuple.value))
894 ppd->TTRasterizer = RO_Accept68K;
895 else if(!strcasecmp("Type42", tuple.value))
896 ppd->TTRasterizer = RO_Type42;
897 else if(!strcasecmp("TrueImage", tuple.value))
898 ppd->TTRasterizer = RO_TrueImage;
899 else {
900 FIXME("Unknown option %s for *TTRasterizer\n",
901 tuple.value);
902 ppd->TTRasterizer = RO_None;
903 }
904 TRACE("*TTRasterizer = %d\n", ppd->TTRasterizer);
905 }
906
907 else if(!strcmp("*Duplex", tuple.key))
908 {
909 DUPLEX *duplex = HeapAlloc( GetProcessHeap(), 0, sizeof(*duplex) );
910 duplex->Name = tuple.option;
911 duplex->FullName = tuple.opttrans;
912 duplex->InvocationString = tuple.value;
913 if(!strcasecmp("None", tuple.option) || !strcasecmp("False", tuple.option)
914 || !strcasecmp("Simplex", tuple.option))
915 duplex->WinDuplex = DMDUP_SIMPLEX;
916 else if(!strcasecmp("DuplexNoTumble", tuple.option))
917 duplex->WinDuplex = DMDUP_VERTICAL;
918 else if(!strcasecmp("DuplexTumble", tuple.option))
919 duplex->WinDuplex = DMDUP_HORIZONTAL;
920 else if(!strcasecmp("Notcapable", tuple.option))
921 duplex->WinDuplex = 0;
922 else {
923 FIXME("Unknown option %s for *Duplex defaulting to simplex\n", tuple.option);
924 duplex->WinDuplex = DMDUP_SIMPLEX;
925 }
926 tuple.option = tuple.opttrans = tuple.value = NULL;
927 list_add_tail( &ppd->Duplexes, &duplex->entry );
928 }
929
930 else if (!strcmp("*DefaultDuplex", tuple.key))
931 {
932 if (!default_duplex)
933 {
934 default_duplex = tuple.value;
935 tuple.value = NULL;
936 }
937 }
938
939 HeapFree(PSDRV_Heap, 0, tuple.key);
940 HeapFree(PSDRV_Heap, 0, tuple.option);
941 HeapFree(PSDRV_Heap, 0, tuple.value);
942 HeapFree(PSDRV_Heap, 0, tuple.opttrans);
943 HeapFree(PSDRV_Heap, 0, tuple.valtrans);
944
945 }
946
947 /* Remove any partial page size entries, that is any without a PageSize or a PaperDimension (we can
948 cope with a missing ImageableArea). */
949 LIST_FOR_EACH_ENTRY_SAFE(page, page_cursor2, &ppd->PageSizes, PAGESIZE, entry)
950 {
951 if(!page->InvocationString || !page->PaperDimension)
952 {
953 WARN("Removing page %s since it has a missing %s entry\n", debugstr_a(page->FullName),
954 page->InvocationString ? "PaperDimension" : "InvocationString");
955 HeapFree(PSDRV_Heap, 0, page->Name);
956 HeapFree(PSDRV_Heap, 0, page->FullName);
957 HeapFree(PSDRV_Heap, 0, page->InvocationString);
958 HeapFree(PSDRV_Heap, 0, page->ImageableArea);
959 HeapFree(PSDRV_Heap, 0, page->PaperDimension);
960 list_remove(&page->entry);
961 }
962 }
963
964 ppd->DefaultPageSize = NULL;
965 def_pagesize_override = get_ppd_override( printer, "DefaultPageSize" );
966 if (def_pagesize_override)
967 ppd->DefaultPageSize = get_pagesize( ppd, def_pagesize_override, FALSE );
968 if (!ppd->DefaultPageSize && default_pagesize)
969 ppd->DefaultPageSize = get_pagesize( ppd, default_pagesize, FALSE );
970
971 if (!ppd->DefaultPageSize)
972 {
973 struct list *head = list_head( &ppd->PageSizes );
974 if (head) ppd->DefaultPageSize = LIST_ENTRY( head, PAGESIZE, entry );
975 TRACE("Setting DefaultPageSize to first in list\n");
976 }
977 TRACE( "DefaultPageSize: %s\n", ppd->DefaultPageSize ? ppd->DefaultPageSize->Name : "<not set>" );
978
979 HeapFree( PSDRV_Heap, 0, def_pagesize_override );
980 HeapFree( PSDRV_Heap, 0, default_pagesize );
981
982 ppd->DefaultDuplex = NULL;
983 def_duplex_override = get_ppd_override( printer, "DefaultDuplex" );
984 if (def_duplex_override)
985 ppd->DefaultDuplex = get_duplex( ppd, def_duplex_override );
986 if (!ppd->DefaultDuplex && default_duplex)
987 ppd->DefaultDuplex = get_duplex( ppd, default_duplex );
988
989 if (!ppd->DefaultDuplex)
990 {
991 struct list *head = list_head( &ppd->Duplexes );
992 if (head) ppd->DefaultDuplex = LIST_ENTRY( head, DUPLEX, entry );
993 TRACE("Setting DefaultDuplex to first in list\n");
994 }
995 TRACE( "DefaultDuplex: %s\n", ppd->DefaultDuplex ? ppd->DefaultDuplex->Name : "<not set>" );
996
997 HeapFree( PSDRV_Heap, 0, def_duplex_override );
998 HeapFree( PSDRV_Heap, 0, default_duplex );
999
1000
1001 {
1002 FONTNAME *fn;
1003 PAGESIZE *page;
1004 CONSTRAINT *con;
1005 INPUTSLOT *slot;
1006
1007 LIST_FOR_EACH_ENTRY( fn, &ppd->InstalledFonts, FONTNAME, entry )
1008 TRACE("'%s'\n", fn->Name);
1009
1010 LIST_FOR_EACH_ENTRY(page, &ppd->PageSizes, PAGESIZE, entry) {
1011 TRACE("'%s' aka '%s' (%d) invoked by '%s'\n", page->Name,
1012 page->FullName, page->WinPage, page->InvocationString);
1013 if(page->ImageableArea)
1014 TRACE("Area = %.2f,%.2f - %.2f, %.2f\n",
1015 page->ImageableArea->llx, page->ImageableArea->lly,
1016 page->ImageableArea->urx, page->ImageableArea->ury);
1017 if(page->PaperDimension)
1018 TRACE("Dimension = %.2f x %.2f\n",
1019 page->PaperDimension->x, page->PaperDimension->y);
1020 }
1021
1022 LIST_FOR_EACH_ENTRY( con, &ppd->Constraints, CONSTRAINT, entry )
1023 TRACE("CONSTRAINTS@ %s %s %s %s\n", con->Feature1,
1024 con->Value1, con->Feature2, con->Value2);
1025
1026 LIST_FOR_EACH_ENTRY( slot, &ppd->InputSlots, INPUTSLOT, entry )
1027 TRACE("INPUTSLOTS '%s' Name '%s' (%d) Invocation '%s'\n",
1028 debugstr_a(slot->Name), slot->FullName, slot->WinBin,
1029 debugstr_a(slot->InvocationString));
1030 }
1031
1032 fclose(fp);
1033 return ppd;
1034 }
Windows API implementation