/[public]/psiconv/trunk/lib/psiconv/parse_layout.c
ViewVC logotype

Annotation of /psiconv/trunk/lib/psiconv/parse_layout.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 110 - (hide annotations)
Sun Mar 4 22:10:45 2001 UTC (23 years ago) by frodo
File MIME type: text/plain
File size: 24825 byte(s)
(Frodo) Thomas Decsi's major sheet patch

1 frodo 2 /*
2     parse_layout.c - Part of psiconv, a PSION 5 file formats converter
3 frodo 63 Copyright (c) 1999, 2000 Frodo Looijaard <frodol@dds.nl>
4 frodo 2
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9    
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13     GNU General Public License for more details.
14    
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18     */
19    
20     #include "config.h"
21 frodo 71 #include "compat.h"
22    
23 frodo 2 #include <stdlib.h>
24     #include <math.h>
25    
26     #include "parse_routines.h"
27 frodo 71 #include "error.h"
28 frodo 2
29     int psiconv_parse_color(const psiconv_buffer buf, int lev, psiconv_u32 off,
30     int *length, psiconv_color *result)
31     {
32     int res = 0;
33     int len = 0;
34    
35     psiconv_progress(lev+1,off,"Going to parse color");
36 frodo 64 if (!(*result = malloc(sizeof(**result))))
37     goto ERROR1;
38 frodo 2
39 frodo 64 (*result)->red = psiconv_read_u8(buf,lev+2,off+len,&res);
40     if (res)
41     goto ERROR2;
42     (*result)->green = psiconv_read_u8(buf,lev+2,off+len+1,&res);
43     if (res)
44     goto ERROR2;
45     (*result)->blue = psiconv_read_u8(buf,lev+2,off+len+2,&res);
46     if (res)
47     goto ERROR2;
48 frodo 2 len += 3;
49    
50     psiconv_debug(lev+2,off,"Color: red %02x, green %02x, blue %02x",
51     (*result)->red, (*result)->green, (*result)->blue);
52     if (length)
53     *length = len;
54    
55     psiconv_progress(lev+1,off+len-1,"End of color (total length: %08x)",len);
56 frodo 64 return 0;
57    
58     ERROR2:
59     free(*result);
60     ERROR1:
61     psiconv_warn(lev+1,off,"Reading of Color failed");
62     if (length)
63     *length = 0;
64     if (res == 0)
65     return -PSICONV_E_NOMEM;
66     else
67     return res;
68 frodo 2 }
69    
70    
71    
72     int psiconv_parse_font(const psiconv_buffer buf, int lev, psiconv_u32 off,
73     int *length, psiconv_font *result)
74     {
75     int res = 0;
76     int strlength,i;
77     char *str_copy;
78     int len;
79    
80     psiconv_progress(lev+1,off,"Going to parse font");
81 frodo 64 if (!(*result = malloc(sizeof(**result))))
82     goto ERROR1;
83 frodo 2
84 frodo 64 strlength = psiconv_read_u8(buf,lev+2,off,&res);
85     if (res)
86     goto ERROR2;
87     if (!((*result)->name = malloc(strlength))) {
88     goto ERROR2;
89     }
90     for (i = 0; (i < strlength-1) && !res; i++)
91     (*result)->name[i] = psiconv_read_u8(buf,lev+2,off + 1 + i,&res);
92     if (res)
93     goto ERROR3;
94 frodo 2 (*result)->name[strlength-1] = 0;
95 frodo 64 (*result)->screenfont = psiconv_read_u8(buf,lev+2,off + strlength,&res);
96     if (res)
97     goto ERROR3;
98 frodo 2
99 frodo 64 if (!(str_copy = psiconv_make_printable((*result)->name)))
100     goto ERROR3;
101    
102 frodo 2 psiconv_debug(lev+2,off+1,"Found font `%s', displayed with screen font %02x",
103     str_copy,(*result)->screenfont);
104     free(str_copy);
105     len = strlength + 1;
106     if (length)
107     *length = len;
108    
109     psiconv_progress(lev+1,off + len - 1,"End of font (total length: %08x)",len);
110 frodo 64 return 0;
111    
112     ERROR3:
113     free ((*result)->name);
114     ERROR2:
115     free (*result);
116     ERROR1:
117     psiconv_warn(lev+1,off,"Reading of Font failed");
118     if (length)
119     *length = 0;
120     if (!res)
121     return -PSICONV_E_NOMEM;
122     else
123     return res;
124 frodo 2 }
125    
126     int psiconv_parse_border(const psiconv_buffer buf,int lev,psiconv_u32 off,
127     int *length, psiconv_border *result)
128     {
129     int res = 0;
130     int len = 0;
131     psiconv_u32 temp;
132     int leng;
133    
134     psiconv_progress(lev+1,off,"Going to parse border data");
135 frodo 64 if (!(*result = malloc(sizeof(**result)))) {
136     goto ERROR1;
137     }
138 frodo 2
139     psiconv_progress(lev+2,off+len,"Going to read border kind");
140 frodo 64 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
141     if (res)
142     goto ERROR2;
143 frodo 2 if (temp == 0x00)
144     (*result)->kind = psiconv_border_none;
145     else if (temp == 0x01)
146     (*result)->kind = psiconv_border_solid;
147     else if (temp == 0x02)
148     (*result)->kind = psiconv_border_double;
149     else if (temp == 0x03)
150     (*result)->kind = psiconv_border_dotted;
151     else if (temp == 0x04)
152 frodo 67 (*result)->kind = psiconv_border_dashed;
153 frodo 2 else if (temp == 0x05)
154 frodo 67 (*result)->kind = psiconv_border_dotdashed;
155 frodo 2 else if (temp == 0x06)
156 frodo 67 (*result)->kind = psiconv_border_dotdotdashed;
157 frodo 2 else {
158     psiconv_warn(lev+2,off,"Unknown border kind (defaults to `none')");
159     (*result)->kind = psiconv_border_none;
160     }
161     psiconv_debug(lev+2,off+len,"Kind: %02x",temp);
162     len ++;
163    
164     psiconv_progress(lev+2,off+len,"Going to read border thickness");
165 frodo 64 (*result)->thickness = psiconv_read_size(buf,lev+2,off+len,&leng,&res);
166     if (res)
167     goto ERROR2;
168 frodo 84 #if 0
169     /* This seems no longer necessary to test? */
170 frodo 2 if (((*result)->kind != psiconv_border_solid) &&
171     ((*result)->kind != psiconv_border_double) &&
172     ((*result)->thickness != 0.0) &&
173     (fabs((*result)->thickness - 1/20) >= 1/1000)) {
174     psiconv_warn(lev+2,off,
175     "Border thickness specified for unlikely border type");
176     }
177 frodo 84 #endif
178 frodo 2 psiconv_debug(lev+2,off+len,"Thickness: %f",(*result)->thickness);
179     len += leng;
180    
181     psiconv_progress(lev+2,off+len,"Going to read the border color");
182 frodo 64 if ((psiconv_parse_color(buf,lev+2,off+len,&leng,&(*result)->color)))
183     goto ERROR2;
184 frodo 2 len += leng;
185    
186     psiconv_progress(lev+2,off+len,"Going to read the final unknown byte "
187 frodo 84 "(0x00 or 0x01 expected)");
188 frodo 64 temp = psiconv_read_u8(buf,lev+2,off + len,&res);
189     if (res)
190     goto ERROR3;
191 frodo 84 if ((temp != 0x01) && (temp != 0x00)) {
192 frodo 2 psiconv_warn(lev+2,off,"Unknown last byte in border specification");
193 frodo 84 psiconv_debug(lev+2,off+len, "Last byte: read %02x, expected %02x or %02x",
194     temp,0x00,0x01);
195 frodo 2 }
196     len ++;
197    
198     if (length)
199     *length = len;
200    
201     psiconv_progress(lev+1,off + len - 1,
202     "End of border (total length: %08x)",len);
203    
204 frodo 64 return 0;
205    
206     ERROR3:
207     psiconv_free_color((*result)->color);
208     ERROR2:
209     free (result);
210     ERROR1:
211     psiconv_warn(lev+1,off,"Reading of Border failed");
212     if (length)
213     *length = 0;
214     if (!res)
215     return -PSICONV_E_NOMEM;
216     else
217     return res;
218 frodo 2 }
219    
220     int psiconv_parse_bullet(const psiconv_buffer buf,int lev,psiconv_u32 off,
221     int *length, psiconv_bullet *result)
222     {
223     int res = 0;
224     int len = 0;
225     int leng;
226     int bullet_length;
227    
228 frodo 64 if (!(*result = malloc(sizeof(**result))))
229     goto ERROR1;
230 frodo 2 (*result)->on = psiconv_bool_true;
231    
232     psiconv_progress(lev+1,off,"Going to parse bullet data");
233     psiconv_progress(lev+2,off+len,"Going to read bullet length");
234 frodo 64 bullet_length = psiconv_read_u8(buf,lev+2,off+len,&res);
235     if (res)
236     goto ERROR2;
237 frodo 2 psiconv_debug(lev+2,off+len,"Length: %02x",bullet_length);
238     len ++;
239    
240     psiconv_progress(lev+2,off+len,"Going to read bullet font size");
241 frodo 64 (*result)->font_size = psiconv_read_size(buf,lev+2,off+len, &leng,&res);
242     if (res)
243     goto ERROR2;
244 frodo 2 len +=leng;
245    
246     psiconv_progress(lev+2,off+len,"Going to read bullet character");
247 frodo 64 (*result)->character = psiconv_read_u8(buf,lev+2,off+len,&res);
248     if (res)
249     goto ERROR2;
250 frodo 2 psiconv_debug(lev+2,off+len,"Character: %02x",(*result)->character);
251     len ++;
252    
253     psiconv_progress(lev+2,off+len,"Going to read indent on/off");
254 frodo 64 if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,&(*result)->indent)))
255     goto ERROR2;
256 frodo 2 psiconv_debug(lev+2,off+len,"Indent on: %02x",(*result)->indent);
257     len += leng;
258    
259     psiconv_progress(lev+2,off+len,"Going to read bullet color");
260 frodo 64 if ((res = psiconv_parse_color(buf,lev+2,off+len,&leng,&(*result)->color)))
261     goto ERROR2;
262 frodo 2 len += leng;
263    
264     psiconv_progress(lev+2,off+len,"Going to read bullet font");
265 frodo 64 if ((res = psiconv_parse_font(buf,lev+2,off+len,&leng,&(*result)->font)))
266     goto ERROR3;
267 frodo 2 len += leng;
268    
269     if (len != bullet_length + 1) {
270     psiconv_warn(lev+2,off,"Bullet data structure length mismatch");
271     psiconv_debug(lev+2,off,"Length: specified %02x, found %02x",
272     bullet_length,len-1);
273     }
274    
275     psiconv_progress(lev+1,off + len - 1,
276     "End of bullet data (total length: %08x)",len);
277    
278     if (length)
279     *length = len;
280 frodo 65 return 0;
281 frodo 64
282     ERROR3:
283     psiconv_free_color((*result)->color);
284     ERROR2:
285     free (result);
286     ERROR1:
287     psiconv_warn(lev+1,off,"Reading of Bullet failed");
288     if (length)
289     *length = 0;
290     if (!res)
291     return -PSICONV_E_NOMEM;
292     else
293     return res;
294 frodo 2 }
295    
296     int psiconv_parse_tab(const psiconv_buffer buf, int lev, psiconv_u32 off,
297     int *length, psiconv_tab *result)
298     {
299     int res = 0;
300     int len = 0;
301     int leng;
302     psiconv_u8 temp;
303    
304     psiconv_progress(lev+1,off,"Going to parse tab");
305 frodo 64 if (!(*result = malloc(sizeof(**result))))
306     goto ERROR1;
307 frodo 2
308     psiconv_progress(lev+2,off,"Going to read tab location");
309 frodo 64 (*result)->location = psiconv_read_length(buf,lev+2,off+len,&leng,&res);
310     if (res)
311     goto ERROR2;
312 frodo 2 len += leng;
313    
314     psiconv_progress(lev+2,off+len,"Going to read the tab kind");
315 frodo 64 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
316     if (res)
317     goto ERROR2;
318 frodo 2 if (temp == 1)
319     (*result)->kind = psiconv_tab_left;
320     else if (temp == 2)
321     (*result)->kind = psiconv_tab_centre;
322     else if (temp == 3)
323     (*result)->kind = psiconv_tab_right;
324     else {
325     psiconv_warn(lev+2,off+len,"Unknown tab kind argument");
326     psiconv_debug(lev+2,off+len,"Kind found: %02x (defaulted to left tab)",
327     temp);
328     (*result)->kind = psiconv_tab_left;
329     }
330     psiconv_debug(lev+2,off+len,"Kind: %02x",temp);
331     len ++;
332    
333     if (length)
334     *length = len;
335    
336     psiconv_progress(lev+1,off+len-1,"End of tab (total length: %08x)",len);
337 frodo 64 return 0;
338 frodo 2
339 frodo 64 ERROR2:
340     free (result);
341     ERROR1:
342     psiconv_warn(lev+1,off,"Reading of Tab failed");
343     if (length)
344     *length = 0;
345     if (!res)
346     return -PSICONV_E_NOMEM;
347     else
348     return res;
349 frodo 2 }
350    
351     int psiconv_parse_paragraph_layout_list(const psiconv_buffer buf, int lev,
352     psiconv_u32 off, int *length,
353     psiconv_paragraph_layout result)
354     {
355     int res=0;
356     int len=0;
357     int list_length,leng,nr;
358     psiconv_u8 id;
359     psiconv_u32 temp;
360 frodo 64 psiconv_tab temp_tab;
361     psiconv_color temp_color;
362     psiconv_border temp_border;
363     psiconv_bullet temp_bullet;
364 frodo 2
365     psiconv_progress(lev+1,off,"Going to read paragraph layout list");
366    
367     psiconv_progress(lev+2,off,"Going to read the list length");
368 frodo 64 list_length = psiconv_read_u32(buf,lev+2,off + len,&res);
369     if (res)
370     goto ERROR1;
371 frodo 2 psiconv_debug(lev+2,off,"Length in bytes: %08x",list_length);
372     len += 4;
373    
374     nr = 0;
375     while(len - 4 < list_length) {
376     psiconv_progress(lev+2,off+len,"Going to read element %d",nr);
377     psiconv_progress(lev+3,off+len,"Going to read the element id");
378 frodo 64 id = psiconv_read_u8(buf,lev+2,off+len,&res);
379     if (res)
380     goto ERROR1;
381 frodo 2 psiconv_debug(lev+3,off+len,"Id: %02x",id);
382     len ++;
383     switch(id) {
384     case 0x01:
385     psiconv_progress(lev+3,off+len,"Going to read background color");
386 frodo 64 if ((res = psiconv_parse_color(buf,lev+3,off+len,&leng,&temp_color)))
387     goto ERROR1;
388 frodo 2 psiconv_free_color(result->back_color);
389 frodo 64 result->back_color = temp_color;
390 frodo 2 len += leng;
391     break;
392     case 0x02:
393     psiconv_progress(lev+3,off+len ,"Going to read indent left");
394 frodo 64 result->indent_left = psiconv_read_length(buf,lev+3,off+len,&leng,&res);
395     if (res)
396     goto ERROR1;
397 frodo 2 len += leng;
398     break;
399     case 0x03:
400     psiconv_progress(lev+3,off+len,"Going to read indent right");
401 frodo 64 result->indent_right = psiconv_read_length(buf,lev+2,off+len,&leng,
402     &res);
403     if (res)
404     goto ERROR1;
405 frodo 2 len += leng;
406     break;
407     case 0x04:
408     psiconv_progress(lev+3,off+len,"Going to read indent left first line");
409 frodo 64 result->indent_first = psiconv_read_length(buf,lev+2,off+len, &leng,
410     &res);
411     if (res)
412     goto ERROR1;
413 frodo 2 len += leng;
414     break;
415     case 0x05:
416     psiconv_progress(lev+3,off+len,"Going to read horizontal justify");
417 frodo 64 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
418     if (res)
419     goto ERROR1;
420 frodo 2 if (temp == 0x00)
421     result->justify_hor = psiconv_justify_left;
422     else if (temp == 0x01)
423     result->justify_hor = psiconv_justify_centre;
424     else if (temp == 0x02)
425     result->justify_hor = psiconv_justify_right;
426     else if (temp == 0x03)
427     result->justify_hor = psiconv_justify_full;
428     else {
429     psiconv_warn(lev+3,off+len, "Unknown horizontal justify argument "
430     "in paragraph layout codes list");
431 frodo 64 result->justify_hor = psiconv_justify_left;
432 frodo 2 }
433     psiconv_debug(lev+3,off+len,"Justify: %02x",temp);
434     len ++;
435     break;
436     case 0x06:
437     psiconv_progress(lev+3,off+len,"Going to read vertical justify");
438 frodo 64 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
439     if (res)
440     goto ERROR1;
441 frodo 2 if (temp == 0x00)
442     result->justify_ver = psiconv_justify_top;
443     else if (temp == 0x01)
444     result->justify_ver = psiconv_justify_middle;
445     else if (temp == 0x02)
446     result->justify_ver = psiconv_justify_bottom;
447     else {
448     psiconv_warn(lev+3,off+len, "Unknown vertical justify argument "
449     "in paragraph layout codes list");
450 frodo 64 result->justify_ver = psiconv_justify_bottom;
451 frodo 2 }
452     psiconv_debug(lev+3,off+len,"Justify: %02x",temp);
453     len ++;
454 frodo 110 break;
455 frodo 2 case 0x07:
456 frodo 67 psiconv_progress(lev+3,off+len,"Going to read linespacing distance");
457     result->linespacing = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
458 frodo 64 if (res)
459     goto ERROR1;
460 frodo 2 len += leng;
461     break;
462     case 0x08:
463 frodo 67 psiconv_progress(lev+3,off+len,"Going to read linespacing exact");
464 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
465 frodo 67 &result->linespacing_exact)))
466 frodo 64 goto ERROR1;
467 frodo 2 len += leng;
468     break;
469     case 0x09:
470     psiconv_progress(lev+3,off+len,"Going to read top space");
471 frodo 67 result->space_above = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
472 frodo 64 if (res)
473     goto ERROR1;
474 frodo 2 len += leng;
475     break;
476     case 0x0a:
477     psiconv_progress(lev+3,off+len,"Going to read bottom space");
478 frodo 67 result->space_below = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
479 frodo 64 if (res)
480     goto ERROR1;
481 frodo 2 len += leng;
482     break;
483     case 0x0b:
484     psiconv_progress(lev+3,off+len,"Going to read on one page");
485 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
486 frodo 67 &result->keep_together)))
487 frodo 64 goto ERROR1;
488 frodo 2 len += leng;
489     break;
490     case 0x0c:
491     psiconv_progress(lev+3,off+len,"Going to read together with");
492 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
493 frodo 67 &result->keep_with_next)))
494 frodo 64 goto ERROR1;
495 frodo 2 len += leng;
496     break;
497     case 0x0d:
498     psiconv_progress(lev+3,off+len,"Going to read on next page");
499 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
500     &result->on_next_page)))
501     goto ERROR1;
502 frodo 2 len += leng;
503     break;
504     case 0x0e:
505     psiconv_progress(lev+3,off+len,"Going to read no widow protection");
506 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
507     &result->no_widow_protection)))
508     goto ERROR1;
509 frodo 2 len += leng;
510     break;
511 frodo 104 case 0x0f:
512     psiconv_progress(lev+3,off+len,"Going to read wrap to fit cell limits");
513     if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
514     &result->wrap_to_fit_cell)))
515     goto ERROR1;
516     len += leng;
517     break;
518 frodo 2 case 0x10:
519     psiconv_progress(lev+3,off+len,"Going to read border distance to text");
520     result->border_distance = psiconv_read_length(buf,lev+3,
521 frodo 64 off+len,&leng,&res);
522     if (res)
523     goto ERROR1;
524 frodo 2 len += leng;
525     break;
526     case 0x11:
527     psiconv_progress(lev+3,off+len,"Going to read top border");
528 frodo 64 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
529     goto ERROR1;
530 frodo 2 psiconv_free_border(result->top_border);
531 frodo 64 result->top_border = temp_border;
532 frodo 2 len += leng;
533     break;
534     case 0x12:
535     psiconv_progress(lev+3,off+len,"Going to read bottom border");
536 frodo 64 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
537     goto ERROR1;
538 frodo 2 psiconv_free_border(result->bottom_border);
539 frodo 64 result->bottom_border = temp_border;
540 frodo 2 len += leng;
541     break;
542     case 0x13:
543     psiconv_progress(lev+3,off+len,"Going to read left border");
544 frodo 64 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
545     goto ERROR1;
546 frodo 2 psiconv_free_border(result->left_border);
547 frodo 64 result->left_border = temp_border;
548 frodo 2 len += leng;
549     break;
550     case 0x14:
551     psiconv_progress(lev+3,off+len,"Going to read right border");
552 frodo 64 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
553     goto ERROR1;
554 frodo 2 psiconv_free_border(result->right_border);
555 frodo 64 result->right_border = temp_border;
556 frodo 2 len += leng;
557     break;
558     case 0x15:
559     psiconv_progress(lev+3,off+len,"Going to read bullet");
560 frodo 65 if ((res = psiconv_parse_bullet(buf,lev+3,off+len,&leng,&temp_bullet)))
561 frodo 64 goto ERROR1;
562 frodo 2 psiconv_free_bullet(result->bullet);
563 frodo 64 result->bullet = temp_bullet;
564 frodo 2 len += leng;
565     break;
566     case 0x16:
567     psiconv_progress(lev+3,off+len,"Going to read standard tabs");
568 frodo 64 result->tabs->normal = psiconv_read_length(buf,lev+3,off+len,&leng,
569     &res);
570     if (res)
571     goto ERROR1;
572 frodo 2 len += leng;
573     break;
574     case 0x17:
575     psiconv_progress(lev+3,off+len,"Going to read extra tab");
576 frodo 64 if ((res = psiconv_parse_tab(buf,lev+3,off+len,&leng,&temp_tab)))
577     goto ERROR1;
578     if ((res = psiconv_list_add(result->tabs->extras,temp_tab))) {
579     psiconv_free_tab(temp_tab);
580     goto ERROR1;
581     }
582 frodo 2 len += leng;
583     break;
584     default:
585     psiconv_warn(lev+3,off+len,
586     "Unknown code in paragraph layout codes list");
587     psiconv_debug(lev+3,off+len,"Code: %02x",id);
588     len ++;
589     break;
590     }
591     nr ++;
592     }
593    
594     if (len - 4 != list_length) {
595     psiconv_warn(lev+2,off+len,
596     "Read past end of paragraph layout codes list. I probably lost track"
597     "somewhere!");
598     psiconv_debug(lev+2,off+len,"Read %d characters instead of %d",
599     len-4,list_length);
600 frodo 64 res = PSICONV_E_PARSE;
601     goto ERROR1;
602 frodo 2 }
603    
604     len = list_length + 4;
605    
606     psiconv_progress(lev+1,off+len,
607     "End of paragraph layout list (total length: %08x)",len);
608    
609     if (length)
610     *length = len;
611 frodo 64 return 0;
612    
613     ERROR1:
614     psiconv_warn(lev+1,off,"Reading of paragraph_layout_list failed");
615     if (length)
616     *length = 0;
617     if (!res)
618     return -PSICONV_E_NOMEM;
619     else
620     return res;
621 frodo 2 }
622    
623     int psiconv_parse_character_layout_list(const psiconv_buffer buf, int lev,
624     psiconv_u32 off, int *length,
625     psiconv_character_layout result)
626     {
627     int res=0;
628     int len=0;
629     int list_length,leng,nr;
630     psiconv_u8 id;
631     psiconv_u32 temp;
632 frodo 64 psiconv_color temp_color;
633     psiconv_font temp_font;
634 frodo 2
635     psiconv_progress(lev+1,off,"Going to read character layout codes");
636    
637     psiconv_progress(lev+2,off,"Going to read the list length");
638 frodo 64 list_length = psiconv_read_u32(buf,lev+2,off + len,&res);
639     if (res)
640     goto ERROR1;
641 frodo 2 psiconv_debug(lev+2,off,"Length in bytes: %08x",list_length);
642     len += 4;
643    
644     nr = 0;
645     while(len-4 < list_length) {
646     psiconv_progress(lev+2,off+len,"Going to read element %d",nr);
647     psiconv_progress(lev+3,off+len,"Going to read the element id");
648 frodo 64 id = psiconv_read_u8(buf,lev+2,off+len,&res);
649     if (res)
650     goto ERROR1;
651 frodo 2 psiconv_debug(lev+3,off+len,"Id: %02x",id);
652     len ++;
653     switch(id) {
654 frodo 86 case 0x18:
655     psiconv_progress(lev+3,off+len,"Going to skip an unknown setting");
656     len ++;
657     break;
658 frodo 2 case 0x19:
659     psiconv_progress(lev+3,off+len,"Going to read text color");
660 frodo 64 if ((res = psiconv_parse_color(buf,lev+3,off+len, &leng,&temp_color)))
661     goto ERROR1;
662 frodo 2 psiconv_free_color(result->color);
663 frodo 64 result->color = temp_color;
664 frodo 2 len += leng;
665     break;
666     case 0x1a:
667     psiconv_progress(lev+3,off+len,"Going to read background color (?)");
668 frodo 64 if ((res = psiconv_parse_color(buf,lev+2,off+len, &leng,&temp_color)))
669     goto ERROR1;
670 frodo 2 psiconv_free_color(result->back_color);
671 frodo 64 result->back_color = temp_color;
672 frodo 2 len += leng;
673     break;
674 frodo 86 case 0x1b:
675     psiconv_progress(lev+3,off+len,"Going to skip an unknown setting");
676     len ++;
677     break;
678 frodo 2 case 0x1c:
679     psiconv_progress(lev+3,off+len,"Going to read font size");
680 frodo 64 result->font_size = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
681     if (res)
682     goto ERROR1;
683 frodo 2 len += leng;
684     break;
685     case 0x1d:
686     psiconv_progress(lev+3,off+len,"Going to read italic");
687 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,&result->italic)))
688     goto ERROR1;
689 frodo 2 len += leng;
690     break;
691     case 0x1e:
692     psiconv_progress(lev+3,off+len,"Going to read bold");
693 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,&result->bold)))
694     goto ERROR1;
695 frodo 2 len += leng;
696     break;
697     case 0x1f:
698     psiconv_progress(lev+3,off+len,"Going to read super_sub");
699 frodo 64 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
700     if (res)
701     goto ERROR1;
702 frodo 2 if (temp == 0x00)
703     result->super_sub = psiconv_normalscript;
704     else if (temp == 0x01)
705     result->super_sub = psiconv_superscript;
706     else if (temp == 0x02)
707     result->super_sub = psiconv_subscript;
708     else {
709     psiconv_warn(lev+3,off+len,
710     "Unknown super_sub argument in character layout codes list");
711     }
712     psiconv_debug(lev+3,off+len,"Super_sub: %02x",temp);
713     len ++;
714     break;
715     case 0x20:
716     psiconv_progress(lev+3,off+len,"Going to read underline");
717 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
718     &result->underline)))
719     goto ERROR1;
720 frodo 2 len += leng;
721     break;
722     case 0x21:
723 frodo 67 psiconv_progress(lev+3,off+len,"Going to read strikethrough");
724 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
725 frodo 67 &result->strikethrough)))
726 frodo 64 goto ERROR1;
727 frodo 2 len += leng;
728     break;
729     case 0x22:
730     psiconv_progress(lev+3,off+len,"Going to read font");
731 frodo 64 if ((res = psiconv_parse_font(buf,lev+3,off+len, &leng, &temp_font)))
732     goto ERROR1;
733 frodo 2 psiconv_free_font(result->font);
734 frodo 64 result->font = temp_font;
735 frodo 2 len += leng;
736     break;
737 frodo 86 case 0x23:
738     psiconv_progress(lev+3,off+len,"Going to skip an unknown setting");
739     len ++;
740     break;
741 frodo 27 case 0x24:
742     psiconv_progress(lev+3,off+len,
743     "Going to read unknown code 0x24 (%02x expected)", 0);
744 frodo 64 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
745     if (res)
746     goto ERROR1;
747 frodo 27 if (temp != 0) {
748     psiconv_warn(lev+3,off+len,
749     "Unknown code 0x24 value != 0x0 (0x%02x)", temp);
750     }
751     len ++;
752     break;
753 frodo 2 default:
754     psiconv_warn(lev+3,off+len,"Unknown code in character layout list");
755     psiconv_debug(lev+3,off+len,"Code: %02x",id);
756     len ++;
757     break;
758     }
759     nr ++;
760     }
761    
762     if (len - 4 != list_length) {
763     psiconv_warn(lev+2,off+len,
764     "Read past end of character layout codes list. I probably lost track"
765     "somewhere!");
766     psiconv_debug(lev+2,off+len,"Read %d characters instead of %d",
767     len-4,list_length);
768 frodo 64 res = PSICONV_E_PARSE;
769     goto ERROR1;
770 frodo 2 }
771    
772     len = list_length + 4;
773    
774     psiconv_progress(lev+1,off+len,
775     "End of character layout list (total length: %08x)",len);
776    
777     if (length)
778     *length = len;
779     return res;
780 frodo 64
781     ERROR1:
782     psiconv_warn(lev+1,off,"Reading of character_layout_list failed");
783     if (length)
784     *length = 0;
785     if (!res)
786     return -PSICONV_E_NOMEM;
787     else
788     return res;
789 frodo 2 }

frodo@frodo.looijaard.name
ViewVC Help
Powered by ViewVC 1.1.26