Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1
/*
2
 * output.c
3
 * Copyright (C) 2002-2004 A.J. van Os; Released under GNU GPL
4
 *
5
 * Description:
6
 * Generic output generating functions
7
 */
8
 
9
#include "antiword.h"
10
 
11
static conversion_type	eConversionType = conversion_unknown;
12
static encoding_type	eEncoding = encoding_neutral;
13
 
14
 
15
/*
16
 * vPrologue1 - get options and call a specific initialization
17
 */
18
static void
19
vPrologue1(diagram_type *pDiag, const char *szTask, const char *szFilename)
20
{
21
	options_type	tOptions;
22
 
23
	fail(pDiag == NULL);
24
	fail(szTask == NULL || szTask[0] == '\0');
25
 
26
	vGetOptions(&tOptions);
27
	eConversionType = tOptions.eConversionType;
28
	eEncoding = tOptions.eEncoding;
29
 
30
	switch (eConversionType) {
31
	case conversion_text:
32
		vPrologueTXT(pDiag, &tOptions);
33
		break;
34
	case conversion_fmt_text:
35
		vPrologueFMT(pDiag, &tOptions);
36
		break;
37
	case conversion_ps:
38
		vProloguePS(pDiag, szTask, szFilename, &tOptions);
39
		break;
40
	case conversion_xml:
41
		vPrologueXML(pDiag, &tOptions);
42
		break;
43
	case conversion_pdf:
44
		vProloguePDF(pDiag, szTask, &tOptions);
45
		break;
46
	default:
47
		DBG_DEC(eConversionType);
48
		break;
49
	}
50
} /* end of vPrologue1 */
51
 
52
/*
53
 * vEpilogue - clean up after everything is done
54
 */
55
static void
56
vEpilogue(diagram_type *pDiag)
57
{
58
	switch (eConversionType) {
59
	case conversion_text:
60
	case conversion_fmt_text:
61
		vEpilogueTXT(pDiag->pOutFile);
62
		break;
63
	case conversion_ps:
64
		vEpiloguePS(pDiag);
65
		break;
66
	case conversion_xml:
67
		vEpilogueXML(pDiag);
68
		break;
69
	case conversion_pdf:
70
		vEpiloguePDF(pDiag);
71
		break;
72
	default:
73
		DBG_DEC(eConversionType);
74
		break;
75
	}
76
} /* end of vEpilogue */
77
 
78
/*
79
 * vImagePrologue - perform image initialization
80
 */
81
void
82
vImagePrologue(diagram_type *pDiag, const imagedata_type *pImg)
83
{
84
	switch (eConversionType) {
85
	case conversion_text:
86
	case conversion_fmt_text:
87
		break;
88
	case conversion_ps:
89
		vImageProloguePS(pDiag, pImg);
90
		break;
91
	case conversion_xml:
92
		break;
93
	case conversion_pdf:
94
		vImageProloguePDF(pDiag, pImg);
95
		break;
96
	default:
97
		DBG_DEC(eConversionType);
98
		break;
99
	}
100
} /* end of vImagePrologue */
101
 
102
/*
103
 * vImageEpilogue - clean up an image
104
 */
105
void
106
vImageEpilogue(diagram_type *pDiag)
107
{
108
	switch (eConversionType) {
109
	case conversion_text:
110
	case conversion_fmt_text:
111
		break;
112
	case conversion_ps:
113
		vImageEpiloguePS(pDiag);
114
		break;
115
	case conversion_xml:
116
		break;
117
	case conversion_pdf:
118
		vImageEpiloguePDF(pDiag);
119
		break;
120
	default:
121
		DBG_DEC(eConversionType);
122
		break;
123
	}
124
} /* end of vImageEpilogue */
125
 
126
/*
127
 * bAddDummyImage - add a dummy image
128
 *
129
 * return TRUE when successful, otherwise FALSE
130
 */
131
BOOL
132
bAddDummyImage(diagram_type *pDiag, const imagedata_type *pImg)
133
{
134
	switch (eConversionType) {
135
	case conversion_text:
136
	case conversion_fmt_text:
137
		return FALSE;
138
	case conversion_ps:
139
		return bAddDummyImagePS(pDiag, pImg);
140
	case conversion_xml:
141
		return FALSE;
142
	case conversion_pdf:
143
		return bAddDummyImagePDF(pDiag, pImg);
144
	default:
145
		DBG_DEC(eConversionType);
146
		return FALSE;
147
	}
148
} /* end of bAddDummyImage */
149
 
