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