Const correctness, pointer cast correctness, removed extraneous ';'.
[wine.git] / dlls / wineps / ppd.c
blobf156e1555e789705579cfe996d36a08988dca313
1 /* PostScript Printer Description (PPD) file parser
3 * See http://www.adobe.com/supportservice/devrelations/PDFS/TN/5003.PPD_Spec_v4.3.pdf
5 * Copyright 1998 Huw D M Davies
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.
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.
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
22 #include <string.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <ctype.h>
26 #include "windef.h"
27 #include "winbase.h"
28 #include "wine/debug.h"
29 #include "psdrv.h"
30 #include "winspool.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
34 typedef struct {
35 char *key;
36 char *option;
37 char *opttrans;
38 char *value;
39 char *valtrans;
40 } PPDTuple;
43 /* map of page names in ppd file to Windows paper constants */
45 static const struct {
46 const char *PSName;
47 WORD WinPage;
48 } PageTrans[] = {
49 {"10x11", DMPAPER_10X11},
50 {"10x14", DMPAPER_10X14},
51 {"11x17", DMPAPER_11X17}, /* not in Adobe PPD file spec */
52 {"12x11", DMPAPER_12X11},
53 {"15x11", DMPAPER_15X11},
54 {"9x11", DMPAPER_9X11},
55 {"A2", DMPAPER_A2},
56 {"A3", DMPAPER_A3},
57 {"A3.Transverse", DMPAPER_A3_TRANSVERSE},
58 {"A3Extra", DMPAPER_A3_EXTRA},
59 {"A3Extra.Transverse", DMPAPER_A3_EXTRA_TRANSVERSE},
60 {"A3Rotated", DMPAPER_A3_ROTATED},
61 {"A4", DMPAPER_A4},
62 {"A4.Transverse", DMPAPER_A4_TRANSVERSE},
63 {"A4Extra", DMPAPER_A4_EXTRA},
64 {"A4Plus", DMPAPER_A4_PLUS},
65 {"A4Rotated", DMPAPER_A4_ROTATED},
66 {"A4Small", DMPAPER_A4SMALL},
67 {"A5", DMPAPER_A5},
68 {"A5.Transverse", DMPAPER_A5_TRANSVERSE},
69 {"A5Extra", DMPAPER_A5_EXTRA},
70 {"A5Rotated", DMPAPER_A5_ROTATED},
71 {"A6", DMPAPER_A6},
72 {"A6Rotated", DMPAPER_A6_ROTATED},
73 {"ARCHC", DMPAPER_CSHEET},
74 {"ARCHD", DMPAPER_DSHEET},
75 {"ARCHE", DMPAPER_ESHEET},
76 {"B4", DMPAPER_B4},
77 {"B4Rotated", DMPAPER_B4_JIS_ROTATED},
78 {"B5", DMPAPER_B5},
79 {"B5.Transverse", DMPAPER_B5_TRANSVERSE},
80 {"B5Rotated", DMPAPER_B5_JIS_ROTATED},
81 {"B6", DMPAPER_B6_JIS},
82 {"B6Rotated", DMPAPER_B6_JIS_ROTATED},
83 {"C4", DMPAPER_ENV_C4}, /* use EnvC4 */
84 {"C5", DMPAPER_ENV_C5}, /* use EnvC5 */
85 {"C6", DMPAPER_ENV_C6}, /* use EnvC6 */
86 {"Comm10", DMPAPER_ENV_10}, /* use Env10 */
87 {"DL", DMPAPER_ENV_DL}, /* use EnvDL */
88 {"DoublePostcard", DMPAPER_DBL_JAPANESE_POSTCARD},
89 {"DoublePostcardRotated", DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED},
90 {"Env10", DMPAPER_ENV_10},
91 {"Env11", DMPAPER_ENV_11},
92 {"Env12", DMPAPER_ENV_12},
93 {"Env14", DMPAPER_ENV_14},
94 {"Env9", DMPAPER_ENV_9},
95 {"EnvC3", DMPAPER_ENV_C3},
96 {"EnvC4", DMPAPER_ENV_C4},
97 {"EnvC5", DMPAPER_ENV_C5},
98 {"EnvC6", DMPAPER_ENV_C6},
99 {"EnvC65", DMPAPER_ENV_C65},
100 {"EnvChou3", DMPAPER_JENV_CHOU3},
101 {"EnvChou3Rotated", DMPAPER_JENV_CHOU3_ROTATED},
102 {"EnvChou4", DMPAPER_JENV_CHOU4},
103 {"EnvChou4Rotated", DMPAPER_JENV_CHOU4_ROTATED},
104 {"EnvDL", DMPAPER_ENV_DL},
105 {"EnvISOB4", DMPAPER_ENV_B4},
106 {"EnvISOB5", DMPAPER_ENV_B5},
107 {"EnvISOB6", DMPAPER_ENV_B6},
108 {"EnvInvite", DMPAPER_ENV_INVITE},
109 {"EnvItalian", DMPAPER_ENV_ITALY},
110 {"EnvKaku2", DMPAPER_JENV_KAKU2},
111 {"EnvKaku2Rotated", DMPAPER_JENV_KAKU2_ROTATED},
112 {"EnvKaku3", DMPAPER_JENV_KAKU3},
113 {"EnvKaku3Rotated", DMPAPER_JENV_KAKU3_ROTATED},
114 {"EnvMonarch", DMPAPER_ENV_MONARCH},
115 {"EnvPRC1", DMPAPER_PENV_1},
116 {"EnvPRC10", DMPAPER_PENV_10},
117 {"EnvPRC10Rotated", DMPAPER_PENV_10_ROTATED},
118 {"EnvPRC1Rotated", DMPAPER_PENV_1_ROTATED},
119 {"EnvPRC2", DMPAPER_PENV_2},
120 {"EnvPRC2Rotated", DMPAPER_PENV_2_ROTATED},
121 {"EnvPRC3", DMPAPER_PENV_3},
122 {"EnvPRC3Rotated", DMPAPER_PENV_3_ROTATED},
123 {"EnvPRC4", DMPAPER_PENV_4},
124 {"EnvPRC4Rotated", DMPAPER_PENV_4_ROTATED},
125 {"EnvPRC5", DMPAPER_PENV_5},
126 {"EnvPRC5Rotated", DMPAPER_PENV_5_ROTATED},
127 {"EnvPRC6", DMPAPER_PENV_6},
128 {"EnvPRC6Rotated", DMPAPER_PENV_6_ROTATED},
129 {"EnvPRC7", DMPAPER_PENV_7},
130 {"EnvPRC7Rotated", DMPAPER_PENV_7_ROTATED},
131 {"EnvPRC8", DMPAPER_PENV_8},
132 {"EnvPRC8Rotated", DMPAPER_PENV_8_ROTATED},
133 {"EnvPRC9", DMPAPER_PENV_9},
134 {"EnvPRC9Rotated", DMPAPER_PENV_9_ROTATED},
135 {"EnvPersonal", DMPAPER_ENV_PERSONAL},
136 {"EnvYou4", DMPAPER_JENV_YOU4},
137 {"EnvYou4Rotated", DMPAPER_JENV_YOU4_ROTATED},
138 {"Executive", DMPAPER_EXECUTIVE},
139 {"FanFoldGerman", DMPAPER_FANFOLD_STD_GERMAN},
140 {"FanFoldGermanLegal", DMPAPER_FANFOLD_LGL_GERMAN},
141 {"FanFoldUS", DMPAPER_FANFOLD_US},
142 {"Folio", DMPAPER_FOLIO},
143 {"ISOB4", DMPAPER_ISO_B4},
144 {"ISOB5Extra", DMPAPER_B5_EXTRA},
145 {"Ledger", DMPAPER_LEDGER},
146 {"Legal", DMPAPER_LEGAL},
147 {"LegalExtra", DMPAPER_LEGAL_EXTRA},
148 {"Letter", DMPAPER_LETTER},
149 {"Letter.Transverse", DMPAPER_LETTER_TRANSVERSE},
150 {"LetterExtra", DMPAPER_LETTER_EXTRA},
151 {"LetterExtra.Transverse", DMPAPER_LETTER_EXTRA_TRANSVERSE},
152 {"LetterPlus", DMPAPER_LETTER_PLUS},
153 {"LetterRotated", DMPAPER_LETTER_ROTATED},
154 {"LetterSmall", DMPAPER_LETTERSMALL},
155 {"Monarch", DMPAPER_ENV_MONARCH}, /* use EnvMonarch */
156 {"Note", DMPAPER_NOTE},
157 {"PRC16K", DMPAPER_P16K},
158 {"PRC16KRotated", DMPAPER_P16K_ROTATED},
159 {"PRC32K", DMPAPER_P32K},
160 {"PRC32KBig", DMPAPER_P32KBIG},
161 {"PRC32KBigRotated", DMPAPER_P32KBIG_ROTATED},
162 {"PRC32KRotated", DMPAPER_P32K_ROTATED},
163 {"Postcard", DMPAPER_JAPANESE_POSTCARD},
164 {"PostcardRotated", DMPAPER_JAPANESE_POSTCARD_ROTATED},
165 {"Quarto", DMPAPER_QUARTO},
166 {"Statement", DMPAPER_STATEMENT},
167 {"SuperA", DMPAPER_A_PLUS},
168 {"SuperB", DMPAPER_B_PLUS},
169 {"Tabloid", DMPAPER_TABLOID},
170 {"TabloidExtra", DMPAPER_TABLOID_EXTRA},
171 {NULL, 0}
174 static WORD UserPageType = DMPAPER_USER;
175 static WORD UserBinType = DMBIN_USER;
177 /***********************************************************************
179 * PSDRV_PPDDecodeHex
181 * Copies str into a newly allocated string from the process heap subsituting
182 * hex strings enclosed in '<' and '>' for their byte codes.
185 static char *PSDRV_PPDDecodeHex(char *str)
187 char *buf, *in, *out;
188 BOOL inhex = FALSE;
190 buf = HeapAlloc(PSDRV_Heap, 0, strlen(str) + 1);
191 if(!buf)
192 return NULL;
194 for(in = str, out = buf; *in; in++) {
195 if(!inhex) {
196 if(*in != '<')
197 *out++ = *in;
198 else
199 inhex = TRUE;
200 } else {
201 if(*in == '>') {
202 inhex = FALSE;
203 continue;
205 else if(isspace(*in))
206 continue;
207 else {
208 int i;
209 if(!isxdigit(*in) || !isxdigit(*(in + 1))) {
210 ERR("Invalid hex char in hex string\n");
211 HeapFree(PSDRV_Heap, 0, buf);
212 return NULL;
214 *out = 0;
215 for(i = 0; i < 2; i++) {
216 if(isdigit(*(in + i)))
217 *out |= (*(in + i) - '0') << ((1-i) * 4);
218 else
219 *out |= (toupper(*(in + i)) - 'A' + 10) << ((1-i) * 4);
221 out++;
222 in++;
226 *out = '\0';
227 return buf;
231 /***********************************************************************
233 * PSDRV_PPDGetTransValue
236 static BOOL PSDRV_PPDGetTransValue(char *start, PPDTuple *tuple)
238 char *buf, *end;
240 end = strpbrk(start, "\r\n");
241 if(end == start) return FALSE;
242 if(!end) end = start + strlen(start);
243 buf = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
244 memcpy(buf, start, end - start);
245 *(buf + (end - start)) = '\0';
246 tuple->valtrans = PSDRV_PPDDecodeHex(buf);
247 HeapFree( PSDRV_Heap, 0, buf );
248 return TRUE;
252 /***********************************************************************
254 * PSDRV_PPDGetInvocationValue
256 * Passed string that should be surrounded by `"'s, return string alloced
257 * from process heap.
259 static BOOL PSDRV_PPDGetInvocationValue(FILE *fp, char *pos, PPDTuple *tuple)
261 char *start, *end, *buf;
262 char line[257];
263 int len;
265 start = pos + 1;
266 buf = HeapAlloc( PSDRV_Heap, 0, strlen(start) + 1 );
267 len = 0;
268 do {
269 end = strchr(start, '"');
270 if(end) {
271 buf = HeapReAlloc( PSDRV_Heap, 0, buf,
272 len + (end - start) + 1 );
273 memcpy(buf + len, start, end - start);
274 *(buf + len + (end - start)) = '\0';
275 tuple->value = buf;
276 start = strchr(end, '/');
277 if(start)
278 return PSDRV_PPDGetTransValue(start + 1, tuple);
279 return TRUE;
280 } else {
281 int sl = strlen(start);
282 buf = HeapReAlloc( PSDRV_Heap, 0, buf, len + sl + 1 );
283 strcpy(buf + len, start);
284 len += sl;
286 } while( fgets((start = line), sizeof(line), fp) );
288 tuple->value = NULL;
289 HeapFree( PSDRV_Heap, 0, buf );
290 return FALSE;
294 /***********************************************************************
296 * PSDRV_PPDGetQuotedValue
298 * Passed string that should be surrounded by `"'s. Expand <xx> as hex
299 * return string alloced from process heap.
301 static BOOL PSDRV_PPDGetQuotedValue(FILE *fp, char *pos, PPDTuple *tuple)
303 char *buf;
305 if(!PSDRV_PPDGetInvocationValue(fp, pos, tuple))
306 return FALSE;
307 buf = PSDRV_PPDDecodeHex(tuple->value);
308 HeapFree(PSDRV_Heap, 0, tuple->value);
309 tuple->value = buf;
310 return TRUE;
314 /***********************************************************************
316 * PSDRV_PPDGetStringValue
318 * Just strip leading white space.
320 static BOOL PSDRV_PPDGetStringValue(char *str, PPDTuple *tuple)
322 char *start = str, *end;
324 while(*start != '\0' && isspace(*start))
325 start++;
327 end = strpbrk(start, "/\r\n");
328 if(!end) end = start + strlen(start);
329 tuple->value = HeapAlloc( PSDRV_Heap, 0, (end - start) + 1 );
330 memcpy(tuple->value, start, end - start);
331 *(tuple->value + (end - start)) = '\0';
332 if(*end == '/')
333 PSDRV_PPDGetTransValue(end + 1, tuple);
334 return TRUE;
338 /***********************************************************************
340 * PSDRV_PPDSymbolValue
342 * Not implemented yet.
344 static BOOL PSDRV_PPDGetSymbolValue(char *pos, PPDTuple *tuple)
346 FIXME("Stub\n");
347 return FALSE;
351 /*********************************************************************
353 * PSDRV_PPDGetNextTuple
355 * Gets the next Keyword Option Value tuple from the file. Allocs space off
356 * the process heap which should be free()ed by the caller if not needed.
358 static BOOL PSDRV_PPDGetNextTuple(FILE *fp, PPDTuple *tuple)
360 char line[257], *opt, *cp, *trans, *endkey;
361 BOOL gotoption;
363 start:
365 gotoption = TRUE;
366 opt = NULL;
367 memset(tuple, 0, sizeof(*tuple));
369 do {
370 if(!fgets(line, sizeof(line), fp))
371 return FALSE;
372 if(line[0] == '*' && line[1] != '%' && strncmp(line, "*End", 4))
373 break;
374 } while(1);
376 if(line[strlen(line)-1] != '\n') {
377 ERR("Line too long.\n");
378 goto start;
381 for(cp = line; !isspace(*cp) && *cp != ':'; cp++)
384 endkey = cp;
385 if(*cp == ':') { /* <key>: */
386 gotoption = FALSE;
387 } else {
388 while(isspace(*cp))
389 cp++;
390 if(*cp == ':') { /* <key> : */
391 gotoption = FALSE;
392 } else { /* <key> <option> */
393 opt = cp;
397 tuple->key = HeapAlloc( PSDRV_Heap, 0, endkey - line + 1 );
398 if(!tuple->key) return FALSE;
400 memcpy(tuple->key, line, endkey - line);
401 tuple->key[endkey - line] = '\0';
403 if(gotoption) { /* opt points to 1st non-space character of the option */
404 cp = strpbrk(opt, ":/");
405 if(!cp) {
406 ERR("Error in line '%s'?\n", line);
407 HeapFree(GetProcessHeap(), 0, tuple->key);
408 goto start;
410 tuple->option = HeapAlloc( PSDRV_Heap, 0, cp - opt + 1 );
411 if(!tuple->option) return FALSE;
412 memcpy(tuple->option, opt, cp - opt);
413 tuple->option[cp - opt] = '\0';
414 if(*cp == '/') {
415 char *buf;
416 trans = cp + 1;
417 cp = strchr(trans, ':');
418 if(!cp) {
419 ERR("Error in line '%s'?\n", line);
420 HeapFree(GetProcessHeap(), 0, tuple->option);
421 HeapFree(GetProcessHeap(), 0, tuple->key);
422 goto start;
424 buf = HeapAlloc( PSDRV_Heap, 0, cp - trans + 1 );
425 if(!buf) return FALSE;
426 memcpy(buf, trans, cp - trans);
427 buf[cp - trans] = '\0';
428 tuple->opttrans = PSDRV_PPDDecodeHex(buf);
429 HeapFree( PSDRV_Heap, 0, buf );
433 /* cp should point to a ':', so we increment past it */
434 cp++;
436 while(isspace(*cp))
437 cp++;
439 switch(*cp) {
440 case '"':
441 if( (!gotoption && strncmp(tuple->key, "*?", 2) ) ||
442 !strncmp(tuple->key, "*JCL", 4))
443 PSDRV_PPDGetQuotedValue(fp, cp, tuple);
444 else
445 PSDRV_PPDGetInvocationValue(fp, cp, tuple);
446 break;
448 case '^':
449 PSDRV_PPDGetSymbolValue(cp, tuple);
450 break;
452 default:
453 PSDRV_PPDGetStringValue(cp, tuple);
455 return TRUE;
458 /*********************************************************************
460 * PSDRV_PPDGetPageSizeInfo
462 * Searches ppd PageSize list to return entry matching name or creates new
463 * entry which is appended to the list if name is not found.
466 PAGESIZE *PSDRV_PPDGetPageSizeInfo(PPD *ppd, char *name)
468 PAGESIZE *page = ppd->PageSizes, *lastpage;
470 if(!page) {
471 page = ppd->PageSizes = HeapAlloc( PSDRV_Heap,
472 HEAP_ZERO_MEMORY, sizeof(*page) );
473 return page;
474 } else {
475 for( ; page; page = page->next) {
476 if(!strcmp(page->Name, name))
477 return page;
478 lastpage = page;
481 lastpage->next = HeapAlloc( PSDRV_Heap,
482 HEAP_ZERO_MEMORY, sizeof(*page) );
483 return lastpage->next;
487 /**********************************************************************
489 * PSDRV_PPDGetWord
491 * Returns ptr alloced from heap to first word in str. Strips leading spaces.
492 * Puts ptr to next word in next
494 static char *PSDRV_PPDGetWord(char *str, char **next)
496 char *start, *end, *ret;
498 start = str;
499 while(start && *start && isspace(*start))
500 start++;
501 if(!start || !*start) return FALSE;
503 end = start;
504 while(*end && !isspace(*end))
505 end++;
507 ret = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
508 memcpy(ret, start, end - start );
509 *(ret + (end - start)) = '\0';
511 while(*end && isspace(*end))
512 end++;
513 if(*end)
514 *next = end;
515 else
516 *next = NULL;
518 return ret;
521 /*******************************************************************************
522 * PSDRV_AddSlot
525 static INT PSDRV_AddSlot(PPD *ppd, LPSTR szName, LPSTR szFullName,
526 LPSTR szInvocationString, WORD wWinBin)
528 INPUTSLOT *slot, **insert = &ppd->InputSlots;
530 while (*insert)
531 insert = &((*insert)->next);
533 slot = *insert = HeapAlloc(PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(INPUTSLOT));
534 if (!slot)
536 ERR("Failed to allocate %i bytes of memory\n", sizeof(INPUTSLOT));
537 return 1;
540 slot->Name = szName;
541 slot->FullName = szFullName;
542 slot->InvocationString = szInvocationString;
543 slot->WinBin = wWinBin;
545 return 0;
548 /***********************************************************************
550 * PSDRV_ParsePPD
554 PPD *PSDRV_ParsePPD(char *fname)
556 FILE *fp;
557 PPD *ppd;
558 PPDTuple tuple;
559 char *default_pagesize = NULL, *default_duplex = NULL;
561 TRACE("file '%s'\n", fname);
563 if((fp = fopen(fname, "r")) == NULL) {
564 WARN("Couldn't open ppd file '%s'\n", fname);
565 return NULL;
568 ppd = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(*ppd));
569 if(!ppd) {
570 ERR("Unable to allocate memory for ppd\n");
571 fclose(fp);
572 return NULL;
576 * The Windows PostScript drivers create the following "virtual bin" for
577 * every PostScript printer
579 if (PSDRV_AddSlot(ppd, NULL, "Automatically Select", NULL,
580 DMBIN_FORMSOURCE))
582 HeapFree (PSDRV_Heap, 0, ppd);
583 fclose(fp);
584 return NULL;
587 while( PSDRV_PPDGetNextTuple(fp, &tuple)) {
589 if(!strcmp("*NickName", tuple.key)) {
590 ppd->NickName = tuple.value;
591 tuple.value = NULL;
592 TRACE("NickName = '%s'\n", ppd->NickName);
595 else if(!strcmp("*LanguageLevel", tuple.key)) {
596 sscanf(tuple.value, "%d", &(ppd->LanguageLevel));
597 TRACE("LanguageLevel = %d\n", ppd->LanguageLevel);
600 else if(!strcmp("*ColorDevice", tuple.key)) {
601 if(!strcasecmp(tuple.value, "true"))
602 ppd->ColorDevice = TRUE;
603 TRACE("ColorDevice = %d\n", (int)ppd->ColorDevice);
606 else if((!strcmp("*DefaultResolution", tuple.key)) ||
607 (!strcmp("*DefaultJCLResolution", tuple.key))) {
608 sscanf(tuple.value, "%d", &(ppd->DefaultResolution));
609 TRACE("DefaultResolution = %d\n", ppd->DefaultResolution);
612 else if(!strcmp("*Font", tuple.key)) {
613 FONTNAME *fn;
615 for(fn = ppd->InstalledFonts; fn && fn->next; fn = fn->next)
617 if(!fn) {
618 ppd->InstalledFonts = HeapAlloc(PSDRV_Heap,
619 HEAP_ZERO_MEMORY, sizeof(*fn));
620 fn = ppd->InstalledFonts;
621 } else {
622 fn->next = HeapAlloc(PSDRV_Heap,
623 HEAP_ZERO_MEMORY, sizeof(*fn));
624 fn = fn->next;
626 fn->Name = tuple.option;
627 tuple.option = NULL;
630 else if(!strcmp("*DefaultFont", tuple.key)) {
631 ppd->DefaultFont = tuple.value;
632 tuple.value = NULL;
635 else if(!strcmp("*JCLBegin", tuple.key)) {
636 ppd->JCLBegin = tuple.value;
637 tuple.value = NULL;
640 else if(!strcmp("*JCLToPSInterpreter", tuple.key)) {
641 ppd->JCLToPSInterpreter = tuple.value;
642 tuple.value = NULL;
645 else if(!strcmp("*JCLEnd", tuple.key)) {
646 ppd->JCLEnd = tuple.value;
647 tuple.value = NULL;
650 else if(!strcmp("*PageSize", tuple.key)) {
651 PAGESIZE *page;
652 page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
654 if(!page->Name) {
655 int i;
657 page->Name = tuple.option;
658 tuple.option = NULL;
660 for(i = 0; PageTrans[i].PSName; i++) {
661 if(!strcmp(PageTrans[i].PSName, page->Name)) { /* case ? */
662 page->WinPage = PageTrans[i].WinPage;
663 break;
666 if(!page->WinPage) {
667 TRACE("Can't find Windows page type for '%s' - using %u\n",
668 page->Name, UserPageType);
669 page->WinPage = UserPageType++;
672 if(!page->FullName) {
673 if(tuple.opttrans) {
674 page->FullName = tuple.opttrans;
675 tuple.opttrans = NULL;
676 } else
678 page->FullName = HeapAlloc( PSDRV_Heap, 0, strlen(page->Name)+1 );
679 strcpy( page->FullName, page->Name );
682 if(!page->InvocationString) {
683 page->InvocationString = tuple.value;
684 tuple.value = NULL;
688 else if(!strcmp("*DefaultPageSize", tuple.key)) {
689 if(default_pagesize) {
690 WARN("Already set default pagesize\n");
691 } else {
692 default_pagesize = tuple.value;
693 tuple.value = NULL;
697 else if(!strcmp("*ImageableArea", tuple.key)) {
698 PAGESIZE *page;
699 page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
701 if(!page->Name) {
702 page->Name = tuple.option;
703 tuple.option = NULL;
705 if(!page->FullName) {
706 page->FullName = tuple.opttrans;
707 tuple.opttrans = NULL;
710 #define PIA page->ImageableArea
711 if(!PIA) {
712 PIA = HeapAlloc( PSDRV_Heap, 0, sizeof(*PIA) );
713 sscanf(tuple.value, "%f%f%f%f", &PIA->llx, &PIA->lly,
714 &PIA->urx, &PIA->ury);
716 #undef PIA
720 else if(!strcmp("*PaperDimension", tuple.key)) {
721 PAGESIZE *page;
722 page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
724 if(!page->Name) {
725 page->Name = tuple.option;
726 tuple.option = NULL;
728 if(!page->FullName) {
729 page->FullName = tuple.opttrans;
730 tuple.opttrans = NULL;
733 #define PD page->PaperDimension
734 if(!PD) {
735 PD = HeapAlloc( PSDRV_Heap, 0, sizeof(*PD) );
736 sscanf(tuple.value, "%f%f", &PD->x, &PD->y);
738 #undef PD
741 else if(!strcmp("*LandscapeOrientation", tuple.key)) {
742 if(!strcmp(tuple.value, "Plus90"))
743 ppd->LandscapeOrientation = 90;
744 else if(!strcmp(tuple.value, "Minus90"))
745 ppd->LandscapeOrientation = -90;
747 /* anything else, namely 'any', leaves value at 0 */
749 TRACE("LandscapeOrientation = %d\n",
750 ppd->LandscapeOrientation);
753 else if(!strcmp("*UIConstraints", tuple.key)) {
754 char *start;
755 CONSTRAINT *con, **insert = &ppd->Constraints;
757 while(*insert)
758 insert = &((*insert)->next);
760 con = *insert = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY,
761 sizeof(*con) );
763 start = tuple.value;
765 con->Feature1 = PSDRV_PPDGetWord(start, &start);
766 con->Value1 = PSDRV_PPDGetWord(start, &start);
767 con->Feature2 = PSDRV_PPDGetWord(start, &start);
768 con->Value2 = PSDRV_PPDGetWord(start, &start);
771 else if (!strcmp("*InputSlot", tuple.key))
774 if (!tuple.opttrans)
775 tuple.opttrans = tuple.option;
777 TRACE("Using Windows bin type %u for '%s'\n", UserBinType,
778 tuple.option);
780 /* FIXME - should check for failure */
781 PSDRV_AddSlot(ppd, tuple.option, tuple.opttrans, tuple.value,
782 UserBinType++);
784 tuple.option = tuple.opttrans = tuple.value = NULL;
788 * Windows treats "manual feed" as another paper source. Most PPD
789 * files, however, treat it as a separate option which is either on or
790 * off.
792 else if (!strcmp("*ManualFeed", tuple.key) && tuple.option &&
793 !strcmp ("True", tuple.option))
795 /* FIXME - should check for failure */
796 PSDRV_AddSlot(ppd, "Manual Feed", "Manual Feed", tuple.value, DMBIN_MANUAL);
797 tuple.value = NULL;
800 else if(!strcmp("*TTRasterizer", tuple.key)) {
801 if(!strcasecmp("None", tuple.value))
802 ppd->TTRasterizer = RO_None;
803 else if(!strcasecmp("Accept68K", tuple.value))
804 ppd->TTRasterizer = RO_Accept68K;
805 else if(!strcasecmp("Type42", tuple.value))
806 ppd->TTRasterizer = RO_Type42;
807 else if(!strcasecmp("TrueImage", tuple.value))
808 ppd->TTRasterizer = RO_TrueImage;
809 else {
810 FIXME("Unknown option %s for *TTRasterizer\n",
811 tuple.value);
812 ppd->TTRasterizer = RO_None;
814 TRACE("*TTRasterizer = %d\n", ppd->TTRasterizer);
817 else if(!strcmp("*Duplex", tuple.key)) {
818 DUPLEX **duplex;
819 for(duplex = &ppd->Duplexes; *duplex; duplex = &(*duplex)->next)
821 *duplex = HeapAlloc(GetProcessHeap(), 0, sizeof(**duplex));
822 (*duplex)->Name = tuple.option;
823 (*duplex)->FullName = tuple.opttrans;
824 (*duplex)->InvocationString = tuple.value;
825 (*duplex)->next = NULL;
826 if(!strcasecmp("None", tuple.option) || !strcasecmp("False", tuple.option)
827 || !strcasecmp("Simplex", tuple.option))
828 (*duplex)->WinDuplex = DMDUP_SIMPLEX;
829 else if(!strcasecmp("DuplexNoTumble", tuple.option))
830 (*duplex)->WinDuplex = DMDUP_VERTICAL;
831 else if(!strcasecmp("DuplexTumble", tuple.option))
832 (*duplex)->WinDuplex = DMDUP_HORIZONTAL;
833 else if(!strcasecmp("Notcapable", tuple.option))
834 (*duplex)->WinDuplex = 0;
835 else {
836 FIXME("Unknown option %s for *Duplex defaulting to simplex\n", tuple.option);
837 (*duplex)->WinDuplex = DMDUP_SIMPLEX;
839 tuple.option = tuple.opttrans = tuple.value = NULL;
842 else if(!strcmp("*DefaultDuplex", tuple.key)) {
843 if(default_duplex) {
844 WARN("Already set default duplex\n");
845 } else {
846 default_duplex = tuple.value;
847 tuple.value = NULL;
851 if(tuple.key) HeapFree(PSDRV_Heap, 0, tuple.key);
852 if(tuple.option) HeapFree(PSDRV_Heap, 0, tuple.option);
853 if(tuple.value) HeapFree(PSDRV_Heap, 0, tuple.value);
854 if(tuple.opttrans) HeapFree(PSDRV_Heap, 0, tuple.opttrans);
855 if(tuple.valtrans) HeapFree(PSDRV_Heap, 0, tuple.valtrans);
860 ppd->DefaultPageSize = NULL;
861 if(default_pagesize) {
862 PAGESIZE *page;
863 for(page = ppd->PageSizes; page; page = page->next) {
864 if(!strcmp(page->Name, default_pagesize)) {
865 ppd->DefaultPageSize = page;
866 TRACE("DefaultPageSize: %s\n", page->Name);
867 break;
870 HeapFree(PSDRV_Heap, 0, default_pagesize);
872 if(!ppd->DefaultPageSize) {
873 ppd->DefaultPageSize = ppd->PageSizes;
874 TRACE("Setting DefaultPageSize to first in list\n");
877 ppd->DefaultDuplex = NULL;
878 if(default_duplex) {
879 DUPLEX *duplex;
880 for(duplex = ppd->Duplexes; duplex; duplex = duplex->next) {
881 if(!strcmp(duplex->Name, default_duplex)) {
882 ppd->DefaultDuplex = duplex;
883 TRACE("DefaultDuplex: %s\n", duplex->Name);
884 break;
887 HeapFree(PSDRV_Heap, 0, default_duplex);
889 if(!ppd->DefaultDuplex) {
890 ppd->DefaultDuplex = ppd->Duplexes;
891 TRACE("Setting DefaultDuplex to first in list\n");
896 FONTNAME *fn;
897 PAGESIZE *page;
898 CONSTRAINT *con;
899 INPUTSLOT *slot;
900 OPTION *option;
901 OPTIONENTRY *optionEntry;
903 for(fn = ppd->InstalledFonts; fn; fn = fn->next)
904 TRACE("'%s'\n", fn->Name);
906 for(page = ppd->PageSizes; page; page = page->next) {
907 TRACE("'%s' aka '%s' (%d) invoked by '%s'\n", page->Name,
908 page->FullName, page->WinPage, page->InvocationString);
909 if(page->ImageableArea)
910 TRACE("Area = %.2f,%.2f - %.2f, %.2f\n",
911 page->ImageableArea->llx, page->ImageableArea->lly,
912 page->ImageableArea->urx, page->ImageableArea->ury);
913 if(page->PaperDimension)
914 TRACE("Dimension = %.2f x %.2f\n",
915 page->PaperDimension->x, page->PaperDimension->y);
918 for(con = ppd->Constraints; con; con = con->next)
919 TRACE("CONSTRAINTS@ %s %s %s %s\n", con->Feature1,
920 con->Value1, con->Feature2, con->Value2);
922 for(option = ppd->InstalledOptions; option; option = option->next) {
923 TRACE("OPTION: %s %s %s\n", option->OptionName,
924 option->FullName, option->DefaultOption);
925 for(optionEntry = option->Options; optionEntry;
926 optionEntry = optionEntry->next)
927 TRACE("\tOPTIONENTRY: %s %s %s\n", optionEntry->Name,
928 optionEntry->FullName, optionEntry->InvocationString);
931 for(slot = ppd->InputSlots; slot; slot = slot->next)
932 TRACE("INPUTSLOTS '%s' Name '%s' (%d) Invocation '%s'\n",
933 slot->Name, slot->FullName, slot->WinBin,
934 slot->InvocationString);
937 return ppd;