150
/*
151
 * pCreateDiagram - create and initialize a diagram
152
 *
153
 * remark: does not return if the diagram can't be created
154
 */
155
diagram_type *
156
pCreateDiagram(const char *szTask, const char *szFilename)
157
{
158
	diagram_type	*pDiag;
159
 
160
	fail(szTask == NULL || szTask[0] == '\0');
161
	DBG_MSG("pCreateDiagram");
162
 
163
	/* Get the necessary memory */
164
	pDiag = xmalloc(sizeof(diagram_type));
165
	/* Initialization */
166
	pDiag->pOutFile = stdout;
167
	vPrologue1(pDiag, szTask, szFilename);
168
	/* Return success */
169
	return pDiag;
170
} /* end of pCreateDiagram */
171
 
172
/*
173
 * vDestroyDiagram - remove a diagram by freeing the memory it uses
174
 */
175
void
176
vDestroyDiagram(diagram_type *pDiag)
177
{
178
	DBG_MSG("vDestroyDiagram");
179
 
180
	fail(pDiag == NULL);
181
 
182
	if (pDiag == NULL) {
183
		return;
184
	}
185
	vEpilogue(pDiag);
186
	pDiag = xfree(pDiag);
187
} /* end of vDestroyDiagram */
188
 
189
/*
190
 * vPrologue2 - call a specific initialization
191
 */
192
void
193
vPrologue2(diagram_type *pDiag, int iWordVersion)
194
{
195
	switch (eConversionType) {
196
	case conversion_text:
197
	case conversion_fmt_text:
198
		break;
199
	case conversion_ps:
200
		vAddFontsPS(pDiag);
201
		break;
202
	case conversion_xml:
203
		vCreateBookIntro(pDiag, iWordVersion);
204
		break;
205
	case conversion_pdf:
206
		vCreateInfoDictionary(pDiag, iWordVersion);
207
		vAddFontsPDF(pDiag);
208
		break;
209
	default:
210
		DBG_DEC(eConversionType);
211
		break;
212
	}
213
} /* end of vPrologue2 */
214
 
215
/*
216
 * vMove2NextLine - move to the next line
217
 */
218
void
219
vMove2NextLine(diagram_type *pDiag, drawfile_fontref tFontRef,
220
	USHORT usFontSize)
221
{
222
	fail(pDiag == NULL);
223
	fail(pDiag->pOutFile == NULL);
224
	fail(usFontSize < MIN_FONT_SIZE || usFontSize > MAX_FONT_SIZE);
225
 
226
	switch (eConversionType) {
227
	case conversion_text:
228
	case conversion_fmt_text:
229
		vMove2NextLineTXT(pDiag);
230
		break;
231
	case conversion_ps:
232
		vMove2NextLinePS(pDiag, usFontSize);
233
		break;
234
	case conversion_xml:
235
		vMove2NextLineXML(pDiag);
236
		break;
237
	case conversion_pdf:
238
		vMove2NextLinePDF(pDiag, usFontSize);
239
		break;
240
	default:
241
		DBG_DEC(eConversionType);
242
		break;
243
	}
244
} /* end of vMove2NextLine */
245
 
246
/*
247
 * vSubstring2Diagram - put a sub string into a diagram
248
 */
249
void
250
vSubstring2Diagram(diagram_type *pDiag,
251
	char *szString, size_t tStringLength, long lStringWidth,
252
	UCHAR ucFontColor, USHORT usFontstyle, drawfile_fontref tFontRef,
253
	USHORT usFontSize, USHORT usMaxFontSize)
