1 /* wvWare
2 * Copyright (C) Caolan McNamara, Dom Lachowicz, and others
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
17 * 02111-1307, USA.
18 */
19
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <math.h>
28 #include <ctype.h>
29 #include "wv.h"
30 #include "wvinternal.h"
31 #ifdef HAVE_LIBXML2
32 #include <libxml/parser.h>
33 #include <libxml/parserInternals.h>
34 #define XML_Char xmlChar
35 #else
36 #ifdef HAVE_EXPAT
37 #include <expat.h>
38 #else
39 #include "xmlparse.h"
40 #endif
41 #endif
42
43 extern int (*wvConvertUnicodeToEntity) (U16 char16);
44
45 #define HANDLE_B_PARA_ELE(a,b,c,d) \
46 if ( (((PAP*)(mydata->props))->b == d) && (c == 0) ) \
47 { \
48 text = (char *)wvMalloc(strlen(mydata->sd->elements[a].str[0])+1); \
49 strcpy(text,mydata->sd->elements[a].str[0]); \
50 str = mydata->retstring; \
51 wvExpand(mydata,text,strlen(text)); \
52 wvAppendStr(&str,mydata->retstring); \
53 wvFree(mydata->retstring); \
54 mydata->retstring = str; \
55 wvFree(text); \
56 mydata->currentlen = strlen(mydata->retstring); \
57 c=d; \
58 }
59
60 #define HANDLE_B_CHAR_ELE(a,b,c,d) \
61 if ( (((CHP*)(mydata->props))->b == d) && (c == 0) ) \
62 { \
63 text = (char *)wvMalloc(strlen(mydata->sd->elements[a].str[0])+1); \
64 strcpy(text,mydata->sd->elements[a].str[0]); \
65 str = mydata->retstring; \
66 wvExpand(mydata,text,strlen(text)); \
67 wvAppendStr(&str,mydata->retstring); \
68 wvFree(mydata->retstring); \
69 mydata->retstring = str; \
70 wvFree(text); \
71 mydata->currentlen = strlen(mydata->retstring); \
72 c=d; \
73 }
74
75 #define HANDLE_E_CHAR_ELE(a,b,c,d) \
76 /* \
77 if ( (!((CHP*)(mydata->props))->b) && (c != 0) ) \
78 */ \
79 if (c == d) \
80 { \
81 text = (char *)wvMalloc(strlen(mydata->sd->elements[a].str[1])+1); \
82 strcpy(text,mydata->sd->elements[a].str[1]); \
83 str = mydata->retstring; \
84 wvExpand(mydata,text,strlen(text)); \
85 wvAppendStr(&str,mydata->retstring); \
86 wvFree(mydata->retstring); \
87 mydata->retstring = str; \
88 wvFree(text); \
89 mydata->currentlen = strlen(mydata->retstring); \
90 c=0; \
91 }
92
93 #define HANDLE_E_PARA_ELE(a,b,c,d) \
94 /* \
95 if ( (!((PAP*)(mydata->props))->b) && (c != 0) ) \
96 */ \
97 if (c == d) \
98 { \
99 text = (char *)wvMalloc(strlen(mydata->sd->elements[a].str[1])+1); \
100 strcpy(text,mydata->sd->elements[a].str[1]); \
101 str = mydata->retstring; \
102 wvExpand(mydata,text,strlen(text)); \
103 wvAppendStr(&str,mydata->retstring); \
104 wvFree(mydata->retstring); \
105 mydata->retstring = str; \
106 wvFree(text); \
107 mydata->currentlen = strlen(mydata->retstring); \
108 c=0; \
109 }
110
111 void
wvInitStateData(state_data * data)112 wvInitStateData (state_data * data)
113 {
114 int i;
115 data->fp = NULL;
116 data->path = NULL;
117 data->currentele = NULL;
118 data->current = NULL;
119 data->currentlen = 0;
120 for (i = 0; i < TokenTableSize; i++)
121 {
122 data->elements[i].nostr = 0;
123 data->elements[i].str = NULL;
124 }
125 }
126
127 void
wvListStateData(state_data * data)128 wvListStateData (state_data * data)
129 {
130 int i, j;
131 for (i = 0; i < TokenTableSize; i++)
132 {
133 for (j = 0; j < data->elements[i].nostr; j++)
134 {
135 if (data->elements[i].str[j])
136 wvError (
137 ("listing->element %s\n",
138 data->elements[i].str[j]));
139 }
140 }
141
142 }
143
144 void
wvReleaseStateData(state_data * data)145 wvReleaseStateData (state_data * data)
146 {
147 int i, k;
148 if (data->fp)
149 fclose (data->fp);
150 for (i = 0; i < TokenTableSize; i++)
151 {
152 for (k = 0; k < data->elements[i].nostr; k++)
153 wvFree (data->elements[i].str[k]);
154 wvFree (data->elements[i].str);
155 }
156 }
157
158
159 static void
exstartElement(void * userData,const char * name,const char ** atts)160 exstartElement (void *userData, const char *name, const char **atts)
161 {
162 unsigned int token_type;
163 expand_data *mydata = (expand_data *) userData;
164 char *text, *str;
165 static int bold, italic, strike, outline, smallcaps, caps, vanish,
166 shadow, lowercase, emboss, imprint, dstrike, iss, kul, color, fontstr,
167 proprmark, animation, deleted, added, FldRMark, ilfo, ilvl =
168 -1, ulist, olist, fintable, fttp = 1, table, txt, lastcell;
169 char buffer[64];
170 static LVL lvl;
171 static U32 lastid = 0;
172 static LFO *retlfo;
173 U32 k;
174 int i, j;
175
176 /*
177 PATCH
178 */
179 PAP *pap;
180
181 /* printf("exstart: %s \n",name);*/
182
183 /* tokenIndex = s_mapNameToToken ((const char *) name);
184 token_type = s_Tokens[tokenIndex].m_type;
185 */ token_type = wvMapNameToTokenType ((const char *) name);
186 switch (token_type)
187 {
188 case TT_TITLE:
189 if (mydata->retstring)
190 {
191 printf ("%s", mydata->retstring);
192 wvFree (mydata->retstring);
193 mydata->retstring = NULL;
194 mydata->currentlen = 0;
195 }
196 wvPrintTitle (mydata->ps, mydata->anSttbfAssoc);
197 break;
198 case TT_CHARSET:
199 wvTrace (("the charset is %d\n", mydata->charset));
200 wvAppendStr (&mydata->retstring, mydata->charset);
201 mydata->currentlen = strlen (mydata->retstring);
202 break;
203 case TT_ROWSPAN:
204 wvTrace (("This Para is here cell %d %d\n",
205 mydata->whichrow, mydata->whichcell));
206 if (*mydata->vmerges)
207 {
208 wvTrace (
209 ("%d\n",
210 (*mydata->vmerges)[mydata->whichrow][mydata->
211 whichcell]));
212 sprintf (buffer, "%d",
213 (*mydata->vmerges)[mydata->whichrow][mydata->
214 whichcell]);
215 }
216 else
217 sprintf (buffer, "1");
218 wvAppendStr (&mydata->retstring, buffer);
219 mydata->currentlen = strlen (mydata->retstring);
220 break;
221 case TT_no_rows:
222 sprintf (buffer, "%d", *mydata->norows);
223 wvAppendStr (&mydata->retstring, buffer);
224 mydata->currentlen = strlen (mydata->retstring);
225 break;
226 break;
227 case TT_no_cols:
228 sprintf (buffer, "%d", *(mydata->nocellbounds) - 1);
229 wvAppendStr (&mydata->retstring, buffer);
230 mydata->currentlen = strlen (mydata->retstring);
231 break;
232 case TT_TABLERELWIDTH:
233 {
234 S16 width =
235 ((PAP *) (mydata->props))->ptap.
236 rgdxaCenter[((PAP *) (mydata->props))->ptap.itcMac] -
237 ((PAP *) (mydata->props))->ptap.rgdxaCenter[0];
238 sprintf (buffer, "%.2f", wvRelativeWidth (width, mydata->asep));
239 wvAppendStr (&mydata->retstring, buffer);
240 mydata->currentlen = strlen (mydata->retstring);
241 }
242 break;
243 case TT_CELLBGCOLOR:
244 wvTrace (
245 ("%d %d %d %d\n", mydata->whichrow, mydata->whichcell,
246 ((PAP *) (mydata->props))->ptap.itcMac, *(mydata->norows)));
247 k =
248 wvCellBgColor (mydata->whichrow, mydata->whichcell,
249 ((PAP *) (mydata->props))->ptap.itcMac,
250 *(mydata->norows),
251 &(((PAP *) (mydata->props))->ptap.tlp));
252 wvTrace (("k is %d\n", k));
253 if (k == 0)
254 k = 8;
255 text =
256 (char *)
257 wvMalloc (strlen
258 (mydata->sd->elements[TT_BLACK + ((k - 1) * 3)].
259 str[0]) + 1);
260 strcpy (text, mydata->sd->elements[TT_BLACK + ((k - 1) * 3)].str[0]);
261 str = mydata->retstring;
262 wvExpand (mydata, text, strlen (text));
263 wvAppendStr (&str, mydata->retstring);
264 wvFree (mydata->retstring);
265 mydata->retstring = str;
266 wvFree (text);
267 mydata->currentlen = strlen (mydata->retstring);
268 break;
269 case TT_PARABGCOLOR:
270 k = ((PAP *) (mydata->props))->shd.icoBack;
271 if (k == 0)
272 k = 8;
273 text =
274 (char *)
275 wvMalloc (strlen
276 (mydata->sd->elements[TT_BLACK + ((k - 1) * 3)].
277 str[0]) + 1);
278 strcpy (text, mydata->sd->elements[TT_BLACK + ((k - 1) * 3)].str[0]);
279 str = mydata->retstring;
280 wvExpand (mydata, text, strlen (text));
281 wvAppendStr (&str, mydata->retstring);
282 wvFree (mydata->retstring);
283 mydata->retstring = str;
284 wvFree (text);
285 mydata->currentlen = strlen (mydata->retstring);
286 break;
287 case TT_PARAFGCOLOR:
288 k = ((PAP *) (mydata->props))->shd.icoFore;
289 if (k == 0)
290 k = 1;
291 text =
292 (char *)
293 wvMalloc (strlen
294 (mydata->sd->elements[TT_BLACK + ((k - 1) * 3)].
295 str[0]) + 1);
296 strcpy (text, mydata->sd->elements[TT_BLACK + ((k - 1) * 3)].str[0]);
297 str = mydata->retstring;
298 wvExpand (mydata, text, strlen (text));
299 wvAppendStr (&str, mydata->retstring);
300 wvFree (mydata->retstring);
301 mydata->retstring = str;
302 wvFree (text);
303 mydata->currentlen = strlen (mydata->retstring);
304 break;
305 case TT_CELLRELPAGEWIDTH:
306 {
307 S16 width =
308 (((PAP *) (mydata->props))->ptap.
309 rgdxaCenter[mydata->whichcell + 1] -
310 ((PAP *) (mydata->props))->ptap.rgdxaCenter[mydata->
311 whichcell]);
312 sprintf (buffer, "%.2f", wvRelativeWidth (width, mydata->asep));
313 wvAppendStr (&mydata->retstring, buffer);
314 mydata->currentlen = strlen (mydata->retstring);
315 }
316 break;
317 case TT_CELLRELWIDTH:
318 {
319 float pc;
320 long over;
321 long under;
322
323 over =
324 (((PAP *) (mydata->props))->ptap.
325 rgdxaCenter[mydata->whichcell + 1] -
326 ((PAP *) (mydata->props))->ptap.rgdxaCenter[mydata->
327 whichcell]);
328 over *= 100;
329 under =
330 (((PAP *) (mydata->props))->ptap.
331 rgdxaCenter[((PAP *) (mydata->props))->ptap.itcMac] -
332 ((PAP *) (mydata->props))->ptap.rgdxaCenter[0]);
333
334 pc = (float) over / under;
335
336 sprintf (buffer, "%.2f", pc);
337
338 wvAppendStr (&mydata->retstring, buffer);
339 mydata->currentlen = strlen (mydata->retstring);
340 }
341 break;
342 case TT_COLSPAN:
343 if (((PAP *) (mydata->props))->fInTable)
344 {
345 wvTrace (
346 ("this cell is %d, pos %d ends %d\n",
347 mydata->whichcell,
348 ((PAP *) (mydata->props))->ptap.rgdxaCenter[mydata->
349 whichcell],
350 ((PAP *) (mydata->props))->ptap.rgdxaCenter[mydata->
351 whichcell
352 + 1]));
353 i = 0;
354 while (
355 (i < *mydata->nocellbounds) &&
356 (0 ==
357 cellCompEQ (&((*mydata->cellbounds)[i]),
358 &(((PAP *) (mydata->props))->ptap.
359 rgdxaCenter[mydata->whichcell]))))
360 i++;
361
362 j = i;
363 while (
364 (j < *mydata->nocellbounds) &&
365 (0 ==
366 cellCompEQ (&((*mydata->cellbounds)[j]),
367 &(((PAP *) (mydata->props))->ptap.
368 rgdxaCenter[mydata->whichcell + 1]))))
369 {
370 wvTrace (
371 ("j is %d %d %d\n", j,
372 (*mydata->cellbounds)[j],
373 ((PAP *) (mydata->props))->ptap.
374 rgdxaCenter[mydata->whichcell + 1]));
375 j++;
376 }
377
378 sprintf (buffer, "%d", j - i);
379 wvAppendStr (&mydata->retstring, buffer);
380 mydata->currentlen = strlen (mydata->retstring);
381 }
382 break;
383 case TT_FILENAME:
384 if (mydata->filename) {
385 wvAppendStr (&mydata->retstring, mydata->filename);
386 mydata->currentlen = strlen (mydata->retstring);
387 }
388 break;
389 case TT_VERSION:
390 wvTrace (("the version is %s\n", wv_version));
391 wvAppendStr (&mydata->retstring, wv_version);
392 mydata->currentlen = strlen (mydata->retstring);
393 break;
394 case TT_COLORB:
395 wvTrace (("str is %s\n", mydata->sd->elements[TT_COLOR].str[0]));
396 text =
397 (char *)
398 wvMalloc (strlen
399 (mydata->sd->elements[TT_COLOR].
400 str[((CHP *) (mydata->props))->ico]) + 1);
401 wvTrace (("the just is %d\n", ((CHP *) (mydata->props))->ico));
402 strcpy (text,
403 mydata->sd->elements[TT_COLOR].
404 str[((CHP *) (mydata->props))->ico]);
405 str = mydata->retstring;
406 wvExpand (mydata, text, strlen (text));
407 wvAppendStr (&str, mydata->retstring);
408 wvFree (mydata->retstring);
409 mydata->retstring = str;
410 wvFree (text);
411 mydata->currentlen = strlen (mydata->retstring);
412 break;
413 case TT_PARAMARGIN:
414
415
416 if (fintable)
417 {
418 /*
419 if there are any table overrides check to make sure all are filled in,
420 and if all are set to 0
421 */
422 if (
423 (mydata->sd->elements[TT_TABLEOVERRIDES].str) &&
424 (mydata->sd->elements[TT_TABLEOVERRIDES].str[0]) &&
425 (mydata->sd->elements[TT_TABLEOVERRIDES].str[1]) &&
426 (mydata->sd->elements[TT_TABLEOVERRIDES].str[2]) &&
427 (mydata->sd->elements[TT_TABLEOVERRIDES].str[3]))
428 {
429 if (
430 (atoi
431 (mydata->sd->elements[TT_TABLEOVERRIDES].str[0]) ==
432 0)
433 &&
434 (atoi
435 (mydata->sd->elements[TT_TABLEOVERRIDES].str[1]) ==
436 0)
437 &&
438 (atoi
439 (mydata->sd->elements[TT_TABLEOVERRIDES].str[2]) ==
440 0)
441 &&
442 (atoi
443 (mydata->sd->elements[TT_TABLEOVERRIDES].str[3]) ==
444 0))
445 {
446 wvTrace (
447 ("The table has overrides such that paramargin is to be ignored\n"));
448 break;
449 }
450 }
451 }
452
453 if (
454 ((PAP *) (mydata->props))->dyaBefore ||
455 ((PAP *) (mydata->props))->dyaAfter ||
456 ((PAP *) (mydata->props))->dxaLeft ||
457 ((PAP *) (mydata->props))->dxaRight)
458 {
459 text =
460 (char *)
461 wvMalloc (strlen (mydata->sd->elements[TT_PMARGIN].str[0])
462 + 1);
463 strcpy (text, mydata->sd->elements[TT_PMARGIN].str[0]);
464 str = mydata->retstring;
465 wvExpand (mydata, text, strlen (text));
466 wvAppendStr (&str, mydata->retstring);
467 wvFree (mydata->retstring);
468 mydata->retstring = str;
469 wvFree (text);
470 mydata->currentlen = strlen (mydata->retstring);
471 }
472 break;
473 case TT_PARABORDER:
474 if (
475 ((PAP *) (mydata->props))->brcBetween.brcType ||
476 ((PAP *) (mydata->props))->brcRight.brcType ||
477 ((PAP *) (mydata->props))->brcBottom.brcType ||
478 ((PAP *) (mydata->props))->brcLeft.brcType ||
479 ((PAP *) (mydata->props))->brcTop.brcType)
480 {
481 text =
482 (char *)
483 wvMalloc (strlen (mydata->sd->elements[TT_PBORDER].str[0])
484 + 1);
485 strcpy (text, mydata->sd->elements[TT_PBORDER].str[0]);
486 str = mydata->retstring;
487 wvExpand (mydata, text, strlen (text));
488 wvAppendStr (&str, mydata->retstring);
489 wvFree (mydata->retstring);
490 mydata->retstring = str;
491 wvFree (text);
492 mydata->currentlen = strlen (mydata->retstring);
493 }
494 break;
495 case TT_JUST:
496 wvTrace (("just is %d\n", ((PAP *) (mydata->props))->jc));
497 wvTrace (
498 ("str is %s\n",
499 mydata->sd->elements[TT_JUSTIFICATION].str[0]));
500 text =
501 (char *)
502 wvMalloc (strlen
503 (mydata->sd->elements[TT_JUSTIFICATION].str[
504 ((PAP
505 *)
506 (mydata->
507 props))->jc])
508 + 1);
509 wvTrace (("the just is %d\n", ((PAP *) (mydata->props))->jc));
510 strcpy (text,
511 mydata->sd->elements[TT_JUSTIFICATION].
512 str[((PAP *) (mydata->props))->jc]);
513 str = mydata->retstring;
514 wvExpand (mydata, text, strlen (text));
515 wvAppendStr (&str, mydata->retstring);
516 wvFree (mydata->retstring);
517 mydata->retstring = str;
518 wvFree (text);
519 mydata->currentlen = strlen (mydata->retstring);
520 break;
521 case TT_BORDERTopSTYLE:
522 if (isPAPConform (&mydata->lastpap, (PAP *) (mydata->props)))
523 {
524 text =
525 (char *)
526 wvMalloc (strlen
527 (mydata->sd->elements[TT_BORDER].str[
528 ((PAP
529 *)
530 (mydata->
531 props))->brcBetween.
532 brcType]) +
533 1);
534 strcpy (text,
535 mydata->sd->elements[TT_BORDER].
536 str[((PAP *) (mydata->props))->brcBetween.brcType]);
537 }
538 else
539 {
540 text =
541 (char *)
542 wvMalloc (strlen
543 (mydata->sd->elements[TT_BORDER].str[
544 ((PAP
545 *)
546 (mydata->
547 props))->brcTop.
548 brcType]) +
549 1);
550 strcpy (text,
551 mydata->sd->elements[TT_BORDER].
552 str[((PAP *) (mydata->props))->brcTop.brcType]);
553 }
554 str = mydata->retstring;
555 wvExpand (mydata, text, strlen (text));
556 wvAppendStr (&str, mydata->retstring);
557 wvFree (mydata->retstring);
558 mydata->retstring = str;
559 wvFree (text);
560 mydata->currentlen = strlen (mydata->retstring);
561 break;
562 case TT_BORDERLeftSTYLE:
563 text =
564 (char *)
565 wvMalloc (strlen
566 (mydata->sd->elements[TT_BORDER].
567 str[((PAP *) (mydata->props))->brcLeft.brcType]) + 1);
568 strcpy (text,
569 mydata->sd->elements[TT_BORDER].
570 str[((PAP *) (mydata->props))->brcLeft.brcType]);
571 str = mydata->retstring;
572 wvExpand (mydata, text, strlen (text));
573 wvAppendStr (&str, mydata->retstring);
574 wvFree (mydata->retstring);
575 mydata->retstring = str;
576 wvFree (text);
577 mydata->currentlen = strlen (mydata->retstring);
578 break;
579 case TT_BORDERRightSTYLE:
580 text =
581 (char *)
582 wvMalloc (strlen
583 (mydata->sd->elements[TT_BORDER].
584 str[((PAP *) (mydata->props))->brcRight.brcType]) + 1);
585 strcpy (text,
586 mydata->sd->elements[TT_BORDER].
587 str[((PAP *) (mydata->props))->brcRight.brcType]);
588 str = mydata->retstring;
589 wvExpand (mydata, text, strlen (text));
590 wvAppendStr (&str, mydata->retstring);
591 wvFree (mydata->retstring);
592 mydata->retstring = str;
593 wvFree (text);
594 mydata->currentlen = strlen (mydata->retstring);
595 break;
596 case TT_BORDERBottomSTYLE:
597 if (isPAPConform (mydata->nextpap, (PAP *) (mydata->props)))
598 {
599 text =
600 (char *)
601 wvMalloc (strlen
602 (mydata->sd->elements[TT_BORDER].str[
603 ((PAP
604 *)
605 (mydata->
606 props))->brcBetween.
607 brcType]) +
608 1);
609 strcpy (text,
610 mydata->sd->elements[TT_BORDER].
611 str[((PAP *) (mydata->props))->brcBetween.brcType]);
612 }
613 else
614 {
615 text =
616 (char *)
617 wvMalloc (strlen
618 (mydata->sd->elements[TT_BORDER].str[
619 ((PAP
620 *)
621 (mydata->
622 props))->brcBottom.
623 brcType]) +
624 1);
625 strcpy (text,
626 mydata->sd->elements[TT_BORDER].
627 str[((PAP *) (mydata->props))->brcBottom.brcType]);
628 }
629 str = mydata->retstring;
630 wvExpand (mydata, text, strlen (text));
631 wvAppendStr (&str, mydata->retstring);
632 wvFree (mydata->retstring);
633 mydata->retstring = str;
634 wvFree (text);
635 mydata->currentlen = strlen (mydata->retstring);
636 break;
637 case TT_BORDERTopCOLOR:
638 if (isPAPConform (&mydata->lastpap, (PAP *) (mydata->props)))
639 {
640 if (((PAP *) (mydata->props))->brcBetween.ico == 0)
641 {
642 /* temp fix this in a while */
643 ((PAP *) (mydata->props))->brcBetween.ico++;
644 }
645 text =
646 (char *)
647 wvMalloc (strlen
648 (mydata->sd->elements[TT_BLACK +
649 ((((PAP
650 *) (mydata->
651 props))->brcBetween.
652 ico - 1) * 3)].str[0]) +
653 1);
654 strcpy (text,
655 mydata->sd->elements[TT_BLACK +
656 ((((PAP
657 *) (mydata->props))->
658 brcBetween.ico -
659 1) * 3)].str[0]);
660 }
661 else
662 {
663 if (((PAP *) (mydata->props))->brcTop.ico == 0)
664 {
665 /* temp fix this in a while */
666 ((PAP *) (mydata->props))->brcTop.ico++;
667 }
668 text =
669 (char *)
670 wvMalloc (strlen
671 (mydata->sd->elements[TT_BLACK +
672 ((((PAP
673 *) (mydata->
674 props))->brcTop.
675 ico - 1) * 3)].str[0]) +
676 1);
677 strcpy (text,
678 mydata->sd->elements[TT_BLACK +
679 ((((PAP
680 *) (mydata->props))->brcTop.
681 ico - 1) * 3)].str[0]);
682 }
683
684 str = mydata->retstring;
685 wvExpand (mydata, text, strlen (text));
686 wvAppendStr (&str, mydata->retstring);
687 wvFree (mydata->retstring);
688 mydata->retstring = str;
689 wvFree (text);
690 mydata->currentlen = strlen (mydata->retstring);
691 break;
692 case TT_BORDERLeftCOLOR:
693 if (((PAP *) (mydata->props))->brcLeft.ico == 0)
694 {
695 /* temp fix this in a while */
696 ((PAP *) (mydata->props))->brcLeft.ico++;
697 }
698 text =
699 (char *)
700 wvMalloc (strlen
701 (mydata->sd->elements[TT_BLACK +
702 ((((PAP
703 *) (mydata->props))->
704 brcLeft.ico - 1) * 3)].str[0]) +
705 1);
706 strcpy (text,
707 mydata->sd->elements[TT_BLACK +
708 ((((PAP
709 *) (mydata->props))->brcLeft.ico -
710 1) * 3)].str[0]);
711 str = mydata->retstring;
712 wvExpand (mydata, text, strlen (text));
713 wvAppendStr (&str, mydata->retstring);
714 wvFree (mydata->retstring);
715 mydata->retstring = str;
716 wvFree (text);
717 mydata->currentlen = strlen (mydata->retstring);
718 break;
719 case TT_BORDERRightCOLOR:
720 if (((PAP *) (mydata->props))->brcRight.ico == 0)
721 {
722 /* temp fix this in a while */
723 ((PAP *) (mydata->props))->brcRight.ico++;
724 }
725 text =
726 (char *)
727 wvMalloc (strlen
728 (mydata->sd->elements[TT_BLACK +
729 ((((PAP
730 *) (mydata->props))->
731 brcRight.ico -
732 1) * 3)].str[0]) + 1);
733 strcpy (text,
734 mydata->sd->elements[TT_BLACK +
735 ((((PAP
736 *) (mydata->props))->brcRight.ico -
737 1) * 3)].str[0]);
738 str = mydata->retstring;
739 wvExpand (mydata, text, strlen (text));
740 wvAppendStr (&str, mydata->retstring);
741 wvFree (mydata->retstring);
742 mydata->retstring = str;
743 wvFree (text);
744 mydata->currentlen = strlen (mydata->retstring);
745 break;
746 case TT_BORDERBottomCOLOR:
747 if (isPAPConform (mydata->nextpap, (PAP *) (mydata->props)))
748 {
749 if (((PAP *) (mydata->props))->brcBetween.ico == 0)
750 {
751 /* temp fix this in a while */
752 ((PAP *) (mydata->props))->brcBetween.ico++;
753 }
754 text =
755 (char *)
756 wvMalloc (strlen
757 (mydata->sd->elements[TT_BLACK +
758 ((((PAP
759 *) (mydata->
760 props))->brcBetween.
761 ico - 1) * 3)].str[0]) +
762 1);
763 strcpy (text,
764 mydata->sd->elements[TT_BLACK +
765 ((((PAP
766 *) (mydata->props))->
767 brcBetween.ico -
768 1) * 3)].str[0]);
769 }
770 else
771 {
772 if (((PAP *) (mydata->props))->brcBottom.ico == 0)
773 {
774 /* temp fix this in a while */
775 ((PAP *) (mydata->props))->brcBottom.ico++;
776 }
777 text =
778 (char *)
779 wvMalloc (strlen
780 (mydata->sd->elements[TT_BLACK +
781 ((((PAP
782 *) (mydata->
783 props))->brcBottom.
784 ico - 1) * 3)].str[0]) +
785 1);
786 strcpy (text,
787 mydata->sd->elements[TT_BLACK +
788 ((((PAP
789 *) (mydata->props))->
790 brcBottom.ico - 1) * 3)].str[0]);
791 }
792 str = mydata->retstring;
793 wvExpand (mydata, text, strlen (text));
794 wvAppendStr (&str, mydata->retstring);
795 wvFree (mydata->retstring);
796 mydata->retstring = str;
797 wvFree (text);
798 mydata->currentlen = strlen (mydata->retstring);
799 break;
800 case TT_START:
801 wvTrace (
802 ("a: HANDLING INDEX %d, %d %d\n",
803 (((PAP *) (mydata->props))->ilfo - 1) * 9 +
804 ((PAP *) (mydata->props))->ilvl,
805 ((PAP *) (mydata->props))->ilfo,
806 ((PAP *) (mydata->props))->ilvl));
807 wvTrace (
808 ("b: HANDLING INDEX %d, %d %d no is %d\n",
809 (ilfo - 1) * 9 + ilvl, ilfo, ilvl,
810 (*mydata->liststartnos)[(ilfo - 1) * 9 + ilvl]));
811
812 sprintf (buffer, "%d",
813 (*mydata->liststartnos)[(ilfo - 1) * 9 + ilvl]);
814 wvAppendStr (&mydata->retstring, buffer);
815 mydata->currentlen = strlen (mydata->retstring);
816 break;
817 case TT_nfc:
818 wvTrace (("nfc is %d\n", lvl.lvlf.nfc));
819 wvTrace (("nfc is %d\n", (*mydata->listnfcs)[(ilfo - 1) * 9 + ilvl]));
820 if ((*mydata->listnfcs)[(ilfo - 1) * 9 + ilvl] < 5)
821 {
822 wvTrace (
823 ("str is %s\n",
824 mydata->sd->elements[TT_numbering].
825 str[(*mydata->listnfcs)[(ilfo - 1) * 9 + ilvl]]));
826 text =
827 (char *)
828 wvMalloc (strlen
829 (mydata->sd->elements[TT_numbering].
830 str[(*mydata->listnfcs)[(ilfo - 1) * 9 + ilvl]])
831 + 1);
832 strcpy (text,
833 mydata->sd->elements[TT_numbering].
834 str[(*mydata->listnfcs)[(ilfo - 1) * 9 + ilvl]]);
835 str = mydata->retstring;
836 wvExpand (mydata, text, strlen (text));
837 wvAppendStr (&str, mydata->retstring);
838 wvFree (mydata->retstring);
839 mydata->retstring = str;
840 wvFree (text);
841 mydata->currentlen = strlen (mydata->retstring);
842 }
843 #if 0
844 if (lvl.lvlf.nfc < 5)
845 {
846 wvTrace (
847 ("str is %s\n",
848 mydata->sd->elements[TT_numbering].str[lvl.lvlf.
849 nfc]));
850 text =
851 (char *)
852 wvMalloc (strlen
853 (mydata->sd->elements[TT_numbering].
854 str[lvl.lvlf.nfc]) + 1);
855 strcpy (text,
856 mydata->sd->elements[TT_numbering].str[lvl.lvlf.nfc]);
857 str = mydata->retstring;
858 wvExpand (mydata, text, strlen (text));
859 wvAppendStr (&str, mydata->retstring);
860 wvFree (mydata->retstring);
861 mydata->retstring = str;
862 wvFree (text);
863 mydata->currentlen = strlen (mydata->retstring);
864 }
865 #endif
866 break;
867 case TT_ULISTE:
868 if ((ilfo != 0) && (ilfo != ((PAP *) (mydata->props))->ilfo))
869 {
870 if (ulist)
871 {
872 while (ilvl >= 0)
873 {
874 wvTrace (
875 ("str is %s\n",
876 mydata->sd->elements[TT_ULIST].str[1]));
877 text =
878 (char *)
879 wvMalloc (strlen
880 (mydata->sd->elements[TT_ULIST].
881 str[1]) + 1);
882 strcpy (text,
883 mydata->sd->elements[TT_ULIST].str[1]);
884 str = mydata->retstring;
885 wvExpand (mydata, text, strlen (text));
886 wvAppendStr (&str, mydata->retstring);
887 wvFree (mydata->retstring);
888 mydata->retstring = str;
889 wvFree (text);
890 mydata->currentlen = strlen (mydata->retstring);
891 ilvl--;
892 }
893 ilfo = 0;
894 ilvl = -1;
895 wvReleaseLVL (&lvl);
896 wvInitLVL (&lvl);
897 ulist = 0;
898 }
899 }
900 break;
901 case TT_ULISTB:
902 wvTrace (("ilfo is %d\n", ((PAP *) (mydata->props))->ilfo));
903 if (wvIsListEntry
904 ((PAP *) (mydata->props), wvQuerySupported (mydata->fib, NULL)))
905 {
906 wvReleaseLVL (&lvl);
907 wvInitLVL (&lvl);
908 wvTrace (
909 ("getting ulist list entry %d %d\n",
910 ((PAP *) (mydata->props))->ilfo,
911 ((PAP *) (mydata->props))->ilvl));
912 if (wvGetListEntryInfo
913 (wvQuerySupported (mydata->fib, NULL), mydata->finallvl,
914 mydata->liststartnos, mydata->listnfcs, &lvl, &retlfo,
915 (PAP *) (mydata->props), mydata->lfo, mydata->lfolvl,
916 mydata->lvl, mydata->nolfo, mydata->lst, mydata->noofLST))
917 {
918 wvError (
919 ("aborted list entry, more work needed obviously\n"));
920 return;
921 }
922 else
923 {
924 U32 i;
925 wvTrace (
926 ("start number is %d, type is %d\n",
927 lvl.lvlf.iStartAt, lvl.lvlf.nfc));
928 if ((*mydata->liststartnos)
929 [(((PAP *) (mydata->props))->ilfo - 1) * 9 +
930 ((PAP *) (mydata->props))->ilvl] == 0xffffffffL)
931 {
932
933 (*mydata->liststartnos)[
934 (((PAP
935 *) (mydata->
936 props))->ilfo -
937 1) * 9 +
938 ((PAP
939 *) (mydata->
940 props))->ilvl] =
941 lvl.lvlf.iStartAt;
942 (*mydata->
943 listnfcs)[(((PAP *) (mydata->props))->ilfo -
944 1) * 9 +
945 ((PAP *) (mydata->props))->ilvl] =
946 lvl.lvlf.nfc;
947 wvTrace (
948 ("start number set to %d\n",
949 (*mydata->
950 liststartnos)[(
951 ((PAP
952 *) (mydata->props))->
953 ilfo - 1) * 9 +
954 ((PAP *) (mydata->props))->ilvl]));
955 wvCopyLVL (&
956 ((*mydata->
957 finallvl)[(((PAP *) (mydata->props))->
958 ilfo - 1) * 9 +
959 ((PAP *) (mydata->props))->
960 ilvl]), &lvl);
961 }
962 for (i = 0; i < *(mydata->nolfo) * 9; i++)
963 {
964 if ((i % 9 > ((PAP *) (mydata->props))->ilvl)
965 && ((*mydata->finallvl)[i].lvlf.fNoRestart ==
966 0))
967 (*mydata->liststartnos)[i] =
968 (*mydata->finallvl)[i].lvlf.iStartAt;
969 }
970 }
971
972 ilfo = ((PAP *) (mydata->props))->ilfo;
973
974 if (((PAP *) (mydata->props))->ilvl > ilvl)
975 while (ilvl < ((PAP *) (mydata->props))->ilvl)
976 {
977 wvTrace (
978 ("str is %s\n",
979 mydata->sd->elements[TT_ULIST].str[0]));
980 text =
981 (char *)
982 wvMalloc (strlen
983 (mydata->sd->elements[TT_ULIST].
984 str[0]) + 1);
985 strcpy (text, mydata->sd->elements[TT_ULIST].str[0]);
986 str = mydata->retstring;
987 wvExpand (mydata, text, strlen (text));
988 wvAppendStr (&str, mydata->retstring);
989 wvFree (mydata->retstring);
990 mydata->retstring = str;
991 wvFree (text);
992 mydata->currentlen = strlen (mydata->retstring);
993 ilvl++;
994 }
995 else if (((PAP *) (mydata->props))->ilvl < ilvl)
996 while (ilvl > ((PAP *) (mydata->props))->ilvl)
997 {
998 wvTrace (
999 ("str is %s\n",
1000 mydata->sd->elements[TT_ULIST].str[1]));
1001 text =
1002 (char *)
1003 wvMalloc (strlen
1004 (mydata->sd->elements[TT_ULIST].
1005 str[1]) + 1);
1006 strcpy (text, mydata->sd->elements[TT_ULIST].str[1]);
1007 str = mydata->retstring;
1008 wvExpand (mydata, text, strlen (text));
1009 wvAppendStr (&str, mydata->retstring);
1010 wvFree (mydata->retstring);
1011 mydata->retstring = str;
1012 wvFree (text);
1013 mydata->currentlen = strlen (mydata->retstring);
1014 ilvl--;
1015 }
1016 ilvl = ((PAP *) (mydata->props))->ilvl;
1017 lastid = retlfo->lsid;
1018 ulist = 1;
1019 wvTrace (
1020 ("start number still set to %d\n",
1021 (*mydata->liststartnos)[(ilfo - 1) * 9 + ilvl]));
1022 }
1023 break;
1024 case TT_OLISTE:
1025 wvTrace (("ilfo 1 is %d\n", ((PAP *) (mydata->props))->ilfo));
1026 wvTrace (("ilfo 2 is %d\n", ilfo));
1027
1028 if (wvIsListEntry
1029 ((PAP *) (mydata->props), wvQuerySupported (mydata->fib, NULL)))
1030 {
1031 wvReleaseLVL (&lvl);
1032 wvInitLVL (&lvl);
1033 wvGetListEntryInfo (wvQuerySupported (mydata->fib, NULL),
1034 mydata->finallvl, mydata->liststartnos,
1035 mydata->listnfcs, &lvl, &retlfo,
1036 (PAP *) (mydata->props), mydata->lfo,
1037 mydata->lfolvl, mydata->lvl,
1038 mydata->nolfo, mydata->lst,
1039 mydata->noofLST);
1040 }
1041
1042 if ((ilfo != 0) && (ilfo != ((PAP *) (mydata->props))->ilfo))
1043 {
1044 if (olist)
1045 {
1046 while (ilvl >= 0)
1047 {
1048 wvTrace (
1049 ("str is %s\n",
1050 mydata->sd->elements[TT_OLIST].str[1]));
1051 text =
1052 (char *)
1053 wvMalloc (strlen
1054 (mydata->sd->elements[TT_OLIST].
1055 str[1]) + 1);
1056 strcpy (text,
1057 mydata->sd->elements[TT_OLIST].str[1]);
1058 str = mydata->retstring;
1059 wvExpand (mydata, text, strlen (text));
1060 wvAppendStr (&str, mydata->retstring);
1061 wvFree (mydata->retstring);
1062 mydata->retstring = str;
1063 wvFree (text);
1064 mydata->currentlen = strlen (mydata->retstring);
1065 ilvl--;
1066 }
1067 ilfo = 0;
1068 ilvl = -1;
1069 olist = 0;
1070 wvReleaseLVL (&lvl);
1071 wvInitLVL (&lvl);
1072 }
1073 }
1074 break;
1075 case TT_TEXTB:
1076 text =
1077 (char *) wvMalloc (strlen (mydata->sd->elements[TT_TEXT].str[0])
1078 + 1);
1079 strcpy (text, mydata->sd->elements[TT_TEXT].str[0]);
1080 str = mydata->retstring;
1081 wvExpand (mydata, text, strlen (text));
1082 wvAppendStr (&str, mydata->retstring);
1083 wvFree (mydata->retstring);
1084 mydata->retstring = str;
1085 wvFree (text);
1086 mydata->currentlen = strlen (mydata->retstring);
1087 txt = 1;
1088 break;
1089 case TT_TEXTE:
1090 if (txt)
1091 {
1092 text =
1093 (char *)
1094 wvMalloc (strlen (mydata->sd->elements[TT_TEXT].str[1]) +
1095 1);
1096 strcpy (text, mydata->sd->elements[TT_TEXT].str[1]);
1097 str = mydata->retstring;
1098 wvExpand (mydata, text, strlen (text));
1099 wvAppendStr (&str, mydata->retstring);
1100 wvFree (mydata->retstring);
1101 mydata->retstring = str;
1102 wvFree (text);
1103 mydata->currentlen = strlen (mydata->retstring);
1104 txt = 0;
1105 }
1106 break;
1107 case TT_OLISTB:
1108 if (wvIsListEntry
1109 ((PAP *) (mydata->props), wvQuerySupported (mydata->fib, NULL)))
1110 {
1111 wvReleaseLVL (&lvl);
1112 wvInitLVL (&lvl);
1113 wvTrace (
1114 ("getting olist list entry %d %d\n",
1115 ((PAP *) (mydata->props))->ilfo,
1116 ((PAP *) (mydata->props))->ilvl));
1117 if (wvGetListEntryInfo
1118 (wvQuerySupported (mydata->fib, NULL), mydata->finallvl,
1119 mydata->liststartnos, mydata->listnfcs, &lvl, &retlfo,
1120 (PAP *) (mydata->props), mydata->lfo, mydata->lfolvl,
1121 mydata->lvl, mydata->nolfo, mydata->lst, mydata->noofLST))
1122 {
1123 wvError (
1124 ("aborted list entry, more work needed obviously\n"));
1125 return;
1126 }
1127 else
1128 {
1129 U8 i2;
1130 U8 tilvl = ((PAP *) (mydata->props))->ilvl;
1131 wvTrace (
1132 ("start number is %d, type is %d\n",
1133 lvl.lvlf.iStartAt, lvl.lvlf.nfc));
1134 wvTrace (
1135 ("lfo is %d, ilvi is %d\n",
1136 ((PAP *) (mydata->props))->ilfo,
1137 ((PAP *) (mydata->props))->ilvl));
1138 wvTrace (
1139 ("Start No is %d\n",
1140 (*mydata->liststartnos)[
1141 (((PAP
1142 *) (mydata->props))->
1143 ilfo - 1) * 9 +
1144 ((PAP
1145 *) (mydata->props))->
1146 ilvl]));
1147
1148 for (i2 = 0; i2 < tilvl + 1; i2++)
1149 {
1150 LVL lvl2;
1151 LFO *retlfo2;
1152 ((PAP *) (mydata->props))->ilvl = i2;
1153 wvTrace (
1154 ("Level %d united (%d %d %d)\n", i2,
1155 ((PAP *) (mydata->props))->ilfo, i2,
1156 (((PAP *) (mydata->props))->ilfo -
1157 1) * 9 + i2));
1158 wvInitLVL (&lvl2);
1159 wvGetListEntryInfo (wvQuerySupported
1160 (mydata->fib, NULL),
1161 mydata->finallvl,
1162 mydata->liststartnos,
1163 mydata->listnfcs, &lvl2,
1164 &retlfo2,
1165 (PAP *) (mydata->props),
1166 mydata->lfo, mydata->lfolvl,
1167 mydata->lvl, mydata->nolfo,
1168 mydata->lst, mydata->noofLST);
1169
1170 /* begin temp special case */
1171 if ((i2 < tilvl)
1172 &&
1173 ((*mydata->liststartnos)
1174 [(((PAP *) (mydata->props))->ilfo - 1) * 9 +
1175 i2] == 0xffffffffL))
1176 {
1177 wvTrace (("Force this Level to be inced\n"));
1178 (*mydata->liststartnos)[
1179 (((PAP
1180 *)
1181 (mydata->props))->
1182 ilfo - 1) * 9 + i2] =
1183 lvl2.lvlf.iStartAt + 1;
1184 }
1185 /* end temp special case */
1186
1187 (*mydata->listnfcs)[
1188 (((PAP *) (mydata->props))->ilfo
1189 - 1) * 9 + i2] = lvl2.lvlf.nfc;
1190 wvTrace (
1191 ("Level %d united,nfc set to %d\n", i2,
1192 lvl2.lvlf.nfc));
1193 wvCopyLVL (&
1194 ((*mydata->
1195 finallvl)[(((PAP *) (mydata->props))->
1196 ilfo - 1) * 9 + i2]),
1197 &lvl2);
1198 wvTrace (("here\n"));
1199 wvReleaseLVL (&lvl2);
1200 }
1201
1202 ((PAP *) (mydata->props))->ilvl =
1203 ((PAP *) (mydata->props))->ilvl;
1204
1205
1206 if ((*mydata->liststartnos)
1207 [(((PAP *) (mydata->props))->ilfo - 1) * 9 +
1208 ((PAP *) (mydata->props))->ilvl] == 0xffffffffL)
1209 {
1210
1211 (*mydata->liststartnos)[
1212 (((PAP
1213 *) (mydata->
1214 props))->ilfo -
1215 1) * 9 +
1216 ((PAP
1217 *) (mydata->
1218 props))->ilvl] =
1219 lvl.lvlf.iStartAt;
1220 wvCopyLVL (&
1221 ((*mydata->
1222 finallvl)[(((PAP *) (mydata->props))->
1223 ilfo - 1) * 9 +
1224 ((PAP *) (mydata->props))->
1225 ilvl]), &lvl);
1226 }
1227
1228 for (i = 0; i < (int) *(mydata->nolfo) * 9; i++)
1229 {
1230 if ((i % 9 > ((PAP *) (mydata->props))->ilvl)
1231 && ((*mydata->finallvl)[i].lvlf.fNoRestart ==
1232 0))
1233 (*mydata->liststartnos)[i] =
1234 (*mydata->finallvl)[i].lvlf.iStartAt;
1235 }
1236
1237 if ((lvl.numbertext == NULL) || (lvl.numbertext[0] <= 1))
1238 {
1239 return;
1240 }
1241
1242 }
1243
1244 ilfo = ((PAP *) (mydata->props))->ilfo;
1245
1246 if ((((PAP *) (mydata->props))->ilvl == ilvl)
1247 && (retlfo->lsid != lastid))
1248 {
1249 if (ulist)
1250 {
1251 wvTrace (
1252 ("str is %s\n",
1253 mydata->sd->elements[TT_ULIST].str[1]));
1254 text =
1255 (char *)
1256 wvMalloc (strlen
1257 (mydata->sd->elements[TT_ULIST].
1258 str[1]) + 1);
1259 strcpy (text,
1260 mydata->sd->elements[TT_ULIST].str[1]);
1261 str = mydata->retstring;
1262 wvExpand (mydata, text, strlen (text));
1263 wvAppendStr (&str, mydata->retstring);
1264 wvFree (mydata->retstring);
1265 mydata->retstring = str;
1266 wvFree (text);
1267 mydata->currentlen = strlen (mydata->retstring);
1268 }
1269 else if (olist)
1270 {
1271 wvTrace (
1272 ("str is %s\n",
1273 mydata->sd->elements[TT_OLIST].str[1]));
1274 text =
1275 (char *)
1276 wvMalloc (strlen
1277 (mydata->sd->elements[TT_OLIST].
1278 str[1]) + 1);
1279 strcpy (text,
1280 mydata->sd->elements[TT_OLIST].str[1]);
1281 str = mydata->retstring;
1282 wvExpand (mydata, text, strlen (text));
1283 wvAppendStr (&str, mydata->retstring);
1284 wvFree (mydata->retstring);
1285 mydata->retstring = str;
1286 wvFree (text);
1287 mydata->currentlen = strlen (mydata->retstring);
1288 }
1289 ilvl--;
1290 }
1291
1292
1293 if (((PAP *) (mydata->props))->ilvl > ilvl)
1294 while (ilvl < ((PAP *) (mydata->props))->ilvl)
1295 {
1296 ilvl++;
1297 wvTrace (
1298 ("2: HANDLING INDEX %d\n",
1299 (((PAP *) (mydata->props))->ilfo -
1300 1) * 9 + ((PAP *) (mydata->props))->ilvl));
1301 wvTrace (
1302 ("3: HANDLING INDEX %d nfc is %d\n",
1303 (ilfo - 1) * 9 + ilvl,
1304 (*mydata->listnfcs)[(ilfo - 1) * 9 +
1305 ilvl]));
1306
1307 wvTrace (
1308 ("str is %s\n",
1309 mydata->sd->elements[TT_OLIST].str[0]));
1310 text =
1311 (char *)
1312 wvMalloc (strlen
1313 (mydata->sd->elements[TT_OLIST].
1314 str[0]) + 1);
1315 strcpy (text, mydata->sd->elements[TT_OLIST].str[0]);
1316 str = mydata->retstring;
1317 wvExpand (mydata, text, strlen (text));
1318 wvAppendStr (&str, mydata->retstring);
1319 wvFree (mydata->retstring);
1320 mydata->retstring = str;
1321 wvFree (text);
1322 mydata->currentlen = strlen (mydata->retstring);
1323 }
1324 else if (((PAP *) (mydata->props))->ilvl < ilvl)
1325 while (ilvl > ((PAP *) (mydata->props))->ilvl)
1326 {
1327 ilvl--;
1328 wvTrace (
1329 ("str is %s\n",
1330 mydata->sd->elements[TT_OLIST].str[1]));
1331 text =
1332 (char *)
1333 wvMalloc (strlen
1334 (mydata->sd->elements[TT_OLIST].
1335 str[1]) + 1);
1336 strcpy (text, mydata->sd->elements[TT_OLIST].str[1]);
1337 str = mydata->retstring;
1338 wvExpand (mydata, text, strlen (text));
1339 wvAppendStr (&str, mydata->retstring);
1340 wvFree (mydata->retstring);
1341 mydata->retstring = str;
1342 wvFree (text);
1343 mydata->currentlen = strlen (mydata->retstring);
1344 }
1345 ilvl = ((PAP *) (mydata->props))->ilvl;
1346 lastid = retlfo->lsid;
1347 olist = 1;
1348 wvTrace (
1349 ("start number still set to %d\n",
1350 (*mydata->liststartnos)[(ilfo - 1) * 9 + ilvl]));
1351 }
1352 break;
1353 case TT_ENTRYB:
1354 fflush (stdout);
1355 wvTrace (("ilvl is %d %d\n", ((PAP *) (mydata->props))->ilvl, ilvl));
1356 if (ilfo)
1357 {
1358 wvTrace (
1359 ("str is %s\n",
1360 mydata->sd->elements[TT_ENTRY].str[0]));
1361 text =
1362 (char *)
1363 wvMalloc (strlen (mydata->sd->elements[TT_ENTRY].str[0]) +
1364 1);
1365 strcpy (text, mydata->sd->elements[TT_ENTRY].str[0]);
1366 str = mydata->retstring;
1367 wvExpand (mydata, text, strlen (text));
1368 wvAppendStr (&str, mydata->retstring);
1369 wvFree (mydata->retstring);
1370 mydata->retstring = str;
1371 wvFree (text);
1372 mydata->currentlen = strlen (mydata->retstring);
1373 }
1374 break;
1375 case TT_ENTRYE:
1376 wvTrace (("ilvl is %d %d\n", ((PAP *) (mydata->props))->ilvl, ilvl));
1377 if (ilfo)
1378 {
1379 wvTrace (
1380 ("str is %s\n",
1381 mydata->sd->elements[TT_ENTRY].str[1]));
1382 text =
1383 (char *)
1384 wvMalloc (strlen (mydata->sd->elements[TT_ENTRY].str[1]) +
1385 1);
1386 strcpy (text, mydata->sd->elements[TT_ENTRY].str[1]);
1387 str = mydata->retstring;
1388 wvExpand (mydata, text, strlen (text));
1389 wvAppendStr (&str, mydata->retstring);
1390 wvFree (mydata->retstring);
1391 mydata->retstring = str;
1392 wvFree (text);
1393 mydata->currentlen = strlen (mydata->retstring);
1394 wvTrace (("no in list is %d\n", 9 * (*(mydata->nolfo))));
1395 (*mydata->liststartnos)[(ilfo - 1) * 9 + ilvl]++;
1396 }
1397 break;
1398 case TT_BOLDB:
1399 HANDLE_B_CHAR_ELE (TT_BOLD, fBold, bold, 1) break;
1400 case TT_DispFldRMarkB:
1401 HANDLE_B_CHAR_ELE (TT_DispFldRMark, fDispFldRMark, FldRMark, 1) break;
1402 case TT_RMarkDelB:
1403 HANDLE_B_CHAR_ELE (TT_RMarkDel, fRMarkDel, deleted, 1) break;
1404 case TT_OUTLINEB:
1405 HANDLE_B_CHAR_ELE (TT_OUTLINE, fOutline, outline, 1) break;
1406 case TT_STRIKEB:
1407 HANDLE_B_CHAR_ELE (TT_STRIKE, fStrike, strike, 1) break;
1408 case TT_ITALICB:
1409 HANDLE_B_CHAR_ELE (TT_ITALIC, fItalic, italic, 1) break;
1410 case TT_RMarkDelE:
1411 HANDLE_E_CHAR_ELE (TT_RMarkDel, fRMarkDel, deleted, 1) break;
1412 case TT_DispFldRMarkE:
1413 HANDLE_E_CHAR_ELE (TT_DispFldRMark, fDispFldRMark, FldRMark, 1) break;
1414 case TT_OUTLINEE:
1415 HANDLE_E_CHAR_ELE (TT_OUTLINE, fOutline, outline, 1) break;
1416 case TT_STRIKEE:
1417 HANDLE_E_CHAR_ELE (TT_STRIKE, fStrike, strike, 1) break;
1418 case TT_ITALICE:
1419 HANDLE_E_CHAR_ELE (TT_ITALIC, fItalic, italic, 1) break;
1420 case TT_BOLDE:
1421 HANDLE_E_CHAR_ELE (TT_BOLD, fBold, bold, 1) break;
1422 case TT_SMALLCAPSB:
1423 HANDLE_B_CHAR_ELE (TT_SMALLCAPS, fSmallCaps, smallcaps, 1) break;
1424 case TT_SMALLCAPSE:
1425 HANDLE_E_CHAR_ELE (TT_SMALLCAPS, fSmallCaps, smallcaps, 1) break;
1426 case TT_CAPSB:
1427 HANDLE_B_CHAR_ELE (TT_CAPS, fCaps, caps, 1) break;
1428 case TT_CAPSE:
1429 HANDLE_E_CHAR_ELE (TT_CAPS, fCaps, caps, 1) break;
1430 case TT_VANISHB:
1431 HANDLE_B_CHAR_ELE (TT_VANISH, fVanish, vanish, 1) break;
1432 case TT_VANISHE:
1433 HANDLE_E_CHAR_ELE (TT_VANISH, fVanish, vanish, 1) break;
1434 case TT_RMarkB:
1435 HANDLE_B_CHAR_ELE (TT_RMark, fRMark, added, 1) break;
1436 case TT_RMarkE:
1437 HANDLE_E_CHAR_ELE (TT_RMark, fRMark, added, 1) break;
1438 case TT_SHADOWB:
1439 HANDLE_B_CHAR_ELE (TT_SHADOW, fShadow, shadow, 1) break;
1440 case TT_SHADOWE:
1441 HANDLE_E_CHAR_ELE (TT_SHADOW, fShadow, shadow, 1) break;
1442 case TT_LOWERCASEB:
1443 HANDLE_B_CHAR_ELE (TT_LOWERCASE, fLowerCase, lowercase, 1) break;
1444 case TT_LOWERCASEE:
1445 HANDLE_E_CHAR_ELE (TT_LOWERCASE, fLowerCase, lowercase, 1) break;
1446 case TT_EMBOSSB:
1447 HANDLE_B_CHAR_ELE (TT_EMBOSS, fEmboss, emboss, 1) break;
1448 case TT_EMBOSSE:
1449 HANDLE_E_CHAR_ELE (TT_EMBOSS, fEmboss, emboss, 1) break;
1450 case TT_IMPRINTB:
1451 HANDLE_B_CHAR_ELE (TT_IMPRINT, fImprint, imprint, 1) break;
1452 case TT_IMPRINTE:
1453 HANDLE_E_CHAR_ELE (TT_IMPRINT, fImprint, imprint, 1) break;
1454 case TT_DSTRIKEB:
1455 HANDLE_B_CHAR_ELE (TT_DSTRIKE, fDStrike, dstrike, 1) break;
1456 case TT_DSTRIKEE:
1457 HANDLE_E_CHAR_ELE (TT_DSTRIKE, fDStrike, dstrike, 1) break;
1458 case TT_SUPERB:
1459 case TT_SUBB:
1460 HANDLE_B_CHAR_ELE (token_type - 1, iss, iss,
1461 (U32) (token_type - TT_SUPERB) / 3 +
1462 1) break;
1463 case TT_SUPERE:
1464 case TT_SUBE:
1465 HANDLE_E_CHAR_ELE (token_type - 2, iss, iss,
1466 (token_type - TT_SUPERE) / 3 +
1467 1) break;
1468
1469 case TT_SINGLEUB:
1470 case TT_WORDUB:
1471 case TT_DOUBLEUB:
1472 case TT_DOTTEDUB:
1473 case TT_HIDDENUB:
1474 case TT_THICKUB:
1475 case TT_DASHUB:
1476 case TT_DOTUB:
1477 case TT_DOTDASHUB:
1478 case TT_DOTDOTDASHUB:
1479 case TT_WAVEUB:
1480 HANDLE_B_CHAR_ELE (token_type - 1, kul, kul,
1481 (U32) (token_type - TT_SINGLEUB) / 3 +
1482 1) break;
1483
1484 case TT_BLACKB:
1485 case TT_BLUEB:
1486 case TT_CYANB:
1487 case TT_GREENB:
1488 case TT_MAGENTAB:
1489 case TT_REDB:
1490 case TT_YELLOWB:
1491 case TT_WHITEB:
1492 case TT_DKBLUEB:
1493 case TT_DKCYANB:
1494 case TT_DKGREENB:
1495 case TT_DKMAGENTAB:
1496 case TT_DKREDB:
1497 case TT_DKYELLOWB:
1498 case TT_DKGRAYB:
1499 case TT_LTGRAYB:
1500 HANDLE_B_CHAR_ELE (token_type - 1, ico, color,
1501 (U32) (token_type - TT_BLACKB) / 3 +
1502 1) break;
1503
1504
1505 case TT_SINGLEUE:
1506 case TT_WORDUE:
1507 case TT_DOUBLEUE:
1508 case TT_DOTTEDUE:
1509 case TT_HIDDENUE:
1510 case TT_THICKUE:
1511 case TT_DASHUE:
1512 case TT_DOTUE:
1513 case TT_DOTDASHUE:
1514 case TT_DOTDOTDASHUE:
1515 case TT_WAVEUE:
1516 HANDLE_E_CHAR_ELE (token_type - 2, kul, kul,
1517 (token_type - TT_SINGLEUE) / 3 +
1518 1) break;
1519
1520 case TT_BLACKE:
1521 case TT_BLUEE:
1522 case TT_CYANE:
1523 case TT_GREENE:
1524 case TT_MAGENTAE:
1525 case TT_REDE:
1526 case TT_YELLOWE:
1527 case TT_WHITEE:
1528 case TT_DKBLUEE:
1529 case TT_DKCYANE:
1530 case TT_DKGREENE:
1531 case TT_DKMAGENTAE:
1532 case TT_DKREDE:
1533 case TT_DKYELLOWE:
1534 case TT_DKGRAYE:
1535 case TT_LTGRAYE:
1536 HANDLE_E_CHAR_ELE (token_type - 2, ico, color,
1537 (token_type - TT_BLACKE) / 3 +
1538 1) break;
1539
1540 case TT_LasVegasB:
1541 case TT_BackgroundBlinkB:
1542 case TT_SparkleTextB:
1543 case TT_MarchingAntsB:
1544 case TT_MarchingRedAntsB:
1545 case TT_ShimmerB:
1546 HANDLE_B_CHAR_ELE (token_type - 1, sfxtText,
1547 animation,
1548 (token_type -
1549 TT_LasVegasB) / 3 + 1) break;
1550
1551 case TT_LasVegasE:
1552 case TT_BackgroundBlinkE:
1553 case TT_SparkleTextE:
1554 case TT_MarchingAntsE:
1555 case TT_MarchingRedAntsE:
1556 case TT_ShimmerE:
1557 HANDLE_E_CHAR_ELE (token_type - 2, sfxtText,
1558 animation,
1559 (token_type -
1560 TT_LasVegasE) / 3 + 1) break;
1561
1562 case TT_FONTSTRB:
1563 wvTrace (("flag is %d\n", ((CHP *) (mydata->props))->ico));
1564 wvTrace (("str is %s\n", mydata->sd->elements[TT_FONTSTR].str[0]));
1565 if ((((CHP *) (mydata->props))->ico) && (fontstr == 0))
1566 {
1567 text =
1568 (char *)
1569 wvMalloc (strlen (mydata->sd->elements[TT_FONTSTR].str[0])
1570 + 1);
1571 strcpy (text, mydata->sd->elements[TT_FONTSTR].str[0]);
1572 str = mydata->retstring;
1573 wvExpand (mydata, text, strlen (text));
1574 wvAppendStr (&str, mydata->retstring);
1575 wvFree (mydata->retstring);
1576 mydata->retstring = str;
1577 wvFree (text);
1578 mydata->currentlen = strlen (mydata->retstring);
1579 fontstr = 1;
1580 }
1581
1582 break;
1583 case TT_FONTSTRE:
1584 wvTrace (("str is %s\n", mydata->sd->elements[TT_FONTSTR].str[0]));
1585 if (fontstr)
1586 {
1587 text =
1588 (char *)
1589 wvMalloc (strlen (mydata->sd->elements[TT_FONTSTR].str[1])
1590 + 1);
1591 strcpy (text, mydata->sd->elements[TT_FONTSTR].str[1]);
1592 str = mydata->retstring;
1593 wvExpand (mydata, text, strlen (text));
1594 wvAppendStr (&str, mydata->retstring);
1595 wvFree (mydata->retstring);
1596 mydata->retstring = str;
1597 wvFree (text);
1598 mydata->currentlen = strlen (mydata->retstring);
1599 fontstr = 0;
1600 }
1601 break;
1602
1603 case TT_ANIMATIONB:
1604 wvTrace (("flag is %d\n", ((CHP *) (mydata->props))->sfxtText));
1605 wvTrace (("str is %s\n", mydata->sd->elements[TT_ANIMATION].str[0]));
1606 if ((((CHP *) (mydata->props))->sfxtText) && (animation == 0))
1607 {
1608 text =
1609 (char *)
1610 wvMalloc (strlen
1611 (mydata->sd->elements[TT_ANIMATION].str[0]) + 1);
1612 strcpy (text, mydata->sd->elements[TT_ANIMATION].str[0]);
1613 str = mydata->retstring;
1614 wvExpand (mydata, text, strlen (text));
1615 wvAppendStr (&str, mydata->retstring);
1616 wvFree (mydata->retstring);
1617 mydata->retstring = str;
1618 wvFree (text);
1619 mydata->currentlen = strlen (mydata->retstring);
1620 animation = 1;
1621 }
1622
1623 break;
1624 case TT_ANIMATIONE:
1625 wvTrace (("str is %s\n", mydata->sd->elements[TT_ANIMATION].str[0]));
1626 if (animation)
1627 {
1628 text =
1629 (char *)
1630 wvMalloc (strlen
1631 (mydata->sd->elements[TT_ANIMATION].str[1]) + 1);
1632 strcpy (text, mydata->sd->elements[TT_ANIMATION].str[1]);
1633 str = mydata->retstring;
1634 wvExpand (mydata, text, strlen (text));
1635 wvAppendStr (&str, mydata->retstring);
1636 wvFree (mydata->retstring);
1637 mydata->retstring = str;
1638 wvFree (text);
1639 mydata->currentlen = strlen (mydata->retstring);
1640 animation = 0;
1641 }
1642 break;
1643
1644 case TT_IBSTANNO:
1645 sprintf (buffer, "%d", ((ATRD *) (mydata->props))->ibst);
1646 wvAppendStr (&mydata->retstring, buffer);
1647 mydata->currentlen = strlen (mydata->retstring);
1648 break;
1649
1650 case TT_xstUsrInitl:
1651 str = wvWideStrToMB (((ATRD *) (mydata->props))->xstUsrInitl + 1);
1652 sprintf (buffer, "%s", str);
1653 wvFree (str);
1654 wvAppendStr (&mydata->retstring, buffer);
1655 mydata->currentlen = strlen (mydata->retstring);
1656 break;
1657 case TT_mmParaBefore:
1658 if (fintable)
1659 {
1660 if ((mydata->sd->elements[TT_TABLEOVERRIDES].str)
1661 && (mydata->sd->elements[TT_TABLEOVERRIDES].str[0]))
1662 {
1663 text =
1664 (char *)
1665 wvMalloc (strlen
1666 (mydata->sd->elements[TT_TABLEOVERRIDES].
1667 str[0]) + 1);
1668 strcpy (text,
1669 mydata->sd->elements[TT_TABLEOVERRIDES].str[0]);
1670 str = mydata->retstring;
1671
1672 wvExpand (mydata, text, strlen (text));
1673 sprintf (buffer, "%.2fmm",
1674 (double) wvTwipsToMM ( (S16) atoi (mydata->retstring)));
1675 wvFree (mydata->retstring);
1676
1677 mydata->retstring = str;
1678 wvFree (text);
1679 wvAppendStr (&mydata->retstring, buffer);
1680 mydata->currentlen = strlen (mydata->retstring);
1681 break;
1682 }
1683 }
1684 sprintf (buffer, "%.2fmm",
1685 (double) wvTwipsToMM ( (S16) ((PAP *) (mydata->props))->dyaBefore));
1686 wvAppendStr (&mydata->retstring, buffer);
1687 mydata->currentlen = strlen (mydata->retstring);
1688 break;
1689 case TT_mmParaAfter:
1690 if (fintable)
1691 {
1692 if ((mydata->sd->elements[TT_TABLEOVERRIDES].str)
1693 && (mydata->sd->elements[TT_TABLEOVERRIDES].str[2]))
1694 {
1695 text =
1696 (char *)
1697 wvMalloc (strlen
1698 (mydata->sd->elements[TT_TABLEOVERRIDES].
1699 str[2]) + 1);
1700 strcpy (text,
1701 mydata->sd->elements[TT_TABLEOVERRIDES].str[2]);
1702 str = mydata->retstring;
1703
1704 wvExpand (mydata, text, strlen (text));
1705 sprintf (buffer, "%.2fmm",
1706 (double) wvTwipsToMM ( (S16) atoi (mydata->retstring)));
1707 wvFree (mydata->retstring);
1708
1709 mydata->retstring = str;
1710 wvFree (text);
1711 wvAppendStr (&mydata->retstring, buffer);
1712 mydata->currentlen = strlen (mydata->retstring);
1713 break;
1714 }
1715 }
1716 sprintf (buffer, "%.2fmm",
1717 (double) wvTwipsToMM ( (S16) ((PAP *) (mydata->props))->dyaAfter));
1718 wvAppendStr (&mydata->retstring, buffer);
1719 mydata->currentlen = strlen (mydata->retstring);
1720 break;
1721 case TT_mmParaLeft:
1722 if (fintable)
1723 {
1724 if ((mydata->sd->elements[TT_TABLEOVERRIDES].str)
1725 && (mydata->sd->elements[TT_TABLEOVERRIDES].str[3]))
1726 {
1727 text =
1728 (char *)
1729 wvMalloc (strlen
1730 (mydata->sd->elements[TT_TABLEOVERRIDES].
1731 str[3]) + 1);
1732 strcpy (text,
1733 mydata->sd->elements[TT_TABLEOVERRIDES].str[3]);
1734 str = mydata->retstring;
1735
1736 wvExpand (mydata, text, strlen (text));
1737 sprintf (buffer, "%.2fmm",
1738 (double) wvTwipsToMM ( (S16) atoi (mydata->retstring)));
1739 wvFree (mydata->retstring);
1740
1741 mydata->retstring = str;
1742 wvFree (text);
1743 wvAppendStr (&mydata->retstring, buffer);
1744 mydata->currentlen = strlen (mydata->retstring);
1745 break;
1746 }
1747 }
1748 sprintf (buffer, "%.2fmm",
1749 (double) wvTwipsToMM ( (S16) ((PAP *) (mydata->props))->dxaLeft));
1750 wvAppendStr (&mydata->retstring, buffer);
1751 mydata->currentlen = strlen (mydata->retstring);
1752 break;
1753 /* >> PATCH ----------------------- */
1754 case TT_stylename:
1755 pap=(PAP *)(mydata->props);
1756 #if 0
1757 wvAppendStr (&mydata->retstring, pap->stylename);
1758 #else
1759 wvAppendStr(&mydata->retstring,
1760 wvConvertStylename(pap->stylename, mydata->charset));
1761 #endif
1762 mydata->currentlen = strlen (mydata->retstring);
1763 break;
1764
1765 /* -------------------------<< */
1766 case TT_mmParaRight:
1767
1768 /* printf("name: %s \n",mydata->stsh->std[0].xstzName);*/
1769 /*pap=(PAP *)(mydata->props);
1770 printf("name: %s \n",(char *)(pap->stylename));*/
1771
1772
1773 if (fintable)
1774 {
1775 if ((mydata->sd->elements[TT_TABLEOVERRIDES].str)
1776 && (mydata->sd->elements[TT_TABLEOVERRIDES].str[1]))
1777 {
1778 text =
1779 (char *)
1780 wvMalloc (strlen
1781 (mydata->sd->elements[TT_TABLEOVERRIDES].
1782 str[1]) + 1);
1783 strcpy (text,
1784 mydata->sd->elements[TT_TABLEOVERRIDES].str[1]);
1785 str = mydata->retstring;
1786
1787 wvExpand (mydata, text, strlen (text));
1788 sprintf (buffer, "%.2fmm",
1789 (double) wvTwipsToMM ( (S16) atoi (mydata->retstring)));
1790 wvFree (mydata->retstring);
1791
1792 mydata->retstring = str;
1793 wvFree (text);
1794 wvAppendStr (&mydata->retstring, buffer);
1795 mydata->currentlen = strlen (mydata->retstring);
1796 break;
1797 }
1798 }
1799 sprintf (buffer, "%.2fmm",
1800 (double) wvTwipsToMM ( (S16) ((PAP *) (mydata->props))->dxaRight));
1801 wvAppendStr (&mydata->retstring, buffer);
1802 mydata->currentlen = strlen (mydata->retstring);
1803 break;
1804 case TT_mmParaLeft1:
1805 if (fintable)
1806 {
1807 if ((mydata->sd->elements[TT_TABLEOVERRIDES].str)
1808 && (mydata->sd->elements[TT_TABLEOVERRIDES].str[4]))
1809 {
1810 text =
1811 (char *)
1812 wvMalloc (strlen
1813 (mydata->sd->elements[TT_TABLEOVERRIDES].
1814 str[4]) + 1);
1815 strcpy (text,
1816 mydata->sd->elements[TT_TABLEOVERRIDES].str[4]);
1817 str = mydata->retstring;
1818
1819 wvExpand (mydata, text, strlen (text));
1820 sprintf (buffer, "%.2fmm",
1821 (double) wvTwipsToMM ( (S16) atoi (mydata->retstring)));
1822 wvFree (mydata->retstring);
1823
1824 mydata->retstring = str;
1825 wvFree (text);
1826 wvAppendStr (&mydata->retstring, buffer);
1827 mydata->currentlen = strlen (mydata->retstring);
1828 break;
1829 }
1830 }
1831 sprintf (buffer, "%.2fmm",
1832 (double) wvTwipsToMM ( (S16) ((PAP *) (mydata->props))->dxaLeft1));
1833 wvAppendStr (&mydata->retstring, buffer);
1834 mydata->currentlen = strlen (mydata->retstring);
1835 break;
1836 case TT_mmPadTop:
1837 if (isPAPConform (&mydata->lastpap, (PAP *) (mydata->props)))
1838 sprintf (buffer, "%.2fmm",
1839 (double)
1840 wvPointsToMM ( (S16) ((PAP *) (mydata->props))->
1841 brcBetween.dptSpace));
1842 else
1843 sprintf (buffer, "%.2fmm",
1844 (double) wvPointsToMM ( (S16) ((PAP *) (mydata->props))->
1845 brcTop.dptSpace));
1846 wvAppendStr (&mydata->retstring, buffer);
1847 mydata->currentlen = strlen (mydata->retstring);
1848 break;
1849 case TT_mmPadRight:
1850
1851
1852 sprintf (buffer, "%.2fmm",
1853 (double) wvPointsToMM ( (S16) ((PAP *) (mydata->props))->brcRight.
1854 dptSpace));
1855 wvAppendStr (&mydata->retstring, buffer);
1856 mydata->currentlen = strlen (mydata->retstring);
1857 break;
1858 case TT_mmPadBottom:
1859 if (isPAPConform (mydata->nextpap, (PAP *) (mydata->props)))
1860 sprintf (buffer, "%.2fmm",
1861 (double)
1862 wvPointsToMM ( (S16) ((PAP *) (mydata->props))->
1863 brcBetween.dptSpace));
1864 else
1865 sprintf (buffer, "%.2fmm",
1866 (double) wvPointsToMM ( (S16) ((PAP *) (mydata->props))->
1867 brcBottom.dptSpace));
1868 wvAppendStr (&mydata->retstring, buffer);
1869 mydata->currentlen = strlen (mydata->retstring);
1870 break;
1871 case TT_mmPadLeft:
1872 sprintf (buffer, "%.2fmm",
1873 (double) wvPointsToMM ( (S16) ((PAP *) (mydata->props))->brcLeft.
1874 dptSpace));
1875 wvAppendStr (&mydata->retstring, buffer);
1876 mydata->currentlen = strlen (mydata->retstring);
1877 break;
1878 case TT_mmLineHeight:
1879 if (wvTwipsToMM (((PAP *) (mydata->props))->lspd.dyaLine))
1880 sprintf (buffer, "%fmm",
1881 fabs (wvTwipsToMM
1882 (((PAP *) (mydata->props))->lspd.dyaLine)));
1883 else
1884 sprintf (buffer, "normal");
1885 wvAppendStr (&mydata->retstring, buffer);
1886 mydata->currentlen = strlen (mydata->retstring);
1887 break;
1888
1889 case TT_pixPicWidth:
1890 {
1891 FSPA *fspa = (FSPA *) (mydata->props);
1892 sprintf (buffer, "%d",
1893 (int) (wvTwipsToHPixels ( (S16) ( fspa->xaRight - fspa->xaLeft ) )
1894 + (float) 0.5));
1895 wvAppendStr (&mydata->retstring, buffer);
1896 mydata->currentlen = strlen (mydata->retstring);
1897 }
1898 break;
1899 case TT_pixPicHeight:
1900 {
1901 FSPA *fspa = (FSPA *) (mydata->props);
1902 sprintf (buffer, "%d",
1903 (int) (wvTwipsToVPixels ( (S16) ( fspa->yaBottom - fspa->yaTop ) )
1904 + (float) 0.5));
1905 wvAppendStr (&mydata->retstring, buffer);
1906 mydata->currentlen = strlen (mydata->retstring);
1907 }
1908 break;
1909 case TT_htmlNextLineGuess:
1910 {
1911 FSPA *fspa = (FSPA *) (mydata->props);
1912 if (fspa->wr == 1)
1913 sprintf (buffer, "<br>");
1914 else
1915 sprintf (buffer, "\n");
1916 wvAppendStr (&mydata->retstring, buffer);
1917 mydata->currentlen = strlen (mydata->retstring);
1918 }
1919 break;
1920 case TT_htmlAlignGuess:
1921 {
1922 FSPA *fspa = (FSPA *) (mydata->props);
1923 switch (fspa->wr)
1924 {
1925 default:
1926 case 1:
1927 case 3:
1928 buffer[0] = '\0';
1929 break;
1930 case 0:
1931 case 5:
1932 sprintf (buffer, "align=\"left\"");
1933 break;
1934 case 2:
1935 case 4:
1936 if (fspa->wrk == 1)
1937 sprintf (buffer, "align=\"right\"");
1938 else
1939 sprintf (buffer, "align=\"left\"");
1940 break;
1941 }
1942 wvAppendStr (&mydata->retstring, buffer);
1943 mydata->currentlen = strlen (mydata->retstring);
1944 }
1945 break;
1946 case TT_ibstRMark:
1947 sprintf (buffer, "%d", ((CHP *) (mydata->props))->ibstRMark);
1948 wvAppendStr (&mydata->retstring, buffer);
1949 mydata->currentlen = strlen (mydata->retstring);
1950 break;
1951 case TT_ibstRMarkDel:
1952 sprintf (buffer, "%d", ((CHP *) (mydata->props))->ibstRMarkDel);
1953 wvAppendStr (&mydata->retstring, buffer);
1954 mydata->currentlen = strlen (mydata->retstring);
1955 break;
1956 case TT_ibstDispFldRMark:
1957 sprintf (buffer, "%d", ((CHP *) (mydata->props))->ibstDispFldRMark);
1958 wvAppendStr (&mydata->retstring, buffer);
1959 mydata->currentlen = strlen (mydata->retstring);
1960 break;
1961 case TT_dttmRMark:
1962 wvAppendStr (&mydata->retstring,
1963 wvDTTMtoUnix (&(((CHP *) (mydata->props))->dttmRMark)));
1964 mydata->currentlen = strlen (mydata->retstring);
1965 break;
1966 case TT_dttmRMarkDel:
1967 wvAppendStr (&mydata->retstring,
1968 wvDTTMtoUnix (&
1969 (((CHP
1970 *) (mydata->props))->dttmRMarkDel)));
1971 mydata->currentlen = strlen (mydata->retstring);
1972 break;
1973 case TT_dttmDispFldRMark:
1974 wvAppendStr (&mydata->retstring,
1975 wvDTTMtoUnix (&
1976 (((CHP
1977 *) (mydata->props))->
1978 dttmDispFldRMark)));
1979 mydata->currentlen = strlen (mydata->retstring);
1980 break;
1981 case TT_xstDispFldRMark:
1982 text = wvWideStrToMB (((CHP *) (mydata->props))->xstDispFldRMark);
1983 wvAppendStr (&mydata->retstring, text);
1984 mydata->currentlen = strlen (mydata->retstring);
1985 break;
1986 case TT_PropRMarkB:
1987 HANDLE_B_CHAR_ELE (TT_PropRMark, fPropRMark, proprmark, 1) break;
1988 case TT_PropRMarkE:
1989 HANDLE_E_CHAR_ELE (TT_PropRMark, fPropRMark, proprmark, 1) break;
1990 case TT_ibstPropRMark:
1991 wvTrace (("flag is %d\n", ((CHP *) (mydata->props))->ibstPropRMark));
1992 sprintf (buffer, "%d", ((CHP *) (mydata->props))->ibstPropRMark);
1993 wvAppendStr (&mydata->retstring, buffer);
1994 mydata->currentlen = strlen (mydata->retstring);
1995 break;
1996 case TT_dttmPropRMark:
1997 wvAppendStr (&mydata->retstring,
1998 wvDTTMtoUnix (&
1999 (((CHP
2000 *) (mydata->props))->dttmPropRMark)));
2001 mydata->currentlen = strlen (mydata->retstring);
2002 break;
2003
2004 case TT_TABLEB:
2005 if ((((PAP *) (mydata->props))->fInTable) && (table == 0))
2006 {
2007 text =
2008 (char *)
2009 wvMalloc (strlen (mydata->sd->elements[TT_TABLE].str[0]) +
2010 1);
2011 strcpy (text, mydata->sd->elements[TT_TABLE].str[0]);
2012 str = mydata->retstring;
2013 wvExpand (mydata, text, strlen (text));
2014 wvAppendStr (&str, mydata->retstring);
2015 wvFree (mydata->retstring);
2016 mydata->retstring = str;
2017 wvFree (text);
2018 mydata->currentlen = strlen (mydata->retstring);
2019 table = 1;
2020 }
2021 break;
2022 case TT_ROWB:
2023 if ((((PAP *) (mydata->props))->fInTable)
2024 && (((PAP *) (mydata->props))->fTtp == 0) && (fttp == 1))
2025 {
2026 text =
2027 (char *)
2028 wvMalloc (strlen (mydata->sd->elements[TT_ROW].str[0]) + 1);
2029 strcpy (text, mydata->sd->elements[TT_ROW].str[0]);
2030 str = mydata->retstring;
2031 wvExpand (mydata, text, strlen (text));
2032 wvAppendStr (&str, mydata->retstring);
2033 wvFree (mydata->retstring);
2034 mydata->retstring = str;
2035 wvFree (text);
2036 mydata->currentlen = strlen (mydata->retstring);
2037 fttp = 0;
2038 }
2039 break;
2040 case TT_CELLB:
2041 if ((fintable != 1) && (((PAP *) (mydata->props))->fInTable == 1))
2042 {
2043 wvTrace (("the current cell is %d\n", mydata->whichcell));
2044 wvTrace (
2045 ("the end boundary is %d\n",
2046 ((PAP *) (mydata->props))->ptap.rgdxaCenter[mydata->
2047 whichcell
2048 + 1]));
2049 wvTrace (
2050 ("the table look for this cell is %d\n",
2051 ((PAP *) (mydata->props))->ptap.tlp.itl));
2052 if (((PAP *) (mydata->props))->ptap.tlp.itl)
2053 {
2054 wvTrace (
2055 ("table look is %d\n",
2056 ((PAP *) (mydata->props))->ptap.tlp.itl));
2057 }
2058 HANDLE_B_PARA_ELE (TT_CELL, fInTable, fintable, 1)}
2059 break;
2060 case TT_CELLE:
2061 if (*(mydata->endcell))
2062 {
2063 if (fintable == 1)
2064 {
2065 mydata->whichcell++;
2066 wvTrace (("inc whichcell to %d\n", mydata->whichcell));
2067 }
2068 HANDLE_E_PARA_ELE (TT_CELL, fInTable, fintable, 1)
2069 * (mydata->endcell) = 0;
2070 }
2071 break;
2072 case TT_LASTCELLB:
2073 if ((fintable != 1) && (((PAP *) (mydata->props))->fInTable == 1)
2074 && (mydata->whichcell ==
2075 ((PAP *) (mydata->props))->ptap.itcMac - 1))
2076 {
2077 wvTrace (("the current cell is %d\n", mydata->whichcell));
2078 wvTrace (
2079 ("the end boundary is %d\n",
2080 ((PAP *) (mydata->props))->ptap.rgdxaCenter[mydata->
2081 whichcell
2082 + 1]));
2083 wvTrace (
2084 ("the table look for this cell is %d\n",
2085 ((PAP *) (mydata->props))->ptap.tlp.itl));
2086 if (((PAP *) (mydata->props))->ptap.tlp.itl)
2087 {
2088 wvTrace (
2089 ("table look is %d\n",
2090 ((PAP *) (mydata->props))->ptap.tlp.itl));
2091 }
2092 HANDLE_B_PARA_ELE (TT_LASTCELL, fInTable, fintable, 1)
2093 lastcell = 1;
2094 }
2095 break;
2096 case TT_LASTCELLE:
2097 if ((*(mydata->endcell)) && (lastcell))
2098 {
2099 if (fintable == 1)
2100 {
2101 mydata->whichcell++;
2102 wvTrace (("inc whichcell to %d\n", mydata->whichcell));
2103 }
2104 HANDLE_E_PARA_ELE (TT_LASTCELL, fInTable, fintable, 1)
2105 * (mydata->endcell) = 0;
2106 lastcell = 0;
2107 }
2108 break;
2109 case TT_ROWE:
2110 if ((((PAP *) (mydata->props))->fTtp == 1) && (fttp == 0))
2111 {
2112 mydata->whichrow++;
2113 text =
2114 (char *)
2115 wvMalloc (strlen (mydata->sd->elements[TT_ROW].str[1]) + 1);
2116 strcpy (text, mydata->sd->elements[TT_ROW].str[1]);
2117 str = mydata->retstring;
2118 wvExpand (mydata, text, strlen (text));
2119 wvAppendStr (&str, mydata->retstring);
2120 wvFree (mydata->retstring);
2121 mydata->retstring = str;
2122 wvFree (text);
2123 mydata->currentlen = strlen (mydata->retstring);
2124 mydata->whichcell = 0;
2125 fttp = 1;
2126 }
2127 break;
2128
2129 case TT_TABLEE:
2130 if ((((PAP *) (mydata->props))->fInTable == 0) && (table == 1))
2131 {
2132 text =
2133 (char *)
2134 wvMalloc (strlen (mydata->sd->elements[TT_TABLE].str[1]) +
2135 1);
2136 strcpy (text, mydata->sd->elements[TT_TABLE].str[1]);
2137 str = mydata->retstring;
2138 wvExpand (mydata, text, strlen (text));
2139 wvAppendStr (&str, mydata->retstring);
2140 wvFree (mydata->retstring);
2141 mydata->retstring = str;
2142 wvFree (text);
2143 mydata->currentlen = strlen (mydata->retstring);
2144 table = 0;
2145 mydata->whichrow = 0;
2146 *(mydata->intable) = 0;
2147 }
2148 break;
2149
2150 }
2151
2152 }
2153
2154 static void
wvstartElement(void * userData,const XML_Char * name,const XML_Char ** atts)2155 wvstartElement (void *userData, const XML_Char *name, const XML_Char **atts)
2156 {
2157 unsigned int nAtts = 0;
2158 const XML_Char **p;
2159 unsigned int token_type, i;
2160 state_data *mydata = (state_data *) userData;
2161 if (atts)
2162 {
2163 p = atts;
2164 while (*p)
2165 ++p;
2166 nAtts = (p - atts) >> 1;
2167 }
2168 /* tokenIndex = s_mapNameToToken ((const char *) name);
2169 token_type = s_Tokens[tokenIndex].m_type;
2170 */ token_type = wvMapNameToTokenType ((const char *) name);
2171 /* printf("start: %s \n",name);*/
2172
2173 wvTrace (("element %s started\n", name));
2174 switch (token_type)
2175 {
2176 case TT_DOCUMENT:
2177 case TT_PARA:
2178 case TT_COMMENT:
2179 case TT_SECTION:
2180 case TT_BOLD:
2181 case TT_ITALIC:
2182 case TT_STRIKE:
2183 case TT_RMarkDel:
2184 case TT_OUTLINE:
2185 case TT_SMALLCAPS:
2186 case TT_CAPS:
2187 case TT_VANISH:
2188 case TT_RMark:
2189 case TT_SHADOW:
2190 case TT_LOWERCASE:
2191 case TT_EMBOSS:
2192 case TT_IMPRINT:
2193 case TT_DSTRIKE:
2194 case TT_SUPER:
2195 case TT_SUB:
2196 case TT_SINGLEU:
2197 case TT_WORDU:
2198 case TT_DOUBLEU:
2199 case TT_DOTTEDU:
2200 case TT_HIDDENU:
2201 case TT_THICKU:
2202 case TT_DASHU:
2203 case TT_DOTU:
2204 case TT_DOTDASHU:
2205 case TT_DOTDOTDASHU:
2206 case TT_WAVEU:
2207 case TT_BLACK:
2208 case TT_BLUE:
2209 case TT_CYAN:
2210 case TT_GREEN:
2211 case TT_MAGENTA:
2212 case TT_RED:
2213 case TT_YELLOW:
2214 case TT_WHITE:
2215 case TT_DKBLUE:
2216 case TT_DKCYAN:
2217 case TT_DKGREEN:
2218 case TT_DKMAGENTA:
2219 case TT_DKRED:
2220 case TT_DKYELLOW:
2221 case TT_DKGRAY:
2222 case TT_LTGRAY:
2223 case TT_FONTSTR:
2224 case TT_ANIMATION:
2225 case TT_PropRMark:
2226 case TT_LasVegas:
2227 case TT_BackgroundBlink:
2228 case TT_SparkleText:
2229 case TT_MarchingAnts:
2230 case TT_MarchingRedAnts:
2231 case TT_Shimmer:
2232 case TT_DispFldRMark:
2233 case TT_OLIST:
2234 case TT_TEXT:
2235 case TT_ULIST:
2236 case TT_ENTRY:
2237 case TT_TABLE:
2238 case TT_ROW:
2239 case TT_CELL:
2240 case TT_LASTCELL:
2241 mydata->elements[token_type].str =
2242 (char **) wvMalloc (sizeof (char *) * 2);
2243 mydata->elements[token_type].nostr = 2;
2244 for (i = 0; i < 2; i++)
2245 mydata->elements[token_type].str[i] = NULL;
2246 mydata->currentele = &(mydata->elements[token_type]);
2247 break;
2248 case TT_PICTURE:
2249 case TT_CHARENTITY:
2250 case TT_PMARGIN:
2251 case TT_PBORDER:
2252
2253
2254 mydata->elements[token_type].str =
2255 (char **) wvMalloc (sizeof (char *) * 1);
2256 mydata->elements[token_type].nostr = 1;
2257 mydata->elements[token_type].str[0] = NULL;
2258 mydata->currentele = &(mydata->elements[token_type]);
2259 break;
2260 case TT_CHAR:
2261 mydata->elements[token_type].str =
2262 (char **) wvMalloc (sizeof (char *) * 2);
2263 mydata->elements[token_type].nostr = 2;
2264 for (i = 0; i < 2; i++)
2265 mydata->elements[token_type].str[i] = NULL;
2266 mydata->currentele = &(mydata->elements[token_type]);
2267 break;
2268 break;
2269 case TT_JUSTIFICATION:
2270 case TT_numbering:
2271 mydata->elements[token_type].str =
2272 (char **) wvMalloc (sizeof (char *) * 5);
2273 mydata->elements[token_type].nostr = 5;
2274 for (i = 0; i < 5; i++)
2275 mydata->elements[token_type].str[i] = NULL;
2276 mydata->currentele = &(mydata->elements[token_type]);
2277 break;
2278 case TT_TABLEOVERRIDES:
2279 mydata->elements[token_type].str =
2280 (char **) wvMalloc (sizeof (char *) * 6);
2281 mydata->elements[token_type].nostr = 6;
2282 for (i = 0; i < 6; i++)
2283 mydata->elements[token_type].str[i] = NULL;
2284 mydata->currentele = &(mydata->elements[token_type]);
2285 break;
2286 case TT_COLOR:
2287 mydata->elements[token_type].str =
2288 (char **) wvMalloc (sizeof (char *) * 16);
2289 mydata->elements[token_type].nostr = 16;
2290 for (i = 0; i < 16; i++)
2291 mydata->elements[token_type].str[i] = NULL;
2292 mydata->currentele = &(mydata->elements[token_type]);
2293 break;
2294 case TT_BORDER:
2295 mydata->elements[token_type].str =
2296 (char **) wvMalloc (sizeof (char *) * 27);
2297 mydata->elements[token_type].nostr = 27;
2298 for (i = 0; i < 27; i++)
2299 mydata->elements[token_type].str[i] = NULL;
2300 mydata->currentele = &(mydata->elements[token_type]);
2301 break;
2302
2303 case TT_STYLE:
2304 wvTrace (("style element, no atts is %d\n", nAtts));
2305
2306 for (i = 0; i < nAtts; i++) {
2307 wvTrace (("%s is %s\n", atts[i * 2], atts[(i * 2) + 1]));
2308 }
2309
2310 break;
2311
2312 case TT_BEGIN:
2313 case TT_LEFT:
2314 case TT_Arabic:
2315 case TT_NONED:
2316 case TT_ParaBefore:
2317 mydata->current = &(mydata->currentele->str[0]);
2318 wvAppendStr (mydata->current, "<begin>");
2319 mydata->currentlen = strlen (*(mydata->current));
2320 break;
2321 case TT_END:
2322 case TT_CENTER:
2323 case TT_UpperRoman:
2324 case TT_SINGLED:
2325 case TT_ParaRight:
2326 mydata->current = &(mydata->currentele->str[1]);
2327 wvAppendStr (mydata->current, "<begin>");
2328 mydata->currentlen = strlen (*(mydata->current));
2329 break;
2330 case TT_RIGHT:
2331 case TT_LowerRoman:
2332 case TT_THICKD:
2333 case TT_ParaAfter:
2334 mydata->current = &(mydata->currentele->str[2]);
2335 wvAppendStr (mydata->current, "<begin>");
2336 mydata->currentlen = strlen (*(mydata->current));
2337 break;
2338 case TT_BLOCK:
2339 case TT_UpperCaseN:
2340 case TT_DOUBLED:
2341 case TT_ParaLeft:
2342 mydata->current = &(mydata->currentele->str[3]);
2343 wvAppendStr (mydata->current, "<begin>");
2344 mydata->currentlen = strlen (*(mydata->current));
2345 break;
2346 case TT_ASIAN:
2347 case TT_LowerCaseN:
2348 case TT_NUMBER4D:
2349 case TT_ParaLeft1:
2350 mydata->current = &(mydata->currentele->str[4]);
2351 wvAppendStr (mydata->current, "<begin>");
2352 mydata->currentlen = strlen (*(mydata->current));
2353 break;
2354 case TT_VertMergedCells:
2355 mydata->current = &(mydata->currentele->str[5]);
2356 wvAppendStr (mydata->current, "<begin>");
2357 mydata->currentlen = strlen (*(mydata->current));
2358 break;
2359 case TT_HAIRLINED:
2360 case TT_DOTD:
2361 case TT_DASHLARGEGAPD:
2362 case TT_DOTDASHD:
2363 case TT_DOTDOTDASHD:
2364 case TT_TRIPLED:
2365 case TT_thin_thicksmallgapD:
2366 case TT_thick_thinsmallgapD:
2367 case TT_thin_thick_thinsmallgapD:
2368 case TT_thin_thickmediumgapD:
2369 case TT_thick_thinmediumgapD:
2370 case TT_thin_thick_thinmediumgapD:
2371 case TT_thin_thicklargegapD:
2372 case TT_thick_thinlargegapD:
2373 case TT_thin_thick_thinlargegapD:
2374 case TT_WAVED:
2375 case TT_DOUBLEWAVED:
2376 case TT_DASHSMALLGAPD:
2377 case TT_DASHDOTSTROKEDD:
2378 case TT_EMBOSS3DD:
2379 case TT_ENGRAVE3DD:
2380 case TT_DEFAULTD:
2381 mydata->current =
2382 &(mydata->currentele->str[5 +
2383 (token_type -
2384 TT_HAIRLINED)]);
2385 wvAppendStr (mydata->current, "<begin>");
2386 mydata->currentlen = strlen (*(mydata->current));
2387 break;
2388 case TT_TITLE:
2389 wvAppendStr (mydata->current, "<title/>");
2390 mydata->currentlen = strlen (*(mydata->current));
2391 break;
2392 case TT_CHARSET:
2393 wvAppendStr (mydata->current, "<charset/>");
2394 mydata->currentlen = strlen (*(mydata->current));
2395 break;
2396 case TT_COLSPAN:
2397 wvAppendStr (mydata->current, "<colspan/>");
2398 mydata->currentlen = strlen (*(mydata->current));
2399 break;
2400 case TT_CELLRELWIDTH:
2401 wvAppendStr (mydata->current, "<cellrelwidth/>");
2402 mydata->currentlen = strlen (*(mydata->current));
2403 break;
2404 case TT_CELLRELPAGEWIDTH:
2405 wvAppendStr (mydata->current, "<cellrelpagewidth/>");
2406 mydata->currentlen = strlen (*(mydata->current));
2407 break;
2408 case TT_TABLERELWIDTH:
2409 wvAppendStr (mydata->current, "<tablerelwidth/>");
2410 mydata->currentlen = strlen (*(mydata->current));
2411 break;
2412 case TT_no_rows:
2413 wvAppendStr (mydata->current, "<no_rows/>");
2414 mydata->currentlen = strlen (*(mydata->current));
2415 break;
2416 case TT_no_cols:
2417 wvAppendStr (mydata->current, "<no_cols/>");
2418 mydata->currentlen = strlen (*(mydata->current));
2419 break;
2420 case TT_CELLBGCOLOR:
2421 wvAppendStr (mydata->current, "<cellbgcolor/>");
2422 mydata->currentlen = strlen (*(mydata->current));
2423 break;
2424 case TT_PARABGCOLOR:
2425 wvAppendStr (mydata->current, "<parabgcolor/>");
2426 mydata->currentlen = strlen (*(mydata->current));
2427 break;
2428 case TT_PARAFGCOLOR:
2429 wvAppendStr (mydata->current, "<parafgcolor/>");
2430 mydata->currentlen = strlen (*(mydata->current));
2431 break;
2432 case TT_ROWSPAN:
2433 wvAppendStr (mydata->current, "<rowspan/>");
2434 mydata->currentlen = strlen (*(mydata->current));
2435 break;
2436 case TT_FILENAME:
2437 wvAppendStr (mydata->current, "<filename/>");
2438 mydata->currentlen = strlen (*(mydata->current));
2439 break;
2440 case TT_VERSION:
2441 wvAppendStr (mydata->current, "<version/>");
2442 mydata->currentlen = strlen (*(mydata->current));
2443 break;
2444 case TT_STRIKEB:
2445 wvAppendStr (mydata->current, "<strike.begin/>");
2446 mydata->currentlen = strlen (*(mydata->current));
2447 break;
2448 case TT_OUTLINEB:
2449 wvAppendStr (mydata->current, "<outline.begin/>");
2450 mydata->currentlen = strlen (*(mydata->current));
2451 break;
2452 case TT_RMarkDelB:
2453 wvAppendStr (mydata->current, "<rmarkdel.begin/>");
2454 mydata->currentlen = strlen (*(mydata->current));
2455 break;
2456 case TT_DispFldRMarkB:
2457 wvAppendStr (mydata->current, "<DispFldRMark.begin/>");
2458 mydata->currentlen = strlen (*(mydata->current));
2459 break;
2460 case TT_ITALICB:
2461 wvAppendStr (mydata->current, "<italic.begin/>");
2462 mydata->currentlen = strlen (*(mydata->current));
2463 break;
2464 case TT_ITALICE:
2465 wvAppendStr (mydata->current, "<italic.end/>");
2466 mydata->currentlen = strlen (*(mydata->current));
2467 break;
2468 case TT_OUTLINEE:
2469 wvAppendStr (mydata->current, "<outline.end/>");
2470 mydata->currentlen = strlen (*(mydata->current));
2471 break;
2472 case TT_STRIKEE:
2473 wvAppendStr (mydata->current, "<strike.end/>");
2474 mydata->currentlen = strlen (*(mydata->current));
2475 break;
2476 case TT_RMarkDelE:
2477 wvAppendStr (mydata->current, "<rmarkdel.end/>");
2478 mydata->currentlen = strlen (*(mydata->current));
2479 break;
2480 case TT_DispFldRMarkE:
2481 wvAppendStr (mydata->current, "<DispFldRMark.end/>");
2482 mydata->currentlen = strlen (*(mydata->current));
2483 break;
2484 case TT_BOLDB:
2485 wvAppendStr (mydata->current, "<bold.begin/>");
2486 mydata->currentlen = strlen (*(mydata->current));
2487 break;
2488 case TT_BOLDE:
2489 wvAppendStr (mydata->current, "<bold.end/>");
2490 mydata->currentlen = strlen (*(mydata->current));
2491 break;
2492 case TT_SMALLCAPSB:
2493 wvAppendStr (mydata->current, "<smallcaps.begin/>");
2494 mydata->currentlen = strlen (*(mydata->current));
2495 break;
2496 case TT_SMALLCAPSE:
2497 wvAppendStr (mydata->current, "<smallcaps.end/>");
2498 mydata->currentlen = strlen (*(mydata->current));
2499 break;
2500 case TT_CAPSB:
2501 wvAppendStr (mydata->current, "<caps.begin/>");
2502 mydata->currentlen = strlen (*(mydata->current));
2503 break;
2504 case TT_CAPSE:
2505 wvAppendStr (mydata->current, "<caps.end/>");
2506 mydata->currentlen = strlen (*(mydata->current));
2507 break;
2508 case TT_VANISHB:
2509 wvAppendStr (mydata->current, "<vanish.begin/>");
2510 mydata->currentlen = strlen (*(mydata->current));
2511 break;
2512 case TT_VANISHE:
2513 wvAppendStr (mydata->current, "<vanish.end/>");
2514 mydata->currentlen = strlen (*(mydata->current));
2515 break;
2516 case TT_RMarkB:
2517 wvAppendStr (mydata->current, "<rmark.begin/>");
2518 mydata->currentlen = strlen (*(mydata->current));
2519 break;
2520 case TT_RMarkE:
2521 wvAppendStr (mydata->current, "<rmark.end/>");
2522 mydata->currentlen = strlen (*(mydata->current));
2523 break;
2524 case TT_SHADOWB:
2525 wvAppendStr (mydata->current, "<shadow.begin/>");
2526 mydata->currentlen = strlen (*(mydata->current));
2527 break;
2528 case TT_SHADOWE:
2529 wvAppendStr (mydata->current, "<shadow.end/>");
2530 mydata->currentlen = strlen (*(mydata->current));
2531 break;
2532 case TT_LOWERCASEB:
2533 wvAppendStr (mydata->current, "<lowercase.begin/>");
2534 mydata->currentlen = strlen (*(mydata->current));
2535 break;
2536 case TT_LOWERCASEE:
2537 wvAppendStr (mydata->current, "<lowercase.end/>");
2538 mydata->currentlen = strlen (*(mydata->current));
2539 break;
2540 case TT_EMBOSSB:
2541 wvAppendStr (mydata->current, "<emboss.begin/>");
2542 mydata->currentlen = strlen (*(mydata->current));
2543 break;
2544 case TT_EMBOSSE:
2545 wvAppendStr (mydata->current, "<emboss.end/>");
2546 mydata->currentlen = strlen (*(mydata->current));
2547 break;
2548 case TT_IMPRINTB:
2549 wvAppendStr (mydata->current, "<imprint.begin/>");
2550 mydata->currentlen = strlen (*(mydata->current));
2551 break;
2552 case TT_IMPRINTE:
2553 wvAppendStr (mydata->current, "<imprint.end/>");
2554 mydata->currentlen = strlen (*(mydata->current));
2555 break;
2556 case TT_DSTRIKEB:
2557 wvAppendStr (mydata->current, "<dstrike.begin/>");
2558 mydata->currentlen = strlen (*(mydata->current));
2559 break;
2560 case TT_DSTRIKEE:
2561 wvAppendStr (mydata->current, "<dstrike.end/>");
2562 mydata->currentlen = strlen (*(mydata->current));
2563 break;
2564 case TT_SUPERB:
2565 wvAppendStr (mydata->current, "<super.begin/>");
2566 mydata->currentlen = strlen (*(mydata->current));
2567 break;
2568 case TT_SUPERE:
2569 wvAppendStr (mydata->current, "<super.end/>");
2570 mydata->currentlen = strlen (*(mydata->current));
2571 break;
2572 case TT_SUBB:
2573 wvAppendStr (mydata->current, "<sub.begin/>");
2574 mydata->currentlen = strlen (*(mydata->current));
2575 break;
2576 case TT_SUBE:
2577 wvAppendStr (mydata->current, "<sub.end/>");
2578 mydata->currentlen = strlen (*(mydata->current));
2579 break;
2580 case TT_JUST:
2581 wvAppendStr (mydata->current, "<just/>");
2582 mydata->currentlen = strlen (*(mydata->current));
2583 break;
2584 case TT_PARAMARGIN:
2585 wvAppendStr (mydata->current, "<paramargin/>");
2586 mydata->currentlen = strlen (*(mydata->current));
2587 break;
2588 case TT_PARABORDER:
2589 wvAppendStr (mydata->current, "<paraborder/>");
2590 mydata->currentlen = strlen (*(mydata->current));
2591 break;
2592 case TT_BORDERTopSTYLE:
2593 wvAppendStr (mydata->current, "<bordertopstyle/>");
2594 mydata->currentlen = strlen (*(mydata->current));
2595 break;
2596 case TT_BORDERTopCOLOR:
2597 wvAppendStr (mydata->current, "<bordertopcolor/>");
2598 mydata->currentlen = strlen (*(mydata->current));
2599 break;
2600 case TT_BORDERLeftSTYLE:
2601 wvAppendStr (mydata->current, "<borderleftstyle/>");
2602 mydata->currentlen = strlen (*(mydata->current));
2603 break;
2604 case TT_BORDERLeftCOLOR:
2605 wvAppendStr (mydata->current, "<borderleftcolor/>");
2606 mydata->currentlen = strlen (*(mydata->current));
2607 break;
2608 case TT_BORDERRightSTYLE:
2609 wvAppendStr (mydata->current, "<borderrightstyle/>");
2610 mydata->currentlen = strlen (*(mydata->current));
2611 break;
2612 case TT_BORDERRightCOLOR:
2613 wvAppendStr (mydata->current, "<borderrightcolor/>");
2614 mydata->currentlen = strlen (*(mydata->current));
2615 break;
2616 case TT_BORDERBottomSTYLE:
2617 wvAppendStr (mydata->current, "<borderbottomstyle/>");
2618 mydata->currentlen = strlen (*(mydata->current));
2619 break;
2620 case TT_BORDERBottomCOLOR:
2621 wvAppendStr (mydata->current, "<borderbottomcolor/>");
2622 mydata->currentlen = strlen (*(mydata->current));
2623 break;
2624 case TT_nfc:
2625 wvAppendStr (mydata->current, "<nfc/>");
2626 mydata->currentlen = strlen (*(mydata->current));
2627 break;
2628 case TT_START:
2629 wvAppendStr (mydata->current, "<start/>");
2630 mydata->currentlen = strlen (*(mydata->current));
2631 break;
2632 case TT_COLORB:
2633 wvAppendStr (mydata->current, "<color.begin/>");
2634 mydata->currentlen = strlen (*(mydata->current));
2635 break;
2636
2637 case TT_SINGLEUB:
2638 wvAppendStr (mydata->current, "<singleu.begin/>");
2639 mydata->currentlen = strlen (*(mydata->current));
2640 break;
2641 case TT_WORDUB:
2642 wvAppendStr (mydata->current, "<wordu.begin/>");
2643 mydata->currentlen = strlen (*(mydata->current));
2644 break;
2645 case TT_DOUBLEUB:
2646 wvAppendStr (mydata->current, "<doubleu.begin/>");
2647 mydata->currentlen = strlen (*(mydata->current));
2648 break;
2649 case TT_DOTTEDUB:
2650 wvAppendStr (mydata->current, "<dottedu.begin/>");
2651 mydata->currentlen = strlen (*(mydata->current));
2652 break;
2653 case TT_HIDDENUB:
2654 wvAppendStr (mydata->current, "<hiddenu.begin/>");
2655 mydata->currentlen = strlen (*(mydata->current));
2656 break;
2657 case TT_THICKUB:
2658 wvAppendStr (mydata->current, "<thicku.begin/>");
2659 mydata->currentlen = strlen (*(mydata->current));
2660 break;
2661 case TT_DASHUB:
2662 wvAppendStr (mydata->current, "<dashu.begin/>");
2663 mydata->currentlen = strlen (*(mydata->current));
2664 break;
2665 case TT_DOTUB:
2666 wvAppendStr (mydata->current, "<dotu.begin/>");
2667 mydata->currentlen = strlen (*(mydata->current));
2668 break;
2669 case TT_DOTDASHUB:
2670 wvAppendStr (mydata->current, "<dotdashu.begin/>");
2671 mydata->currentlen = strlen (*(mydata->current));
2672 break;
2673 case TT_DOTDOTDASHUB:
2674 wvAppendStr (mydata->current, "<dotdotdashu.begin/>");
2675 mydata->currentlen = strlen (*(mydata->current));
2676 break;
2677 case TT_WAVEUB:
2678 wvAppendStr (mydata->current, "<waveu.begin/>");
2679 mydata->currentlen = strlen (*(mydata->current));
2680 break;
2681 case TT_SINGLEUE:
2682 wvAppendStr (mydata->current, "<singleu.end/>");
2683 mydata->currentlen = strlen (*(mydata->current));
2684 break;
2685 case TT_WORDUE:
2686 wvAppendStr (mydata->current, "<wordu.end/>");
2687 mydata->currentlen = strlen (*(mydata->current));
2688 break;
2689 case TT_DOUBLEUE:
2690 wvAppendStr (mydata->current, "<doubleu.end/>");
2691 mydata->currentlen = strlen (*(mydata->current));
2692 break;
2693 case TT_DOTTEDUE:
2694 wvAppendStr (mydata->current, "<dottedu.end/>");
2695 mydata->currentlen = strlen (*(mydata->current));
2696 break;
2697 case TT_HIDDENUE:
2698 wvAppendStr (mydata->current, "<hiddenu.end/>");
2699 mydata->currentlen = strlen (*(mydata->current));
2700 break;
2701 case TT_THICKUE:
2702 wvAppendStr (mydata->current, "<thicku.end/>");
2703 mydata->currentlen = strlen (*(mydata->current));
2704 break;
2705 case TT_DASHUE:
2706 wvAppendStr (mydata->current, "<dashu.end/>");
2707 mydata->currentlen = strlen (*(mydata->current));
2708 break;
2709 case TT_DOTUE:
2710 wvAppendStr (mydata->current, "<dotu.end/>");
2711 mydata->currentlen = strlen (*(mydata->current));
2712 break;
2713 case TT_DOTDASHUE:
2714 wvAppendStr (mydata->current, "<dotdashu.end/>");
2715 mydata->currentlen = strlen (*(mydata->current));
2716 break;
2717 case TT_DOTDOTDASHUE:
2718 wvAppendStr (mydata->current, "<dotdotdashu.end/>");
2719 mydata->currentlen = strlen (*(mydata->current));
2720 break;
2721 case TT_WAVEUE:
2722 wvAppendStr (mydata->current, "<waveu.end/>");
2723 mydata->currentlen = strlen (*(mydata->current));
2724 break;
2725
2726 case TT_BLACKB:
2727 wvAppendStr (mydata->current, "<black.begin/>");
2728 mydata->currentlen = strlen (*(mydata->current));
2729 break;
2730 case TT_BLUEB:
2731 wvAppendStr (mydata->current, "<blue.begin/>");
2732 mydata->currentlen = strlen (*(mydata->current));
2733 break;
2734 case TT_CYANB:
2735 wvAppendStr (mydata->current, "<cyan.begin/>");
2736 mydata->currentlen = strlen (*(mydata->current));
2737 break;
2738 case TT_GREENB:
2739 wvAppendStr (mydata->current, "<green.begin/>");
2740 mydata->currentlen = strlen (*(mydata->current));
2741 break;
2742 case TT_MAGENTAB:
2743 wvAppendStr (mydata->current, "<magenta.begin/>");
2744 mydata->currentlen = strlen (*(mydata->current));
2745 break;
2746 case TT_REDB:
2747 wvAppendStr (mydata->current, "<red.begin/>");
2748 mydata->currentlen = strlen (*(mydata->current));
2749 break;
2750 case TT_YELLOWB:
2751 wvAppendStr (mydata->current, "<yellow.begin/>");
2752 mydata->currentlen = strlen (*(mydata->current));
2753 break;
2754 case TT_WHITEB:
2755 wvAppendStr (mydata->current, "<white.begin/>");
2756 mydata->currentlen = strlen (*(mydata->current));
2757 break;
2758 case TT_DKBLUEB:
2759 wvAppendStr (mydata->current, "<dkblue.begin/>");
2760 mydata->currentlen = strlen (*(mydata->current));
2761 break;
2762 case TT_DKCYANB:
2763 wvAppendStr (mydata->current, "<dkcyan.begin/>");
2764 mydata->currentlen = strlen (*(mydata->current));
2765 break;
2766 case TT_DKGREENB:
2767 wvAppendStr (mydata->current, "<dkgreen.begin/>");
2768 mydata->currentlen = strlen (*(mydata->current));
2769 break;
2770 case TT_DKMAGENTAB:
2771 wvAppendStr (mydata->current, "<dkmagenta.begin/>");
2772 mydata->currentlen = strlen (*(mydata->current));
2773 break;
2774 case TT_DKREDB:
2775 wvAppendStr (mydata->current, "<dkred.begin/>");
2776 mydata->currentlen = strlen (*(mydata->current));
2777 break;
2778 case TT_DKYELLOWB:
2779 wvAppendStr (mydata->current, "<dkyellow.begin/>");
2780 mydata->currentlen = strlen (*(mydata->current));
2781 break;
2782 case TT_DKGRAYB:
2783 wvAppendStr (mydata->current, "<dkgray.begin/>");
2784 mydata->currentlen = strlen (*(mydata->current));
2785 break;
2786 case TT_LTGRAYB:
2787 wvAppendStr (mydata->current, "<ltgray.begin/>");
2788 mydata->currentlen = strlen (*(mydata->current));
2789 break;
2790
2791 case TT_BLACKE:
2792 wvAppendStr (mydata->current, "<black.end/>");
2793 mydata->currentlen = strlen (*(mydata->current));
2794 break;
2795 case TT_BLUEE:
2796 wvAppendStr (mydata->current, "<blue.end/>");
2797 mydata->currentlen = strlen (*(mydata->current));
2798 break;
2799 case TT_CYANE:
2800 wvAppendStr (mydata->current, "<cyan.end/>");
2801 mydata->currentlen = strlen (*(mydata->current));
2802 break;
2803 case TT_GREENE:
2804 wvAppendStr (mydata->current, "<green.end/>");
2805 mydata->currentlen = strlen (*(mydata->current));
2806 break;
2807 case TT_MAGENTAE:
2808 wvAppendStr (mydata->current, "<magenta.end/>");
2809 mydata->currentlen = strlen (*(mydata->current));
2810 break;
2811 case TT_REDE:
2812 wvAppendStr (mydata->current, "<red.end/>");
2813 mydata->currentlen = strlen (*(mydata->current));
2814 break;
2815 case TT_YELLOWE:
2816 wvAppendStr (mydata->current, "<yellow.end/>");
2817 mydata->currentlen = strlen (*(mydata->current));
2818 break;
2819 case TT_WHITEE:
2820 wvAppendStr (mydata->current, "<white.end/>");
2821 mydata->currentlen = strlen (*(mydata->current));
2822 break;
2823 case TT_DKBLUEE:
2824 wvAppendStr (mydata->current, "<dkblue.end/>");
2825 mydata->currentlen = strlen (*(mydata->current));
2826 break;
2827 case TT_DKCYANE:
2828 wvAppendStr (mydata->current, "<dkcyan.end/>");
2829 mydata->currentlen = strlen (*(mydata->current));
2830 break;
2831 case TT_DKGREENE:
2832 wvAppendStr (mydata->current, "<dkgreen.end/>");
2833 mydata->currentlen = strlen (*(mydata->current));
2834 break;
2835 case TT_DKMAGENTAE:
2836 wvAppendStr (mydata->current, "<dkmagenta.end/>");
2837 mydata->currentlen = strlen (*(mydata->current));
2838 break;
2839 case TT_DKREDE:
2840 wvAppendStr (mydata->current, "<dkred.end/>");
2841 mydata->currentlen = strlen (*(mydata->current));
2842 break;
2843 case TT_DKYELLOWE:
2844 wvAppendStr (mydata->current, "<dkyellow.end/>");
2845 mydata->currentlen = strlen (*(mydata->current));
2846 break;
2847 case TT_DKGRAYE:
2848 wvAppendStr (mydata->current, "<dkgray.end/>");
2849 mydata->currentlen = strlen (*(mydata->current));
2850 break;
2851 case TT_LTGRAYE:
2852 wvAppendStr (mydata->current, "<ltgray.end/>");
2853 mydata->currentlen = strlen (*(mydata->current));
2854 break;
2855
2856 case TT_FONTSTRB:
2857 wvAppendStr (mydata->current, "<fontstr.begin/>");
2858 mydata->currentlen = strlen (*(mydata->current));
2859 break;
2860 case TT_FONTSTRE:
2861 wvAppendStr (mydata->current, "<fontstr.end/>");
2862 mydata->currentlen = strlen (*(mydata->current));
2863 break;
2864
2865 case TT_ANIMATIONB:
2866 wvAppendStr (mydata->current, "<animation.begin/>");
2867 mydata->currentlen = strlen (*(mydata->current));
2868 break;
2869 case TT_ANIMATIONE:
2870 wvAppendStr (mydata->current, "<animation.end/>");
2871 mydata->currentlen = strlen (*(mydata->current));
2872 break;
2873
2874 case TT_IBSTANNO:
2875 wvAppendStr (mydata->current, "<ibstanno/>");
2876 mydata->currentlen = strlen (*(mydata->current));
2877 break;
2878 case TT_xstUsrInitl:
2879 wvAppendStr (mydata->current, "<xstUsrInitl/>");
2880 mydata->currentlen = strlen (*(mydata->current));
2881 break;
2882 case TT_mmParaBefore:
2883 wvAppendStr (mydata->current, "<mmParaBefore/>");
2884 mydata->currentlen = strlen (*(mydata->current));
2885 break;
2886 case TT_mmParaAfter:
2887 wvAppendStr (mydata->current, "<mmParaAfter/>");
2888 mydata->currentlen = strlen (*(mydata->current));
2889 break;
2890 case TT_mmParaLeft:
2891 wvAppendStr (mydata->current, "<mmParaLeft/>");
2892 mydata->currentlen = strlen (*(mydata->current));
2893 break;
2894 case TT_mmParaRight:
2895 wvAppendStr (mydata->current, "<mmParaRight/>");
2896 mydata->currentlen = strlen (*(mydata->current));
2897 break;
2898 /* >>----------- PATCH */
2899 case TT_stylename:
2900 wvAppendStr (mydata->current, "<stylename/>");
2901 mydata->currentlen = strlen (*(mydata->current));
2902 break;
2903 /* --------------<< */
2904
2905 case TT_mmParaLeft1:
2906 wvAppendStr (mydata->current, "<mmParaLeft1/>");
2907 mydata->currentlen = strlen (*(mydata->current));
2908 break;
2909 case TT_mmPadTop:
2910 wvAppendStr (mydata->current, "<mmPadTop/>");
2911 mydata->currentlen = strlen (*(mydata->current));
2912 break;
2913 case TT_mmPadRight:
2914 wvAppendStr (mydata->current, "<mmPadRight/>");
2915 mydata->currentlen = strlen (*(mydata->current));
2916 break;
2917 case TT_mmPadBottom:
2918 wvAppendStr (mydata->current, "<mmPadBottom/>");
2919 mydata->currentlen = strlen (*(mydata->current));
2920 break;
2921 case TT_mmPadLeft:
2922 wvAppendStr (mydata->current, "<mmPadLeft/>");
2923 mydata->currentlen = strlen (*(mydata->current));
2924 break;
2925 case TT_mmLineHeight:
2926 wvAppendStr (mydata->current, "<mmLineHeight/>");
2927 mydata->currentlen = strlen (*(mydata->current));
2928 break;
2929 case TT_pixPicWidth:
2930 wvAppendStr (mydata->current, "<pixPicWidth/>");
2931 mydata->currentlen = strlen (*(mydata->current));
2932 break;
2933 case TT_pixPicHeight:
2934 wvAppendStr (mydata->current, "<pixPicHeight/>");
2935 mydata->currentlen = strlen (*(mydata->current));
2936 break;
2937 case TT_htmlAlignGuess:
2938 wvAppendStr (mydata->current, "<htmlAlignGuess/>");
2939 mydata->currentlen = strlen (*(mydata->current));
2940 break;
2941 case TT_htmlNextLineGuess:
2942 wvAppendStr (mydata->current, "<htmlNextLineGuess/>");
2943 mydata->currentlen = strlen (*(mydata->current));
2944 break;
2945 case TT_ibstRMark:
2946 wvAppendStr (mydata->current, "<ibstrmark/>");
2947 mydata->currentlen = strlen (*(mydata->current));
2948 break;
2949 case TT_ibstRMarkDel:
2950 wvAppendStr (mydata->current, "<ibstrmarkdel/>");
2951 mydata->currentlen = strlen (*(mydata->current));
2952 break;
2953 case TT_ibstDispFldRMark:
2954 wvAppendStr (mydata->current, "<ibstdispfldrmark/>");
2955 mydata->currentlen = strlen (*(mydata->current));
2956 break;
2957
2958 case TT_dttmRMark:
2959 wvAppendStr (mydata->current, "<dttmrmark/>");
2960 mydata->currentlen = strlen (*(mydata->current));
2961 break;
2962 case TT_dttmRMarkDel:
2963 wvAppendStr (mydata->current, "<dttmrmarkdel/>");
2964 mydata->currentlen = strlen (*(mydata->current));
2965 break;
2966 case TT_dttmDispFldRMark:
2967 wvAppendStr (mydata->current, "<dttmdispfldrmark/>");
2968 mydata->currentlen = strlen (*(mydata->current));
2969 break;
2970 case TT_xstDispFldRMark:
2971 wvAppendStr (mydata->current, "<xstDispFldRMark/>");
2972 mydata->currentlen = strlen (*(mydata->current));
2973 break;
2974 case TT_PropRMarkB:
2975 wvAppendStr (mydata->current, "<proprmark.begin/>");
2976 mydata->currentlen = strlen (*(mydata->current));
2977 break;
2978 case TT_PropRMarkE:
2979 wvAppendStr (mydata->current, "<proprmark.end/>");
2980 mydata->currentlen = strlen (*(mydata->current));
2981 break;
2982 case TT_ibstPropRMark:
2983 wvAppendStr (mydata->current, "<ibstPropRMark/>");
2984 mydata->currentlen = strlen (*(mydata->current));
2985 break;
2986 case TT_dttmPropRMark:
2987 wvAppendStr (mydata->current, "<dttmPropRMark/>");
2988 mydata->currentlen = strlen (*(mydata->current));
2989 break;
2990
2991 case TT_LasVegasB:
2992 wvAppendStr (mydata->current, "<lasvegas.begin/>");
2993 mydata->currentlen = strlen (*(mydata->current));
2994 break;
2995 case TT_BackgroundBlinkB:
2996 wvAppendStr (mydata->current, "<backgroundblink.begin/>");
2997 mydata->currentlen = strlen (*(mydata->current));
2998 break;
2999 case TT_SparkleTextB:
3000 wvAppendStr (mydata->current, "<sparkletext.begin/>");
3001 mydata->currentlen = strlen (*(mydata->current));
3002 break;
3003 case TT_MarchingAntsB:
3004 wvAppendStr (mydata->current, "<marchingants.begin/>");
3005 mydata->currentlen = strlen (*(mydata->current));
3006 break;
3007 case TT_MarchingRedAntsB:
3008 wvAppendStr (mydata->current, "<marchingredants.begin/>");
3009 mydata->currentlen = strlen (*(mydata->current));
3010 break;
3011 case TT_ShimmerB:
3012 wvAppendStr (mydata->current, "<shimmer.begin/>");
3013 mydata->currentlen = strlen (*(mydata->current));
3014 break;
3015
3016 case TT_LasVegasE:
3017 wvAppendStr (mydata->current, "<lasvegas.end/>");
3018 mydata->currentlen = strlen (*(mydata->current));
3019 break;
3020 case TT_BackgroundBlinkE:
3021 wvAppendStr (mydata->current, "<backgroundblink.end/>");
3022 mydata->currentlen = strlen (*(mydata->current));
3023 break;
3024 case TT_SparkleTextE:
3025 wvAppendStr (mydata->current, "<sparkletext.end/>");
3026 mydata->currentlen = strlen (*(mydata->current));
3027 break;
3028 case TT_MarchingAntsE:
3029 wvAppendStr (mydata->current, "<marchingants.end/>");
3030 mydata->currentlen = strlen (*(mydata->current));
3031 break;
3032 case TT_MarchingRedAntsE:
3033 wvAppendStr (mydata->current, "<marchingredants.end/>");
3034 mydata->currentlen = strlen (*(mydata->current));
3035 break;
3036 case TT_ShimmerE:
3037 wvAppendStr (mydata->current, "<shimmer.end/>");
3038 mydata->currentlen = strlen (*(mydata->current));
3039 break;
3040
3041 case TT_TEXTB:
3042 wvAppendStr (mydata->current, "<text.begin/>");
3043 mydata->currentlen = strlen (*(mydata->current));
3044 break;
3045 break;
3046 case TT_TEXTE:
3047 wvAppendStr (mydata->current, "<text.end/>");
3048 mydata->currentlen = strlen (*(mydata->current));
3049 break;
3050
3051 case TT_OLISTB:
3052 wvAppendStr (mydata->current, "<olist.begin/>");
3053 mydata->currentlen = strlen (*(mydata->current));
3054 break;
3055 break;
3056 case TT_OLISTE:
3057 wvAppendStr (mydata->current, "<olist.end/>");
3058 mydata->currentlen = strlen (*(mydata->current));
3059 break;
3060 case TT_ULISTB:
3061 wvAppendStr (mydata->current, "<ulist.begin/>");
3062 mydata->currentlen = strlen (*(mydata->current));
3063 break;
3064 break;
3065 case TT_ULISTE:
3066 wvAppendStr (mydata->current, "<ulist.end/>");
3067 mydata->currentlen = strlen (*(mydata->current));
3068 break;
3069 case TT_ENTRYB:
3070 wvAppendStr (mydata->current, "<entry.begin/>");
3071 mydata->currentlen = strlen (*(mydata->current));
3072 break;
3073 break;
3074 case TT_ENTRYE:
3075 wvAppendStr (mydata->current, "<entry.end/>");
3076 mydata->currentlen = strlen (*(mydata->current));
3077 break;
3078 case TT_TABLEB:
3079 wvAppendStr (mydata->current, "<table.begin/>");
3080 mydata->currentlen = strlen (*(mydata->current));
3081 break;
3082 break;
3083 case TT_TABLEE:
3084 wvAppendStr (mydata->current, "<table.end/>");
3085 mydata->currentlen = strlen (*(mydata->current));
3086 break;
3087 case TT_ROWB:
3088 wvAppendStr (mydata->current, "<row.begin/>");
3089 mydata->currentlen = strlen (*(mydata->current));
3090 break;
3091 break;
3092 case TT_ROWE:
3093 wvAppendStr (mydata->current, "<row.end/>");
3094 mydata->currentlen = strlen (*(mydata->current));
3095 break;
3096 case TT_CELLB:
3097 wvAppendStr (mydata->current, "<cell.begin/>");
3098 mydata->currentlen = strlen (*(mydata->current));
3099 break;
3100 break;
3101 case TT_CELLE:
3102 wvAppendStr (mydata->current, "<cell.end/>");
3103 mydata->currentlen = strlen (*(mydata->current));
3104 break;
3105 case TT_LASTCELLB:
3106 wvAppendStr (mydata->current, "<lastcell.begin/>");
3107 mydata->currentlen = strlen (*(mydata->current));
3108 break;
3109 break;
3110 case TT_LASTCELLE:
3111 wvAppendStr (mydata->current, "<lastcell.end/>");
3112 mydata->currentlen = strlen (*(mydata->current));
3113 break;
3114
3115 }
3116 }
3117
3118 static void
wvendElement(void * userData,const XML_Char * name)3119 wvendElement (void *userData, const XML_Char *name)
3120 {
3121 state_data *mydata = (state_data *) userData;
3122 unsigned int token_type;
3123
3124 /* tokenIndex = s_mapNameToToken ((const char *) name);
3125 token_type = s_Tokens[tokenIndex].m_type;
3126 */ token_type = wvMapNameToTokenType ((const char *) name);
3127 switch (token_type)
3128 {
3129 case TT_BEGIN:
3130 case TT_END:
3131 case TT_ParaBefore:
3132 case TT_ParaRight:
3133 case TT_ParaAfter:
3134 case TT_ParaLeft:
3135 case TT_ParaLeft1:
3136 case TT_VertMergedCells:
3137 case TT_LEFT:
3138 case TT_RIGHT:
3139 case TT_CENTER:
3140 case TT_BLOCK:
3141 case TT_ASIAN:
3142 case TT_Arabic:
3143 case TT_UpperRoman:
3144 case TT_LowerRoman:
3145 case TT_UpperCaseN:
3146 case TT_LowerCaseN:
3147 case TT_NONED:
3148 case TT_SINGLED:
3149 case TT_THICKD:
3150 case TT_DOUBLED:
3151 case TT_NUMBER4D:
3152 case TT_HAIRLINED:
3153 case TT_DOTD:
3154 case TT_DASHLARGEGAPD:
3155 case TT_DOTDASHD:
3156 case TT_DOTDOTDASHD:
3157 case TT_TRIPLED:
3158 case TT_thin_thicksmallgapD:
3159 case TT_thick_thinsmallgapD:
3160 case TT_thin_thick_thinsmallgapD:
3161 case TT_thin_thickmediumgapD:
3162 case TT_thick_thinmediumgapD:
3163 case TT_thin_thick_thinmediumgapD:
3164 case TT_thin_thicklargegapD:
3165 case TT_thick_thinlargegapD:
3166 case TT_thin_thick_thinlargegapD:
3167 case TT_WAVED:
3168 case TT_DOUBLEWAVED:
3169 case TT_DASHSMALLGAPD:
3170 case TT_DASHDOTSTROKEDD:
3171 case TT_EMBOSS3DD:
3172 case TT_ENGRAVE3DD:
3173 case TT_DEFAULTD:
3174 wvAppendStr (mydata->current, "</begin>");
3175 wvTrace (("When we finish the str is %s\n", *(mydata->current)));
3176 mydata->currentlen = 0;
3177 mydata->current = NULL;
3178 break;
3179 case TT_TITLE:
3180 case TT_CHARSET:
3181 case TT_COLSPAN:
3182 case TT_CELLRELWIDTH:
3183 case TT_CELLRELPAGEWIDTH:
3184 case TT_ROWSPAN:
3185 case TT_CELLBGCOLOR:
3186 case TT_PARABGCOLOR:
3187 case TT_PARAFGCOLOR:
3188 case TT_TABLERELWIDTH:
3189 case TT_no_cols:
3190 case TT_no_rows:
3191 case TT_VERSION:
3192 case TT_FILENAME:
3193 case TT_JUST:
3194 case TT_PARAMARGIN:
3195 case TT_PARABORDER:
3196 case TT_BORDERTopSTYLE:
3197 case TT_BORDERTopCOLOR:
3198 case TT_BORDERLeftSTYLE:
3199 case TT_BORDERLeftCOLOR:
3200 case TT_BORDERRightSTYLE:
3201 case TT_BORDERRightCOLOR:
3202 case TT_BORDERBottomSTYLE:
3203 case TT_BORDERBottomCOLOR:
3204 case TT_nfc:
3205 case TT_START:
3206 case TT_BOLDB:
3207 case TT_BOLDE:
3208 case TT_ITALICB:
3209 case TT_ITALICE:
3210 case TT_STRIKEB:
3211 case TT_STRIKEE:
3212 case TT_RMarkDelB:
3213 case TT_RMarkDelE:
3214 case TT_OUTLINEB:
3215 case TT_OUTLINEE:
3216 case TT_SMALLCAPSB:
3217 case TT_SMALLCAPSE:
3218 case TT_CAPSB:
3219 case TT_CAPSE:
3220 case TT_VANISHB:
3221 case TT_VANISHE:
3222 case TT_RMarkB:
3223 case TT_RMarkE:
3224 case TT_SHADOWB:
3225 case TT_SHADOWE:
3226 case TT_LOWERCASEB:
3227 case TT_LOWERCASEE:
3228 case TT_EMBOSSB:
3229 case TT_EMBOSSE:
3230 case TT_IMPRINTB:
3231 case TT_IMPRINTE:
3232 case TT_DSTRIKEB:
3233 case TT_DSTRIKEE:
3234 case TT_SUPERB:
3235 case TT_SUPERE:
3236 case TT_SUBB:
3237 case TT_SUBE:
3238
3239 case TT_SINGLEUB:
3240 case TT_WORDUB:
3241 case TT_DOUBLEUB:
3242 case TT_DOTTEDUB:
3243 case TT_HIDDENUB:
3244 case TT_THICKUB:
3245 case TT_DASHUB:
3246 case TT_DOTUB:
3247 case TT_DOTDASHUB:
3248 case TT_DOTDOTDASHUB:
3249 case TT_WAVEUB:
3250 case TT_SINGLEUE:
3251 case TT_WORDUE:
3252 case TT_DOUBLEUE:
3253 case TT_DOTTEDUE:
3254 case TT_HIDDENUE:
3255 case TT_THICKUE:
3256 case TT_DASHUE:
3257 case TT_DOTUE:
3258 case TT_DOTDASHUE:
3259 case TT_DOTDOTDASHUE:
3260 case TT_WAVEUE:
3261
3262 case TT_BLACKB:
3263 case TT_BLUEB:
3264 case TT_CYANB:
3265 case TT_GREENB:
3266 case TT_MAGENTAB:
3267 case TT_REDB:
3268 case TT_YELLOWB:
3269 case TT_WHITEB:
3270 case TT_DKBLUEB:
3271 case TT_DKCYANB:
3272 case TT_DKGREENB:
3273 case TT_DKMAGENTAB:
3274 case TT_DKREDB:
3275 case TT_DKYELLOWB:
3276 case TT_DKGRAYB:
3277 case TT_LTGRAYB:
3278 case TT_BLACKE:
3279 case TT_BLUEE:
3280 case TT_CYANE:
3281 case TT_GREENE:
3282 case TT_MAGENTAE:
3283 case TT_REDE:
3284 case TT_YELLOWE:
3285 case TT_WHITEE:
3286 case TT_DKBLUEE:
3287 case TT_DKCYANE:
3288 case TT_DKGREENE:
3289 case TT_DKMAGENTAE:
3290 case TT_DKREDE:
3291 case TT_DKYELLOWE:
3292 case TT_DKGRAYE:
3293 case TT_LTGRAYE:
3294 case TT_FONTSTRB:
3295 case TT_FONTSTRE:
3296 case TT_COLORB:
3297 case TT_COLORE:
3298 case TT_IBSTANNO:
3299 case TT_xstUsrInitl:
3300 case TT_mmParaBefore:
3301 case TT_mmParaAfter:
3302 case TT_mmParaLeft:
3303 case TT_mmParaRight:
3304
3305 /* >>----------- PATCH */
3306 case TT_stylename:
3307 /* ------------------ << */
3308 case TT_mmParaLeft1:
3309 case TT_mmPadTop:
3310 case TT_mmPadRight:
3311 case TT_mmPadBottom:
3312 case TT_mmPadLeft:
3313 case TT_mmLineHeight:
3314 case TT_pixPicWidth:
3315 case TT_pixPicHeight:
3316 case TT_htmlAlignGuess:
3317 case TT_htmlNextLineGuess:
3318 case TT_ibstRMark:
3319 case TT_ibstRMarkDel:
3320 case TT_ibstDispFldRMark:
3321 case TT_dttmRMark:
3322 case TT_dttmRMarkDel:
3323 case TT_dttmDispFldRMark:
3324 case TT_xstDispFldRMark:
3325 case TT_PropRMarkB:
3326 case TT_PropRMarkE:
3327 case TT_ibstPropRMark:
3328 case TT_dttmPropRMark:
3329 case TT_LasVegasB:
3330 case TT_BackgroundBlinkB:
3331 case TT_SparkleTextB:
3332 case TT_MarchingAntsB:
3333 case TT_MarchingRedAntsB:
3334 case TT_ShimmerB:
3335 case TT_LasVegasE:
3336 case TT_BackgroundBlinkE:
3337 case TT_SparkleTextE:
3338 case TT_MarchingAntsE:
3339 case TT_MarchingRedAntsE:
3340 case TT_ShimmerE:
3341 case TT_ANIMATIONB:
3342 case TT_ANIMATIONE:
3343 case TT_DispFldRMarkB:
3344 case TT_DispFldRMarkE:
3345 case TT_TEXTB:
3346 case TT_TEXTE:
3347 case TT_OLISTB:
3348 case TT_OLISTE:
3349 case TT_ULISTB:
3350 case TT_ULISTE:
3351 case TT_ENTRYB:
3352 case TT_ENTRYE:
3353 case TT_TABLEB:
3354 case TT_TABLEE:
3355 case TT_ROWB:
3356 case TT_ROWE:
3357 case TT_CELLB:
3358 case TT_CELLE:
3359 case TT_LASTCELLB:
3360 case TT_LASTCELLE:
3361
3362 case TT_STYLE:
3363 break;
3364 default:
3365 mydata->currentlen = 0;
3366 mydata->current = NULL;
3367 break;
3368 }
3369 wvTrace (("ele ended\n"));
3370 }
3371
3372 static void
exendElement(void * userData,const char * name)3373 exendElement (void *userData, const char *name)
3374 {
3375 /*
3376 expand_data *mydata = (expand_data *)userData;
3377 */
3378 unsigned int token_type;
3379
3380 /* tokenIndex = s_mapNameToToken ((const char *) name);
3381 token_type = s_Tokens[tokenIndex].m_type;
3382 */ token_type = wvMapNameToTokenType ((const char *) name);
3383 switch (token_type)
3384 {
3385 case TT_TITLE:
3386 case TT_CHARSET:
3387 case TT_COLSPAN:
3388 case TT_ROWSPAN:
3389 case TT_CELLBGCOLOR:
3390 case TT_PARABGCOLOR:
3391 case TT_PARAFGCOLOR:
3392 case TT_TABLERELWIDTH:
3393 case TT_no_rows:
3394 case TT_no_cols:
3395 case TT_CELLRELWIDTH:
3396 case TT_CELLRELPAGEWIDTH:
3397 case TT_VERSION:
3398 case TT_FILENAME:
3399 break;
3400 default:
3401 break;
3402 }
3403 wvTrace (("ele ended\n"));
3404 }
3405
3406 static void
charData(void * userData,const XML_Char * s,int len)3407 charData (void *userData, const XML_Char * s, int len)
3408 {
3409 int i;
3410
3411 state_data *mydata = (state_data *) userData;
3412 if ((len > 0) && (mydata->current != NULL))
3413 *(mydata->current) =
3414 (char *) realloc (*(mydata->current), len + mydata->currentlen + 1);
3415 else
3416 return;
3417
3418 (*(mydata->current))[mydata->currentlen] = 0;
3419
3420 for (i = 0; i < len; i++)
3421 {
3422 switch (s[i])
3423 {
3424 case '&':
3425 mydata->currentlen += strlen ("&") - 1;
3426 *(mydata->current) =
3427 (char *) realloc (*(mydata->current), len + mydata->currentlen + 1);
3428 wvStrcat (*mydata->current, "&");
3429 break;
3430 case '<':
3431 mydata->currentlen += strlen ("<") - 1;
3432 *(mydata->current) =
3433 (char *) realloc (*(mydata->current), len + mydata->currentlen + 1);
3434 wvStrcat (*mydata->current, "<");
3435 break;
3436 case '>':
3437 mydata->currentlen += strlen (">") - 1;
3438 *(mydata->current) =
3439 (char *) realloc (*(mydata->current), len + mydata->currentlen + 1);
3440 wvStrcat (*mydata->current, ">");
3441 break;
3442 case '"':
3443 mydata->currentlen += strlen (""") - 1;
3444 *(mydata->current) =
3445 (char *) realloc (*(mydata->current), len + mydata->currentlen + 1);
3446 wvStrcat (*mydata->current, """);
3447 break;
3448 default:
3449 (*(mydata->current))[i + mydata->currentlen] = s[i];
3450 (*(mydata->current))[i + mydata->currentlen + 1] = 0;
3451 break;
3452 }
3453 }
3454 if (mydata->current != NULL)
3455 {
3456 (*(mydata->current))[len + mydata->currentlen] = '\0';
3457 mydata->currentlen += len;
3458 }
3459 }
3460
3461 static void
excharData(void * userData,const XML_Char * s,int len)3462 excharData (void *userData, const XML_Char * s, int len)
3463 {
3464 int i;
3465
3466 expand_data *mydata = (expand_data *) userData;
3467 if (len > 0)
3468 mydata->retstring =
3469 (char *) realloc (mydata->retstring, len + mydata->currentlen + 1);
3470 else
3471 return;
3472
3473 for (i = 0; i < len; i++)
3474 {
3475 if (mydata->retstring != NULL)
3476 mydata->retstring[i + mydata->currentlen] = s[i];
3477 }
3478 if (mydata->retstring != NULL)
3479 {
3480 mydata->retstring[i + mydata->currentlen] = '\0';
3481 mydata->currentlen += len;
3482 }
3483 }
3484
3485 #ifdef HAVE_LIBXML2
3486
3487 static void
free_libxml2_parser(xmlParserCtxtPtr ctxt)3488 free_libxml2_parser (xmlParserCtxtPtr ctxt)
3489 {
3490 xmlDocPtr xmlDoc;
3491
3492 ctxt->sax = NULL;
3493
3494 xmlDoc = ctxt->myDoc;
3495 xmlFreeParserCtxt (ctxt);
3496
3497 if (xmlDoc)
3498 xmlFreeDoc(xmlDoc);
3499 }
3500
3501 static xmlEntityPtr
_getEntity(void * user_data,const xmlChar * name)3502 _getEntity (void * user_data, const xmlChar * name)
3503 {
3504 return xmlGetPredefinedEntity (name);
3505 }
3506
3507 int
wvParseConfig(state_data * myhandle)3508 wvParseConfig (state_data * myhandle)
3509 {
3510 int ret = 0;
3511
3512 xmlSAXHandler hdl; /* flagrant copying from AbiWord */
3513 xmlParserCtxtPtr ctxt;
3514
3515 memset(&hdl, 0, sizeof(hdl));
3516
3517 hdl.getEntity = _getEntity;
3518 hdl.startElement = wvstartElement;
3519 hdl.endElement = wvendElement;
3520 hdl.characters = charData;
3521
3522 if (myhandle->fp)
3523 {
3524 fclose (myhandle->fp);
3525 myhandle->fp = NULL;
3526 }
3527 if (myhandle->path == NULL)
3528 {
3529 wvError (("No path has been set? Since I'm using libxml2 at the moment, I need a path.\n"));
3530 exit (-1);
3531 }
3532
3533 ctxt = xmlCreateFileParserCtxt (myhandle->path);
3534 if (ctxt == NULL)
3535 {
3536 /* by this point we haven't allocated anything so we can just return right here */
3537 return 1;
3538 }
3539 ctxt->sax = &hdl;
3540 ctxt->userData = (void *) myhandle;
3541
3542 xmlParseDocument (ctxt);
3543
3544 if (!ctxt->wellFormed) ret = 1;
3545
3546 free_libxml2_parser (ctxt);
3547
3548 return ret;
3549 }
3550 #else
3551 int
wvParseConfig(state_data * myhandle)3552 wvParseConfig (state_data * myhandle)
3553 {
3554 char buf[BUFSIZ];
3555
3556 XML_Parser parser = XML_ParserCreate (NULL);
3557 int done;
3558 size_t len;
3559
3560 XML_SetUserData (parser, myhandle);
3561 XML_SetElementHandler (parser, wvstartElement, wvendElement);
3562 XML_SetCharacterDataHandler (parser, charData);
3563
3564 if (myhandle->fp == NULL)
3565 {
3566 wvError (
3567 ("how can this happen, i bet you added TT_ lines to wv.h and didn't recompile wvHtml.o etc\n"));
3568 exit (-1);
3569 }
3570
3571 do
3572 {
3573 wvTrace (("loop in\n"));
3574 len = fread (buf, 1, sizeof (buf), myhandle->fp);
3575 wvTrace (("loop out\n"));
3576 done = len < sizeof (buf);
3577 if (!XML_Parse (parser, buf, len, done))
3578 {
3579 wvError (("%s at line %d\n",
3580 XML_ErrorString (XML_GetErrorCode (parser)),
3581 XML_GetCurrentLineNumber (parser)));
3582 return (1);
3583 }
3584 }
3585 while (!done);
3586 XML_ParserFree (parser);
3587 #ifdef DEBUG
3588 wvListStateData (myhandle);
3589 #endif
3590
3591 return 0;
3592 }
3593 #endif
3594
3595
3596
3597 void
wvInitExpandData(expand_data * data)3598 wvInitExpandData (expand_data * data)
3599 {
3600 data->retstring = NULL;
3601 data->currentlen = 0;
3602 }
3603
3604 #ifdef HAVE_LIBXML2
3605 int
wvExpand(expand_data * myhandle,char * buf,int len)3606 wvExpand (expand_data * myhandle, char *buf, int len)
3607 {
3608 int ret = 0;
3609
3610 xmlSAXHandler hdl;
3611 xmlParserCtxtPtr ctxt;
3612
3613 memset(&hdl, 0, sizeof(hdl));
3614
3615 hdl.getEntity = _getEntity;
3616 hdl.startElement = exstartElement;
3617 hdl.endElement = exendElement;
3618 hdl.characters = excharData;
3619
3620 ctxt = xmlCreateMemoryParserCtxt ((const char *) buf, len);
3621 if (ctxt == NULL)
3622 {
3623 /* by this point we haven't allocated anything so we can just return right here */
3624 return 1;
3625 }
3626 ctxt->sax = &hdl;
3627 ctxt->userData = (void *) myhandle;
3628
3629 wvInitExpandData (myhandle);
3630
3631 xmlParseDocument (ctxt);
3632
3633 if (!ctxt->wellFormed) ret = 1;
3634
3635 free_libxml2_parser (ctxt);
3636
3637 return ret;
3638 }
3639 #else
3640 int
wvExpand(expand_data * myhandle,char * buf,int len)3641 wvExpand (expand_data * myhandle, char *buf, int len)
3642 {
3643 XML_Parser parser = XML_ParserCreate (NULL);
3644
3645 wvTrace (("expanding string %s\n", buf));
3646
3647 XML_SetUserData (parser, myhandle);
3648 XML_SetElementHandler (parser, exstartElement, exendElement);
3649 XML_SetCharacterDataHandler (parser, excharData);
3650 wvInitExpandData (myhandle);
3651
3652 if (!XML_Parse (parser, buf, len, 1))
3653 {
3654 wvError (("%s at line %d\n",
3655 XML_ErrorString (XML_GetErrorCode (parser)),
3656 XML_GetCurrentLineNumber (parser)));
3657 return 1;
3658 }
3659
3660 XML_ParserFree (parser);
3661
3662 return 0;
3663 }
3664 #endif
3665
3666 void
wvSetEntityConverter(expand_data * data)3667 wvSetEntityConverter (expand_data * data)
3668 {
3669 if ((data->sd) && (data->sd->elements[TT_CHARENTITY].str)
3670 && (data->sd->elements[TT_CHARENTITY].str[0]))
3671 {
3672 wvExpand (data, data->sd->elements[TT_CHARENTITY].str[0],
3673 strlen (data->sd->elements[TT_CHARENTITY].str[0]));
3674 if (data->retstring)
3675 {
3676 if (!(strcasecmp (data->retstring, "HTML")))
3677 wvConvertUnicodeToEntity = wvConvertUnicodeToHtml;
3678 else if (!(strcasecmp (data->retstring, "LaTeX")))
3679 wvConvertUnicodeToEntity = wvConvertUnicodeToLaTeX;
3680 else if (!(strcasecmp (data->retstring, "XML")))
3681 wvConvertUnicodeToEntity = wvConvertUnicodeToXml;
3682 wvTrace (
3683 ("Using %s entity conversion in conjunction with ordinary charset conversion\n",
3684 data->retstring));
3685 wvFree (data->retstring);
3686 }
3687 }
3688 }
3689
3690 void
wvBeginDocument(expand_data * data)3691 wvBeginDocument (expand_data * data)
3692 {
3693 if ((data->sd) && (data->sd->elements[TT_DOCUMENT].str)
3694 && (data->sd->elements[TT_DOCUMENT].str[0] != NULL))
3695 {
3696 wvTrace (("doc begin is %s", data->sd->elements[TT_DOCUMENT].str[0]));
3697 wvExpand (data, data->sd->elements[TT_DOCUMENT].str[0],
3698 strlen (data->sd->elements[TT_DOCUMENT].str[0]));
3699 if (data->retstring)
3700 {
3701 wvTrace (("doc begin is now %s", data->retstring));
3702 printf ("%s", data->retstring);
3703 wvFree (data->retstring);
3704 }
3705 }
3706 }
3707
3708 void
wvEndDocument(expand_data * data)3709 wvEndDocument (expand_data * data)
3710 {
3711 PAP apap;
3712 /*
3713 just for html mode, as this is designed for, I always have an empty
3714 para end just to close off any open lists
3715 */
3716 wvInitPAP (&apap);
3717 data->props = (void *) &apap;
3718 wvEndPara (data);
3719
3720 if ((data->sd) && (data->sd->elements[TT_DOCUMENT].str)
3721 && (data->sd->elements[TT_DOCUMENT].str[1] != NULL))
3722 {
3723 wvExpand (data, data->sd->elements[TT_DOCUMENT].str[1],
3724 strlen (data->sd->elements[TT_DOCUMENT].str[1]));
3725 if (data->retstring)
3726 {
3727 wvTrace (("doc end is now %s", data->retstring));
3728 printf ("%s", data->retstring);
3729 wvFree (data->retstring);
3730 }
3731 }
3732 }
3733
3734 void
wvBeginSection(expand_data * data)3735 wvBeginSection (expand_data * data)
3736 {
3737 if (data != NULL)
3738 data->asep = (SEP *) data->props;
3739
3740 if ((data != NULL) && (data->sd != NULL)
3741 && (data->sd->elements[TT_SECTION].str != NULL)
3742 && (data->sd->elements[TT_SECTION].str[0] != NULL))
3743 {
3744 wvExpand (data, data->sd->elements[TT_SECTION].str[0],
3745 strlen (data->sd->elements[TT_SECTION].str[0]));
3746 if (data->retstring)
3747 {
3748 wvTrace (("para begin is now %s", data->retstring));
3749 printf ("%s", data->retstring);
3750 wvFree (data->retstring);
3751 }
3752 }
3753 }
3754
3755 void
wvEndSection(expand_data * data)3756 wvEndSection (expand_data * data)
3757 {
3758 if ((data != NULL) && (data->sd != NULL)
3759 && (data->sd->elements[TT_SECTION].str != NULL)
3760 && (data->sd->elements[TT_SECTION].str[1] != NULL))
3761 {
3762 wvExpand (data, data->sd->elements[TT_SECTION].str[1],
3763 strlen (data->sd->elements[TT_SECTION].str[1]));
3764 if (data->retstring)
3765 {
3766 wvTrace (("para end is now %s", data->retstring));
3767 printf ("%s", data->retstring);
3768 wvFree (data->retstring);
3769 }
3770 }
3771 }
3772
3773 void
wvBeginComment(expand_data * data)3774 wvBeginComment (expand_data * data)
3775 {
3776 if (data != NULL)
3777 {
3778 wvTrace (("comment beginning\n"));
3779 if ((data->sd != NULL) && (data->sd->elements[TT_COMMENT].str)
3780 && (data->sd->elements[TT_COMMENT].str[0] != NULL))
3781 {
3782 wvExpand (data, data->sd->elements[TT_COMMENT].str[0],
3783 strlen (data->sd->elements[TT_COMMENT].str[0]));
3784 if (data->retstring)
3785 {
3786 printf ("%s", data->retstring);
3787 wvFree (data->retstring);
3788 }
3789 }
3790 }
3791 }
3792
3793 void
wvEndComment(expand_data * data)3794 wvEndComment (expand_data * data)
3795 {
3796 if ((data->sd != NULL) && (data->sd->elements[TT_COMMENT].str)
3797 && (data->sd->elements[TT_COMMENT].str[1] != NULL))
3798 {
3799 wvTrace (("comment ending\n"));
3800 wvExpand (data, data->sd->elements[TT_COMMENT].str[1],
3801 strlen (data->sd->elements[TT_COMMENT].str[1]));
3802 if (data->retstring)
3803 {
3804 wvTrace (("comment end is now %s", data->retstring));
3805 printf ("%s", data->retstring);
3806 wvFree (data->retstring);
3807 }
3808 }
3809 }
3810
3811 void
wvBeginPara(expand_data * data)3812 wvBeginPara (expand_data * data)
3813 {
3814 if (wvIsEmptyPara ((PAP *) data->props, data, 1))
3815 return;
3816
3817 if (data != NULL)
3818 {
3819 wvTrace (
3820 ("para of style %d beginning\n",
3821 ((PAP *) (data->props))->istd));
3822 if ((data->sd != NULL) && (data->sd->elements[TT_PARA].str)
3823 && (data->sd->elements[TT_PARA].str[0] != NULL))
3824 {
3825 wvExpand (data, data->sd->elements[TT_PARA].str[0],
3826 strlen (data->sd->elements[TT_PARA].str[0]));
3827 if (data->retstring)
3828 {
3829 printf ("%s", data->retstring);
3830 wvFree (data->retstring);
3831 }
3832 }
3833 }
3834 wvTrace (
3835 ("This Para is out cell %d %d \n", data->whichrow,
3836 data->whichcell));
3837 }
3838
3839 void
wvEndPara(expand_data * data)3840 wvEndPara (expand_data * data)
3841 {
3842 if ((data->sd != NULL) && (data->sd->elements[TT_PARA].str)
3843 && (data->sd->elements[TT_PARA].str[1] != NULL))
3844 {
3845 wvExpand (data, data->sd->elements[TT_PARA].str[1],
3846 strlen (data->sd->elements[TT_PARA].str[1]));
3847 if (data->retstring)
3848 {
3849 wvTrace (("para end is now %s", data->retstring));
3850 printf ("%s", data->retstring);
3851 wvFree (data->retstring);
3852 }
3853 }
3854 }
3855
3856 int
wvIsEmptyPara(PAP * apap,expand_data * data,int inc)3857 wvIsEmptyPara (PAP * apap, expand_data * data, int inc)
3858 {
3859 /*
3860 if we are a end of table para then i consist of nothing that is of
3861 any use for beginning of a para
3862 */
3863 if (apap == NULL)
3864 return (0);
3865
3866 if (apap->fTtp == 1)
3867 return (1);
3868
3869 /*
3870 if i consist of a vertically merged cell that is not the top one, then
3871 also i am of no use
3872 */
3873 if (apap->fInTable == 1)
3874 {
3875 #if 0
3876 wvTrace (
3877 ("This Para is in cell %d %d\n", data->whichrow,
3878 data->whichcell));
3879 if (*data->vmerges)
3880 {
3881 /* only ignore a vertically merged cell if the setting in the config file have been set that way */
3882 if (data
3883 && data->sd
3884 && data->sd->elements[TT_TABLEOVERRIDES].str
3885 && data->sd->elements[TT_TABLEOVERRIDES].str[5])
3886 {
3887 if ((*data->vmerges)[data->whichrow][data->whichcell] ==
3888 0)
3889
3890 {
3891 wvTrace (("Skipping the next paragraph\n"));
3892 if (inc)
3893 data->whichcell++;
3894 return (1);
3895 }
3896 }
3897 }
3898 #else
3899 return 0;
3900 #endif
3901 }
3902 return (0);
3903 }
3904
3905 void
wvBeginCharProp(expand_data * data,PAP * apap)3906 wvBeginCharProp (expand_data * data, PAP * apap)
3907 {
3908 CHP *achp;
3909
3910 if (wvIsEmptyPara (apap, data, 0))
3911 return;
3912
3913 achp = (CHP *) data->props;
3914 wvTrace (("beginning character run\n"));
3915 if (achp->ico)
3916 {
3917 wvTrace (("color is %d\n", achp->ico));
3918 }
3919
3920 if ((data != NULL) && (data->sd != NULL)
3921 && (data->sd->elements[TT_CHAR].str)
3922 && (data->sd->elements[TT_CHAR].str[0] != NULL))
3923 {
3924 wvExpand (data, data->sd->elements[TT_CHAR].str[0],
3925 strlen (data->sd->elements[TT_CHAR].str[0]));
3926 if (data->retstring)
3927 {
3928 wvTrace (("char begin is now %s", data->retstring));
3929 printf ("%s", data->retstring);
3930 wvFree (data->retstring);
3931 }
3932 }
3933 }
3934
3935 void
wvEndCharProp(expand_data * data)3936 wvEndCharProp (expand_data * data)
3937 {
3938 wvTrace (("ending character run\n"));
3939 if ((data->sd != NULL) && (data->sd->elements[TT_CHAR].str)
3940 && (data->sd->elements[TT_CHAR].str[1] != NULL))
3941 {
3942 wvExpand (data, data->sd->elements[TT_CHAR].str[1],
3943 strlen (data->sd->elements[TT_CHAR].str[1]));
3944 if (data->retstring)
3945 {
3946 wvTrace (("char end is now %s", data->retstring));
3947 printf ("%s", data->retstring);
3948 wvFree (data->retstring);
3949 }
3950 }
3951 }
3952