?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed callback parameters (bogus hWave); added acm conversion for
[wine.git] / dlls / wineps / ppd.c
blobab535eedeed16b5d9812e979cc94ee531ca166e1
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 "heap.h"
13 #include "debugtools.h"
14 #include "psdrv.h"
15 #include "winspool.h"
16
17 DEFAULT_DEBUG_CHANNEL(psdrv);
18
19 typedef struct {
20 char *key;
21 char *option;
22 char *opttrans;
23 char *value;
24 char *valtrans;
25 } PPDTuple;
26
27
28 /* map of page names in ppd file to Windows paper constants */
29
30 static struct {
31 char *PSName;
32 WORD WinPage;
33 } PageTrans[] = {
34 {"10x11", DMPAPER_10X11},
35 {"10x14", DMPAPER_10X14},
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},
68 {"C5", DMPAPER_ENV_C5},
69 {"C6", DMPAPER_ENV_C6},
70 {"Comm10", DMPAPER_ENV_10},
71 {"DL", DMPAPER_ENV_DL},
72 {"DoublePostcard", DMPAPER_DBL_JAPANESE_POSTCARD},
73 {"DoublePostcardRotated", DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED},
74 {"Env9", DMPAPER_ENV_9},
75 {"Env10", DMPAPER_ENV_10},
76 {"Env11", DMPAPER_ENV_11},
77 {"Env12", DMPAPER_ENV_12},
78 {"Env14", DMPAPER_ENV_14},
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 {"EnvInvite", DMPAPER_ENV_INVITE},
90 {"EnvISOB4", DMPAPER_ENV_B4},
91 {"EnvISOB5", DMPAPER_ENV_B5},
92 {"EnvISOB6", DMPAPER_ENV_B6},
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 {"EnvPersonal", DMPAPER_ENV_PERSONAL},
100 {"EnvPRC1", DMPAPER_PENV_1},
101 {"EnvPRC1Rotated", DMPAPER_PENV_1_ROTATED},
102 {"EnvPRC2", DMPAPER_PENV_2},
103 {"EnvPRC2Rotated", DMPAPER_PENV_2_ROTATED},
104 {"EnvPRC3", DMPAPER_PENV_3},
105 {"EnvPRC3Rotated", DMPAPER_PENV_3_ROTATED},
106 {"EnvPRC4", DMPAPER_PENV_4},
107 {"EnvPRC4Rotated", DMPAPER_PENV_4_ROTATED},
108 {"EnvPRC5", DMPAPER_PENV_5},
109 {"EnvPRC5Rotated", DMPAPER_PENV_5_ROTATED},
110 {"EnvPRC6", DMPAPER_PENV_6},
111 {"EnvPRC6Rotated", DMPAPER_PENV_6_ROTATED},
112 {"EnvPRC7", DMPAPER_PENV_7},
113 {"EnvPRC7Rotated", DMPAPER_PENV_7_ROTATED},
114 {"EnvPRC8", DMPAPER_PENV_8},
115 {"EnvPRC8Rotated", DMPAPER_PENV_8_ROTATED},
116 {"EnvPRC9", DMPAPER_PENV_9},
117 {"EnvPRC9Rotated", DMPAPER_PENV_9_ROTATED},
118 {"EnvPRC10", DMPAPER_PENV_10},
119 {"EnvPRC10Rotated", DMPAPER_PENV_10_ROTATED},
120 {"EnvYou4", DMPAPER_JENV_YOU4},
121 {"EnvYou4Rotated", DMPAPER_JENV_YOU4_ROTATED},
122 {"Executive", DMPAPER_EXECUTIVE},
123 {"FanFoldUS", DMPAPER_FANFOLD_US},
124 {"FanFoldGerman", DMPAPER_FANFOLD_STD_GERMAN},
125 {"FanFoldGermanLegal", DMPAPER_FANFOLD_LGL_GERMAN},
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},
140 {"Note", DMPAPER_NOTE},
141 {"Postcard", DMPAPER_JAPANESE_POSTCARD},
142 {"PostcardRotated", DMPAPER_JAPANESE_POSTCARD_ROTATED},
143 {"PRC16K", DMPAPER_P16K},
144 {"PRC16KRotated", DMPAPER_P16K_ROTATED},
145 {"PRC32K", DMPAPER_P32K},
146 {"PRC32KBig", DMPAPER_P32KBIG},
147 {"PRC32KBigRotated", DMPAPER_P32KBIG_ROTATED},
148 {"PRC32KRotated", DMPAPER_P32K_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 /* the same for bin names */
159
160 static struct {
161 char *PSName;
162 WORD WinBin;
163 } BinTrans[] = {
164 /* In alphabetical order by the PSName member */
165 {"Cassette", DMBIN_CASSETTE},
166 {"Envelope", DMBIN_ENVELOPE},
167 {"LargeCapacity", DMBIN_LARGECAPACITY},
168 {"Lower", DMBIN_LOWER},
169 {"Manual", DMBIN_MANUAL},
170 {"ManualEnv", DMBIN_ENVMANUAL},
171 {"ManualFeed", DMBIN_MANUAL},
172 {"Middle", DMBIN_MIDDLE},
173 {"OnlyOne", DMBIN_ONLYONE},
174 {"Upper", DMBIN_UPPER},
175 {NULL, 0}
176 };
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 = NULL, *cp, *trans, *endkey;
362 BOOL gotoption = TRUE;
363
364 memset(tuple, 0, sizeof(*tuple));
365
366 do {
367 if(!fgets(line, sizeof(line), fp))
368 return FALSE;
369 if(line[0] == '*' && line[1] != '%' && strncmp(line, "*End", 4))
370 break;
371 } while(1);
372
373 if(line[strlen(line)-1] != '\n') {
374 ERR("Line too long.\n");
375 return FALSE;
376 }
377
378 for(cp = line; !isspace(*cp) && *cp != ':'; cp++)
379 ;
380
381 endkey = cp;
382 if(*cp == ':') { /* <key>: */
383 gotoption = FALSE;
384 } else {
385 while(isspace(*cp))
386 cp++;
387 if(*cp == ':') { /* <key> : */
388 gotoption = FALSE;
389 } else { /* <key> <option> */
390 opt = cp;
391 }
392 }
393
394 tuple->key = HeapAlloc( PSDRV_Heap, 0, endkey - line + 1 );
395 if(!tuple->key) return FALSE;
396
397 memcpy(tuple->key, line, endkey - line);
398 tuple->key[endkey - line] = '\0';
399
400 if(gotoption) { /* opt points to 1st non-space character of the option */
401 cp = strpbrk(opt, ":/");
402 if(!cp) {
403 ERR("Error in line '%s'?\n", line);
404 return FALSE;
405 }
406 tuple->option = HeapAlloc( PSDRV_Heap, 0, cp - opt + 1 );
407 if(!tuple->option) return FALSE;
408 memcpy(tuple->option, opt, cp - opt);
409 tuple->option[cp - opt] = '\0';
410 if(*cp == '/') {
411 char *buf;
412 trans = cp + 1;
413 cp = strchr(trans, ':');
414 if(!cp) {
415 ERR("Error in line '%s'?\n", line);
416 return FALSE;
417 }
418 buf = HeapAlloc( PSDRV_Heap, 0, cp - trans + 1 );
419 if(!buf) return FALSE;
420 memcpy(buf, trans, cp - trans);
421 buf[cp - trans] = '\0';
422 tuple->opttrans = PSDRV_PPDDecodeHex(buf);
423 HeapFree( PSDRV_Heap, 0, buf );
424 }
425 }
426
427 /* cp should point to a ':', so we increment past it */
428 cp++;
429
430 while(isspace(*cp))
431 cp++;
432
433 switch(*cp) {
434 case '"':
435 if( (!gotoption && strncmp(tuple->key, "*?", 2) ) ||
436 !strncmp(tuple->key, "*JCL", 4))
437 PSDRV_PPDGetQuotedValue(fp, cp, tuple);
438 else
439 PSDRV_PPDGetInvocationValue(fp, cp, tuple);
440 break;
441
442 case '^':
443 PSDRV_PPDGetSymbolValue(cp, tuple);
444 break;
445
446 default:
447 PSDRV_PPDGetStringValue(cp, tuple);
448 }
449 return TRUE;
450 }
451
452 /*********************************************************************
453 *
454 * PSDRV_PPDGetPageSizeInfo
455 *
456 * Searches ppd PageSize list to return entry matching name or creates new
457 * entry which is appended to the list if name is not found.
458 *
459 */
460 PAGESIZE *PSDRV_PPDGetPageSizeInfo(PPD *ppd, char *name)
461 {
462 PAGESIZE *page = ppd->PageSizes, *lastpage;
463
464 if(!page) {
465 page = ppd->PageSizes = HeapAlloc( PSDRV_Heap,
466 HEAP_ZERO_MEMORY, sizeof(*page) );
467 return page;
468 } else {
469 for( ; page; page = page->next) {
470 if(!strcmp(page->Name, name))
471 return page;
472 lastpage = page;
473 }
474
475 lastpage->next = HeapAlloc( PSDRV_Heap,
476 HEAP_ZERO_MEMORY, sizeof(*page) );
477 return lastpage->next;
478 }
479 }
480
481 /**********************************************************************
482 *
483 * PSDRV_PPDGetWord
484 *
485 * Returns ptr alloced from heap to first word in str. Strips leading spaces.
486 * Puts ptr to next word in next
487 */
488 static char *PSDRV_PPDGetWord(char *str, char **next)
489 {
490 char *start, *end, *ret;
491
492 start = str;
493 while(start && *start && isspace(*start))
494 start++;
495 if(!start || !*start) return FALSE;
496
497 end = start;
498 while(*end && !isspace(*end))
499 end++;
500
501 ret = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
502 memcpy(ret, start, end - start );
503 *(ret + (end - start)) = '\0';
504
505 while(*end && isspace(*end))
506 end++;
507 if(*end)
508 *next = end;
509 else
510 *next = NULL;
511
512 return ret;
513 }
514
515 /***********************************************************************
516 *
517 * PSDRV_ParsePPD
518 *
519 *
520 */
521 PPD *PSDRV_ParsePPD(char *fname)
522 {
523 FILE *fp;
524 PPD *ppd;
525 PPDTuple tuple;
526
527 TRACE("%s\n", fname);
528
529 if((fp = fopen(fname, "r")) == NULL) {
530 WARN("Couldn't open ppd file '%s'\n", fname);
531 return NULL;
532 }
533
534 ppd = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(*ppd));
535 if(!ppd) {
536 ERR("Unable to allocate memory for ppd\n");
537 fclose(fp);
538 return NULL;
539 }
540
541
542 while( PSDRV_PPDGetNextTuple(fp, &tuple)) {
543
544 if(!strcmp("*NickName", tuple.key)) {
545 ppd->NickName = tuple.value;
546 tuple.value = NULL;
547 TRACE("NickName = '%s'\n", ppd->NickName);
548 }
549
550 else if(!strcmp("*LanguageLevel", tuple.key)) {
551 sscanf(tuple.value, "%d", &(ppd->LanguageLevel));
552 TRACE("LanguageLevel = %d\n", ppd->LanguageLevel);
553 }
554
555 else if(!strcmp("*ColorDevice", tuple.key)) {
556 if(!strcasecmp(tuple.value, "true"))
557 ppd->ColorDevice = TRUE;
558 TRACE("ColorDevice = %d\n", (int)ppd->ColorDevice);
559 }
560
561 else if((!strcmp("*DefaultResolution", tuple.key)) ||
562 (!strcmp("*DefaultJCLResolution", tuple.key))) {
563 sscanf(tuple.value, "%d", &(ppd->DefaultResolution));
564 TRACE("DefaultResolution = %d\n", ppd->DefaultResolution);
565 }
566
567 else if(!strcmp("*Font", tuple.key)) {
568 FONTNAME *fn;
569
570 for(fn = ppd->InstalledFonts; fn && fn->next; fn = fn->next)
571 ;
572 if(!fn) {
573 ppd->InstalledFonts = HeapAlloc(PSDRV_Heap,
574 HEAP_ZERO_MEMORY, sizeof(*fn));
575 fn = ppd->InstalledFonts;
576 } else {
577 fn->next = HeapAlloc(PSDRV_Heap,
578 HEAP_ZERO_MEMORY, sizeof(*fn));
579 fn = fn->next;
580 }
581 fn->Name = tuple.option;
582 tuple.option = NULL;
583 }
584
585 else if(!strcmp("*DefaultFont", tuple.key)) {
586 ppd->DefaultFont = tuple.value;
587 tuple.value = NULL;
588 }
589
590 else if(!strcmp("*JCLBegin", tuple.key)) {
591 ppd->JCLBegin = tuple.value;
592 tuple.value = NULL;
593 }
594
595 else if(!strcmp("*JCLToPSInterpreter", tuple.key)) {
596 ppd->JCLToPSInterpreter = tuple.value;
597 tuple.value = NULL;
598 }
599
600 else if(!strcmp("*JCLEnd", tuple.key)) {
601 ppd->JCLEnd = tuple.value;
602 tuple.value = NULL;
603 }
604
605 else if(!strcmp("*PageSize", tuple.key)) {
606 PAGESIZE *page;
607 page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
608
609 if(!page->Name) {
610 int i;
611
612 page->Name = tuple.option;
613 tuple.option = NULL;
614
615 for(i = 0; PageTrans[i].PSName; i++) {
616 if(!strcmp(PageTrans[i].PSName, page->Name)) { /* case ? */
617 page->WinPage = PageTrans[i].WinPage;
618 break;
619 }
620 }
621 if(!page->WinPage)
622 FIXME("Can't find Windows page type for '%s'\n",
623 page->Name);
624 }
625 if(!page->FullName) {
626 if(tuple.opttrans) {
627 page->FullName = tuple.opttrans;
628 tuple.opttrans = NULL;
629 } else {
630 page->FullName = HEAP_strdupA( PSDRV_Heap, 0, page->Name );
631 }
632 }
633 if(!page->InvocationString) {
634 page->InvocationString = tuple.value;
635 tuple.value = NULL;
636 }
637 }
638
639 else if(!strcmp("*ImageableArea", tuple.key)) {
640 PAGESIZE *page;
641 page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
642
643 if(!page->Name) {
644 page->Name = tuple.option;
645 tuple.option = NULL;
646 }
647 if(!page->FullName) {
648 page->FullName = tuple.opttrans;
649 tuple.opttrans = NULL;
650 }
651
652 #define PIA page->ImageableArea
653 if(!PIA) {
654 PIA = HeapAlloc( PSDRV_Heap, 0, sizeof(*PIA) );
655 sscanf(tuple.value, "%f%f%f%f", &PIA->llx, &PIA->lly,
656 &PIA->urx, &PIA->ury);
657 }
658 #undef PIA
659 }
660
661
662 else if(!strcmp("*PaperDimension", tuple.key)) {
663 PAGESIZE *page;
664 page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
665
666 if(!page->Name) {
667 page->Name = tuple.option;
668 tuple.option = NULL;
669 }
670 if(!page->FullName) {
671 page->FullName = tuple.opttrans;
672 tuple.opttrans = NULL;
673 }
674
675 #define PD page->PaperDimension
676 if(!PD) {
677 PD = HeapAlloc( PSDRV_Heap, 0, sizeof(*PD) );
678 sscanf(tuple.value, "%f%f", &PD->x, &PD->y);
679 }
680 #undef PD
681 }
682
683 else if(!strcmp("*LandscapeOrientation", tuple.key)) {
684 if(!strcmp(tuple.value, "Plus90"))
685 ppd->LandscapeOrientation = 90;
686 else if(!strcmp(tuple.value, "Minus90"))
687 ppd->LandscapeOrientation = -90;
688
689 /* anything else, namely 'any', leaves value at 0 */
690
691 TRACE("LandscapeOrientation = %d\n",
692 ppd->LandscapeOrientation);
693 }
694
695 else if(!strcmp("*UIConstraints", tuple.key)) {
696 char *start;
697 CONSTRAINT *con, **insert = &ppd->Constraints;
698
699 while(*insert)
700 insert = &((*insert)->next);
701
702 con = *insert = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY,
703 sizeof(*con) );
704
705 start = tuple.value;
706
707 con->Feature1 = PSDRV_PPDGetWord(start, &start);
708 con->Value1 = PSDRV_PPDGetWord(start, &start);
709 con->Feature2 = PSDRV_PPDGetWord(start, &start);
710 con->Value2 = PSDRV_PPDGetWord(start, &start);
711 }
712
713 else if(!strcmp("*InputSlot", tuple.key)) {
714 INPUTSLOT *slot, **insert = &ppd->InputSlots;
715 int i;
716
717 while(*insert)
718 insert = &((*insert)->next);
719
720 slot = *insert = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY,
721 sizeof(*slot) );
722
723 slot->Name = tuple.option;
724 tuple.option = NULL;
725 if(tuple.opttrans) {
726 slot->FullName = tuple.opttrans;
727 tuple.opttrans = NULL;
728 } else {
729 slot->FullName = HEAP_strdupA( PSDRV_Heap, 0, slot->Name );
730 }
731
732 if(tuple.value) {
733 slot->InvocationString = tuple.value;
734 tuple.value = NULL;
735 }
736
737
738 for(i = 0; BinTrans[i].PSName; i++) {
739 if(!strcmp(BinTrans[i].PSName, slot->Name)) { /* case ? */
740 slot->WinBin = BinTrans[i].WinBin;
741 break;
742 }
743 }
744 if(!slot->WinBin)
745 FIXME("Can't find Windows bin type for '%s'\n",
746 slot->Name);
747
748 }
749
750 if(tuple.key) HeapFree(PSDRV_Heap, 0, tuple.key);
751 if(tuple.option) HeapFree(PSDRV_Heap, 0, tuple.option);
752 if(tuple.value) HeapFree(PSDRV_Heap, 0, tuple.value);
753 if(tuple.opttrans) HeapFree(PSDRV_Heap, 0, tuple.opttrans);
754 if(tuple.valtrans) HeapFree(PSDRV_Heap, 0, tuple.valtrans);
755
756 }
757
758
759 {
760 FONTNAME *fn;
761 PAGESIZE *page;
762 CONSTRAINT *con;
763 INPUTSLOT *slot;
764 OPTION *option;
765 OPTIONENTRY *optionEntry;
766
767 for(fn = ppd->InstalledFonts; fn; fn = fn->next)
768 TRACE("'%s'\n", fn->Name);
769
770 for(page = ppd->PageSizes; page; page = page->next) {
771 TRACE("'%s' aka '%s' (%d) invoked by '%s'\n", page->Name,
772 page->FullName, page->WinPage, page->InvocationString);
773 if(page->ImageableArea)
774 TRACE("Area = %.2f,%.2f - %.2f, %.2f\n",
775 page->ImageableArea->llx, page->ImageableArea->lly,
776 page->ImageableArea->urx, page->ImageableArea->ury);
777 if(page->PaperDimension)
778 TRACE("Dimension = %.2f x %.2f\n",
779 page->PaperDimension->x, page->PaperDimension->y);
780 }
781
782 for(con = ppd->Constraints; con; con = con->next)
783 TRACE("CONSTRAINTS@ %s %s %s %s\n", con->Feature1,
784 con->Value1, con->Feature2, con->Value2);
785
786 for(option = ppd->InstalledOptions; option; option = option->next) {
787 TRACE("OPTION: %s %s %s\n", option->OptionName,
788 option->FullName, option->DefaultOption);
789 for(optionEntry = option->Options; optionEntry;
790 optionEntry = optionEntry->next)
791 TRACE("\tOPTIONENTRY: %s %s %s\n", optionEntry->Name,
792 optionEntry->FullName, optionEntry->InvocationString);
793 }
794
795 for(slot = ppd->InputSlots; slot; slot = slot->next)
796 TRACE("INPUTSLOTS '%s' Name '%s' (%d) Invocation '%s'\n",
797 slot->Name, slot->FullName, slot->WinBin,
798 slot->InvocationString);
799 }
800
801 return ppd;
802 }
803
Windows API implementation