254
{
255
	switch (eConversionType) {
256
	case conversion_text:
257
		vSubstringTXT(pDiag, szString, tStringLength, lStringWidth);
258
		break;
259
	case conversion_fmt_text:
260
		vSubstringFMT(pDiag, szString, tStringLength, lStringWidth,
261
				usFontstyle);
262
		break;
263
	case conversion_ps:
264
		vSubstringPS(pDiag, szString, tStringLength, lStringWidth,
265
				ucFontColor, usFontstyle, tFontRef,
266
				usFontSize, usMaxFontSize);
267
		break;
268
	case conversion_xml:
269
		vSubstringXML(pDiag, szString, tStringLength, lStringWidth,
270
				usFontstyle);
271
		break;
272
	case conversion_pdf:
273
		vSubstringPDF(pDiag, szString, tStringLength, lStringWidth,
274
				ucFontColor, usFontstyle, tFontRef,
275
				usFontSize, usMaxFontSize);
276
		break;
277
	default:
278
		DBG_DEC(eConversionType);
279
		break;
280
	}
281
	pDiag->lXleft += lStringWidth;
282
} /* end of vSubstring2Diagram */
283
 
284
/*
285
 * Create a start of paragraph (phase 1)
286
 * Before indentation, list numbering, bullets etc.
287
 */
288
void
289
vStartOfParagraph1(diagram_type *pDiag, long lBeforeIndentation)
290
{
291
	fail(pDiag == NULL);
292
 
293
	switch (eConversionType) {
294
	case conversion_text:
295
	case conversion_fmt_text:
296
		vStartOfParagraphTXT(pDiag, lBeforeIndentation);
297
		break;
298
	case conversion_ps:
299
		vStartOfParagraphPS(pDiag, lBeforeIndentation);
300
		break;
301
	case conversion_xml:
302
		break;
303
	case conversion_pdf:
304
		vStartOfParagraphPDF(pDiag, lBeforeIndentation);
305
		break;
306
	default:
307
		DBG_DEC(eConversionType);
308
		break;
309
	}
310
} /* end of vStartOfParagraph1 */
311
 
312
/*
313
 * Create a start of paragraph (phase 2)
314
 * After indentation, list numbering, bullets etc.
315
 */
316
void
317
vStartOfParagraph2(diagram_type *pDiag)
318
{
319
	fail(pDiag == NULL);
320
 
321
	switch (eConversionType) {
322
	case conversion_text:
323
	case conversion_fmt_text:
324
		break;
325
	case conversion_ps:
326
		break;
327
	case conversion_xml:
328
		vStartOfParagraphXML(pDiag, 1);
329
		break;
330
	case conversion_pdf:
331
		break;
332
	default:
333
		DBG_DEC(eConversionType);
334
		break;
335
	}
336
} /* end of vStartOfParagraph2 */
337
 
338
/*
339
 * Create an end of paragraph
340
 */
341
void
342
vEndOfParagraph(diagram_type *pDiag,
343
	drawfile_fontref tFontRef, USHORT usFontSize, long lAfterIndentation)
344
{
345
	fail(pDiag == NULL);
346
	fail(pDiag->pOutFile == NULL);
347
	fail(usFontSize < MIN_FONT_SIZE || usFontSize > MAX_FONT_SIZE);
348
	fail(lAfterIndentation < 0);
349
 
350
	switch (eConversionType) {
351
	case conversion_text:
352
	case conversion_fmt_text:
353
		vEndOfParagraphTXT(pDiag, lAfterIndentation);
354
		break;
355
	case conversion_ps:
356
		vEndOfParagraphPS(pDiag, usFontSize, lAfterIndentation);
357
		break;
358
	case conversion_xml:
359
		vEndOfParagraphXML(pDiag, 1);
360
		break;
361
	case conversion_pdf:
362
		vEndOfParagraphPDF(pDiag, usFontSize, lAfterIndentation);
363
		break;
364
	default:
365
		DBG_DEC(eConversionType);
366
		break;
367
	}
368
} /* end of vEndOfParagraph */
369
 
370
/*
371
 * Create an end of page
372
 */
373
void
374
vEndOfPage(diagram_type *pDiag, long lAfterIndentation, BOOL bNewSection)
375
{
376
	switch (eConversionType) {
377
	case conversion_text:
378
	case conversion_fmt_text:
379
		vEndOfPageTXT(pDiag, lAfterIndentation);
380
		break;
381
	case conversion_ps:
382
		vEndOfPagePS(pDiag, bNewSection);
383
		break;
384
	case conversion_xml:
385
		vEndOfPageXML(pDiag);
386
		break;
387
	case conversion_pdf:
388
		vEndOfPagePDF(pDiag, bNewSection);
389
		break;
390
	default:
391
		DBG_DEC(eConversionType);
392
		break;
393
	}
394
} /* end of vEndOfPage */
395
 
