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