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