396
/*
397
 * vSetHeaders - set the headers
398
 */
399
void
400
vSetHeaders(diagram_type *pDiag, USHORT usIstd)
401
{
402
	switch (eConversionType) {
403
	case conversion_text:
404
	case conversion_fmt_text:
405
		break;
406
	case conversion_ps:
407
		break;
408
	case conversion_xml:
409
		vSetHeadersXML(pDiag, usIstd);
410
		break;
411
	case conversion_pdf:
412
		break;
413
	default:
414
		DBG_DEC(eConversionType);
415
		break;
416
	}
417
} /* end of vSetHeaders */
418
 
419
/*
420
 * Create a start of list
421
 */
422
void
423
vStartOfList(diagram_type *pDiag, UCHAR ucNFC, BOOL bIsEndOfTable)
424
{
425
	switch (eConversionType) {
426
	case conversion_text:
427
	case conversion_fmt_text:
428
		break;
429
	case conversion_ps:
430
		break;
431
	case conversion_xml:
432
		vStartOfListXML(pDiag, ucNFC, bIsEndOfTable);
433
		break;
434
	case conversion_pdf:
435
		break;
436
	default:
437
		DBG_DEC(eConversionType);
438
		break;
439
	}
440
} /* end of vStartOfList */
441
 
442
/*
443
 * Create an end of list
444
 */
445
void
446
vEndOfList(diagram_type *pDiag)
447
{
448
	switch (eConversionType) {
449
	case conversion_text:
450
	case conversion_fmt_text:
451
		break;
452
	case conversion_ps:
453
		break;
454
	case conversion_xml:
455
		vEndOfListXML(pDiag);
456
		break;
457
	case conversion_pdf:
458
		break;
459
	default:
460
		DBG_DEC(eConversionType);
461
		break;
462
	}
463
} /* end of vEndOfList */
464
 
465
/*
466
 * Create a start of a list item
467
 */
468
void
469
vStartOfListItem(diagram_type *pDiag, BOOL bNoMarks)
470
{
471
	switch (eConversionType) {
472
	case conversion_text:
473
	case conversion_fmt_text:
474
		break;
475
	case conversion_ps:
476
		break;
477
	case conversion_xml:
478
		vStartOfListItemXML(pDiag, bNoMarks);
479
		break;
480
	case conversion_pdf:
481
		break;
482
	default:
483
		DBG_DEC(eConversionType);
484
		break;
485
	}
486
} /* end of vStartOfListItem */
487
 
488
/*
489
 * Create an end of a table
490
 */
491
void
492
vEndOfTable(diagram_type *pDiag)
493
{
494
	switch (eConversionType) {
495
	case conversion_text:
496
	case conversion_fmt_text:
497
		break;
498
	case conversion_ps:
499
		break;
500
	case conversion_xml:
501
		vEndOfTableXML(pDiag);
502
		break;
503
	case conversion_pdf:
504
		break;
505
	default:
506
		DBG_DEC(eConversionType);
507
		break;
508
	}
509
} /* end of vEndOfTable */
510
 
511
/*
512
 * Add a table row
513
 *
514
 * Returns TRUE when conversion type is XML
515
 */
516
BOOL
517
bAddTableRow(diagram_type *pDiag, char **aszColTxt,
518
	int iNbrOfColumns, const short *asColumnWidth, UCHAR ucBorderInfo)
519
{
520
	switch (eConversionType) {
521
	case conversion_text:
522
	case conversion_fmt_text:
523
		break;
524
	case conversion_ps:
525
		break;
526
	case conversion_xml:
527
		vAddTableRowXML(pDiag, aszColTxt,
528
				iNbrOfColumns, asColumnWidth,
529
				ucBorderInfo);
530
		return TRUE;
531
	case conversion_pdf:
532
		break;
533
	default:
534
		DBG_DEC(eConversionType);
535
		break;
536
	}
537
	return FALSE;
538
} /* end of bAddTableRow */