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